urls = new Array(
"Leo/Basics/Tutorials/B4 What is Leo",
"Leo/Basics/Tutorials/B6 What is Leo - Continued",
"Leo/Basics/Tutorials/C2 Installation",
"Leo/Basics/Tutorials/C4 Outlining",
"Leo/Basics/Tutorials/Derived Files Part 1",
"Leo/Basics/Tutorials/Derived Files Part 2",
"Leo/Examples/Tutorials/B4 The Evisa Site",
"Leo/Examples/Tutorials/B6 Screenbook Maker XSLT",
"Leo/Examples/Tutorials/B8 Perl Utilities",
"Leo/Examples/Tutorials/C8 Flextable",
"Leo/Examples/Tutorials/D2 A NSIS Installer for Python Applications",
""
);
 
sbookText = new Array(

" 0 leo is a unique powerful computer program that you can use to organize analyze and describe text and text files leo is a free program written by edward k ream for information about downloading leo see installation tutorial in this series leo runs on windows mac or linux use leo: to brainstorm a new project as a personal information manager to add multiple outlines and commentary to any text file as a tool to facilitate a new kind of literate programming because leo is unlike other tools you may have used a series of examples may be the best way to demonstrate what can be done with leo ",
" 0 from one perspective leo is an outlining editor  this is a screenshot of leo you create an outline in the top left pane  a later tutorial explains how to create an outline like the one in the screenshot ",
" 0 clicking on the indicated box will open the indicated node ",
" 0 here the node has been opened clicking on the box again will close the node ",
" 0 here the indicated node has been closed ",
" 0 clicking on a node headline 1 will show the text for that node in the body pane 2 below the body pane is a text editor - you can enter delete or change text here by typing it in ",
" 0 you can save the outline in a leo file click file - save ",
" 0 here we will save our outline in a file name "pim leo" ",
" 0 the file is now saved and the file name appears in the title bar ",
" 0 you've just seen an introduction to leo as an outlining editor you can use leo to make an outline with optional text for each outline element you can save the outline to a file outlines are explained more in a later tutorial in this series the outlining capability of leo goes far beyond what has just been demonstrated including multipath outlines and multiple outlines in one file  what we've shown so far is no different from other outlining editors what makes leo unique is the addition of a new feature using simple directives you can instruct leo to extract text from any number of nodes in any order and write the text to a new file you can also embed outline information in the second file giving leo the ability to read the text pieces back into the leo outline even if they have been changed  in effect leo is a meta-text editor  it gives you the ability to create a structural document for a non structured document or a document that is structured in some other way what does this mean in practice some examples should help clarify things  ",
" 0 here is the "pim leo" file again we've: selected the "2000" node entered a couple of directives the second @root tells leo the file name that we want to derive extract to  the @silent directive is explained in a later tutorial  entered some node text ",
" 0 now we tell leo to tangle the node this means leo should start at the current node and look for a @root directive create the file named in the @root directive or open it if it already exists write all of the node text to the file named in the root directive why is this operation called tangling we'll see that a few pages from now ",
" 0 leo has derived the file written the file to the hard disk ",
" 0 here the file is listed in windows explorer ",
" 0 and here is the file displayed in a text editor ",
" 0 that example wasn't very useful all that we extracted was the text "this is my diary " we'll probably want to extract more than that in fact when tangling we can extract not only the node text as we just saw but also all or part of the text of any subnode and we can put these extracted pieces into the derived file in any order that is why the process of extraction is called tangling let's try this select the "jul" node ",
" 0 we add angle brackets to the headline this tells leo that the node is a section we add the @c directive this tells leo where to start extracting text from this node ",
" 0 now we go back to the 2000 node we enter the section name jul into the node text where we want the jul section text to be output when tangling leo will replace this section name with the section text this operation is recursive so if a section text contains a section name this also will be replaced with the named section's text note: when we put a section name into node text the section name must correspond to a section located under the current node leo only looks in subnodes for section names ",
" 0 choose tangle ",
" 0 the file has been updated ",
" 0 here is the extracted file viewed in a text editor ",
" 0 this tutorial has given you a brief introduction of leo's: outlining capacity ability to create derived files these two things are the main features of leo however there is much more to say about both of them: outlining - see the outlining tutorial in this series to see how leo can be used to create outlines with multiple paths or views making it a powerful tool for project planning or any kind of tree-based analysis derived files - we've seen the simple case of deriving a text file from a node this give you the ability to collect a number of text files in one leo outline but leo can do much more that that - leo can extract not only node text but also outline structure and can then read back this embedded structure for a look at this feature and why it is so useful particularly for programmers see the next tutorial in this series: what is leo - continued in addition in the following tutorials you will see much more complex examples of derived files ",
" 0 in addition to outlining and file deriving features like tangle leo also has the following features: can be scripted with python contains a syntax highlighting programmer's editor the leo format is xml meaning that a leo file can be easily converted to any other text format such as html ",
" 1 in the first tutorial in this series we saw the basic outlining and file derivation features of leo let's take a further look at how leo's derived file functions can be put to use we will use the creation of a computer program as an example however the operations are useful in other situations involving complex text documents ",
" 2 windows users: installing leo requires two steps: install python: click here save to your desktop then double-click on the saved file install leo: click here save to your desktop then double-click on the saved file  python is a type of software for creating and running computer programs  unix and max users: please continue to next page  also if you are a programmer and want to get the leo files without using an installer continue to the next page ",
" 2 full installation of leo requires that you: install python install the leo files to install python follow the directions on this page to install leo go to this page and download the most recent zip file under the heading "leo2 py" download the zip file to your desktop or other location and then unzip it to the folder of your choice to run leo double-click on the file leo py that you have just unzipped ",
" 2 once you have installed leo you can configure leo using the leoconfig txt file for more information about this see the documentation distributed with leo ",
" 2 leo is a free program distributed under the python license this means that not only can you use the program freely including commercially the full installation comes with source code that you can modify as you wish as long as you give credit to the author of the program edward k ream leo is written in python - a full featured powerful programming language that is comparatively easy to learn and use for an excellent introduction to python for non-programmers see this tutorial not only is leo written in python it is scriptable via python meaning that you can embed python commands in your outlines and execute them leo is under active development and all are welcome to contribute for more information see the leo sourceforge site not only is leo free software it is supported software post questions and bug reports to one of the leo support forums ",
" 3 here we have opened a new file in leo ",
" 3 let's add a node choose outline - insert node or key in [ctrl-i] ",
" 3 a new node has been created ",
" 3 click on the headline to edit the headline text ",
" 3 here we have also changed the text for the first untitled node ",
" 3 now let's make the second node the child of the first click on the node then enter [ctrl-r] this will move the node to the right  you can also perform this operation with the outline menu ",
" 3 here we have entered [ctrl-i] and created another new node ",
" 3 here we've edited the name of the third node and moved it to the right with [ctrl-r] ",
" 3 we've added another node  ",
" 3 changed the name ",
" 3 to move it left enter [ctrl-l] ",
" 3 now we'll add another child node with [ctrl-i] and [ctrl-r]",
" 3 to move a node up click on the node and enter [ctrl-u] as many times as necessary ",
" 3 here we've moved "bob" down by entering [ctrl-d] and then right by entering [ctrl-r] ",
" 3 to enter text for node click on the text pane and type ",
" 3 to summarize: [ctrl-i] = insert a new node [ctrl-r] = move node right [ctrl-l] = move node left [ctrl-u] = move node up [ctrl-d] = move node down you can also delete a node with:[ctrl-shift-backspace] you can also drag nodes from one point to another ",
" 3 that is all that you really need to create an outline but there is one more powerful feature: clones  to demonstrate this feature first i've added more nodes  ",
" 3 now i've closed up the nodes and added a new node at the level of the first  so another top level node ",
" 3 i want to add a list of people who owe me money so i open a node and select a person ",
" 3 next i enter [ctrl-`] to create a clone node you can see that a new node is created with the same name as the selected node but now both nodes have a small red arrow ",
" 3 now i've moved one of the cloned nodes down to a new location under the "people who owe me money" node ",
" 3 cloned nodes are basically the same node you just have another "view copy" let's demonstrate this here we've entered some text for the second clone ",
" 3 now we've selected the first cloned node you can see that the text is the same although we did not enter any text with this node selected ",
" 3 however clones are not linked when deleting we've just deleted the first clone and the second remains except that now it is just a regular node ",
" 3 a cloned node can have child nodes so you can clone entire subtrees in effect cloning allows you to make multiple trees for one set of "leaves" there are more outline commands available from the outline menu but with just what you've learned in this tutorial you are ready to create outlines of any level of complexity in the next tutorial we'll see how to create separate text files derived from an outline and how these derived files can be read back into an outline ",
" 4 using directives you can make leo extract text from any number of nodes to another file of your choosing a directive is a simple command starting with the @ sign that you add to the text of the node the directive directs leo how to process the node directives are always the first word on a line this tutorial will cover one way of doing this which is to use the @root directive a second tutorial will cover the @file directive ",
" 4 the file name of our leo outline is "sample2 leo" this @root directive is saying put the text of this node in a separate file called "samplehello c" ",
" 4 next we will tangle derive the file this will cause leo to create the file "samplehello c" write all of the text following the @root line into the samplehello c file  however the text of this node contains section names section names are indicated by the angle brackets in place of the section names leo will write out to samplehello c the text of the named section this operation is called tangling because the section names in the node text do not have to be in the same order as they are in the outline so the order of the text in the derived file can be different than the order of the text as it appears in the outline ",
" 4 for example there is a section name called methods ",
" 4 here we have selected the methods node showing the text for that node since this node headline is enclosed in angle brackets the leo considers the node to be a section when tangling the @root directive shown in the previous screen leo will not write out methods  instead it will write out everything following the @code directive in the methods node shown here ",
" 4 let's try it first again select the node containing the root directive ",
" 4 now choose file - tangle - tangle ",
" 4 leo has created and written the file ",
" 4 here is the samplehello c file opened with a text editor  the text editor shown in the screenshot ultraedit  does automatic syntax highlighting so code comments are in cyan keywords are in blue and other code is in black ",
" 4 leo has added the section names as comments ",
" 4 you can see that in lines 14 - 17 the text for the methods node has been output as is ",
" 4 here we've added another line of code in the text editor ",
" 4 we then save the file ",
" 4 now we look at the file in leo again you can see the text for the methods node has not changed it will not change even if we open and close our leo outline we can have leo update our outline from the changes we made to the samplehello c file this process is called untangling because it is the reverse of tangling ",
" 4 again choose the node with the @root directive ",
" 4 choose file - untangle - untangle ",
" 4 leo untangles the samplehello c file it has identified that the methods node has changed and has updated the text for that node ",
" 4 you can see that the methods node is now marked with a red line to indicate that it has been changed externally ",
" 4 when we select the methods node we can see that the node text has been updated with the changes we made using the text editor ",
" 4 the @silent directive causes leo not to insert structure comments in derived files let's take a look at it in more detail choose the node with the @root directive enter a @silent directive ",
" 4 now let's tangle the samplehello c file again ",
" 4 samplehello c has been updated ",
" 4 this time samplehello c looks quite different because of the @silent directive leo has written only node text leo hasn't put any extra comments into the derived file "this can be useful when you want to make your derived files contain only a particular kind of information however we will not be able to untangle this file now because the file has no outline information ",
" 4 although we cannot untangle a file that has no outline embedded into it it is worth noting that we can still import any text file using file - import export - import using this feature you can read any text file into a node if the text file is a c or java file leo will automatically create subnodes for classes and methods  this feature was demonstrated in the second tutorial in this series ",
" 4 we've just covered the main points for deriving files using the @root directive but there is a completely different way to work with external files using leo: the @file directive the @file directive is similar to the @root directive but with some very interesting differences read on to the next tutorial to learn more about it ",
" 5 leo has a second way of creating derived files this is the @file directive this directive at first seems similar to the @root directive but there is an important conceptual difference when you use the @file directive outline information is always written to the derived file therefore you cannot use the @silent directive the benefit of using the @file directive is that there is no longer any need to explicity tangle and untangle tangling and untangling happen automatically by opening a leo file and saving it this makes alternating between leo and another editor or ide completely transparent in addition when you use the @file directive you can have unnamed sections  to see how these work read on  ",
" 5 here we've added a second node with a @file directive to our tree from the previous tutorial the @file directive in contrast to the @root directive appears only in a node headline not in node text as before the node text has the includes section name but this time instead of a methods section name it has a new directive: @others this directive means "put the node text from all of the unnamed sections here " unnamed sections are nodes that are not sections i e nodes that do not have double angle brackets in the node headline ",
" 5 we enter [ctrl-s] to save our leo file and the samplehello2 c file is automatically written ",
" 5 here is the samplehello2 c file in our text editor embedded outlines created with the @file directive have a different embedding format than those created with the @root directive all of the outline information embedded by leo starts with the @ sign plus in this case two slashes  needless to say we can't delete any such sentinel line without interfering with the ability of leo to read the file back into an outline ",
" 5 let's try adding some code in the text editor ",
" 5 next we save the file with the text editor ",
" 5 when we return to leo we do not see the changes we must either reopen the file or reread it ",
" 5 when we reopen our sample2 leo file we can see that the changes we made to samplehello2 c have been incorporated into our outline in the proper place ",
" 5 if you are a programmer you now have all of the information you need to start using leo with your own programs you may find that leo quickly brings about a great improvement in programming speed and enjoyment both for your own projects and for team projects for a look at some sample projects that have used leo successfully see the examples section in this tutorial series ",
" 6 this tutorial shows how using leo greatly simplified the development of the language learning applications online at evisa com a multilingual information and learning site  the leo file containing the code for this application is not available for download but the leo outline is illustrated via screenshots first let's take a look at how the site application works and then we'll examine the leo file that contains all of the code for the language applications ",
" 6 here is the language learning site at evisa com this site contains a number of vocabulary drills and activities for numerous languages ",
" 6 in addition to being able to study words students can take tests and save their scores saving a score however requires registration free ",
" 6 let's choose the french language option ",
" 6 this brings us to the french language study page there are two activities available from this page: word study: a set of language study activities my flashcards: a page that shows word flashcards saved by the registered user who is viewing the page ",
" 6 let's take a look at the word study activities ",
" 6 this presents us with a list of word groups the word groups are marked with red green or yellow icons to show which groups have been already been reviewed by the currently logged on user we'll choose the colors group ",
" 6 this brings us to the activity page for the colors word group let's take a look at view and listen ",
" 6 this brings us to a list of colors in french and english also the merlin character microsoft agent appears we can click on any french word to hear merlin speak the word ",
" 6 to try another activity we can go back to the activity menu or click on the indicated mark to go to the next activity ",
" 6 this brings us to the flashcards page this presents the colors as a series of cards clicking on a card shows the word in the target language we can also choose to save cards to the my flashcards page for which we saw a link earlier ",
" 6 now we'll go to the next activity ",
" 6 this brings us to the concentration card game page this allows one or two players to play a game of concentration with the vocabulary items ",
" 6 the final activity is the match test  this is pairing test you click on a word first in one column then in the next if the words match you get a point if you get a score of 100% and you are logged in and your pass is automatically saved so that you can see it later in the my achievement page to which we saw a link earlier ",
" 6 both the match test and the concentration card game allow you to configure the sound effects for right and wrong answers ",
" 6 now let's consider what will be involved in programming an application like the one we've just seen the same words appear in many pages so we'll want a database of words with the pages inserted into each page as required this needs to work with a number of languages so the database will need tables for each language paired with english we'll need at least: a program or module to do the basic word activities a program or module for registration this involves sending the user an email and the user then clicks on a link to register a program to display personal achievement a program for the my flashcards page ",
" 6 the application is going to be getting words from the database and inserting them into each activity page that means we need a template for each of these pages but evisa com doesn't just serve an english user base it also has a complete subsite for japanese users with sites for other languages planned so we'll need templates for other languages we'll need to plan the database so we'll something explaining that we need to make input pages for the database so that administrators can add words since we want the database to be as fast as possible for reads we want to make some utilities to replace certain database functions that could slow down reads such as data constraints most of the activity pages have a lot of javascript some of which could be put in a libary file and all of which should be organized ",
" 6 hmmm  this is starting to look like a major project each task is simple but keeping everything organized so that the job can be done as fast as possible even when the the project is being stopped and started over a period of time  that could be a challenge here's a look at the leo file that is actually behind the all of the code ",
" 6 an explanation of some of the nodes: phonics: this is a program that allows an administrator to build the phonetic library used for showing the pronunciation of english words sql: utilities for maintaining the word database words: the application that takes care of the server side of all of the language learning activities recorders: small programs that record user information such as passed tests and flashcards flashbox: the application for my flashbox",
" 6 in addition to the actual code for all programs the outline contains just about every other useful piece of information for the site programmer including how to log on to the mysql database and other documentation of third party programs used ",
" 6 let's take a look at the words cgi program because that does most of the work here we see the node for the words cgi program expanded already the basic structure of the program is apparent we are going to get/initialize the cgi object check to see what browser is being used connect to the database and retrieve words and then make the outgoing page ",
" 6 in the text for the make page section we can see that one of the included sections is for word groups  looking down the outline we can see that the word groups page consists of getting data from the database filling in the template with the data if we were debugging the word groups page we would have jumped right to this spot in the code immediately no hunting around trying to remember how the program works and where things are ",
" 6 in this screen we are viewing the text for the word groups: fill in the template node all of the code for this node fits in one screen you might note that the code displayed in this node text does not stand on its own so to debug it you might need to look at another node this code and outline could have been written otherwise but writing it in this way is not a great impediment since finding the code that this node is dependent on is just as easy as it was to find this node itself when you are using literate programming techniques the whole program simply becomes much easier to navigate ",
" 6 we've seen that the program is retrieving these words and then filling in a template where are these templates in leo of course underneath the words node we find the templates node ",
" 6 since evisa com has viewers in langages other than english there must be a separate set of templates for each language ",
" 6 here we can see that all of the templates are embedded in the leo file ",
" 6 let's take a look at the speak htm template this is the file that will display the page where the user can click to hear a word spoken the words cgi program simply fills words into this template the template contains all of the code for making the page speak in the browser the way it does this is to embed an activex object for a microsoft agent and then call that activex object with javascript here the code for embedding the activex objects is shown since these same objects are embedded in the same page for each language this is a clone node all of the other templates that use this code simply share this node ",
" 6 this has been a brief overview of the language applications at evisa com as you can see all of the code and virtually all of the supplemental information needed to work on this application is embedded in one leo file the programmer opens the file works on the application in leo and then tangles the output code files this application was written in perl because of perl's excellent text manipulation capability and speed of development there is no scalability problem with this kind of perl application because it runs with apache mod_perl while programming this application in certain other languages would have given it some more inherent structure this would sacrifice some of the advantages of development with perl in fact one can think of leo doing for the supposed "structure" problem of perl what mod_perl has done for the scalability problem the application as written in leo simply could not be easier to understand are there alternatives to this approach there are more than fifty files embedded in this one leo file every file is grouped and described not just with a name but with whatever additional information is necessary some files are sharing components i e nodes this application was developed on a very constrained budget and simply would not have been possible without leo ",
" 7 the page that you are looking is an html page created by the screenbook maker program screenbook maker makes it easy to create online tutorials with screenshots it also automatically creates tables of contents full text search pages rdf files and other resources before screenbook maker created this html page that you are reading now however it saved all of the text of this tutorial in an xml file then it generates the html for this page from an xslt template but screenbook maker doesn't just create one html view of the tutorial screenbook maker looks in the bookshelf folder the folder containing the screenbook tutorials for xslt files for every xslt file that it finds there it generates a different tutorial output an xslt template file is a text file that contains xslt a specialized language instructions and other output text a processor is used to take the xml file for the tutorial and create an output file based on the xslt instructions and text in the xslt template ",
" 7 let's take a look at what this means in practice here is a screenshot from the first page of one of the windows 2000 tutorials in the evisa com screenbook library ",
" 7 each folder containing html pages for a screenbook tutorial has the file sbook xml  which contains all of the text and image names for the tutorial if we change the url we can see the xml file ",
" 7 here we've closed up some of the xml elements to make it easier to see the structure of this screenbook's xml you can see that it contains a number of page elements ",
" 7 here we've opened up the first page element you can see that each page element contains the page text and other information for the page ",
" 7 now we've returned to the first page of the tutorial and will look at the bookshelf table of contents ",
" 7 now the bookshelf table of contents is displaying ",
" 7 here you can see that there is a menu to choose other tutorial formats we will choose titles with thumbnails ",
" 7 you can see that now the same tutorial is being displayed in thumbnail format ",
" 7 we saw in a previous screen that there are five different tutorial formats that can be chosen from each of these formats consists of html pages output from processing the xml file we saw previously there is also another xml file to be aware of that for the bookshelf a bookshelf is a folder that contains multiple tutorials when screenbook maker creates a tutorial it automatically updates a file called sbooktoc xml in the bookshelf folder where the screenbook is stored here is a view of the xml file for the bookshelf we are examining ",
" 7 so we've seen that we've got at least two xml files and numerous output files that must be produced all output is produced by xslt templates screenbook maker is distributed with xslt templates for all the output formats shown and more each output format corresponds to one xslt file since screenbook maker users have access to the xslt files they can easily change the way an output format looks by editing the xslt for example if you want to put a banner ad at the top of every html page in slide view you simply edit the xslt template that creates the slide version of the screenbook the only problem is how is the average user to be able to figure out which of the many xslt files to edit and since users may not know xslt how can the xslt files be distributed and explained in such a way that the anyone who knows html will be able to edit the xslt templates which produce html output there are basically only two possible solutions: hire a team of programmers to create a fancy wysywig editor that allows users to make some but not all of the changes they could make by editing the xslt directly use leo to distribute categorize and explain the xslt in such a clear fashion that any intelligent user who knows html will be able to edit the xslt to produce any kind of html output that they want more advanced users will be able to add completely new output formats since at this point screenbook maker is a free program produced by a single programmer option #1 is not realistic ",
" 7 here is a view of the sbstylesheets leo file that comes with screenbook maker if you would like to look at this file download and install screenbook maker you can see that there are a number of categories the node highlighted contains all of the xslt templates for the xml in a single screenbook folder that is the xslt for the tutorial formats ",
" 7 when we expand the node for the xslt templates for a screenbook we can see that there are numerous files one for each format ",
" 7 let's look at the first template this is the one that creates the slide view format one html page per screenbook page there is a directive here that may be new to you: this is the @first directive this allows you to specify that the following text will be written to the target file first before any leo sentinel lines this is necessary since the xslt format requires that the xml declaration be the first line of the file ",
" 7 now let's look at the main template node you can see that it contains some xslt instructions with the special files element used by screenbook maker to break a single xml input file into multiple output files  plus the html /html elements plus a couple of subsections ",
" 7 at this point there are probably two main reactions by the reader:xslt experts: a lightbulb should be going on over your head at this point that's right this is the holy grail of xslt development - the tool that makes xslt as easy to read as any other language xslt is an extremely powerful tool but xslt templates can be very difficult to read that makes it harder to for multiple people to work on a single template no wysywig tool will ever beat leo in terms of making xslt readable and by using real xslt you get all of its power  still not a convinced fanatic move ahead to the dhtml grid example and see if you can imagine doing that one in anything but leo  average users: if you know html but don't xslt hang on - you'll see that leo makes the structure of the xslt so transparent that you can make substantial changes to the output format without even glancing at the actual xslt instructions ",
" 7 to recap what the xslt is doing it is reading the sbook xml file and on the basis of that outputting some html it does this by executing some xslt instructions and copying verbatim the html tags in the xslt template so now let's look at the head element well hey  this is mostly just html want to change the stylesheet the screenbook will point to just edit the link here ",
" 7 hmm  the body tag doesn't have much in it  suppose our goal is to add a banner ad to the output that would probably be in the node entitled "layer 1" ",
" 7 now we are looking at the "layer 1" node there are some xsl xslt elements at the beginning of the code we'll just ignore those we can see that the next thing is a div tag then there is a table the div tag's position is one pixel from the top so this must be the first thing on the page if we want to put in a banner add we can just move this div tag down and put another div tag or table in front of it or we could add another row to that first table ",
" 7 after we make our changes and save the leo file we can have screenbook maker regenerate our tutorials using this new xslt template we may have to come back and change some more html since this template is using absolute positioning but you can see that it is basically a matter of editing html and for each change you make you can add a leo node documenting your change for others in your organization who will be working with these files ",
" 7 a further note for xslt developers since the leo file contains a library of xslt templates for manipulating the xml generated by screenbook maker when you want to add a totally new output format all you need to do is add a new xslt file and you already have examples of just about every possible useful expression you could need for extracting from the xml using xslt in the screenshot here we can see that there is a file name toc_imsmanifest xml xsl screenbook maker will use this xslt file to create a file named imsmanifest xml the format for this xml is taken from microsoft's lrn resource meaning that this bookshelf will now be scorm compliant since it will have a properly formatted imsmanifest xml file in other words adding scorm compliance an industry standard for online training structure consisted of: examining micorsoft's lrn format using the same xslt elements as in other files in this leo tree to extract the data from the bookshelf xml and output to the lrn format ",
" 8 perl is a great language for many things but one thing it really shines at is in making small programs for system administration there is a huge library of components for system administration that you can use from perl and it is easy to do a lot with a small script scripts that are dashed off quickly to take care of small tasks tend not to be terribly readable and well documented particularly in a language like perl that has so many ways to pack a lot of functionality into a few statements such scripts also tend to proliferate since often it can be faster to write a new script than find out whether a script already exists that can do the job this tutorial provides an example of how using leo can solve both of these problems one sample script is presented but it is easy to see how adding more scripts to this example outline could result in a package that is very well documented addind a new script to this outline would not take much more effort than dashing off a script in a standard text editor ",
" 8 the leo file used in this tutorial is available from my leo resource page to download it right-click on this link and choose "save target" here is how the file looks when first opened ",
" 8 the driveinfo leo file contains a single script with documentation and other supplementary files the script in driveinfo leo is driveinfo pl  a perl script for checking drive space on a windows machine and then emailing this information to any number of people  this script doesn't use the newest modules so it may not be useful for deployment at this point but still can serve as an illustration of leo's capability  if you've downloaded the file and are investigating it with leo now you can quickly see that the leo outline clearly shows what the program is how to use it and how it is programmed since the benefits of such an outline will probably be immediately obvious this tutorial will not go into much detail but will simply point out a few features of the outline ",
" 8 the first node of the outline explains what is in the outline and how to use it  this node has info about installing the modules necessary to run this script most scripts use perl modules and not everyone will know how to get and install a perl module this node has the actual script ",
" 8 users of the script will not need to look at the script node since documentation of how to use it is contained in other nodes only progammers who want to change the script will be interested in opening the script node and looking at it ",
" 8 the driveinfo script is broken down into four sections plus a section for functions the indicated node is where the script reads the drive space of the drives on the current machine some people claim that perl is hard to read but anyone with a basic knowledge of perl should find the code in this node to be simple to understand ",
" 8 leo not only makes it easy to deploy a program it makes it easy to study the program to learn how to implement a particular feature let's suppose we aren't interested in drive space but we do want to write a script to send email that information is obviously going to be in the indicated node ",
" 8 but apparently that functionality is implemented in the notify function we'll have to find and look at that ",
" 8 since it is a function we'll expect to find it in this node ",
" 8 the entire function is displayed in the body pane this is all the code we need to send email using perl and smtp module ",
"9 flextable is a dhtml component you can use in your web pages to display data in a tabular form this component has many features not available in html tables such as click-sort movable columns frozen columns resizable columns etc flextable only works with internet explorer 5 5 or later if you are using ie 5 5+ you can view a sample page and other information here a leo file containing the component is also available from the same location flextable is distributed in an xslt stylesheet you use the stylesheet to process tabular xml and the ouput is a dhtml page with the flextable component ",
"9 since the flextable component is distributed in an xslt stylesheet the process of actually displaying the component to the viewer goes like this: server e g jsp page makes xml server applies the client xsl stylesheet to the xml the result is dhtml html + a javascript array of data + javascript for the component that is sent back to the browser the browser executes the javascript of which the component consists the actual component is a javascript object any developer wishing to extend or modify the component is going to need information about the xml format that the stylesheet explains it is also going to be difficult for a javascript developer to work directly from the stylesheet since that contains a mixture of xslt and javascript rather than the final javascript output ",
"9 packaging the xslt template and a sample xml file in a single leo file makes distribution of the component much more easy and understandable the xslt and javascript can be separated simply by putting each in separate nodes ",
"9 opening up the main template of the xslt stylesheet we can immediately see where the output for the html head and body elements will be ",
"9 looking at the headlines in the head and body elements we can see that the actual script for the flextable is probably in node #1 and that this script gets called in node #2 ",
"9 sure enough a further look at the script node shows that the javascript for the dhtmltable flextable object is in a subnode and that this is further divided into the constructor and methods once we are in the script node we are looking at pure javascript that will be passed to the browser we don't need to worry about xslt ",
"9 suppose our aim is to examine the code that allows for column resizing by the dhtml object in order to add this feature to another component opening the methods node allows us to jump right to the node containing all of the code for column resizing note that this node contains several methods there are a number of small methods that enable column resizing none of the methods really merits its own node they belong together this analysis is much more helpful than a simple class analyzer that would simply list all of the object methods ",
"10 nullsoft the makers of the winamp mp3 software have released a powerful free installer called nsis available here this application allows you to make installation packages for windows applications you create nsis packages by writing a nsis script and then compiling it depending on the application nsis can often be a better choice than more expensive installation generators since nsis installations are easy to create are small and fast and yet can be configured with many features ",
"10 when you install leo you'll find that it comes with a script for generating an installer for leo this script is called leo nsi and is distributed in the leo file nsis leo if you have nsis installed right-clicking on a nsi file will give you the option of compiling the script to create a package ",
"10 since the nsis script for the leo installation is included in the leo distribution in the nsis leo file it is easy to understand the how the script works this nsi file creates an installer that packages all of the leo program files and creates a desktop shortcut a program menu item and the file association for leo files ",
"10 in this screenshot we're looking at the code that checks to see whether python has been installed since leo is a python application modifying this installation script to create a script to build a windows installer for your own python application is relatively simple you would leave this section alone and check other sections for the program name "leo" and change these to your program name ",
"10 for example here is the section that creates a registry entry for associating the leo extension with leo you would change the name "leo" to the name of your application if you are going to use nsis to create an installer for something other than a python application this leo file still contains examples of several useful nsis techniques which can be easily referred to since the script is documented in outline form in a leo file"
);
 
var noiseWords = /\s(this|that|these|those|a|the|an|some|any|who|what|where|why|when|of|in|at|on)\s/;
