} 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)] ] =image %./business_programming/blogger2.png =image %./business_programming/blogger.png ---FTP Group Chat This example is a simple chat application that lets users send instant text messages back and forth across the Internet. 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). This enables unlimited private conversation spaces that can be used to connect any number of individuals or teams within a group. This program runs entirely in the REBOL console (i.e., there is no graphic user interface - it's all printed text), so it can be used even on simple devices which don't have GUI support. 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"], in this example case). 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 ask trim/lines { URL of text file on your server (ftp://user:pass@site.com/chat.txt): } ; The following line gets the user's name: name: ask "Enter your name: " ; 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. If the file ; doesn't exist, it is created. Any number of "room" files can be ; automatically created on the web server: 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: prin "^(1B)[J" ; 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 [ ; "switch" handles multiple "if" cases ; 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: "clear" [ ; "if/else" does the same thing as "either" (deprecated): adminu: ask "Admin Username: " adminp: ask "Admin Password: " if/else ((adminu = "secret") and (adminp = "password")) [ write webserver "" ] [ ask trim/auto { ^LYou 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 ask rejoin [ {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: ask trim/lines { ^LPress [Enter] to resume. You'll need the correct username and password to continue. } ; Don't go on until the user gets the password right: forever [ ; The while loop below continually asks the user for ; a password, until correct: while [ adminu: ask "Admin Username: " adminp: ask "Admin Password: " ((adminu <> "secret") or (adminp <> "password")) ][ ask "^LIncorrect 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: prin "^(1B)[J" ; clear screen print "Goodbye!" write/append webserver rejoin [now ": " name " has closed chat." newline] wait 1 =image %./business_programming/chat_room.png The bulk of this program runs within the "forever" loop, and uses the conditional "switch" structure to decide how to respond to user input. 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. ---Group Reminder This program operates along the same lines as the FTP Chat app. It stores reminder notes for a group of users in a text file accessible by FTP. Unlike the FTP chat application, this program makes use of GUI features, and focuses on popping up when new messages are sent to the group. Users can run the program at any time to type a new text reminder into a text area widget. The program can also be started and minimized to run in the background and listen for reminders. In listen mode, a GUI window will pop up with a message whenever someone else in the group adds a new reminder. The system can be used to share event reminders, notes, task lists, or any other relevant and time sensitive information. This app only requires that someone in the group has access to an FTP server. Just like the FTP chat program, nothing needs to be configured on the server. All that's required is a username and password, and a connection to the Internet. REBOL [title: "Group Reminder System"] ; This variable is set to store the username, password, folder, file and ; URL of the FTP server at which the reminder texts are stored: group-url: ftp://user:pass@site.com/public_html/reminders.txt ; The request-list function here allows the user to choose between adding ; a new reminder text, or listening in the background. The user's ; response is stored in the variable "menu": menu: request-list "" ["Create New Reminder" "Listen For Reminders"] ; The code pattern below was demonstrated earlier in the "Parts" program. ; It creates a new file, if the file doesn't exist. Otherwise, it does ; nothing: write/append %reminders.txt "" ; If the user chose to create a new reminder, do the following code: if menu = "Create New Reminder" [ ; Create a GUI window with some header text, an area widget, and a ; button: view center-face layout [ h3 "Add a new reminder for the group:" a: area wrap btn "Submit" [ ; When clicked, run the following code with an error check, ; just in case an Internet connection isn't available: if error? try [ ; Attempt to write the area widget text to the FTP file: write/append group-url mold a/text ; If there's an error writing, alert the user and quit: ] [alert "ERROR: Not Saved (check Internet connection)" quit] ; Otherwise, alert with user with a success message, and end: alert "Saved" quit ] ] ] ; If the user chose to listen for reminders, do the following code: if menu = "Listen For Reminders" [ ; Print a waiting message in the console. This can be minimized: print "Listening for reminders..." ; Repeat the following code endlessly: forever [ ; Waiting a few seconds saves a lot of bandwidth: wait 5 ; "Attempt" is just like "if error? try" - it just doesn't do ; anything if an error occurs. The point of attempting the ; following code is to ensure the program continues to run if ; the Internet connection is disabled, or the FTP file can't be ; read for any other reason: attempt [ ; Read the text in the FTP file, and assign it the label ; "reminders": reminders: read group-url ; If a new reminder has been added by anyone in the group, ; the "reminders" text will not match the text stored in the ; file reminders.txt: if reminders <> read %reminders.txt [ ; If that's the case, update the reminders.txt file, with ; the new text read from the FTP file: write %reminders.txt reminders ; Create a blank string to store the current reminders: remind: copy {} ; Reverse the order of all reminders in the FTP file, so ; that the newest messages are first, then loop through ; them with the "foreach" function: foreach reminder (reverse load reminders) [ ; Append each reminder to the blank text string ; created above, separated by 2 blank lines: append remind rejoin [reminder newline newline] ] ; Open a GUI window and display the formatted reminder ; text in an area widget: view center-face layout [ h3 "Reminders for the group:" area remind ] ] ] ] ] Here's the whole program without comments: REBOL [title: "Group Reminder System"] group-url: ftp://user:pass@site.com/public_html/reminders.txt menu: request-list "" ["Create New Reminder" "Listen For Reminders"] write/append %reminders.txt "" if "" = read group-url [write group-url {""}] if menu = "Create New Reminder" [ view center-face layout [ h3 "Add a new reminder for the group:" a: area wrap btn "Submit" [ if error? try [ write/append group-url mold a/text ] [alert "ERROR: Not Saved (check Internet connection)" quit] alert "Saved" quit ] ] ] if menu = "Listen For Reminders" [ print "Listening for reminders..." forever [ wait 5 attempt [ reminders: read group-url if reminders <> read %reminders.txt [ write %reminders.txt reminders remind: copy {} foreach reminder (reverse load reminders) [ append remind rejoin [reminder newline newline] ] view center-face layout [ h3 "Reminders for the group:" area remind ] ] ] ] ] =image %./business_programming/reminder1.png =image %./business_programming/reminder2.png =image %./business_programming/reminder3.png =image %./business_programming/reminder4.png =image %./business_programming/reminder5.png ---A Univeral Report Generator, For Paypal and any other CSV Table Data This example creates reports on columns and rows of data in a .csv table. The script demonstrates typical CSV file operations using parse, foreach, and simple series functions. The code performs sums upon columns, and selective calculations upon specified fields, based upon conditional evaluations, searches, etc. Practical column and row based reporting capabilities such as this are a simple and useful skill in REBOL. Using basic permutations of techniques shown here, it's easy to surpass the capabilities of spreadsheets and other "office" reporting tools. Actual data for use in testing this example can be downloaded as follows: #Log into your Paypal account #Click on My Account -> History -> Download History #Pick a range of dates #Select "Comma Delimited - All Activity" (where it's labeled "File Types to Download") #Save the file to %Download.csv. At the time this example code was created, the author's CSV file download contained the following fields ("A" through "AP" - 42 columns). Date, Time, Time Zone, Name, Type, Status, Currency, Gross, Fee, Net, From Email Address, To Email Address, Transaction ID, Counterparty Status, Address Status, Item Title, Item ID, Shipping and Handling Amount, Insurance Amount, Sales Tax, Option 1 Name, Option 1 Value, Option 2 Name, Option 2 Value, Auction Site, Buyer ID, Item URL, Closing Date, Escrow Id, Invoice Id, Reference Txn ID, Invoice Number, Custom Number, Receipt ID, Balance, Address Line 1, Address Line 2/District/Neighborhood, Town/City, State/Province/Region/County/Territory/Prefecture/Republic, Zip/Postal Code, Country, Contact Phone Number The code automatically handles tables with any arbitrary number of columns, allowing fields to be referred to by labels present in the first line of the .csv file. The script is simple to understand: REBOL [title: "Paypal Reports"] ; First, read in the lines of the CSV file ; (as described earlier in the CSV/parse section of this tutorial): filename: request-file/only/file %Download.csv lines: read/lines filename ; The first row contains column labels. Let's convert that CSV line to a ; block, using the parse/all function: labels: copy parse/all lines/1 "," ; Remove extra spaces from each of the labels in the "labels" block: foreach label labels [trim label] ; Now we'll convert the CSV lines into a REBOL data block. First, ; create an empty block to store the data: database: copy [] ; The data values start at line two of the CSV file. Use foreach and ; parse/all to separate the individual values in each line, and collect ; them into a block of blocks (as described in the CSV/parse section): foreach line (at lines 2) [ parsed: parse/all line "," append/only database parsed ] ; For the first report, let's get a list of every person in the "Name" ; Column. Find the index number of the "Name" column in the "labels" ; block. We'll use that to pick out name values from each row: name-index: index? find labels "Name" ; Create an empty text string to collect the names: names: copy {} ; Loop through the database, picking the item at the name-index location ; from each row foreach row database [ append names rejoin ["Name: " (pick row name-index) newline] ] ; Display the results: editor names ; Now let's view every transaction in which the name field includes ; "Netflix". It's basically the same routine as above, only now with an ; added conditional evaluation that uses the "find" function. And for ; this report, I want to see the amount paid. I'll set a variable to ; refer to the index position of the "Net" column: net-index: index? find labels "Net" amounts: copy {} foreach row database [ if find/only (pick row name-index) "Netflix" [ append amounts rejoin ["Amount: " (pick row net-index) newline] ] ] editor amounts ; Now, let's get a sum of every Netflix transaction between January and ; December, 2012. The dates are stored in a column labeled "Date", with ; a format like: "12/26/2012" (month/day/year). We'll need to convert ; that to REBOL's internal format (day-month-year) date-index: index? find labels "Date" ; You've seen earlier how to collect sums. Start by setting a sum ; variable to 0. We'll add values to the sum to get a total: sum: $0 ; Now loop through the database and perform some conditional evaluations ; on every row: foreach row database [ if find/only (pick row name-index) "Netflix" [ ; We'll use "parse" to separate the date text at the ; "/" character: date: parse (pick row date-index) "/" ; Pick the month using the values in system/locale/months month: pick system/locale/months to-integer date/1 ; Then rearrange and put back together the date pieces using ; "rejoin": reb-date: to-date rejoin [date/2 "-" month "-" date/3] ; If the date is within the chosen range, add the value to ; the sum: if ((reb-date >= 1-jan-2012) and (reb-date <= 31-dec-2012)) [ sum: sum + (to-money pick row net-index) ] ] ] ; Show the answer: alert form sum Here's the entire program without comments: REBOL [title: "Paypal Reports"] filename: request-file/only/file %Download.csv lines: read/lines filename labels: copy parse/all lines/1 "," foreach label labels [trim label] database: copy [] foreach line (at lines 2) [ parsed: parse/all line "," append/only database parsed ] name-index: index? find labels "Name" names: copy {} foreach row database [ append names rejoin ["Name: " (pick row name-index) newline] ] editor names net-index: index? find labels "Net" amounts: copy {} foreach row database [ if find/only (pick row name-index) "Netflix" [ append amounts rejoin ["Amount: " (pick row net-index) newline] ] ] editor amounts date-index: index? find labels "Date" sum: $0 foreach row database [ if find/only (pick row name-index) "Netflix" [ date: parse (pick row date-index) "/" month: pick system/locale/months to-integer date/1 reb-date: to-date rejoin [date/2 "-" month "-" date/3] if ((reb-date >= 1-jan-2012) and (reb-date <= 31-dec-2012)) [ sum: sum + (to-money pick row net-index) ] ] ] alert form sum If you want to use this example to create reports for any other CSV file, just copy and paste the first part of the script. It loads and parses a user selected CSV file, and creates a block of labels from the first line: REBOL [title: "Reports"] filename: request-file/only/file %filename.csv lines: read/lines filename labels: copy parse/all lines/1 "," foreach label labels [trim label] database: copy [] foreach line (at lines 2) [ parsed: parse/all line "," append/only database parsed ] You can use this line of code to view the list of column labels in the CSV file: editor labels Next, assign variable(s) to the column label(s), on which you want to perform computations: name-index: index? find labels "Name" date-index: index? find labels "Date" net-index: index? find labels "Net" Set any initial variables needed to perform computations (sum, max/min, etc.), or to hold blocks of collected values: sum: $0 names: copy {} amounts: copy {} Use foreach loop(s) to perform conditional evaluations and desired computations on every row of data: foreach row database [ append names rejoin ["Name: " (pick row name-index) newline] ] foreach row database [ if find/only (pick row name-index) "Netflix" [ append amounts rejoin ["Amount: " (pick row net-index) newline] ] ] foreach row database [ if find/only (pick row name-index) "Netflix" [ date: parse (pick row date-index) "/" month: pick system/locale/months to-integer date/1 reb-date: to-date rejoin [date/2 "-" month "-" date/3] if ((reb-date >= 1-jan-2012) and (reb-date <= 31-dec-2012)) [ sum: sum + (to-money pick row net-index) ] ] ] Display all the computed or collected results: editor names editor amounts alert form sum Of course, the computations above involve quite a bit of evaluation and data processing, in order to demonstrate useful reusable code snippets (such as converting dates to REBOL values that can be manipulated intelligently). In most cases, simple sums, averages, searches, and other common computations will require far less code. You can shorten code even further by using numbers to refer to columns. Simple reports rarely require much more code than the first example in this tutorial: sum: $0 foreach line at read/lines http://re-bol.com/Download.csv 2 [ sum: sum + to-money pick (parse/all line ",") 8 ] alert form sum ---Reviewing and Using the Code You've Seen To Model New Applications You're already well on your way to understanding how to build useful business applications. At this point, it's wise to go back and review every section in the tutorial. The perspective you have now will help to clarify the value of concepts that were skimmed during a first read. Focus on experimenting with individual lines of code, memorizing functions, and understanding the details of syntax that may have been confusing the first time around. Try repurposing, altering, and editing the complete programs you've seen to far, to be useful in data management activities that apply to your own interests. Here are some ideas for experimentation: # Add columns to data blocks in the existing apps (i.e, perhaps "email" and "mobile", "home", "work" fields to the contacts examples, or "name" a "title" fields to messages in the reminder app). # Add new computations to the reporting examples (perhaps average, max, and min functions to columns in the Paypal reports). # Apply the CSV, sorting, computing, and reporting code patterns you've seen to columns of data exported from other desktop applications and web sites. # Apply new and more complex conditional operations to computations (perhaps apply tax only to items in a Paypal file that were shipped from a certain state, or apply a fee to prices of items that are made by a certain manufacturer in the "Parts" database app). # Create a few small GUI apps that save CSV files which can be imported into a spreadsheet (perhaps add a CSV export feature to the "Contacts" or "Parts" examples, and especially try exporting computed reports as CSV files). # Add list features to the email program (perhaps allow email addresses to be chosen from a contact list, or send emails to a group of users). # Add useful features to the file editor and web page editor programs (maybe try storing a history of edited files, or FTP login credentials). # Combine the Inventory and Cash Register programs, so that users can select inventory items from a drop down list in the cash register app. # Add unique computation routines to the calculator app. # Experiment with the "parse" and "find" functions (perhaps try adding a search feature to the schedule and email programs, or send pre-formed responses to email messages that contain a given string of text in the subject). # Experiment with printing and displaying formatted data in the console and in GUI fields (perhaps build an email program that parses the header of each email message, and displays each part on separately printed lines in the console or in separate area widgets in a GUI). # Add image and file sharing features to the Group Reminders app. # Add images to stored records in the Parts database app. # Build GUI versions of the FTP chat and Paypal Reports applications. Use text-list widgets to display messages in chat and to select column names and computation options in reports. # Experiment with GUI layouts. Position text headers, fields, buttons, areas, text lists, etc. in ways that allow data to be arranged coherently and pleasantly on screen, and which invite intuitive user interactions and natural work flow patterns. # Experiment with how colors, fonts, widget sizes, images, and other cosmetic features can be used to change the appearance of applications. You'll see much more about how to approach tasks like this, as the tutorial progresses, but exploring creatively and learning to use the tools you've seen so far, will go a long way towards building fundamental coding ability. If you learn nothing more than the code presented up to this point, you will already be able to create a wide variety of practical business applications that would be impossible to implement quite so personally using generic off-the-shelf software products. Continue learning, and that potential will increase dramatically. ===User Defined Functions and Imported Code Modules ---"Do", "Does", and "Func" 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." alert "Writing to the hard drive was the 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 "Counting some more actions: 4" alert "And another: 5" alert "And finally: 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 +++"Func" 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 with those variables. Here's the "func" syntax: func [names of variables 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) ---Return Values 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 You can also use the word "return" to end the function with a return value. This can be helpful when breaking out of loops (the "for" function performs a count operation - it will be covered in depth in a later section of this tutorial): stop-at: func [num] [ for i 1 99 1 [ if (i = num) [return i] print i ] return num ] print stop-at 38 ---Scope 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 ---Function Documentation 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 ---Doing Imported 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. ---Separating Form and Function in GUIs - The Check Writer App One common use for functions is to help keep GUI layout code clean and easy to read. Separating widget layout code from action block code helps to clarify what each widget does, and simplifies the readability of code which lays out screen design. For example, the following buttons all perform several slightly different actions. The first button counts from 1 to 100 and then alerts the user with a "done" message, the second button counts from 101 to 200 and alerts the user when done, the third button counts from 201 to 300 and alerts the user when done (the "for" function performs a count operation): view layout [ btn "Count 1" [ for i 1 100 1 [print i] alert "Done" ] btn "Count 2" [ for i 101 200 1 [print i] alert "Done" ] btn "Count 3" [ for i 201 300 1 [print i] alert "Done" ] ] The action blocks of each button above can all be reduced to a common function that counts from a start number to an end number, and then alerts the user. That function can be assigned a label, and then only that label needs to be used in the GUI widget action blocks: count: func [start end] [ for i start end 1 [print i] alert "Done" ] view layout [ btn "Count 1" [count 1 100] btn "Count 2" [count 101 200] btn "Count 3" [count 201 300] ] In large applications where the actions can become complex, separating function code from layout code improves clarity. You'll see this outline often: action1: func [args] [ actions actions actions ] action2: func [args] [ other actions other actions other actions ] action3: func [args] [ more actions more actions more actions ] view layout [ widget [action1] widget [action2] widget [action3] ] Here's a simple check writing example that takes amounts and names entered into an area widget and creates blocks of text to be written to a check. One function is created to "verbalize" the entered amounts for printing on the check (it converts number values to their spoken English equivalent, i.e., 23482194 = "Twenty Three million, Four Hundred Eighty Two thousand, One Hundred Ninety Four"). Another function is created to loop through each bit of raw check data and to create a block containing the name, the numerical amount, the verbalized amount, some memo text, and the date. The GUI code consists of only 4 lines: REBOL [title: "Check Writer"] verbalize: func [a-number] [ if error? try [a-number: to-decimal a-number] [ return "** Error ** Input must be a decimal value" ] if a-number = 0 [return "Zero"] the-original-number: round/down a-number pennies: a-number - the-original-number the-number: the-original-number if a-number < 1 [ return join to-integer ((round/to pennies .01) * 100) "/100" ] small-numbers: [ "One" "Two" "Three" "Four" "Five" "Six" "Seven" "Eight" "Nine" "Ten" "Eleven" "Twelve" "Thirteen" "Fourteen" "Fifteen" "Sixteen" "Seventeen" "Eighteen" "Nineteen" ] tens-block: [ { } "Twenty" "Thirty" "Forty" "Fifty" "Sixty" "Seventy" "Eighty" "Ninety" ] big-numbers-block: ["Thousand" "Million" "Billion"] digit-groups: copy [] for i 0 4 1 [ append digit-groups (round/floor (mod the-number 1000)) the-number: the-number / 1000 ] spoken: copy "" for i 5 1 -1 [ flag: false hundreds: (pick digit-groups i) / 100 tens-units: mod (pick digit-groups i) 100 if hundreds <> 0 [ if none <> hundreds-portion: (pick small-numbers hundreds) [ append spoken join hundreds-portion " Hundred " ] flag: true ] tens: tens-units / 10 units: mod tens-units 10 if tens >= 2 [ append spoken (pick tens-block tens) if units <> 0 [ if none <> last-portion: (pick small-numbers units) [ append spoken rejoin [" " last-portion " "] ] flag: true ] ] if tens-units <> 0 [ if none <> tens-portion: (pick small-numbers tens-units) [ append spoken join tens-portion " " ] flag: true ] if flag = true [ commas: copy {} case [ ((i = 4) and (the-original-number > 999999999)) [ commas: {billion, } ] ((i = 3) and (the-original-number > 999999)) [ commas: {million, } ] ((i = 2) and (the-original-number > 999)) [ commas: {thousand, } ] ] append spoken commas ] ] append spoken rejoin [ "and " to-integer ((round/to pennies .01) * 100) "/100" ] return spoken ] write-checks: does [ checks: copy [] data: to-block a1/text foreach [name amount] data [ check: copy [] append/only checks reduce [ rejoin ["Pay to the order of: " name " "] rejoin ["$" amount newline] rejoin ["Amount: " verbalize amount newline] rejoin ["Sales for November " now/date newline newline] ] ] a2/text: form checks show a2 ] view layout [ text "Amounts and Names:" a1: area {"John Smith" 582 "Jen Huck" 95 "Sue Wells" 71 "Joe Lask" 38} btn "Create Check Data" [write-checks] a2: area ] =image %./business_programming/checkwriter.png One of the clear benefits of using functions is that you don't have to remember, or even understand, how they work. Instead, you only really need to know how to use them. In the example above, you don't have to understand exactly how all computations in the "verbalize" function work. You just need to know that if you type "verbalize (number)", it spits out text representing the specified dollar amount. You can use that function in any other program where it's useful, blissfully unaware of how the verbalizing magic happens. Just paste the verbalize code above, and use it like any other function built into the language. This is true of any function you create, or any function that someone else creates. Working with functions in this way helps improve code re-usability, and the power of the language, dramatically. It also encourages clear code structures that others can read more easily. Note: The verbalize algorithm was partially derived from the article at http://www.blackwasp.co.uk/NumberToWords.aspx (C# code): ---A Full Featured Group Note Sharing App In the previous section, the "Group Reminders" and "FTP Chat" applications demonstrated how to save text messages to a web server, so they can be shared with a group of connected users. This application builds on the same idea, adding a number of useful features. The message list display can be updated manually or automatically, at any chosen interval. A repeated beep can be played as an alarm to notify users of new messages (a beep is created with the code: call "echo ^G"). Beep notifications can be turned on and off. Messages are stamped with a time and date, and numbered. Messages can be erased individually by number, or the entire note list can be removed at once. An unlimited number of private "rooms" can be created, simply by changing the URL. A new file will be automatically created at the entered URL, if it doesn't exist. All of the features in this program are implemented as separate functions. The "update" function, in particular is called not only when the user clicks the update button, but also by other functions, any time a change is made which requires updating the display (when erasing messages, when autoupdate is turned on, etc). Notice that the GUI layout is kept clean, and each widget simply calls a function: REBOL [title: "Group Notes"] url: ftp://user:pass@site.com/public_html/Notes beep: false autoupdt: false call "" write/append %notes.txt "" update: does [ if error? try [notes: copy read/lines url] [write url notes: ""] if ((beep = true) and (notes <> read/lines %notes.txt)) [ loop 4 [call "echo ^G" wait 1] ] write/lines %notes.txt notes display: copy {} count: 0 foreach note reverse notes [ either note = "" [ note: newline ] [ count: count + 1 note: rejoin [count ") "note] ] append display note ] a/text: display if a/text = "" [a/text: copy " "] show a ] autoupdate: does [ either autoupdt: not autoupdt [ time: request-text/title/default "Refresh display (seconds):" "10" b/text: join "Auto Update: " autoupdt show b forever [ either autoupdt = true [wait to-integer time update] [break] ] ] [ b/text: join "Auto Update: " autoupdt show b ] ] submit: does [ if f/text = "" [focus f return] if error? try [ write/lines/append url rejoin [ "^/^/" now " (" n/text "): " f/text ] ] [alert "ERROR: Not Saved (check Internet connection)" return] update f/text: copy "" show f focus f ] erase: func [arg] [ if true = request rejoin ["Really erase " arg "?"] [ write/lines to-file replace/all replace form now "/" "--" ":" "_" notes if arg = "all" [write url ""] if arg = "" [ indx: ( 3 * to-integer request-text/title/default "Index:" "1" ) - 2 remove/part at notes indx 3 write/lines url reverse notes ] update ] ] changeurl: does [ url: to-url u/text update focus f ] setbeep: does [ beep: not beep p/text: join "Beep: " beep show p ] insert-event-func [either event/type = 'close [quit][event]] view center-face layout [ h3 "Current notes for:" u: field 600 form url [changeurl] a: area 600x260 h3 "Name:" n: field 600 h3 "New Note:" f: field 600 [submit] across btn "Update" [update] b: btn join "Auto Update: " autoupdt [autoupdate] p: btn join "Beep: " beep [setbeep] btn "Erase" [erase ""] btn "Erase All" [erase "all"] do [update focus f] ] =image %./business_programming/notes.jpg Later in this text, a web based CGI version of this application will be presented, so that users can view and enter notes with either this desktop version of the program, or with a browser based interface, to share and interact with the exact same live data on any platform. Enabling different interfaces can be useful on mobile OSs or on any system where an executable program can't be installed. ===A Few Useful Data Visualization Tools ---Displaying and Sorting Data Using Spreadsheet-Like GUI Grids As you've already seen in the "Contacts" example, it's possible to dynamically construct GUIs using foreach loops, to display data in GUI fields. We'll build on examples such as the following in a later chapter: REBOL [title: "Display a Table of Data"] ; Build 500 rows of 3 columns of random data: x: copy[] for i 1 500 1[append x reduce [i random "abcd" random 1-1-2012]] ; Display it: grid: copy [across space 0] foreach [indx text date] x [ append grid compose [ field 50 (form indx) field 70 (form text) field 110 (form date) return ] ] view center-face layout [ across g: box 230x200 with [pane: layout/tight grid pane/offset: 0x0] scroller [g/pane/offset/y: g/size/y - g/pane/size/y * value show g] ] Using raw building blocks of GUI field widgets, even the simple example above requires quite a bit of thought to display a small grid filled with table data, and normal features such as column resizing, sorting, etc., require advanced coding skill. To load, display, sort, and save flat lists and blocked table data, the following compressed code is provided to simplify the required code. Just define a block of header labels, assign the variable label "x" to your grid data, and include the compressed grid code, and you've got a fully functional data grid: REBOL [title: "Table/Grid/Listview Example"] headers: ["Numbers" "Text" "Dates"] x: [ [1 "1" 1-1-2012] [11 "11" 1-2-2012] [2 "2" 1-3-2012] ] do decompress #{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} view center-face gui: layout gui-block Other options such as coloring rows, and specifying column data types, using the compressed table code above, are demonstrated in the following example. This is a critically useful tool for data entry, visualization, and demonstration: REBOL [title: "Table/Grid/Listview Example With Expanded Features"] headers: ["Numbers" "TEXT (Note Sort)" "Dates"] ; REQUIRED COLUMN LABELS ; ALL THESE ADDITIONAL SETUP PARAMETERS ARE *** OPTIONAL ***: x: [[1 "1" 1-1-2012][11"11"1-2-2012][2"2"1-3-2012]] ; some default data colors: [blue black red] ; specify column colors like this empty-space: 235 ; size of blank GUI area to appear below grid svv/vid-face/color: white ; default GUI face color ; Here's how to include GUI layout code to appear above the grid: gui-block: { h3 "RIGHT-CLICK/DRAG HEADERS TO RESIZE COLUMNS. RESIZE WINDOW..." text "Click headers to sort (note that sort is DATA-TYPE SPECIFIC)." text "Notice Arrow Keys, PgUp/PgDn Keys, Scroll Bar, and highliting" text "Click any cell to edit data. Buttons load and save data to HD." } ; The following line automatically fits grid to resized GUI window: insert-event-func [either event/type = 'resize [resize-fit none] [event]] do decompress #{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} ; APPEND ANY WIDGETS AND/OR GUI CODE TO APPEAR BELOW THE GRID, HERE: append gui-block [ ; REPLACE 'BTN' WITH 'KEY' TO HIDE BTNS AND STILL USE KEY SHORTCUTS. ; CHANGE/REMOVE BUTTONS AND/OR KEYBOARD SHORTCUTS AS NEEDED: text "" return btn "Insert (Ins)" keycode [insert] [add-line] btn "Remove (Del)" #"^~" [remove-line] btn "Move (CTRL+M)" #"^M" [move-line] btn "Grow (+)" #"+" [resize-grid 1.333] btn "Shrink (-)" #"-" [resize-grid .75] btn "Fit (CTRL+R)" #"^R" [resize-fit] return btn "Load Blocked (CTRL+O)" #"^O" [load-blocked/request %blocked.txt] btn "Save Blocked (CTRL+S)" #"^S" [save-blocked/request %blocked.txt] btn "Load Flat (CTRL+U)" #"^U" [load-flat/request %flat.txt] btn "Save Flat (CTRL+F)" #"^F" [save-flat/request %flat.txt] ; LOAD A DEFAULT DATA *FILE HERE (instead of specifying it in code above): ; Not that the "load-flat" and "save-flat" functions load "flat" blocks, ; which are simply long sequences of data values. The "load-blocked" and ; "save-blocked" functions load block which have rows enclosed inside ; deliniated blocks. All of those functions provide an optional ; "/request" refinement that allows the user to select a file: ; do [load-blocked %blocked.txt] ] view/options center-face gui: layout gui-block [resize] =image %./business_programming/grid.png Details about how to build GUI grids from native REBOL code, including the compressed code above, will be examined fully in later sections of this tutorial. For now, the general solution above is immediately functional, and can be applied to the majority of situations where a visual grid tool is required to enter, display, sort, load, save, and otherwise manipulate table data. ---Creating Graphs, Plots, and Charts with "Q-Plot" REBOL's complete graphics toolkit will be fully explored in detail, in future sections of this tutorial. For the moment, the "q-plot" dialect by Matt Licholai is a simple solution for creating bar, line, pie and other charts from block data. You can download and run the q-plot dialect like this: REBOL [] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r Once q-plot is downloaded, graphing a block of values is as simple as this: view quick-plot [ 600x400 ; set the program window size bars [5 3 8 2 10 3 4 9 5 7] ; set graph type and data to plot ] Using the code above, here's a complete bar graph example: REBOL [title: "Minimal Bar Graph Example"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r view quick-plot [ 600x400 bars [5 3 8 2 10 3 4 9 5 7] ] =image %./business_programming/chart1.png Notice that the q-plot dialect syntax looks very much like REBOL's build in VID dialect for building GUIs. The primary difference is that "view layout" is replaced with "view quick-plot". Here's an example that demonstrates how to adjust colors, add text labels, and attach scales for each XxY data axis: REBOL [title: "Another Bar Graph Example"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r view center-face quick-plot [ 600x300 y-min 0 ; minimum value to display on y axis fill-pen blue ; set fill color pen green ; set outline and text color bar-width 80 ; set bar width bars [5 3 8 2 10 3 4 9 5 7] pen black ; set outline and text color label "Fat Bars" ; optionally add labels y-axis 11 x-axis 10 ] =image %./business_programming/chart2.png Pie charts are just as simple to create. Here's a pie chart example with 2 specified sections of the pie "exploded" out for emphasis (the "explode [3 5]" code is optional): REBOL [title: "Exploded Pie Chart"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r view center-face quick-plot [ 400x400 pie [10 3 6 1 8] labels [A B C D E] explode [3 5] title "Exploded Sections C and E" style vh2 ] =image %./business_programming/chart3.png Line graphs are also simple to create: REBOL [title: "Simple Line Graph Example"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r view quick-plot [ 400x400 line [1 2 4 8 16 32 64 128 256] ] =image %./business_programming/chart4.png Here's a more complex line graph example that demonstrates how to plot a predefined block of data, how to add a title, how to add text with a font and defined position (up and over a percentage of the window), and how to attach a scaled grid to the display: REBOL [title: "Another Line Graph Example"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r my-block: copy [2] loop 10 [append my-block (2 * last my-block)] option-font: make face/font [ size: 30 style: [italic bold underline] name: font-serif ] view center-face quick-plot [ 500x500 scale linear line [(data: copy my-block)] title style vh1 "Linear scale" x-axis 7 border y-axis 7 border x-grid 7 y-grid 7 text font option-font "Formatted Text" color red up 50 over 40 ] =image %./business_programming/chart5.png Here's an extension of the "Paypal Reports" program you've seen earlier in this text. It plots all the gross transaction numbers using a bar graph, and makes a pie chart of transactions with Saoud Gorn: REBOL [title: "Paypal Reports Charts"] transactions: copy [] saoud: copy [] dates: copy [] foreach line at read/lines http://re-bol.com/Download.csv 2 [ row: parse/all line "," append transactions to-integer row/8 if find row/4 "Saoud" [ append saoud to-integer row/8 append dates replace row/1 "/2012" "" ] ] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r view quick-plot [ 594x400 bars [(data: copy transactions)] label "All Paypal Transactions" ] view center-face quick-plot [ 495x530 pen blue pie [(data: copy saoud)] labels [(data: copy dates)] explode [1 2 3] title "Saoud" style vh2 ] =image %./business_programming/paypalchart1.png =image %./business_programming/paypalchart2.png This example demonstrates how to include several plots in one window. The default alignment for multi-plots is vertical. The "multi-plot/across" refinement lays them out horizontally: REBOL [title: "Multi-Plots"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r m-plots: multi-plot/across 594x200 [ [ title "2 to a Power" pen green line [0 2 4 8 16 32 64 128] ] [ title "Rizing" pen white line [0 5 10 15 20 25] ] [ title "Falling" pen blue line [25 20 15 10 5 0] ] ] view m-plots =image %./business_programming/multiplots.png This example demonstrates how to place plots in sub-panels for easy switching: REBOL [title: "Switching Plots"] if not exists? %q-plot.r [write %q-plot.r read http://re-bol.com/q-plot.r] do %q-plot.r window: layout [ vh2 "Switching Plots" guide pad 20 button "Sine Wave" [graph/pane: plot1 show graph] button "Parabola" [graph/pane: plot2 show graph] button "Cubic Curve" [graph/pane: plot3 show graph] return box 2x204 blue return graph: box 354x204 coal ] data1: copy [] data2: copy [] data3: copy [] for i -400 400 .5 [ append data1 sine i append data2 (i * i) append data3 (i ** 3) ] graph-size: 350x200 plot1: quick-plot [ (graph-size) line [(data1)] title "Sine Wave" ] plot2: quick-plot [ (graph-size) line [(data2)] title "Parabola" ] plot3: quick-plot [ (graph-size) line [(data3)] title "Cubic Function" ] plot1/offset: 2x2 plot2/offset: 2x2 plot3/offset: 2x2 graph/pane: plot1 view window =image %./business_programming/plotpane1.png =image %./business_programming/plotpane2.png =image %./business_programming/plotpane3.png Be aware that instead of downloading and running the q-plot dialect from an external file, you can include the compressed q-plot code directly in your program: REBOL [title: "Q-Plot Compressed"] do decompress #{ 789CED7DFB93E3B871F0EFFB57E0A6F2D5483BC779DDAD1F5ADF6DD93EA77229 3B71EE6C5752AA498A92A0197A299126A91DCA17FFEFE9071E0D02943433BB4E 3E27AABB5989041A40BFD16800DFFDEA17FFFC6B357FA5E0F3BBA22BF54C9DFD CBAE58BE57BF2DAB4E7D53E4A55E7667F4FE9BBC83D7376FB2BFD78BECF6FAFA 969EFE41376D516D67EAFAF2E6F29A1EFD7D8170FEDF9FB21A605C36F4ECE7BB EEA16A00FA6FF2AE53BF2E960F5599170CF8BBE2FEA16BE1DD64395500F8E673 84AE7E733928F7FB36BF07C03FFCBED52A6F55AE1665053D5D6BBD2AB6F7EA3B 1ACB1FBEFD46ADB8DB974A7DAFB5D27F361D51EBAA512BDDE545D9FE8520FE76 D7D4558B307FDB541F8A15C0557FA2E1E7DB95D279BB575DA576D09E01492010 5A872D165B6E9481FDB2DA6CF4B60360BFABB26F2AF5D557F4587EFE0146AAB2 2C7AFE1BBDC2C7FF9EFD7B261F5FA8DFD72BC0FAD5AFFA9A3AE446B2AA963B6C 2CEF00F711B85F578F004E25E0FD7CB5526D972FDF43838BBC51CB87BCE9DAA8 E06BF59D7EAC9AF7AA576575AFDA655EC278A91D1EEB3F146D5735FB999A5F5F 02E1D5FCE63AFB462F912D6ED4D9B7DBA2037C39A42DF216DAABB66AB327E4A9 F56EBBC49EB767778AE021945B80F2A580F28BBC2D9640E81A40B40ABB037DB8 9435BE801A3FF6357EF8E543BEBD879680668DEE76CD16C859E6FB6AD7A96AF1 4700F3B9DAE408057AD6D6F006495CE8E6F22F02E8976AFE26FBC77C4B2CAECE 7E59EA7C0B3077B55A56C82040872553BAFD5CE5AB15BC03E4E8AC06C6D64D38 A437D04101EC875F564D03DD802AB9AA9B6A51EA8D7A2CBA0755ADD7AD66A6EA 1EB48A286A3F3D52AFE9545D15DB8EFAB205742EA133BAC1CA40D3560EE647D0 811F253B10345FE60B5DB604EF43DE14D5AE558BDDBD5A17BD0EC0FD18C0FD54 20E7E734FCCDAEEC8A2C20AC44C24FD4FCF64654FA4DB105215A225E33C02A36 DAE84DF50118A65AABFBB25AC03720F72A40E54F018A68FA87EF090F4C712478 BE75342E3630B80F5AD5800CCD4AE2F3518C02051D8F6B46C112FEC0F70EF500 B039FC2531F18800454784B58A10F1BAA94B8D785D528F5AEC12B5FF3981643E 591047D7858E01DE10A104C090EDAE2CCB0968BA0794E317071068F5EA8E40FE 6A034A0E74F026CBDA2C2B8D1ACDB2426B9D6555C3B2EC9052168B262771F68F F4070D10E605B2D606342CE8A13B5F03A4A7035DB8811279598A17DDBE067D3A 37A27FE79EAF2AE8129889F97D93D70FC5B2B5DAA105990416BCDF15BE7007D8 D7AB6CB75D69B019DB6A2B44A2DDD575D574C3C73046BD45553E280DE3CDCBB6 025C38ED492F1153AF48D7D3D3CCF466861A421B56FA0CF0C1AAFD0FDF67DFAE 40B3ABBFC37FAC65FBFC83BAB9FCE20BB459B757F0DFCD4FC13CCEBEB89EDDFC 0407D529D0DBEAEF4065BAEED097B7A09C871FF3E26CA59765DEE83316005006 7907225A966AA1D10EADD0E6A086E00E9A5A60BB1F8A56C17F5BB085AC00EB06 08083A82E104B5D4BAA936AEEA62B758A0764756837A46FE88FC4A4D48090385 F754BFCD37647ACFA12B024007D4D5EDF6BC8376BAA65AED966848B7FAD18001 B12E8094C65C5D4E4DD541A7573B1664543DEF6C8F1F4149B3615F361A581014 1380B2C6089B478B8C83841A2D5A70675B48B515562DB497A6C6F7BA43C8A019 DEEB7D123DD00964A2515A196A81C2CEF6D90699DA1537CFF27EF0AC4F94EB07 E53AF6BFC2DF19A8C5563C244D9D6D1BF108747EF658ACBA07F16C9F81DF908B 07FDF0419DB5C59F6573EB5D590E9F35BA05DD2E1E0086C0D0351BD9A5955EE7 502A5B57DB402AEDF3655556617F41E6860F1D10E075F17857C725ABC76D0C13 C8A86334F419BF0830133DEA333000191980A060EA2913A5EDF6C1D3D57E9B6F 8A65541A9E67F5D222F000438D7E4C1DE35101758CBD0496754F1E1FF4D608D1 739A606A7978331221610AE6CBBC5B3E78ED7C0516352FDD4FE26D45DCAC481E D4DE7C5F15EB35FC435869EC9755F667DD54501E547C4DCC4B5F3ABDA9B345F9 9E95B36FBC58AB89E3BAA99A1BC7CE3DBA83E1B6EF8B9A04D80D82140D3B6C00 E0519F833B9097A041567B6020E0D0A20B75F233F036201243F827DD83CE8549 C7B6DD0195487F234A906A8414FAD6839B55EED0DD8032A00B040014CDA6AA75 032AD7F9CD383634ACA849518EB185DC330114BD2F40DB5F8670BEA9C83B0457 A8510D4F6E406F376441CB42AFB813971F71FC1A342E366035A39A1B05E99EDC 09BE1235585F0DDEB11452FD75D1B484C862B3DB64D5DA5688CA03B551D6DE19 4E8C01E2C7F21AF40B3C0960937A6F00268B3F3EC08456CD05DCE128467BEC5B DA2263044C3EFCDC454FC32777A76307EC5EB362DF353DACBF6534BD8ABF8D30 28C8E3DC586BF7E4190C8AF50D09F2FE290C8AED7F0ACCC7A318EDF1A767D024 765ABDACB62773E8DF1A9E4EE45036ACF3DEABD0FE800AEDC738B41F5112FD11 C4F74F540D23F0F013203E3988D10E7F6206356DDD3C9740C89ABD5721FD0115 72884049213981404F928C2710E8B064F49F4A32F0738C62C714B2E860A9B7F7 DDC3BB319590009EA8BCAE764DF77048558D4BB7F4C7806CE8A4B9B0356A410A 2ED54DB1D4EDE714E1E4701CBA7BCBB26A752BDD60F4E5ECA8EDFC2EEA9C6813 AA04F39234574E26F9A2354A3633EEC095F9FD5ADD5C5F4FD5D7761E334DDA3F 314DEA9A9D3E6E12448535CC6EF571F4F15402E057D94A2F8B4D5E7A3670D0D2 E3CBB77B3537E3F94A5D9B11C2B7148323AC9B6B3509D0313D9525A9A90937F0 F55718B59C5A503FE39FD0A6AD9364BDB7C15C013DFC4505E47DC83F681F7F69 8BFB38E48F1F24E46462C6E0A83A8571D871998730A6E9A9D2107669D9546DAB 7002972C6C1B370D5FA8B03300E874E109BB135024CD223CCD9CA989E0128E72 5CEDA7C4D3C84452263996BEAC36F5CE85DE8359EA50E91FE536C75D18210E40 E102D975521C82426EB6FC3A41B41154E1A7589BB67F063C7EB495ADBECFBBB1 B1862001EB5FAB78301307024B5C593EBFB0A47FED517F3285C306042606A3BF 53C1A4BDC030A96E50B3E2A2424331C3AE52ED43F508862DEFCE5BB5D0B4EA83 337F2CFA6EC836B655DB691A88448E8876F05ACDCC9B750E28A9B90C4281A45F DFC95A18E448F2668FBC299F4F42B385F27BA3A612167246BEFAA3E8C2185B4A B843B0D0EAF5E5ED1B94D2F0CD1885ECFA2E93D17DB5219C678D4E4DC5C84474 B1D114459E9FBB8812FC3DB78125FC7BEEE24EF8867D21FA1BF4F97C187E6ADC 2313880A7F9D9BB894F9E7DCC5A7DC3043F0961D1C5FE023431F4FA914DA8681 AC57FC1EFF9EB05EE02283E17AAA9AE06A3886E12BB56AF247BBC8323D04E815 0B02AE62B647837FD6032127E6B33B75F60BEBCDEC6D500B571FA05767AECE20 60B8CF6AC4172EF8C1FF30FAA2E1E5B70C676FF89810C283173C685843443E61 44F78072FD41377B8CF5DFA313BEAB3FB7EE9209F93908A61554B3CB5DD3EC19 E455C802C1B306CD0434B1E300A37966F11DCF0E68583303C3F184353508620D 1AAAD4EB4EC5958B6DABB1545E9426F4AECE912A52F68BEDB2D19C6710889B69 10399444CE3E301CE8857A5D014E960F4C85A417FD1615E579C7AC854E0DC5F4 0D7127F9BA030CB86E20D2FBD03291E100E0B119B2E4264F8EE86EE51CC7824B 8DF7A4CEA01CB84E9E27EA6E7A64A230823EDBE001CB69283609502B7EA0291B E0125426B36F629E98E8C45CE607DCC9DE1B71777FF6D97D53AC8E0B212B5735 C7A17DE61F6F1B16625EB505548A77910C7A39736CEA110EA37FBEF8BD3A1919 C45918C137E1F247CD5A6B592163ED300F8106F4EAD34B308D392553D6F374BF C0DC9084396C837D9E0A09B5FE41A8035E85A89F4978523356ADF04200B2F457 093738086C57E5AC4F6086D0551B45515F4D323B44FF985AA1C106521889D4C4 767FAAA484523FA777D343848E804FAC4B40E27310AC1FF40E18A18459D3C055 240C320F5F30E90605088F8151090A84FAEAC5687A0AAA3E01BA46474625704A 10786EFEAFFFD3FFD5340F6B4E52B02FB5F347ACEE8508EBF509F1B6F8CDD46D 2CD0F060A0F64F576B42A3459A2CA293E1F0133992636ED4DA5D8267622B7AFD 1CD64B18633F9D0BE105E67336C419184F46BDB3997165985F4A5E8F89383DC2 BB928BF3BE783613BB0C88147B6FF2E6FD69EC6DE60FC8DFFBEC416372AB637A 14C7DA7C47F4B000141FC1D4BE550F94B6C646AE061E874696796BD203AA6D69 03C03861A69FB7AAE8F4A6152070CEDC740888D26A6C4A22CFB168E13A986081 A39797A89D0D608C3E99D99D7932555F8170DD0D15B8488961864E84A6458A8C 592D4A144AE5A3784A0C525EFC0BE412CB059EEA8ECA09B7EEF499BC8332A245 3C201298438B03036C22340B7D6C8E6EC061D6F03BD7747A1DC74D11A47FD373 C473388ED07F4EC04A4C4522B0EA18DC4378B7A234F3042307E9F6CD9815908E 556F1CAB50B78CCEC0C6156FA7FBEEA8E245B31CA3C88EE088DF0490DA8E9279 5303198E88554A622033E54D7ED2898212456022050A8FAD58D5981A6BDE36D5 6EBBCAAED5A40065CFBAFE18B7489EB85002756C45004E7128D6190CFDC24BA4 51BDF17CED39AEDF617AA73DC08809D244170DA7091F08319B8E39FD7337676C DFF2D3BBF1813172C0B27A69416934389A0E4D6A50BF588711458E54F9826F29 693A07146D31AC881989642ED0F2A0D053A400A6EF404A4CB4C2459EB2C51477 5ED8C24C6555E1081F0BB1F8F31611F840B649A389420C71AA2A556BC88E6A30 03958023D666B03E06F87583937653BB622CB691C4BD9CE203CC3E41F1DACF9B 37C957230B31F8F92930F7E4269419B34C50B3E45AFE104A385645D4CAC7D050 2946152DDFCD6BCFA649AF6DFF2287ED096ED99E750347369C01E01924CF92F6 DE217BF984E47F68BC2261788541B1818B1BD1C85342153FFA78F634E6CDE707 223CBB86C2B14F1BD6FFDE88C373CCCECB020F317A8E74FEF4A002FDE1DC84EA A15C1E15F3C1CAC2BCAA61E6F2807BE6CAEA913322EE1405AF8B56E65170687A 74BD01C1B404A74540ADC9AD008EEFD88FC1F158CAD990A825F0C75103D4053B D9096631D42D37C5095E615F6726973378C1FD77D91FC13B21CF38BA99301593 60950054C2974A08CE1A198910F2339CB8CC6DFD9B3B0132E5455F98A686331B D9D88B02B811D70F65759C574D6EB8DBB1891A95DD13182FB826B8FB04FD8DC9 AAA96ADA5A407B60C4563C4A6AD2252D05B4D13A0713D4F0532C9E2264BBCAF7 E7CC84D802F273ABEF116854E9C4E0CF912594E41C043F6E5985A111FF255657 12CD9FD0E2103AB2F03458AF4F9269802B927B831EC496F7FF8CEF87FB6833DC E54AAB631F0B81479DFA09AB8ACC30FC341A2E89F92743E618F443A824D61CE2 92961F3F292A9FC78B2C472FC7DFC44F0D994ECF6EFCC00C0BD774756D512AD5 046E27232BF5412F3B988100A639C72FA86F4C0255A4EFC15B6316E82D7D0FDE B265A097F83578678D03BD1D6411468388A6D2EC54C6515C13C43D840EDCB449 79375A6CBAA1B566DC91F8A0E5E48DE390DB21080556BDD1359098370B020083 C31F08457F09CA233BBC1BE0EE090BB1D265A1BF30ABFD0F74BCAC9FD2F566F3 0CB8E2BBB6A10D6EC6B75080AFA29329849173202DABAB3D4FF40AF3CF5048E7 546262CB82DA4CCCCDA9DD78F95C2AA9F158FA6B1ECE15A57586A88CEBEF71AE 892541DFED6A53494D0F22D80D05D10890B0B3E895F6DD89F518057247E1344D 278A3A5842199AF4661E17BB73BC6B12E5F5903BE71D2FB7C9D27E0B02651EDA 2C405C94B875A56EDF60229F01123A5B020C785CB730479B4BC0B791DB25E7FC BEEAEBD0A91BD27CE0DF99A0905CFA7A2382B4864FA6C3445F8F90305CE82891 90BF97387A83D914851B4DAA8A18FAA159666A3197987228398269EE0C7060D7 E1740635529721ABCC68AFB3C04F6A0942D4A428D113AB13FA12BB86C5F360E7 B07D3EDC8D2C9E07E587F3344C6DA36DF947676867E458E414A000558E478850 4531F90A26715ED8D2119C68F10C8901262D2317655767ECF6719486C3912E23 EF53258905228305DC06EBA158889DD75EA4AE128AE00233380FC65C5F4998AC 015836A2B4C3F4240C0689C7D4B8E410E063F0E9C01ABBDC71BDBA27E4B5EA0C 03B2188FF5447B3B0236F363446D76798DC1DFB2AD68BB3182A7D3124C38D69C C471EEAAC4A3DBDBC4FF672805F7C566B0215724D3D768CE47A6CEFB1A07A67B 3ED52BE1AA16145E48EE15602E3D96CBC69E3C27B13207CBC89C7D769DF07A2D FB275A50F1ACE442F0E9D4A54F63E79F903B77D4DF5F54FD5D2CA0077CE68187 39C2D4A7BB6D0A4F08C8C0E7B37EC12B11653227B7FCD5024DF678028F4F7F3A 817FF6F2701456618C5359A31557F99E9BFABF40D5C70B5445DD7B891FE319E5 7F78A02A1542D078F00FDA1252EFC4D276950F384F4D30FB638B53035C64C30E C1D378A6ED9874E6779CC970066E8D9A04337020A995ABBBB997A75889E575AD E9308CC11CC22808C0956D7BAA06BF4FD08887A22A7F03C1BC97C4F212A8B9E7 5375800ACD5637AD9DE783B9F0137ACBA9ACA5E19D70BAECC769BAD8E8A511F0 31C27342A91EB6E61F2FB0849F431C2670E43D19246F569E16AB4B4D80901A49 5372C07E0FB5D4FFBE98D728A0016AFE3F8B7F914A0CCE688A5C2B1A24BB574B AA143956380EDCEDED9DA91F6868EC31F52003E065804776450FDA2B942C318A F621AF41C4F0102EA8AA7EE0DFD6CAB4FBCDA22AED7622516BBF31B349B7EC0F 55F181C1EE58C568B6490714F5C3738978C5BDE7FD31F0A7EEA259A6CD2DA47D F5F33B39C1095E785569272D752790165A694130935B55775737A365F6AECCED A199E578984BCCFE9E77DC8F4B54E8ED11A1D85ABE41CFA17D31F47E74D3F7F8 7EC760D3B74C44C4ADDF322BE7C806F003A991A1AE3CB2195C36E9B6844BE0FF 3D1BC36576D0607BB81CEBA7DD241E7422D82A2EB1167761C4580DBA364A4121 2B82D50E6C1EA7B4DEFEA4CDE3812A71654FE5DA017FE216F200E0D816F24121 A7C15E8F12F680BD07CB25FB91DE4E3E68D1EC054F8F3E05D86E2A4FF2C700B8 DD692E2B5F85427411F2D26B4FB9E772CF481F046A93E864EF783075EC91243C 754C9B9A174D350F4E31D17CD9C97CE210945EBC36C9F583EA26831EDDAA647D F13E05A04EF9D3D1ACDCA0892D6EBCEF3304194EFADAC7A203A36AFC88D8B12F 9A25481B7CE674C8ABF90DCD581FE204AF1CBD66FE3010FCFD3408AB22DF60D0 C442B0BF9F0685D5AA180CFD7E1A8C7FA514400FC3FC7E1A103E7C5A74C461F5 664CBC2238ECBB0E784A0670FCDE8DD8B97AD0F96A5857BAACF8E7ADF5025D48 C56D92A7F7A2E7D6ABC52DCBBC3EA186EEE5C0731CBA83662FBF3BB440F09943 A9313796859EDEE8AEE6791B465F9B6ED805F376868D6604CABDE20AF4E6227C 33EC37B276D84CDC7766999775DF058F3FEA680860AC70B8C2951BD9D5FE2E00 968E36D8C2BD6950D61AA28D565C42BC99ADA3E1606364920C3F0B9735B704FF 341DFD8056E0DF0422534AB8C6814DE0EFDEA0771AE2E4489D8BA80EB79ED2F6 1D2D3353799CAB48341EAA7291AE3282798F0D8377EE0F3711AE14480DFC7F98 7F36E6EBAADCDF575B83108309468B453EBD1A20BF70DA76B008E3E7ABC14AB1 7FDEE00964923267F81B66FCB8C24E5DF6EB327C9F41189838F3E903620547F7 F5A018872EDC396CDBDD66A1299E45D3F716CF99C7C882397D7F34E9B88129D1 8A2D65BBDBA81A0FBAC70ED3DE4F3E2BE55635B743AEC1104C3B1BB832F755B9 0AADA71E24685765F1218C082E1AB9D2C1B8DF860F1EC1A50D936BEB5D539721 9C0F4555EA3040F8FE217F5F0C1AAB1EB7830EAD9A7C113C2A75BE0E1E2CC103 D4616B5D1E82D9E4F718090B9E6DF30F61DCB86A70E939F412FFB40B2B61F8A5 ED06B09BAA4A4E072DE5ECF6065CFA1607F7CC68B66B0B81C4B8AF89240220BE DC8A7764ED9A4A23BF5CA8610EBEE81F32930F319D08DA38CEC48872968BC5AF B0CD83F90947D75AFCA9EE42398DD432EED1C4E20D7C7E402ACEAA58C839D74C 0E38A1AC04FE83FC354F0C507ECDD1BEF0090FA2273CE7B0B596D50EF9C01390 F681E0DC5CF92040DEC16476A5EF1BAD5BD554E69A03195FFB37323B2DAF93B9 3D6D5D55ABB65205DE81516C776D444A4406116C3E101CEA14FD136DE1C47936 544BCFAF815E48243BE9236D131502D9E5ED2EC882D15B545C182E5F623EE1CD 4F1015D304BB3A5C99925FFC88825FE9823D53BF2DF89CA1E8FD9EDF2FABD112 497396E20A3A4E631A2E1C052C333CB00E3FA90E4F1A28FC662ABA7D9BEAB72F E67B1F176439FAA86318E933B0CBF5299DB6E50EF59AD3E5FECAA87F921C1F85 F6F62D1EB7BFD46DCB71544D5344BFE86E0EDF7777ED94459B58E4C5F5F5EDCA 39132C98E9E856F37A66926A85AE43CD972CDD43E9E6F54172E1676F8B1DA216 7E003FAF0F660F87C47A3DAA58F7AF131C4608C59C3A73F1414F21E13DDF72D0 D12D36F64603663073E3D44867C7D92BECD56BEEECD00ABCE68E8EF4F3A84133 AA32C14407AA5BAF1819F1F54855B3BC0506DA285A32C16F0E9DB72CD423D51C 2D192ACAC3655F8ED831C82172EA5860F0730A5EB1B1A85882A02F20E658D5B2 AA5654AF4C9F3E67924775D354CD3BD5357BDA2F600DAB9F808CAC988C34CB79 F396F17943A7D99D4949F4C97E702CCDCC1C28164BDF79FCAD0997D1F7B8BAEF A85D5B770F06DE67F8EDCEDE66A368CF3ECF0E3157CE46D95803E089D7AC59DD A5261CCBB6A7455A28F4A1E3116DFD026F0873DBF9D7F6CA935D8BC8C8FD9D6D 04C104CCA3F5E933B7A91ADFE39D2734B1E3A70868596DC187DB76624A1886DB E7C64F1649CB0EE6E09D20F5D1F382CD749ABBBB4F3009A6B9ED7119C8DF7913 6CEE157D8CA96A2AD8842B40F6D70428C98A32BF251C7B169CC26BCF763E7D59 701CF2450AB23D5238D5C018331EC2AADDAB43076744200F0F9B4E1DE60E4ED5 D87A5918DBC06333FD622C6A7977CDCF84CE5B12F734E1F59C26A78281F7630C DC2719B83FC4C0FD3106EE4F66E0F135CB00D5FD0803F7A30CDC3F8D81FB5319 B81FB259BC1ADA3F8F81FB218FC490ED2AE14762E014560F8F9592964EE55AFC 6B58D7ECFC8FB88F32DF3902E658C4837CCBF5D40294FA43B1A645161B5540C7 AE6B005ADED9CBFAF063088A70E39565936AFF3305B8C44F8A6F5096D1C76429 82C9331E194AA7D562961C58EDC7143E831CBE093662AE36C8602AFF663A2527 1C26B26364313DFB5A71C7467BF6A4B62FB86D15371E10C8D3E7FA24FA88A8C3 C7254F72C88CC123EC3CA842031F192EFEA153B4FDD59C6A38EA1FBEC5CB5629 EB30BAAED9ADF6D9BB87BB4AF923B1FF50E8C7AB6F9AFCD1E7840DB7062C37AB 564483BFDDD6BBCE5E348D773FF364115A188DFCF262B44B52B3D95E31798EE4 567DA73391C1EF2FAB94D7537249652E0544C4E1D61ECA30E4CCBE636958EEF5 D83E343FAC4FB421CDBD90F75D0E639BEE8BDD1D3B009ABA03133FFDF8652307 EE21F1D7460EABA49F377CC9E34F7C9410BC68F6A9870331218203238CAEEEE4 1E251E46B7737249EACBB58037781032EA8CCFCE6FBCBB6F3977A6BE90E3311B 40AF3DC1C28B3F6927D83A5FEA2BDEE91C28028677F365F010C3A7748FE67C01 33E150796EC187C27D23DB2E6BF36D9BB5BA29FCEA41026D83DB4617652E963F C2DB45EF9B7C2F38C7DF46DAE885DB4E831F7FFB685B941FC45A89BC83F4CB37 97F49FD8C2175C46FAC59B67F3D5F3B877701969F492F9016CCE40F20C31CE1F 8233A74FC902FD46AFED3E11BE73BBD9953A3857F47774418739DC0DDF9232A5 ED48AAAA79BEC79136A3B74FEA81284486226C96D388409FCF40CB9F1B1FF61C E78D93E8D2A204AAA7EA3FE3702156A7438273F2BF8675E2DB9000CA0810EC47 00E1C4BAA9C6636E48D6359C811857733416861B945F549D0CB887FB117A926A E2F7338BC8082DACF3D9AA8CF5F9B93969D53C84665B3528BF0FCAF32F732A9C 2D2FC4C13D46927292EFFC9C8FFA9B0C8408C9776E6E6611EF783C7729DA2214 77469AC58892A730EC0F76A03FD081FE651D0871466C0EE8E21CE3188CE5FB04 0B0C683456627FA8046E541B9D5A4899B45B4342B1A43D082C953681838FE2F3 1B073E630E25058B45EF4862E9686EB3A3DA378996DF40C30426DCDFCC7871B5 01D514C6E3AF515B77B87669F6BFBB9CFA6C906561B6975A5D42F7B611287FF3 DA68D7FD0168A2B4806D36AD3AE8E6B719863ADFD526CDDEECD298D3968ACF60 2C66DF444AD2719D9124DCEF47E56D16508DEB230B0A1C25B9311E5D3C559F04 5B6F6515D763DF0989520E7F58D1373FCDA8CF4DF21E7522D8240242456E35BD 496C048907728011DC4E0CC70AB61BEE4DE8CD4FA5FE2AB4ED3C7C2578F84862 8BC7C221552A60FC42FB3E6561CC521315B70B4AAEB81F7B3350DC01A00976C8 75C62431700DDB03037A2AA3423468A7BAA92E5F6D24C54594BF6F568E6BF902 01ABC358589D0E9B98EB056C576C89A9D4AD12DAFE20B4FD516847CDD0E4D821 E0D348ED8FDBA8C93E009600C11E961D1DFD729C8E6E178D54B861CACAAA7BAE 7819E0B3D01EC1F44AE00CD3525830DC05DC2638404C91B4DA34159330F23E80 013F8FC2E8837EF4613FFAD3FAD107FDE8C37EF4A7F563C13EB7A5943FBA02E1 F85FF161B13CBDB18DF389C6465CF93C188B7D357147DE48EAEABEF3268DD670 DA6A43CB816DD159D5837319FE7A4CEDCA06EFB8493EBB86D2EC518A6952E726 C3522B6D8A76E9FA82C0F0C150F7C3171B3502F08325B7762986861B521D6268 77AA836994D2E1FAF0D4BBE1F373F3D31C9E1C10D1EB55DE9FE874ABD9AE3868 C73C9EB214B94E792591EA96C093A301B6C166CA636B68612DB010E6392E2D0E C66B0D0C42C5EF4F07EA162D0D648F17CB4C440BDA14CCDA591A02B411C661D8 8716C277D13022732B4DD6C9BFB0679471F7C2E248A7B8CA563F8A2AA303C212 B6A81CD0113FD63A8A0921314E5F4A7CACA3967204BCA395AAE9FD91945B5C8C F5C59BCDE44B63D512EFF607DE1D74D10F7AE7CE26A4DFB18E4DB6385EAF3F50 4FE8DCC45B67F712EF9CD24DD5331A35F14A68943415ED3BB34CC00BD4B817D8 AE40DFE3325D53EDEE1F5CB414A3BE112CABFB12CD582D4BFBBE113EB644AD2C 340CACED78996E5BD11159EBAA2CAB478C4A17712EC4C8540A3F2045726A15D5 382D3AF3DB46D7B8726ED622298A0DD3245A46C7845017D17E125CAFBBCDE90F 1695A6195C93C2549F5D97EAB74D78C00A8508B13399281D0B9582061BB5C285 9EEF7EF58B7FFEB5A88FF47BE411EC3907A3B5012453DF152ED63649033A7C85 E5CFE137676C20D967B633572BAD6BB5C0442E5A04104B10C3ADC2D43C823D14 91743EA54D0A21A8302DEEBB265FF2711972D77A70759BEC3E1D4286693AEF3C CCE15A28F78862B034DACFD41937CA87C8982624AA373B78BBD0AE69EECB84D2 EEA7678706C658E3B316A4DC48DEA0C074B409FEF91BCDCDC6F76AD7B8950D5E D2A1B381D9D2D0B85EDCD630330786E0D3BBE8141919699E2A71DC8C88321F48 82960047CFBB247C3E51D039F62A64FAC901555F8699C7F106996A35D1EBB536 9C8BE7B934FCD62F34E3111833D30FE2761FAF0A3944B4B4ADD8A7A4B62C1BE2 204895B7F61E11780D92CEEDA3AA894F3AAAADB059199132E46F69B67B8367C1 319832662FCF2A5DBBE0BCABB99F893352A39A839111AA9271B00857E16BC9FB 6B73C1F5638E6A91051CD59D55E3D682E197AD51056223C55B65AA1871D9B562 29C3E4B1D1E125F38416F9FD365F94B4E3C574B5DA6C803AED59423190987698 6D06FA86D77E3959CB29775A8AA56944B34BABEBB7CE90D035DEC64E97F91E2C 09F2022EFDFA83A8702889BB2CDE9A84313E1F81A6CF3481C27B6B0A770C7678 57E6DA141CE8D5038B92A6BB350CA12F3679A7C1B75802A1CD693D0C6E509A77 11E1DD356002F0686122E0C30DB9D974DADC0207FAE3CB37E072F6183602C6D2 974A7D4FA90EB4903F046986B329567864508982FFA5ADDD151B9380E73732B9 D6DBA877787C0D6D69401A59D6A2815C26D0323C9676224FC1C4136D3335F912 D363CC7198546B3A1D6E050E6085E9A8F695BA1E9C52101F72E429E5D56BD514 F705A660583853E6838908B5C0AC907EC57D1AACAC26181E4895558B3FE2A1AE B6CF8133313C9872D9E8BC33A7743247436DD46840DA479C2DBA84895850F163 2A2562FE64BB8577109530A8B8EEAFA357B8EB57EEDF090019959BCE8F22499E 4FD8B425926413D1624FA6275CFE66EF4A6774BFE252F40FE58A6CA0F5227337 A19F7C91903A93FE1752AED4401E0FCEBB41BC7D2771EBB9C853F15152791749 CEFBF4CF0CEDACE26981662B4DC93945B08D9042F789E27CE61F2DB1DECBF20D EE3612A8C29F6DB49F911472C9474AE1A05B7FCAD26E410D8CE6B36C9B8C7B80 131DC21F4E20B69AF75702F3304E0D1C2E556C4075545D5E66D41F6FF4F0A561 454C0532954CDC14277DFC529E5E2D72666C57664EA5D0CFA4D7CC7899B37DCB F49F7679F9CE55335872434B24DAC5A6F03B8228BC67322F6890B7389BA0156D DAB515704EC8D2412FA91D8F2599A4811FB9A1CF9235EEA7AC2F7E247710C6DF 1C216703CFD4CC06860B61F6742366EAF40E43C71BE75C2C2864F92556F6B7C2 ADA2DD47A35992714374DCF189EDC803F2718FD36D0A2F82516781D204A2A083 92621BC3CC76BA17B2267EC2C93D63D2B06982FFACB08564BD32D09921E2E808 3D36B3B34499544AA968C90AC4A9DC7B881D044A462891BCB5E04AEA994C7D39 55EE92B1D89CC42AE339AD401303FF2281A6C3437180D3572944837ADE50AE4F 807EF006138C264CBA7DADDF193632A3C27B7A79E68FA9AD9BEA83D3E7617DAB DCD9EDC3DDD9D2004E68A78971CAAC3D90783B70136724D3B113E74572AAB8ED 09E92CDBA9E921352BE5595AA18B31B32351463324DA654372452292CA467FD2 20F8DE7176BE8CB29A42054C703E45FC126E92F1195CF36C3ED55BEFD0BCBA7B F55FAB2C8BF4F3A50000 } view quick-plot [ 400x400 line [1 2 4 8 16 32 64 128 256] ] A complete tutorial about all of q-plot's features is available by downloading and running the "ez-plot" tutorial from rebol.org: write %ez-plot.r read http://www.rebol.org/library/scripts/ez-plot.r do %ez-plot.r ---Drawing Charts Using Raw GUI Code It should be noted that creating bar charts using native REBOL GUI elements is as simple as drawing box widgets, each sized to the numerical value of items in a list: REBOL [title: "Simplest Bar Chart Maker"] data: [12 3 9 38 1 23 18] gui: copy [backdrop white] foreach val data [append gui compose [box blue (as-pair (val * 10) 40)]] view layout gui =image %./business_programming/barchart1.png The code below adds a number of features such as text labels, randomly colored bars, and a 3D look using buttons instead of box widgets: REBOL [title: "Simple Bar Chart Maker"] data: [12 3 9 38 1 23 18] labels: [Jan Feb Mar Apr May Jun Jul] gui: copy [backdrop white across] repeat i length? data [ append gui compose [ text bold 30 (form labels/:i) button random white (as-pair (data/:i * 12) 40) (mold data/:i) return ] ] view layout gui =image %./business_programming/barchart2.png This example adds variables for auto scaling and sizing, a gradient and colored grid background pattern, and vertical bar layout: REBOL [title: "Simple Bar Chart Maker"] data: [12 3 9 38 1 23 18] labels: ["Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul"] height: 11 width: 50 gui: copy [ backdrop effect [ gradient 1x1 180.255.255 255.255.100 grid 10x10 220.220.189 ] across ] foreach val reverse data [ append gui compose [ button random white (as-pair width (val * height)) ] ] chart: to-image layout gui gui2: [ backdrop white style txt text bold (width) tabs 20 across image (chart) effect [rotate 180] return tab ] foreach label labels [append gui2 compose [txt (label)]] view center-face layout gui2 =image %./business_programming/barchart.png ---Creating 3D Graphs With r3D A tutorial about the 3D library "r3D" by Andrew Hoadley is covered at http://re-bol.com/rebol.html#section-9.6. A nice business use example of r3D is available by running this code: do http://www.rebol.net/demos/BF02D682713522AA/histogram.r The following example demonstrates how to edit code in histogram.r to create 3D graphs using a block of your own revelent data. This can provide a nice flourish for displaying data graphs in presentation settings. You can use the "asdfghqwerty" keys to adjust the camera position of the 3d view. Simply load your data into the "graph-data" block: REBOL [title: "3D Graph"] ; Here is where you put your block of data to be graphed. ; The first column contains labels for each value. ; The second column contains the actual values to be graphed. graph-data: [ ["Jan" 11.0] ["Feb" 22.0] ["Mar" 25.0] ["Apr" 55.0] ["May" 35.0] ["Jun" 75.0] ["Jul" 20.0] ["Aug" 33.0] ["Sep" 21.0] ["Oct" 55.0] ["Nov" 65.0] ["Dec" 45.0] ] ; This compressed code is the r3D module. You never need to touch it: do to-string decompress 64#{ eJzFWluP2zYWft5/weYl9gSOTUm2x0a2i23aAQq0m0VTZMcWhEAjcTJqdKskq2P/ +j28UxSVmXR3sQHGEs/147lQpJRffvju3U9h1PjpIktJ2WXdeY9C/HqFVtbfV9CY uZo0bU2SLuvJHt2fyiRMw5QkWRHn30RR2JD0lJBne3LJLFHKvDF3XROXbR530tmt dnbQt8cnINwOABwG7o6jaTLHbRLnX+/0djSjw4hydM2aO22qDqZ6O3YbhW1WUga9 wHSSSoz5DVC+EHghPFsw7du5pLOR5D4F6iBAHWxQBwHqICwdFKiDBCUYyukwAfJe 4DvMNeZx8CxUR4HqaKM6ClRHYemoUB2HqI7C7XEQFqX27N5goO7jhCzSrKH9UZUC 2/fvbsK7vEo+fxOdanm3hEuco8f4MWvRmf1e6G8UssseUXNl1cCUspYgsMFlbQYd JU3VtnVTwaw6dKpRCsLnZwkrszImbLDEXB2uF3Gls+Q8T/A8wfMMni94vuD505Gq Ibw0Rovq7jeIlggVH3yUTBksOf7YVR/zqvr8Me4mIwpTimjI+dzfn+5gBYGZOkwg yxv6DyNPww7R/y9H3gIJlKk82JLeZFZsSd+doyJ4LAKRmQLLOKPCs0LekPaUd3QN pFfaaPU5jO6rhsTJQxijO5SgFPRwGNc1KVOhIGc+i9EVGF3i+avZHb9dw23Cb3dw mwoBfy5lPS270bJ4ZQgHStjXwltDGBvCayUcaOFrQ9gzhDdziA+fswhT78swqSj1 E0HqSFHDvYzSUzGTIRNqg5j1KmQ9C0jC7mC2oBllZb/4Yy/kZ/y5KozAHF2JUGwM dpg6+qKY9zwxf0KMQmpId2pKZAdzETdNfBYh7UnTZQlpZTyLwBlZROXI40QVCi5S xpyVqACgIpD2ojHGpCqgdchCN0fcNdkjNHo3kfSkCBY5gQcC/HzqHv6GtAbK7pFg o7+iVSjdGTu3QZEYqpCogTIOh1hh7oybIU9JYRUf1eGozpLPJiKuIyc8mj7bklkB eGJFEPEtAHGxXMPfDv4whBmKqFhu6GBFfwL4odQtHVBZTIUp9ZoOqDDe8MUJSgp2 ok9iQHWcNS3kk5YgbaCUAC5GNGHRkqe2uZcr6RlQjeiBQV8jrRuwaY3EfU02pQ2y adCPFFIFbzZjcJdcky53fByw8VaN12x8PZ8vpIZnafiWxkZqDBXWSmBrKQiYpg9s qVxbKjvbh+9U0CBFhEwfgROWoeLZTjaWxs6tsTWcrC0VMdcRsK0dLs+Kr2/FNxhF y7Ny6Fs5DLQLUS5WtHxrYsEo6dgKlm/Py/ARODU8O1imE98Jy7NjZThZWxoCxkjF N7xsLJ2dGxioRHZHc4DXbPW4EiuKZ9E2irZFUoO1riW3VjQtp2naytpsXvGA0QuP s5txYJUCXlu1ALuNUW4Dq+IMpY1SsnR8K714VOkDT9jWura1diNP/oROYOd44CmY wBfYaTZdbWyl3ZTSetTieNQLDoTr0bSwHWNdh8LVauzKqFUpY+Uba0c7t87Ojic2 /GxtcHJKNrqd9rO1ochY2evSziwIbMv4bnQrY/HCNrq1pSPRmqHbTcGzMwDwInic 72eiFWWrsRVDNKWieYzmD2g+owUDWjCnJuWLKNIh937yUas495KzR7AK6vPI2NCZ OydzR5VWnTgXyj2vPm31T522hL8esyD0/BwFI4+PPD7y+cifR/ZR9E+7DA0vPqRP e/HmxgBzFpaCxsDjLE8KOjabfMMsMT4LF2p/P8UNWTRV1c1mPXfGo8Jd8ZhwfOzh QR39PU2Fl1h6ubPcZXCkmT7scjZWW/wYuc+7M7bdjpk4LWg6uuMjx/zlC4z/A7bF U9h+hpuszs82tlK/jPvfobtCpQPS91kPp6avAoTSrLdBwbGKncZer8J/NlnZoRfc MLo7owtpKhR39HjbkfSFPMPGEdiR60aJ/vy0KJzxxNSrpCdagZ0ydeOgHpGseyDN TJwv53KmofHKJxq1Nu2aJUVOu0Xd+fzOdSauaZgch7EodLzTYMKKEPFhZNhR71P6 kR1Ecohqz22wgdL/BUJLGqH5R9XkqdRO4oI0qhxg4fuNv6HV/LKP2/fZhbCjoX2G ZOs2fR/A7zzY1lUpyfkvcwSMLC4/5aS1S0kxJIFj+ZEfX3mu9FkWcS6SkwUuf1mH +HyYR6b0jpHpgVqB2Gtx/jowqfKqMaV99DOVfsucmK8ABqC4yX+JecGEP8DUlbR8 PcOlJACJO07oTDnLY8Mfy/uKK7+N8+REv+XcAPkfrKBb7YDrygiP3ekk6PzJXbYK MtPideClv0rqos2KOicqe9yTBId09lXQzLS1VdMtG8JDoz3JFEmKZoX3WZ5TMycI vqTC1sf5zukl0GZaAZ5J+DXsfSK3MBVcAANpDUvypcIzpCsc3hTDn2IEjn535XLi hR2LtvvlTErq7qGnZdBj2AKg3kd9V9SY/cIwqVEeN59IO3psKE17Y0a98QTDlmbP 321JRIy+pJ6cDOrfyRCoeE228pMCxSuQ2hyfMZN6P37xb83P/lBAp8zTsKzK/Kxe bupI7NECr+AfLN3wmGL7rG8lL1QylE4fY3TL5eR7gu9P8IEuK0tnSSZDvi+1ssiX 8HH7vWftJ8qDNSFkqyDphy9VimzPyTUaevUt7dWwO4H10ZpNn8+yFXpeFhkAe0RV k33KSiibU8kXnYtdXFxiPzMWhit4Tq7n94NiFwChoIxqpNSMUj3uAbYEyFGb9Jdn XVScYVpAk0aFgM4CZwvrfPCKegELRw6AW4bMQoYZGb1Bq9AMiZyq8XlBRUt6Urh5 3KihsBdoHFkUYi6LYqMjIv8Kxe2C5pBuy9l2nCX7ApXN8wESq9fYZWkmkw4JYaJz R7OYCoMvNT9Vcbp4d3Mjvzbe36dxF09/TmjFk6I8FR/YEG5uJOWHFFqBifG8Aonp QFC6h6xlNNEvqIDjIjwwL3RNjcK/QFaEb5j/m2/RS8AkNjQvvqNgUAYuqg7FJQIW XezJC74GwzZHotkrIx51Lh69kuZTGqEYNU0eOmXye25GLKBcnw/UOsA+iEMt5WrE srxHa7BVk5gHSkUoNNPBQyhfyYFOVy3ERpzveQUubnJenJ+QoFU+Ly5PS0FBCZSS wtY6yIJjpSseGe/s5J0Z7+LkXYTNNypAoY6UsurmSrtu7iUSsZWFxdcMWWE3VfMr VBitRNGNwwAIZai1mcyLoQJN5s0HeeJFLg/1GMI1EftpHvh6lgRkxk4N1XDAjOwT ie7HmWyrhYoemE1Od7CDZvvjMGT/D0b8V42IDRZqtHAMB6Liz9DDQz080GPfy8Ej tMQGdNAGeVHowWVLL1uovdCHyzW9XKMgCgO4rOlljXAUXgNvQy8bSsTIowoY+SAZ Rf8G28Udt8glAAA= } ; This compressed code is some initial preparation to enable plotting. ; You never need to touch it either: do decompress #{ 789CED564B6F9B4010BEF7574C4F6912110763471187F6901E7388A2283D581C D6B0B669318B96C5C1F9F59D7DC00EC458E9BDC896601EDFCC7C33B3000090B2 3D97EC45B2B26E6308A2DB9BDB2F30941F8DFC84E23D867039943F0AF187298D 343FA540A853620DD407C8F2BA2AD8F191AD791183920DA7E25756349C885351 8846F2CC98D7560146F3266491C568501D619518D196ABE0C138C4B069CA1456 D6D4E033C58283468755C6D37CCF8AAF49AF9D152265056468606409AC7A5DBE A1CEDFE10E2B4164C955234B98234391FE4132E9B11C7A20154BFDFBB44768CC 6F90C3332E8BA18B0D323FEB120D5C969FF0980F3C4CDD37E1D94AC281073E8C CA208AC80E88D53515C2F0AE8FB41FA73A6FAE5A31696673D10F9BB97899A174 242C9BBD491167AAE0E556ED7EC056B26A17E8ECBD599B36B216384F169C286A C5AB18BE1974089C1E2E61064A046EC27C14EFB866B2C659E3DAD780C01556BF 44887B64EAD21B6E84E42CDD6100258F2439478537D497E73CB60EB3F947230C 1DEC45C60BC7A08CB260BF68F70B73A7F4CE17487A57B46E8AF96BADC9B94FDE DF90665F414419EE228AF56F9E2A8CC6B326C5ED83B459739BC72823B2C01437 1962B2AA42CEED1478501F696CDFB7B02BEBDAF1EECD88873DB72C3795A87395 8BB203065283313394B5F4E1481FDEC7A94C5F236077CEBAA7C21EAE83A77FC0 5EF58D0CF19F90BA9FA4D0856189B14942D7CC655D69D9819BB38D34F41969E7 F245E6ACDC167A71A411B84ED8E408A4DEB836BA230079797820F4E22306C351 5838676F69E8A3035A79587473B108F2064AA1466F0B2CDCCD8A1C668E8A0B94 C3DB2EC7694F289393FB3EBD8DA32D2B74EC1DCFB73B455FB824D3874F66D9CF 844996EC46B7E0C9680610FB2779BBD233B3E395B7EA976ED7931B6DB29674EB 491127E6AC4E25E72542F41D3A44B665268099876E77269C51DDE2D702BE6DDA F0FE165792D541C572E9D5B390DCCFE1038E23ED798A34B8D0B9D0708EB7104E 9434ECDADDB86B533CBFDA0F8AFF3C0F78C61760AD645E6EFDAB283943E7D401 7DF27CB64BA2BA3CC817C387E3A9FB40F80B7F5D1FA3080B0000 } ; The user definable GUI layout goes here. If you want to use other ; key controls, or widgets such as sliders to control the view angle ; and size of the 3D view, put that code here. The "cameraTrans_" and ; "cameraLookat_" variables make all the adjustments: out: layout [ origin 1x5 at 0x0 scrn: box 400x360 black effect [draw RenderTriangles] across text "" #"a" [cameraTransx: (cameraTransx + 10) update show scrn] text "" #"s" [cameraTransx: (cameraTransx - 10) update show scrn] text "" #"d" [cameraTransy: (cameraTransy + 10) update show scrn] text "" #"f" [cameraTransy: (cameraTransy - 10) update show scrn] text "" #"g" [cameraTransz: (cameraTransz + 10) update show scrn] text "" #"h" [cameraTransz: (cameraTransz - 10) update show scrn] text "" #"q" [cameraLookatx: (cameraLookatx + 10) update show scrn] text "" #"w" [cameraLookatx: (cameraLookatx - 10) update show scrn] text "" #"e" [cameraLookaty: (cameraLookaty + 10) update show scrn] text "" #"r" [cameraLookaty: (cameraLookaty - 10) update show scrn] text "" #"t" [cameraLookatz: (cameraLookatz + 10) update show scrn] text "" #"y" [cameraLookatz: (cameraLookatz - 10) update show scrn] ] ; Try changing the variables below to affect whether the lables and values ; are shown at the bottom of each 3D bar in the graph, and whether or not ; the data is shown in color or black and white: DisplayLabel: true DisplayValue: true ColouredLabels: false ; The following 2 lines update and show the display. Don't change them: update view out =image %./business_programming/chart3d.png ---Using the Google Chart API Google.com provides a powerful and nice looking chart generator which is freely accessible by anyone, at http://https://developers.google.com/chart/. The syntax for preparing chart data and displaying results is dramatically simplified using the REBOL script at http://reb4.me/r/google-charts.r/, by Chris Ross Gill. To use it, just include the line "do http://reb4.me/r/google-charts.r" in your script, or paste the following code: REBOL[title: "Google Chart API"] #{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} That code enables a simple REBOL dialect to create and display charts: REBOL [title: "Google Chart Introduction"] do http://reb4.me/r/google-charts.r probe chart [ title: "Chart Example" type: 'line size: 350x150 labels: ["Red" "Green" "Blue"] data: [50 40 10] colors: reduce [red green blue] area: [color solid 244.244.240] ] halt The block of chart properties is easy to understand. Edit it to include your ownd data values, title, chart type, size, labels, colors, etc. To create the chart above using the native Google API, you'd need to learn how write the following code (paste this into any web browser, all as 1 line, and you'll see the chart appear): http://chart.apis.google.com/chart?cht=p3&chs=350x150& chd=t:50,40,10&chtt=Chart%20Example&chco=ff0000,00ff00, 0000ff&chl=Red|Green|Blue&chf=bg,s,f4f4f0 You can view the results of the REBOL "chart" function using the "browse" function: REBOL [title: "Google Chart Introduction"] do http://reb4.me/r/google-charts.r browse chart [ title: "Chart Example" type: 'pie size: 350x150 labels: ["Red" "Green" "Blue"] data: [50 40 10] colors: reduce [red green blue] area: [color solid 244.244.240] ] =image %./business_programming/googlechart.png Or view it directly in a GUI by loading the results into an "image" widget: REBOL [title: "Google Chart Introduction"] do http://reb4.me/r/google-charts.r my-chart: chart [ title: "Chart Example" type: 'line size: 350x150 labels: ["Red" "Green" "Blue"] data: [50 40 10] colors: reduce [red green blue] area: [color solid 244.244.240] ] view layout [image load my-chart] =image %./business_programming/googlechart3.png Changing the properties is easy: REBOL [title: "Another Google Chart"] do http://reb4.me/r/google-charts.r my-chart: chart [ title: "Chart 2" type: 'pie size: 500x400 labels: ["John" "Paul" "Sue"] data: [35 55 10] colors: reduce [orange purple pink] area: [color solid 225.225.245] ] view layout [image load my-chart] =image %./business_programming/googlechart4.png You can include REBOL code directly in the chart block to perform calculations, format data, etc: REBOL [title: "Example by Chris Ross Gill"] do http://reb4.me/r/google-charts.r clipdata: {Adsense Revenue^-300 Sponsors^-500 Gifts^-50 Others^-58} browse chart [ title: "Revenue" size: 650x300 type: 'pie ; extract raw data data: parse/all clipdata "^/^-" labels: extract data 2 data: extract/index data 2 2 ; format data and labels sum: 0 forall data [sum: sum + data/1: to-integer data/1] forall data [change data round 100 * data/1 / sum] forall labels [ labels/1: rejoin [labels/1 " " data/(index? labels) "%"] ] ] =image %./business_programming/googlechart2.png More information about the REBOL Google Chart API is available at http://www.ross-gill.com/page/Google_Charts_and_REBOL. +++Working with Other Web Site APIs Chris has created a number of other web APIs that make easy work of interacting with popular sites such as Twitter, Facebook, and Etsy. A tutorial about using REBOL with the Etsy API is available here. You can read more about using REBOL with the Twitter API, and simplifying the use of Rest, OAuth, and other protocols at http://www.ross-gill.com/page/REBOL ---Using the "Nano-Sheets" Spreadsheet App In the introductory demos section of this text, you saw a small spreadsheet app titled "Rebocalc". This application idea was extended in an article by Steve Irvin and Steve Shireman at http://www.devx.com/opensource/Article/27454. The resulting "Nano-Sheets" app is actually useful in production situations and can be improved using simple REBOL code. Saving, loading, printing, and other features are already available in the Nano-Sheets app. You can create your own functions that use any of the features of the REBOL language to process cell data (math, graphics, parse, native dialogs and GUI interfaces, Internet connectivity, file and network protocols to connect with data sources, etc.). This program and the free REBOL interpreter are so small that they can both be sent easily, even by email, to others who may need to use it. No large or expensive office software installations are required to run spreadsheets created with this tool. Here's a slightly modified version, with scroll bars, for grids of any size. Column sum and row sum functions are also added the included abilities: REBOL [Title: "Nano-Sheets Spreadsheet"] cell-size: 125x20 sheet-size: 10x50 window-size: 800x450 scalar-types: [ integer! | decimal! | money! | time! | date! | tuple! | pair! ] protect 'scalar-types sheet: lay: current-file: sheet-code: none cells: copy [] sheet-buttons: copy [] use [ buttons== cell== sheet-code== id val text action face style ] [ id: val: text: action: face: none style: 'btn buttons==: [ 'buttons into [ any [ set val word! (id: val) 2 [ set val string! (text: val) | set val block! (action: val) ] ( repend sheet-buttons [id text action] append lay/pane face: make-face/size/offset style cell-size cells/:id/offset if 'button = style [face/edge/size: 1x1] if not none? face [ face/text: text face/action: action face/style: style ] ) ] ] ] cell==: [ set id word! into [ opt 'formula set val [block! | path!](cells/:id/formula: :val) | opt 'value set val [string! | scalar-types] ( set cells/:id/var cells/:id/text: val ) ] ] sheet-code==: ['do set sheet-code block! (do sheet-code)] sheet==: [ (sheet-code: none clear sheet-buttons) opt sheet-code== any [buttons== | cell==] ] ] if link? [ hilight-all: func [face] [ either empty? face/text [unlight-text] [ highlight-start: head face/text highlight-end: tail face/text ] ] ] clear-cell: func [cell] [set cell/var cell/text: cell/formula: none] clear-sheet: does [ foreach [id cell] cells [clear-cell cell] clear next find lay/pane last cells show lay ] compute: does [ unfocus foreach [id cell] cells [ if cell/formula [ if error? try [cell/text: do cell/formula] [ cell/text: "ERROR!" ] set cell/var cell/text show cell ] ] ] cur-cell: does [either in-cell? [system/view/focal-face] [none]] empty-cell?: func [cell] [ all [ none? cell/formula any [ none? cell/text all [string? cell/text empty? cell/text] ] ] ] enter: func [face /local data] [ if empty? face/text [exit] set face/var face/text data: either #"=" = face/text/1 [next face/text][face/text] if error? try [data: load data] [exit] if scalar? :data [face/formula: none set face/var data exit] face/formula: either formula? face/text [compose [(:data)]] [none] ] event-func: func [face event /local f] [ if all ['key = event/type in-cell?] [ switch event/key [ F2 [if in-cell? [show-formula system/view/focal-face]] up [move up] down [move down] ] ] event ] formula?: func [text] [#"=" = text/1] in-cell?: has [f] [all [f: system/view/focal-face 'cell = f/style]] load-sheet: func [file [file! url!]] [ clear-sheet parse load/all file sheet== current-file: file show lay compute ] move: func ['way /local pos] [ pos: find cells cur-cell cell: pick switch way [ up [enter cur-cell skip pos negate sheet-size/x * 2] down [enter cur-cell skip pos sheet-size/x * 2] ] 1 if not object? cell [cell: none] ; if 'A1 = cell [cell: cells/A1] if cell [focus cell] ] new-sheet: does [ clear-sheet current-file: none show lay focus second cells ] use [not-vals] [ not-vals: reduce [none ""] no-val?: func [cell-val] [find not-vals cell-val] ] open-sheet: func [/with file [file! url!]] [ if not file [ if %none = file: to-file request-file [exit] ] load-sheet file focus second cells ] save-sheet: func [/as /local file buffer] [ if any [not file: current-file as] [ if %none = file: to-file request-file/save [exit] ] if all [file <> current-file exists? file] [ if not confirm join file { already exists. Do you want to write over it?} [exit] ] buffer: copy [] if sheet-code [repend buffer ['do sheet-code]] if not empty? sheet-buttons [repend buffer ['buttons sheet-buttons]] foreach [id cell] cells [ if not empty-cell? cell [ repend buffer [ cell/var reduce [any [cell/formula get cell/var]] ] ] ] save file buffer current-file: file ] scalar?: func [val] [find scalar-types type?/word :val] set-cell: func [id val /local cell] [ cell: select cells id cell/text: form val enter cell show cell compute ] show-formula: func [face] [ if face/formula [ face/text: join "=" mold/only face/formula focus face ] ] ctx-html-export: context [ out-buff: make string! 10'000 html-template: {
| either 1 = row [""] [form row - 1] | ] repeat col sheet-size/x [ emit either 1 = row [[col-lbl col | ]] [ [any [ get/any mk-var col row - 1 "" ] | ] ] ] emit
|---|
; 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 color: red type? color color-tuple: 123.54.212 type? color-tuple a-character: #"z" type? a-character a-word: 'asdf type? a-word 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} Try this list of data type conversion examples: to-decimal 3874904 ; Now the number contains a decimal point to-string http://go.com ; now the web site URL is surrounded by quotes form web-site ; "form" also converts various values to string form $29.99 alert form $29.99 ; the alert function REQUIRES a string parameter alert $29.99 ; (this throws an error) 5 + 6 ; you can perform math operations with integers "5" + "6" ; (error) you can't perform math with strings (to-integer "5") + (to-integer "6") ; this eliminates the math problem to-pair [12 43] ; creates a coordinate pair as-pair 12 43 ; a better way to create a coordinate pair to-binary 123.54.212 ; convert a REBOL color value to hex color value to-binary request-color ; convert the color chosen by the user, to hex to-tuple #{00CD00} ; convert a hex color value to REBOL color value form to-tuple #{00CD00} ; covert the hex color value to a string write/binary %floorplan8.pdf debase read clipboard:// ; email attachment 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 to 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. ---Random Values You can create random values of any type: random/seed now/time ; always use this line to get real random values random 50 ; a random number between 0 and 50 random 50x100 ; left side is limited to 50, right limited to 100 random 222.222.222 ; each segment is limited to #s between 0 and 222 random $500 random "asdfqwerty" ; a random mix of the given characters ---More About Reading, Writing, Loading, and Saving to and from Varied Sources Thoughout this tutorial, you'll see examples of functions that read and write data to "local files", web sites, the system "clipboard", emails, and other data sources. If you're totally new to programming, a quick explanation of that topic and related terms is helpful here. It may be familiar that in MS Windows, when you click the "My Computer" (or "Computer") icon on the desktop, you see a list of hard drives, USB flash drives, mapped network drives, and other storage devices attached to the computer: =image %./business_programming/mycomputer.png Data on your computer's permanent hard drive is organized into a tree of folders (or "directories"), each containing individual files and additional branches of nested folders. In Windows, the root directory of your main hard drive is typically called "C:\". C is the letter name given to the disk, and "\" ("backslash") represents the root folder of the directory tree. The REBOL interpreter is installed, by default, in the folder C:\Program Files\rebol\view\ =image %./business_programming/folders.png When you perform any sort of read, write, save, load, editor or other function that reads and writes data "on your computer", you are working with files on one of the "local" storage devices attached to the computer (as opposed to a folder on web server, email account, etc.). When using read and write functions, the default location for those files, in a default installation of REBOL, is "C:\Program Files\rebol\view\". The following image of a Windows file selector shows the list of files currently contained in that folder on the author's computer: =image %./business_programming/localfiles.png 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:\Program Files\rebol\view\" in Windows is referred to as "%/C/Program%20Files/rebol/view/" in REBOL code. Note that Windows uses backslashes (\), and REBOL uses forward slashes (/) to refer to folders. REBOL converts the "%" syntax to the appropriate operating system format, so that your code can be written once and used on every operating system, without alteration. The list of files in the image above would be written in REBOL as below. Notice the forward slashes at the end of folder names: %data/ %desktop/ %local/ %public/ %temp-examples/ %console_email.r %e %edit-prefs.r %r %read-email-header.r %rebol.exe %temp.txt %user.r %word-cats.r %word-defs.r %wordbrowser.r The following 2 functions convert REBOL file format to your operating system's format, and visa versa. This is particularly useful when dealing with files that contain spaces or other characters: print to-local-file %/C/Program%20Files/rebol/view/rebol.exe print to-rebol-file {C:\Program Files\rebol\view\rebol.exe} You can use the "change-dir" (or "cd") function to change folders: change-dir %/c/ ; changes to the C:\ folder in Windows cd %/c/ ; "cd" is a shortcut for "change-dir" To move "up" a folder from the current directory, use "%../". For example, the following code moves from the default C:\Program Files\rebol\view\ folder, up to C:\Program Files\rebol\, and then to C:\Program Files\: cd %../ cd %../ Refer to the current folder with "%./". You can read a listing of the files in the current folder, like this: read %./ probe read %./ editor %./ You can make a new folder within the current folder, using the "make-dir" function. Here are some additional folder functions: make-dir %./newfolder/ what-dir list-dir You can rename, copy, and delete files within a folder, using these functions: rename %temp.txt %temp2.txt ; change file name write %temp.txt read %temp2.txt ; copy file delete %temp2.txt The "write" function writes data to a file. It takes two parameters - a file name to write to, and some data to be written: write %name.txt "John Smith" The "read" function reads data from a file: read %name.txt You can assign variable labels to data that will be written to a file: name: "John Smith" write %name.txt name Assign variable labels to data read from a file: loaded-name: read %name.txt print loaded-name REBOL's built-in text editor can also read, write, and manipulate text data in files: editor %name.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. Writing to a web site "ftp" account requires a username and password: write ftp://user:pass@website.com/folder/test.txt "Text written by REBOL" 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: 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 (blocks, 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. All these examples and options may currently come across as confusing. If the topic is feels daunting at the moment, simply accept this section as reference material and continue studying the next sections. You'll become much more familiar with reading and writing as you see the functions in use within real examples. ---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. Simple requester functions don't require any parameters, but like most functions, they RETURN a useful value. Try pasting these functions directly into the REBOL console to see their return values: request-text request-date request-color request-file request-dir request-pass In the following line, the first function, with its refinements "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 print (10 + 12) / 2 ; 22 / 2 = 11 (same as without parentheses) print 10 + (12 / 2) ; 10 + 6 = 16 (force multiplication first) 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. ---More About Conditional Evaluations You've already seen the "if" and "either" conditional operations. 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."] either now/time > 8:00am [ alert "It's time to get up!" ][ alert "You can keep on sleeping." ] +++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" ] ---More About Loops +++Forever "Loop" structures provide programmatic ways to methodically repeat actions, manage program flow, and automate lengthy data processing activities. You've already seen the "foreach" loop structure. 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] ] Another way to write it would be: for i 1 50 1 [print rejoin ["This is loop #: " i]] +++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 ] +++For The for function can loop through a series of items in a block, just like "foreach", but using a counted index. The for syntax reads like this: "Assign a (variable word) to refer to an ordinally counted sequence of numbers, begin counting on a (start number), count to an (end number), skipping by this (step number) [use the variable label to refer to each consecutive number in the count]: REBOL [] for counter 1 10 1 [print counter] for counter 10 1 -1 [print counter] for counter 10 100 10 [print counter] for counter 1 5 .5 [print counter] halt REBOL will properly increment any data type that it understands: REBOL [] for timer 8:00 9:00 0:05 [print timer] for dimes $0.00 $1.00 $0.10 [print dimes] for date 1-dec-2005 25-jan-2006 8 [print date] for alphabet #"a" #"z" 1 [prin alphabet] halt You can pick out indexed items from a list, using the incrementally counted numbers in a FOR loop. Just determine the length of the block using the "length?" function: REBOL [] months: system/locale/months len: length? months for i 1 len 1 [ print rejoin [(pick months i) " is month number " i] ] halt This code does the exact same thing as above, using one of the alternate syntaxes instead of "pick": REBOL [] months: system/locale/months len: length? months for i 1 len 1 [ print rejoin [months/:i " is month number " i] ] halt As you've seen, you can pick out consecutive items from a list using counter arithmetic (pick index, pick index + 1, pick index + 2). Within a for structure that uses a skip value, this concept allows you to pick out columns of data: REBOL [] months: system/locale/months len: length? months for i 1 len 3 [ print rejoin [ "Months " i " to " (i + 2) " are:" newline newline (pick months i) newline (pick months (i + 1)) newline (pick months (i + 2)) newline ] ] halt Here's an example that uses an "if" conditional evaluation to print only names that contain a requested string of text. This provides a functional search: 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" ] search-text: request-text/title/default "Search for:" "t" for i 1 length? users 3 [ if find/only (pick users i) search-text [ print rejoin [ (pick users i) newline (pick users (i + 1)) newline (pick users (i + 2)) newline ] ] ] halt To clarify the syntactic difference between "for" and "foreach" loops, here is the same program as above, written using foreach: 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" ] search-text: request-text/title/default "Search for:" "t" foreach [name address phone] users [ if find/only name search-text [ print rejoin [ name newline address newline phone newline ] ] ] halt As you can see, the for loop function is useful in almost the exact same way as foreach. It's a bit cryptic, but useful for certain common field selection algorithms which involve non-consecutive fields. You will find that both functions are used in applications of all types that deal with tabular data and lists. You'll see many use cases for each function, as this tutorial progresses - keep your eyes peeled for for and foreach. 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."] ] ] ---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]] For additional detailed information about using blocks and series functions see http://www.rebol.com/docs/core23/rebolcore-6.html. ---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 list functions. 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. ===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 "word browser" script is a useful tool for finding, cross referencing, and learning about all the critical functions in REBOL: write %wordbrowser.r read http://re-bol.com/wordbrowser.r do %wordbrowser.r +++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"):
| First Row |
| Second Row |
| Third Row |