Patch title: Release 87 bulk changes
Abstract:
File: /pliant/protocol/http/page.page
Key:
    Removed line
    Added line
# Copyright (C) 1999  HELIOSAM (France)
# Work performed by  Loic Dumas  loic.dumas@heliosam.fr
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# version 2 along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

module "/pliant/language/unsafe.pli"

title "The Pliant .page format"

section "top"

para
  [The Pliant .page format is an alternative to native HTML.] ; eol
  [The Pliant HTTP server will translate on the fly any .page file to HTML, so the client browser will not see any difference.] ; eol
  [On the server side, there are several advantages using .page format instead of HTML:]
  list
    item
      [.page format enables you to write dynamic pages without adding poor extensions with completely different syntax and rules.]
    item
      [styles binding is performed on server side using the powerfull Pliant language overdefinition capabilities, so you get all the power of CSS without requiring any such feature on the client side.]
para  
  [A document written in Pliant .page format, is saved with [dq].page[dq] extention, and actually is a Pliant program.] ; eol
  [The ] ; link "style/default.style" "style/default.style" ; [ module which is defaultly binded to any .page file provides a basic set of instructions to display text, images, hyperlink, etc, so with .page format you will use instructions instead of HTML tags.] ; eol
  [Several attributes, such as 'bold' need the area it applies on to be specifyed. In HTML this is performed using an start tag and a stop tag. In Pliant, it's done using indentation, so keep in mind that when writing .page files, indentation is not only for nice looking but also has meaning for Pliant dynamic compiler.]
para
  [On this page you will have every .page format instruction described with examples.]
  
center
  table columns 1 border 0  
    cell
      header "Table of content" 
        table columns 2 border 0    
          cell color lsh 78 5 130
          cell color (color hsl 130 5 78)
            list
              item 
                link "Basic Instructions" "" section "basic"
                fixed
                  list 
                    item 
                      [text]                      
                    item 
                      [eol]
                    item 
                     [ html]
                    item 
                      [link]
                    item
                      [note]
                    item 
                      [image]
                    item 
                      [listing] 
                    item 
                      [highlight] 
              item
                link "Structural Instructions" "" section "structural"
                fixed
                  list
                    item
                      [title]
                    item
                      [chapter]
                    item
                      [header]
                    item
                      [para]
                    item
                      [list]
                    item
                      [table]
                            
              item
                link "Attributes" "" section "attributes"
                fixed
                  list
                    item
                      [bold]
                    item
                      [italic]
                    item
                      [small]
                    item
                      [big]
                    item
                      [center]
                    item
                      [fixed]
                    item
                      [color] 
              
              item
                link "Dynamic Instructions" "" section "dynamic"
                fixed
                  list
                    item
                      [dynamic]
                    item
                      [input]
                    item
                      [button]
              item
                link "Shortcuts" "" section "shortcuts"
                fixed
                  list
                    item
                      [[lb]text[rb]]
                    item
                      [;]


section "basic"
header "Basic instructions"

  header "text"
    para
      [The 'text' instruction is to display text.]
    para
      [syntax:]
      listing
        ¤text `string
      [Where 'string' is a character string you want to be displayed as normal text.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            text "hello world "
            text "on the same line [lf]"
            text "on the next line"
        cell
          [------>]
        cell
          text "hello world "
          text "on the same line [lf]"
          text "on the next line"
    small
      [Beware that Pliant uses a non standard encoding for ] ; link "special character in strings" "/../pliant/language/parser/default_syntax.html" section "strings_encoding"
  
  header "eol"
    para
      [The 'eol' instruction inserts a line feed.]
    para
      [Syntax:] ; eol
      listing
        ¤eol
      [So, it's equivalent to:]
      listing
        text "[lf]"
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            text "my first line"
            eol
            text "my second line"
        cell
          [------>]
        cell
          text "my first line"
          eol
          text "my second line"
    para
      text "alternatives that will give the same result:"
      listing
        text "my first line"
        text "[lf]"
        text "my second line"
      listing
        text "my first line[lf]"
        text "my second line"
      listing
        text "my first line[lf]my second line"
  
  header "html"
    para
      [The 'html' instruction, can display pure html code in your page. It can be useful when HTML code is needed where Pliant .page format isn't shaped for.]
    para
      [Syntax:]
      listing
        ¤html 'string 
      [Where 'string' is raw HTML code]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            html "<hr>"
        cell
          [------>]
        cell          
          html "<hr>"  
    small
      [beware that Pliant uses a non standard encoding for ] ; link "special character in strings" "/../pliant/language/parser/default_syntax.html" section "strings_encoding"
  
  header "link"
    para
      [The 'link' instruction makes hyperlinks between pages or programs.]
    para
      [Syntax:]
      listing
        ¤link `label `target [¤section `section] [¤options `options]
      [Where 'label' is the hyperlink label.] ; eol
      [Where 'target' is the link destination.] ; eol
      [Where 'section' specify the section requested in the target page ('#' section in the URL).] ; eol
      [Where 'options' specifies some options to be passed to the target page ('?' section in the URL).]
    para
      [Sample code: 1:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            link "Pliant home page" "http://pliant.cx/"
        cell
          [------>]
        cell
          link "Pliant home page" "http://pliant.cx/"
    para
      [Various sections within a page are defined using 'section' instruction.]
    para
      [Syntax:]
      listing
        ¤section `name
      [Where 'name' is a string.]
    para
      [Sample code 2:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            section "mysection"
            text "bla bla bla[lf]"
            text "more bla bla bla[lf]"
            link "jump to beginning of my section" "" section "mysection"
        cell
          [------>]
        cell
          section "mysection"
          text "bla bla bla[lf]"
          text "more bla bla bla[lf]"
          link "jump to beginning of my section" "" section "mysection"
  
  header "note"
    para
      [The 'note' instruction is set to make a note in your document, you just have to indent the note content under the instruction.];eol
      [On the client side it will appear like an hypertext, and your note will be displayed on a new page]
    para
      [Syntax: ]
      listing
        ¤note `label
          `instructions
      [Where 'label' is the note label] ; eol
      [And 'instructions' is the content of your note.]
    para
      [Sample code:]
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            text "more "
            note "explanations"
              title "My sample note"
              text "As you can see the note is displayed on a new "
              text "page, but you included it in your main document"
            text " about notes."
        cell
          bold
            [------>]
        cell
          text "more "
          note "explanations"
            title "My sample note"
            text "As you can see the note is displayed on a new "
            text "page, but you included it in your main document"
          text " about notes."
  
  header "image"
    para
      [The 'image' instruction inserts image in your page.] ; eol
      [If 'image' has a single parameter, it's a true image pasted in the page, but if it has two or more parameters, it's a graphical hyperlink, just like 'link' introduced a text hyperlink.]
    para
      [Syntax:]
      listing
        ¤image `url [`target] [¤section `section] [¤options `options]
      [Where 'url' is the image access path.] ; eol
      [Where 'target' and the following parameters have exactly the same meaning as with 'link' instruction.] ; eol
      [Please also notice that the image will be inserted in the middle of the text. It means that if you want the image to be displayed alone on a line, you have to insert a '[lb]lf[rb]' character at the end of the text before the image (or an 'eol' instruction), and another at the beginning of the text after the image.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            text "A passive image:[lf]"
            image "/pliant/welcome/image/pliant.jpeg"
            eol
            text "An active image (in other words, an hyperlink):[lf]"
            image "/pliant/welcome/image/pliant.jpeg" "http://pliant.cx/"
            image "/pliant/welcome/image/pliant.jpeg" "http://pliant.cx/" # FIXME
        cell
          [------>]
        cell
          text "A passive image:[lf]"
          image "/pliant/welcome/image/pliant.jpeg"
          eol
          text "An active image (in other words, an hyperlink):[lf]"
          image "/pliant/welcome/image/pliant.jpeg" "http://pliant.cx/"
          image "/pliant/welcome/image/pliant.jpeg" # "http://pliant.cx/"
  
  header "listing"
    para
      [The 'listing' instruction displays pure ASCII code in your page.]
    para
      [Syntax:]
      listing
        ¤listing
          `bloc
      [Where 'bloc' is the ASCII text.] ; eol
      [Please notice that the Syntax is not completely free: all the listing content must be indented from the 'listing' instruction, but with any number, and maybe not always the same number of spaces on each line.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
             listing
                what ever you want
                 with free indentation
                and on several lines
        cell
          [------>]
        cell
          listing
            what ever you want
             with free indentation
            and on several lines
 
  header "highlight"
    para
      [The 'highlight' instruction is a very useful instruction which highlights any character string, to ask for reader's attention.] ; eol
    para
      [Syntax:]
      listing
        ¤highlight `string
      [Where string is the text you want to highlight.];eol
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            highlight "look at this"
        cell
          [------>]
        cell
          highlight "look at this"


section "structural"
header "Structural instructions"
   header "title"
    para
      [The 'title' instruction has the same function than <title> HTML tag, but more than giving a title to the page, it also display page's title in a preformatted style .]
    para  
      [Syntax:]
      listing
        ¤title `string
      [Where string is your page title.]
    para
      [Sample code:];eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            title "My page"
        cell
          [------>]
        cell color lsh 64 100/8 130
        cell color (color hsl 130 100/8 64)
          html "<FONT FACE=[dq]Helvetica[dq] SIZE=[dq]+4[dq]>"+(repeat 10 "&nbsp;")
          bold [My page]
          html (repeat 10 "&nbsp;")+"</FONT>"
    
  header "chapter"
    para 
      [The instruction 'chapter' is a big heading, in a preformatted style.]
    para
      [Syntax:]
      listing
        ¤chapter `string
      [Where 'string' is your chapter name.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            chapter "chapter XVI"
        cell
          [------>]
        cell
          chapter "chapter XVI"
 
  header "header"
    para
      [The `header` instruction is also a heading, if you indent an other 'header' instruction in it, you would have an other kind of heading, more soft with little size fonts.];eol
    para
      [Syntax:]
      listing
        ¤header `string
        `content
      [or]
      listing
        ¤header `string
          `content
      [Where 'string' is your header name.] ; eol
      [If 'content' is indented an contains some 'header' instructions, these will be considered introducing subparts rather then next parts.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            header "first"
            text "first text"
            header "one"
              header "two"
                text "second text"
        cell
          [------>]
        cell
          var Pointer:Int h :> env kmap "default header level" Int
          var Int memo := h ; h := 0
          # FIXME
          # var Pointer:Int h :> environment kmap "default header level" Int
          # var Int memo := h ; h := 0
          header "first"
          text "first text"
          header "one"   
            header "two"
              text "second text"
          h := memo
          # h := memo
               
  header "para"
    para
      [The 'para' instruction creates paragraphs.]
    para
      [Syntax: ]
      listing
        ¤para
          `instructions
      [where 'instructions' defines the content of the paragraph paragraph.]
    para
      [Sample code:];eol   
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:] 
        cell
          listing
            para
              text "once upon a time, bla bla bla"
              eol
              text "more bla bla bla."
            para
              text "and they lived happy and , bal bla bla"
              eol
              text "even more bla bla bla."
        cell
          [------>]
        cell
          para
            text "once upon a time, bla bla bla"
            eol
            text "more bla bla bla."
          para
            text "and they lived happy and , bal bla bla"
            eol
            text "even more bla bla bla."

  header "list"
    para
      [The 'list' instruction makes a list of item.] ; eol
      [Please remind that you must indent each item of the list and introduce it with 'item' instruction.]
    para
      [Syntax:]
      listing
        ¤list 
          ¤item
            `instructions
          ¤item
            `instructions
      [Where 'instructions' defines the content of each item of your list.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            list
              item
                text "banana"
              item
                text "apple"
                eol
                text "and lemon"
              item
                text "orange"
        cell
          [------>]
        cell
          list
            item
              text "banana"
            item
              text "apple" 
              eol
              text "and lemon"
            item
              text "orange"
    para
      [If you indent a new list in a list, you would have different kind.];eol
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            list
              item
                text "fruits"
                list
                  item 
                    text "banana"
                  item 
                    text "apple"
        cell
          [------>]
          
        cell
          list
            item
              [fruits]
              list
                item
                  [banana]
                item 
                  [apple]  
  
  header "table"
    para
      [HTML makes intensive usage of tables with no border, as they are a very efficient way to define the page layout. ]
      [If you are not awarded of tables as a powerfull page layout mechanism, please refer to some HTML documentation.]
    para
      [To make a table with Pliant .page format, you must declare the number of columns so that when introducing a new cell, the system knows if they it has to be displayed on the same row or on the next one.] ; eol
      [Inside the table you have to indent each cell and introduce it with 'cell' instruction.];eol
    para
      [Syntax:]
      listing
        ¤table ¤columns `columns [¤border `size]
          ¤cell [¤color ¤lsh `l `s `h] [¤color ¤rgb `r `g `b]
            `instructions
          ¤cell [¤color ¤lsh `l `s `h] [¤color ¤rgb `r `g `b]
            `instructions
      [If omited, the border size will be one.] ; eol
      [See 'color' instruction for details about the color option in cells.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            table columns 3
              cell
                text"cell one"
              cell
                text "cell two"
              cell 
                text "cell three"
              cell
                text"cell four"
              cell
                text "cell five"
              cell 
                text "cell six"
                  
        cell
          [------>]
        cell
          table columns 3
            cell
              text"cell one"
            cell
              text "cell two"
            cell 
              text "cell three"
            cell
              text"cell four"
            cell
              text "cell five"
            cell 
              text "cell six"
                

section "attributes"
header "Attributes"
  para
    [These instructions change any element's style, you just have to indent any instruction in it.] 
   
  header "bold"
    para
      [The 'bold' instruction displays text in bold.]
    para 
      [Syntax :]
      listing 
        ¤bold
           `instructions
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            bold
              text "Displayed in bold"
              eol
              text "also bold"
            text " no more bold"  
        cell
          [------>]
        cell
          bold
            text "Displayed in bold"
            eol
            text "also bold"
          text " no more bold"  

  header "italic"
    para
      [The 'italic' instruction displays text in italic.]
    para
      [Syntax :]
      listing 
        ¤italic
           `instructions
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            italic
              text "Displayed in italic"   
        cell
          [------>]
        cell
         italic
           text "Displayed in italic"    
    
  header "small"
    para
      [The 'small' instruction decreases the font size.]
    para
      [Syntax :]
      listing 
        ¤small
           `instructions
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            small
              text "small font"   
        cell
          [------>]
        cell
          small
            text "small font"                 
    
  header "big"
    para
      [The 'big' instruction increases the font size.];eol
    para
      [Syntax :]
      listing 
        ¤big
           `instructions
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            big
              text "big font"   
        cell
          [------>]
        cell
          big
            text "big font"   

  header "center"
    para
      [The 'center' instruction aligns any element in the page or table center.]
    para
      [Syntax :]
      listing
        ¤center
          `instructions
    para
      [Sample code; ];eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            center
              text "The Pliant .page format is "
              eol
              text "an alternative to native HTML."   
        cell
          [------>]
          
        cell
          center
            text "The Pliant .page format is "
            eol
            text "an alternative to native HTML."         
  
  header "fixed"
    para
      [The 'fixed' instruction displays text in fixed font.]
    para
      [Syntax :]
      listing 
        ¤fixed
           `instructions
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            fixed
              text "This font is fixed"   
        cell
          [------>]
        cell
          fixed
            text "This font is fixed"

  section "color"                
  header "color"
    para
      [There are two ways to code colors with Pliant .page format: lsh encoding and rgb encoding.] ; eol
      [lsh stands for light saturation and hue. ]
      [Please notice that Pliant lsh encoding does not conform strictly to the CIE lsh encoding. ]
      [In particular, with Pliant lsh encoding 'light' value meaning has no effect when saturation=100.]
    para
      [Syntax :]
      listing 
        ¤color ¤lsh `light `saturation `hue
          `instructions
      [Where 'light' and 'saturation' are two floating point numbers ranging from 0 to 100 (they are percentages).] ; eol
      [And 'hue' is a floating point number ranging from 0 to 360 (it is a number of degrees).]
    para
      [The following tables should help you understand the meaning of 'light' 'saturation' and 'hue':]
      table columns 2 border 0
        var Float light := 50
        var Float sat1 := 10
        var Float hue := 0
        cell
          text "saturation = 0[lf]so hue does not matter"
        cell
          table columns 6
            cell color lsh 90 20 60 bold:[light]
            cell color lsh 90 20 60 [0]
            cell color lsh 90 20 60 [25]
            cell color lsh 90 20 60 [50]
            cell color lsh 90 20 60 [75]
            cell color lsh 90 20 60 [100]
            cell color lsh 90 20 60 [result]
            cell color lsh 0 0 0
              color lsh 100 0 0 [black]
            cell color lsh 25 0 0 [dark grey]
            cell color lsh 50 0 0 [grey]
            cell color lsh 75 0 0 [light grey]
            cell color lsh 100 0 0 [white]
            cell header bold:[light]
            cell header [0]
            cell header [25]
            cell header [50]
            cell header [75]
            cell header [100]
            cell header [result]
            cell color (color hsl 0 0 0)
              font color (color hsl 0 0 100) [black]
            cell color (color hsl 0 0 25) [dark grey]
            cell color (color hsl 0 0 50) [grey]
            cell color (color hsl 0 0 75) [light grey]
            cell color (color hsl 0 0 100) [white]
        cell
          text "light = "+string:light+" , hue = "+string:hue
        cell
          table columns 5
            cell color lsh 90 20 60 bold:[saturation]
            cell color lsh 90 20 60 [0]
            cell color lsh 90 20 60 [10]
            cell color lsh 90 20 60 [50]
            cell color lsh 90 20 60 [100]
            cell color lsh 90 20 60 [result]
            cell color lsh light 0 hue [grey]
            cell color lsh light 10 hue [redish grey]
            cell color lsh light 50 hue [dull red]
            cell color lsh light 100 hue [pure red]
            cell header bold:[saturation]
            cell header [0]
            cell header [10]
            cell header [50]
            cell header [100]
            cell header [result]
            cell color (color hsl hue 0 light) [grey]
            cell color (color hsl hue 10 light) [redish grey]
            cell color (color hsl hue 50 light) [dull red]
            cell color (color hsl hue 100 light) [pure red]
        cell
          text "saturation = 100[lf]so light does not matter"
        cell
          table columns 8
            cell color lsh 90 20 60 bold:[hue]
            cell color lsh 90 20 60 [0]
            cell color lsh 90 20 60 [60]
            cell color lsh 90 20 60 [120]
            cell color lsh 90 20 60 [180]
            cell color lsh 90 20 60 [240]
            cell color lsh 90 20 60 [300]
            cell color lsh 90 20 60 [360]
            cell color lsh 90 20 60 [result]
            cell color lsh light 100 0 [red]
            cell color lsh light 100 60 [yellow]
            cell color lsh light 100 120 [green]
            cell color lsh light 100 180 [cyan]
            cell color lsh light 100 240 [blue]
            cell color lsh light 100 300 [magenta]
            cell color lsh light 100 360 [red]
            cell header bold:[hue]
            cell header [0]
            cell header [60]
            cell header [120]
            cell header [180]
            cell header [240]
            cell header [300]
            cell header [360]
            cell header [result]
            cell color (color hsl 0 100 light) [red]
            cell color (color hsl 60 100 light) [yellow]
            cell color (color hsl 120 100 light) [green]
            cell color (color hsl 180 100 light) [cyan]
            cell color (color hsl 240 100 light) [blue]
            cell color (color hsl 300 100 light) [magenta]
            cell color (color hsl 360 100 light) [red]
        cell
          text "light = "+string:light
        cell
          table columns 4
            cell color lsh 90 20 60 bold:[hue / saturation] ; cell color lsh 90 20 60 (text string:sat1) ; cell color lsh 90 20 60 [50] ; cell color lsh 90 20 60 [100]
            cell color lsh 90 20 60 [0] ; cell color lsh light sat1 0 [red] ; cell color lsh light 50 0 [red] ; cell color lsh light 100 0 [red]
            cell color lsh 90 20 60 [30] ; cell color lsh light sat1 30 [orange] ; cell color lsh light 50 30 [orange] ; cell color lsh light 100 30 [orange]
            cell color lsh 90 20 60 [60] ; cell color lsh light sat1 60 [yellow] ; cell color lsh light 50 60 [yellow] ; cell color lsh light 100 60 [yellow]
            cell color lsh 90 20 60 [120] ; cell color lsh light sat1 120 [green] ; cell color lsh light 50 120 [green] ; cell color lsh light 100 120 [green]
            cell color lsh 90 20 60 [180] ; cell color lsh light sat1 180 [cyan] ; cell color lsh light 50 180 [cyan] ; cell color lsh light 100 180 [cyan]
            cell color lsh 90 20 60 [240] ; cell color lsh light sat1 240 [blue] ; cell color lsh light 50 240 [blue] ; cell color lsh light 100 240 [blue]
            cell color lsh 90 20 60 [300] ; cell color lsh light sat1 360 [magenta] ; cell color lsh light 50 300 [magenta] ; cell color lsh light 100 300 [magenta]
            cell header bold:[hue / saturation] ; cell header (text string:sat1) ; cell header [50] ; cell header [100]
            cell header [0] ; cell color (color hsl 0 sat1 light) [red] ; cell color (color hsl 0 50 light) [red] ; cell color (color hsl 0 100 light) [red]
            cell header [30] ; cell color (color hsl 30 sat1 light) [orange] ; cell color (color hsl 30 50 light) [orange] ; cell color (color hsl 30 100 light) [orange]
            cell header [60] ; cell color (color hsl 60 sat1 light) [yellow] ; cell color (color hsl 60 50 light) [yellow] ; cell color (color hsl 60 100 light) [yellow]
            cell header [120] ; cell color (color hsl 120 sat1 light) [green] ; cell color (color hsl 120 50 light) [green] ; cell color (color hsl 120 100 light) [green]
            cell header [180] ; cell color (color hsl 180 sat1 light) [cyan] ; cell color (color hsl 180 50 light) [cyan] ; cell color (color hsl 180 100 light) [cyan]
            cell header [240] ; cell color (color hsl 240 sat1 light) [blue] ; cell color (color hsl 240 50 light) [blue] ; cell color (color hsl 240 100 light) [blue]
            cell header [300] ; cell color (color hsl 300 sat1 light) [magenta] ; cell color (color hsl 300 50 light) [magenta] ; cell color (color hsl 300 100 light) [magenta]
        cell
          text "hue = "+string:hue
        cell
          table columns 4
            cell color lsh 90 20 60 bold:[light / saturation] ; cell color lsh 90 20 60 (text string:sat1) ; cell color lsh 90 20 60 [50] ; cell color lsh 90 20 60 [100]
            cell color lsh 90 20 60 [0] ; cell color lsh 0 sat1 hue [sample] ; cell color lsh 0 50 hue [sample] ; cell color lsh 0 100 hue [sample]
            cell color lsh 90 20 60 [25] ; cell color lsh 25 sat1 hue [sample] ; cell color lsh 25 50 hue [sample] ; cell color lsh 25 100 hue [sample]
            cell color lsh 90 20 60 [50] ; cell color lsh 50 sat1 hue [sample] ; cell color lsh 50 50 hue [sample] ; cell color lsh 50 100 hue [sample]
            cell color lsh 90 20 60 [75] ; cell color lsh 75 sat1 hue [sample] ; cell color lsh 75 50 hue [sample] ; cell color lsh 75 100 hue [sample]
            cell color lsh 90 20 60 [100] ; cell color lsh 100 sat1 hue [sample] ; cell color lsh 100 50 hue [sample] ; cell color lsh 100 100 hue [sample]
            cell header bold:[light / saturation] ; cell header (text string:sat1) ; cell header [50] ; cell header [100]
            cell header [0] ; cell color (color hsl hue sat1 0) [sample] ; cell color (color hsl hue 50 0) [sample] ; cell color (color hsl hue 100 0) [sample]
            cell header [25] ; cell color (color hsl hue sat1 25) [sample] ; cell color (color hsl hue 50 25) [sample] ; cell color (color hsl hue 100 25) [sample]
            cell header [50] ; cell color (color hsl hue sat1 50) [sample] ; cell color (color hsl hue 50 50) [sample] ; cell color (color hsl hue 100 50) [sample]
            cell header [75] ; cell color (color hsl hue sat1 75) [sample] ; cell color (color hsl hue 50 75) [sample] ; cell color (color hsl hue 100 75) [sample]
            cell header [100] ; cell color (color hsl hue sat1 100) [sample] ; cell color (color hsl hue 50 100) [sample] ; cell color (color hsl hue 100 100) [sample]
    para
      [Alternative syntax :]
      listing 
        ¤color ¤rgb `red `green `blue
          `instructions
      ['red' 'green' and 'blue' are three integers ranging from 0 to 255.] ; eol
      [This syntax will be more familiar to programmers, but it's not very logical, so the light saturation hue one is recommended.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            color lsh 50 100 60
            font color (color hsl 60 100 50)
              text "yellow text."   
        cell
          [------>]
        cell
          color lsh 50 100 60
          font color (color hsl 50 100 60)
            text "yellow text." 
    para
      [Sample code 2:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            color rgb 255 255 0
            font color (color rgb 255 255 0)
              text "yellow text."   
        cell
          [------>]
        cell
          color rgb 255 255 0
          font color (color rgb 255 255 0)
            text "yellow text." 
    para
      [Sample code 3:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            table columns 1
              cell color lsh 0 33 120
                color lsh 0 100 120
              cell color (color hsl 120 33 0)
                font color (color hsl 120 100 0)
                  text "green text, in a dark green cell."   
        cell
          [------>]
        cell
          table columns 1
            cell color lsh 0 33 120
              color lsh 0 100 120
            cell color (color hsl 120 33 0)
              font color (color hsl 120 100 0)
                text "green text, in a dark green cell." 


section "dynamic"
header "Dynamic instructions"
  header "dynamic"
    para
      [Just include the 'dynamic' instruction in your page, to describe your page as a dynamic one.] ; eol
      [If you forget it, and you page does not contain any input field and any button, then the HTTP server is allowed to cache the translated to HTML page.]
    para
      [Syntax:]
      listing
        ¤dynamic
  header "input"  
    para
      [The 'input' instruction creates a text area , which can be filled on the client side.];eol
    para
      [Syntax:]
      listing
        ¤input `label `variable
      [Where 'label' is a character string you want to be displayed as normal text in front of the input field.]
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            var Str name
            input "your name: " name
        cell
          [------>]
        cell
          var Str name
          input "your name: " name
  
  header "button"  
    para
      [The 'button' instruction is used to create dynamism in your web site, clicking on the button in the client browser will ask the server to execute any pliant code indented under it, and display the result on the client browser.]
    para
      [Syntax:]
      listing
        ¤button `label
          `instructions
      [Where 'label' is the button name.];eol
    para
      [Sample code:] ; eol
      table columns 3 border 0
        cell
          [source:]
        cell
          void
        cell
          [result:]
        cell
          listing
            var Int i := 3
            var Int j := 5
            input "Type a number: " i
            input "Type an other number: " j
            button "Calculate"
              text "The sum of "+(string i)+" and "+(string j)
              text " is "+(string i+j)
        cell
          [------>]
        cell
          var Int i := 3
          var Int j := 5
          input "Type a number: " i
          input "Type an other number: " j
          button "Calculate"
            text "The sum of "+(string i)+" and "+(string j)
            text " is "+(string i+j)


section "shortcuts"   
header "Shortcuts"  
  para
    [Some of pliant .page format instructions are very often used, so there are shortcut instructions to go faster.]
  
  header "brackets as a shotcut of 'text' instruction"
    para
      [bracketed text enables you to omit the 'text' instruction.]
    para
      [Syntax: ]
      listing
        ¤[`string¤]
     [Where 'string' is the character string you want to display.]
    para
      [The following sample]
      listing
        [your prose]
      [is equivalent to]
      listing
        text "your prose"
    para
      [So, the following sample]
      listing
        bold [your prose]
      [is equivalent to]
      listing
        bold
          text "your prose"

  header "semi colon for packaging several instruction on a single line"
    para
      [With [dq] ; [dq] you can write instructions on the same line.];eol
    para
      [Syntax: ]
      listing
        `instruction ¤; `instruction
    para
      [The following sample]
      listing
        [A ] ; bold [strong] ; [ word] ; eol
      [is equivalent to]
      listing
        text "A "
        bold
          text "strong"
        text " word"
        eol