The caveman2-widgets Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The caveman2-widgets Reference Manual

This is the caveman2-widgets Reference Manual, version 0.5, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 07:47:04 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

* caveman2-widgets
** What is it
caveman2-widgets is an extension library to [[https://github.com/fukamachi/caveman][caveman2]]. It is influenced
by [[https://github.com/skypher/weblocks][Weblocks]] and introduces its widget system for the developer. By
only using its widget concept it does not control the developer as
much as Weblocks itself. For people who don't now Weblocks' approach:
the developer can create web applications (more) like a normal GUI
application by using subclassable widgets which can have callbacks and
their like. Each Widget is only responsible for its own content but
might interfere with other objects through a given context.
#+LATEX: \\\\
But the really cool part is that the framework automatically creates
your site for dynamically (JavaScript based) access *and* normal
access. For the dynamic approach this means that you don't have to
manage or even care to refresh parts of your website, because widgets
can do that by themselves!

#+CAPTION: Quick overview where caveman2-widgets is in the caveman2 ecosystem
#+ATTR_LATEX: :width 10cm
#+LABEL: fig:overview
[[overview.jpg]]

** Installation
You can use caveman2-widgets with Quicklisp!
#+BEGIN_SRC lisp
(ql:quickload :caveman2-widgets)
#+END_SRC

If you want to contribute or be always up to date you can clone this
git-repository into "~/quicklisp/local-projects" or (if you are using
[[https://github.com/roswell/roswell][Roswell]]) "~/.roswell/local-projects" to QUICKLOAD it.
** See also
- [[https://github.com/ritschmaster/caveman2-widgets-bootstrap][caveman2-widgets-bootstrap]] :: Introduces new widgets that use
     [[https://getbootstrap.com/][Bootstrap]].
- [[https://github.com/ritschmaster/caveman2-widgets-blog][caveman2-widgets-blog]] :: An example application to demonstrate
     caveman2-widgets

** Websites running caveman2-widgets
- [[https://free-your-pc.com][Free-your-PC]] :: My personal website where I have among others a web
                  shop

Let me know if you use it too, to include you here!
** Contributions
You are very welcomed to contribute to this project! You can contribute by:
- Using it and spreading the word!
- Finding flaws and submitting [[https://github.com/ritschmaster/caveman2-widgets/issues][Issues]].
- Finding flaws and removing them (as [[https://github.com/ritschmaster/caveman2-widgets/pulls][Pull-requests]]).
- Adding new features (as [[https://github.com/ritschmaster/caveman2-widgets/pulls][Pull-requests]]). Before shooting in the dark
  create either an [[https://github.com/ritschmaster/caveman2-widgets/issues][Issues]] or mail me. Maybe your feature is on my
  agenda too.
- Showing your appreciation through a donation (please mail me for my
  IBAN). It may be a donation in kind too! Via PayPal you can donate
  to: richard.baeck@free-your-pc.com

If you add new features, please document them. Otherwise other
developers will have a hard time using this framework.
** Usage
*** General 
The only important thing is to run the function INIT-WIDGETS with an
. If you use caveman's MAKE-PROJECT function you will get file
called "src/web.lisp". In this file you can adapt the following:
#+BEGIN_SRC lisp

(defpackage my-caveman2-webapp.web
  (:use :cl
        :caveman2
        :caveman2-widgets ;; easy use of the external symbols of this project
        :my-caveman2-webapp.config
        :my-caveman2-webapp.view
        :my-caveman2-webapp.db
        :datafly
        :sxql)
  (:export :*web*))

;; some other code

;; the following will be generated through MAKE-PROJECT but is very important:
(defclass  () ())
(defvar *web* (make-instance '))
(clear-routing-rules *web*)


;; the neccessary call to initialize the widgets:
(init-widgets *web*)

;; from now on you can do whatever you want
#+END_SRC

*If you create objects from your widget classes, then please always
use the MAKE-WIDGET function!* This method should be used, since it
does all the background stuff for you.

*** Global scope
There are two scopes: /global/ and /session/. The global scope
"limits" the widget to *all* users. Therefore if you create a stateful
widget the state will be displayed to all users of your site. Use
MAKE-WIDGET with :GLOBAL to get a globally scoped widget.
#+LATEX: \\\\
A very simple example of what you can do with it:
#+BEGIN_SRC lisp
(defclass  ()
  ((enabled
    :initform nil
    :accessor enabled)))

(defmethod render-widget ((this ))
  (if (enabled this)
      "

enabled!

" "

not enabled

")) (defvar *global-widget* (make-widget :global ')) (defroute "/" () (render-widget *global-widget*)) (defroute "/disable" () (setf (enabled *global-widget*) nil) "disabled it") (defroute "/enable" () (setf (enabled *global-widget*) t) "enabled it") #+END_SRC A good practice to create disposable widgets is to mark them :GLOBAL. In the following example the widget will be created when a user connects and will afterwards immediately be destroyed again by the garbage collector. #+BEGIN_SRC lisp (defroute "/" () (render-widget (make-widget :global ' :text "Hello world!")) #+END_SRC *** Session scope The other option is to use a /session/ scope. This is a bit more tricky because all your /session/ widgets must be stored within the session (but not as user of this framework). :SESSION is the keyword for MAKE-WIDGET to get a /session/ widget. Of course you only need to save the top level (highest) widget of a widget tree in the session (the children will be saved where the parent is). A short overview of the functions: - SET-WIDGET-FOR-SESSION :: Saves a widget in the session variable. This should be considered ONLY for session scoped widgets. - GET-WIDGET-FOR-SESSION :: Gets a previously saved widget from the session variable (e.g. to render it). - REMOVE-WIDGET-FOR-SESSION :: Removes a saved widget from the session variable. An example (with children): #+BEGIN_SRC lisp (defclass () ()) (defmethod render-widget ((this )) (concatenate 'string "

display-id-widget id: " (caveman2-widgets.widget::id this) "

")) (defclass () ((id-widget :initform (make-widget :session ') :reader id-widget))) (defmethod render-widget ((this )) (concatenate 'string "

The id of your widget

" "

It should be different for each session

" "

My id: " (caveman2-widgets.widget::id this) "

" (render-widget (id-widget this)))) (defroute "/" () (set-widget-for-session :session-widget (make-widget :session ')) (concatenate 'string " " (render-widget (get-widget-for-session :session-widget)) (render-widget (make-widget :global ' :label "Reset session" :callback #'(lambda () (remove-widget-for-session :session-widget)))))) (defroute "/reset-session" () (remove-widget-for-session :session-widget) "reset your session") #+END_SRC *** Some default widgets and layouts There are some helpful default widgets which may help you with your code organisation. These are: - :: A layout which contains widgets that will be rendered vertically. - :: A layout like the but renders the widgets horizontally. - :: A layout which features sections to put widgets in. Please note that this widget has styles in */static/css/widgets.css*. - :: A widget which renders only a string. - :: A widget which uses a supplied function for rendering. Therefore the supplied function has to return a string! A simple example: #+BEGIN_SRC lisp (defroute "/composite" () (with-html-document (doc (make-instance ')) (setf (body doc) (make-widget :global ' :east (make-widget :global ' :text "

Hello from east

") :center (make-widget :global ' :widgets (list (make-widget :global ' :text "

Hello from left

") (make-widget :global ' :function #'(lambda () "

Hello from the mid

")) (make-widget :global ' :text "

Hello from right

"))) :west (make-widget :global ' :text "

Hello from west

"))))) #+END_SRC *** Buttons and links You can use buttons and links that call specific functions. When you create a button/link only for a session the created route will be guarded. Therefore only the user with the associated route may actually access his button. #+LATEX: \\\\ For each button there will be an URI like "/buttons/BUTTONID". You can access buttons via POST only. Links get a URI like "/links/LINKID" and can be accessed either by GET (get a redirect to the stored link) or by POST (return only the value of the link). In any case the callback function gets called - please keep that in mind. #+LATEX: \\\\ If the return value of the link matches the current path then the side will be reloaded entirely or, if JavaScript is enabled, the dirty widgets will be reloaded. Please leave out the starting "/" If you want to address a target on the localhost. E.g. you are on the page "/test", then return "test" if you want to stay on it. #+LATEX: \\\\ The BUTTONID and LINKID are the ID slots of the widget - which is default a symbol generated by GENSYM. But you can change that by giving your a specific ID (like in the example below). This will ensure that the route will persist otherwise the route for the will change with every restart of your website or with every new session (depends on the scope). *Be careful, the ID must be unique on object level, otherwise you overwrite routes!* #+LATEX: \\\\ An example: #+BEGIN_SRC lisp (defvar *got-here-by-link* nil) (defroute "/otherpage" () (if *got-here-by-link* (progn (setf *got-here-by-link* nil) "

Got here by pressing the link

") "

Got here by yourself

")) (defroute "/link-test" () (concatenate 'string (render-widget (make-widget :global ' :label "Github" :callback #'(lambda (args) (format t "LOG: Link clicked!") "http://github.com/ritschmaster") :target-foreign-p t ;; The link goes out of this domain )) (render-widget (make-widget :global ' :label "Otherpage" :id "otherpage" ;; href="/links/otherpage" :callback #'(lambda (args) (setf *got-here-by-link* t) "/otherpage") :target-foreign-p t ;; The link goes out of this domain )) (render-widget (make-widget :global ' :label "Button" :callback #'(lambda (args) (format t "LOG: Button clicked!")))))) #+END_SRC You can create your own callback widgets too. Just look at the , classes for that. *** Use caveman2-widgets for your entire HTML document To make your life really easy you can create an entire HTML document. You can either tinker your own widgets or whatever with the and the or you can use the handy WITH-HTML-DOCUMENT macro. #+BEGIN_SRC lisp (defclass () ()) (defmethod render-widget ((this )) "Hello world!") (defclass () ()) (defmethod render-widget ((this )) "Hello from the other page!") (defvar *header-widget* (make-instance ' ;; the title when this header is used :title "Widgets test" ;; the icon when this header is used :icon-path "/images/icon.png" ;; the following lines will be rendered in the header: :other-header-content '("")) (defvar *root-widget* (make-widget :global ')) (defvar *otherpage-widget* (make-widget :global ')) (defroute "/" () ;; The *root-widget* can be accessed under: ;; /rest/root-widget?id=(caveman2-widgets.widget::id *root-widget*) (render-widget (make-instance ' ;; sets this specific header for this page :header *header-widget* :body *root-widget*))) (defroute "/otherpage" () (with-html-document (doc *header-widget*) (setf (body doc) *otherpage-widget*))) #+END_SRC *** Marking widgets dirty You can mark specific widgets as dirty with the function MARK-DIRTY. This means that they will be reloaded dynamically (if the user has JavaScript is enabled). Please notice that you can mark *any* widget as dirty. Therefore you can order JavaScript to reload global widgets and sessioned widgets. #+LATEX: \\\\ An example: #+BEGIN_SRC lisp (defclass () ((enabled :initform nil :accessor enabled))) (defmethod render-widget ((this )) (concatenate 'string "

Sessioned-widget:

" (if (enabled this) "

enabled!

" "

not enabled

"))) (defclass () ()) (defmethod render-widget ((this )) (concatenate 'string "

MARK-DIRTY test

" (render-widget (get-widget-for-session :sessioned-widget)) (render-widget (make-widget :global ' :label "Enable" :callback #'(lambda () (let ((sessioned-widget (get-widget-for-session :sessioned-widget))) (when sessioned-widget (setf (enabled sessioned-widget) t) (mark-dirty sessioned-widget)))))) (render-widget (make-widget :global ' :label "Disable" :callback #'(lambda () (let ((sessioned-widget (get-widget-for-session :sessioned-widget))) (when sessioned-widget (setf (enabled sessioned-widget) nil) (mark-dirty sessioned-widget)))))))) (defvar *header-widget* (make-instance ' :title "Mark-dirty test")) (defvar *my-body-widget* (make-widget :global ')) (defroute "/mark-dirty-test" () (set-widget-for-session :sessioned-widget (make-widget :session ')) (render-widget (make-instance ' :header *header-widget* :body *my-body-widget*))) #+END_SRC *** Navigation objects You can create navigation objects too! The purpose of navigation objects is that you don't have to manage a navigation ever again! Each navigation object contains another widget which displays the currently selected path. If you click on a navigation link that object is changed and refreshed (either via JavaScript or through the link). Please keep in mind that navigation objects are *session stateful widgets*. #+LATEX: \\\\ Paths are only created automatically by the DEFNAV macro. The first item in the list is the widget which will be displayed at the base path of the navigation. You can use any string as path but be careful to not interfere with the special paths of NINGLE (e.g. "/:some-path"). Do not use those. The only special path you can use is the wildcard (e.g "/*/"). #+LATEX: \\\\ A very basic example: #+BEGIN_SRC lisp (defvar *first-widget* (make-widget :global ' :text "

Hello world from first

")) (defvar *second-widget* (make-widget :global ' :text "

Hello world from second

")) (defclass () () (:documentation "This class enables session based widgets for a navigation.")) (defmethod render-widget ((this )) (set-widget-for-session :string-widget (make-widget :session ' :text "hello world")) (render-widget (get-widget-for-session :string-widget))) (defnav "/sophisticated/path" ((make-instance ' :title "Navigation test") (list (list "First widget" "first" *first-widget*) (list "Second widget" "second" *second-widget*) (list "Third widget" "third" (make-widget :global ')) (list "Hidden widget" "hidden" (make-widget :global ' :text "

You have accessed a hidden widget!

") :hidden)) :kind ')) #+END_SRC If the default navigation object doesn't render as you wish, you can subclass it and overwrite the RENDER-WIDGET method. Please notice that you can actually very easily adjust the path where the navigation and its widgets get rendered. The slot BASE-PATH is created for that. #+LATEX: \\\\ There are two default navigation widgets: - :: A navigation with a menu. You can change the menu appearance with CSS. With the :HIDDEN keyword you can hide a path from the navigation list. - :: A navigation without any menu. It is controlled by the URL only - or by other widgets. *** Table objects You can create a table very simple. A displays *all* items which are supplied through the PRODUCER function. #+LATEX: \\\\ Important for the usage of tables is that you supply a PRODUCER function. The function should return a list of objects. This function can be anything but it has to take the key arguments: - AMOUNT :: Tells how many items to get - ALREADY :: Tells how many items already received - LENGTH-P :: A flag which should tell the function to return the available items if active. AMOUNT and ALREADY can be seen as synonyms for FROM and TO. #+LATEX: \\\\ A object is needed for tables. The essence of those objects is that they can be translated to lists through the generic function GET-AS-LIST. Therefore you don't have to subclass at all just to add an implementation of GET-AS-LIST for your used class. #+LATEX: \\\\ For the consider the following example: #+BEGIN_SRC lisp (defclass () ((id :initarg :id :reader id) (name :initarg :name :reader name) (description :initarg :description :reader description))) (defmethod get-as-list ((this )) (list :id (id this) :name (name this) :description (description this))) (defun producer (&key amount (already 0) (length-p nil)) (if (null length-p) (let ((all '())) (if (null amount) (loop for x from 1 to 1000 do (setf all (append all (list (make-instance ' :id x :name (format nil "~a" x) :description (format nil "The ~a. item." x)))))) (loop for x from (+ already 1) to (+ already amount) do (setf all (append all (list (make-instance ' :id x :name (format nil "~a" x) :description (format nil "The ~a. item." x))))))) all) 1000)) (defvar *table-widget* (make-widget :global ' :producer 'producer :column-descriptions (list (list :name "Name") (list :description "Description")))) (defroute "/table" () (with-html-document (doc (make-instance ')) (setf (body doc) *table-widget*))) #+END_SRC *** Viewgrids The is used to display a bulk of heterogenous items. The items must implement the RENDER-AS method. The calls RENDER-AS with its VIEW slot. Therefore you have provide an implementation for the keyword supplied by VIEW in your . #+LATEX: \\\\ You can limit the displayed items with the MAX-ITEMS-TO-DISPLAY slot. If this slot is active the items are delivered on several pages instead on only one. If you supply additionally the DISPLAY-SELECTOR with the URI path on which the object is rendered, then selectable page numbers are displayed on the bottom too. #+LATEX: \\\\ Each item can be accessed. When accessing the item a specific given function is called with the item as parameter. #+LATEX: \\\\ The following example covers all functionality: #+BEGIN_SRC lisp (defclass () ((id :initarg :id :reader id) (name :initarg :name :reader name) (description :initarg :description :reader description))) (defmethod render-as ((this ) (view (eql :short))) (format nil "
id: ~a
name: ~a
desc: ~a
" (id this) (name this) (description this))) (defun producer (&key (from 0) (to nil) (length-p nil)) (let ((all '())) (loop for x from 1 to 35 do (setf all (append all (list (make-instance ' :id x :name (format nil "~a" x) :description (format nil "The ~a. item." x)))))) (cond (length-p (length all)) ((and from (not to)) (mapcan #'(lambda (item) (if (>= (id item) from) (list item) nil)) all)) ((and from to) (mapcan #'(lambda (item) (if (and (>= (id item) from) (< (id item) to)) (list item) nil)) all))))) (defroute "/viewgrid" () (with-html-document (doc (make-instance ')) (set-widget-for-session :viewgrid (make-widget :session ' :producer #'producer :view :short :max-items-to-display 11 :display-selector "viewgrid" :on-view #'(lambda (item) (format t (render-as item :short)) "viewgrid"))) (setf (body doc) (get-widget-for-session :viewgrid)))) #+END_SRC *** Forms Forms can be pretty annoying but with the you don't have to care for anything but for the naming of the inputs ever again. Each consists of 0 to n objects. If you have 0 objects it essentially only behaves like a . #+LATEX: \\\\ is the base class for fields. Fields can be: - :: Is basically an abstraction of the HTML input-tag. - :: Consists of objects. Of course you can implement your own classes too! But keep in mind that *the default already implements constraints*. #+LATEX: \\\\ To understand how constraints for forms work an examination of the available slots for objects is necessary: - REQUIRED :: A non-nil value indicates that this field has to have some value. - SUPPLIED :: Will be set NIL by SET-REQUIRED-PRESENT and set T by RENDER-WIDGET. It is NIL if the field is not supplied and is therefore not dependent on REQUIRED. It should tell the server whether an parameter was passed or not. - CHECK-FUNCTION :: Will be called by SET-REQUIRED-PRESENT and check if the passed value by the client is "correct". It is a lambda with one argument, which is the passed string from the client. Should return NIL if the passed string was not correct and a non-nil value otherwise. - ERROR-HAPPENED :: Will be set to T by SET-REQUIRED-PRESENT if the CHECK-FUNCTION did not succeed. The rendering the form will set it to NIL again. - ERROR-MESSAGE :: The message that will be displayed if ERROR-HAPPENED is T. You don't have to actually care for that procedure as the calls this the SET-REQUIRED-PRESENT by itself. But it can be helpful to understand the entire process of checking the user input. The only thing to really memorize here is that *the given callback only gets called if all required fields where supplied and those fields where supplied correctly*. #+LATEX: \\\\ Consider the following example for additional help: #+BEGIN_SRC lisp (defvar *password-field* (make-instance ' :input-type "password" :check-function #'(lambda (pass) (if (<= (length pass) 2) nil t)) :error-message "Has to be longer than 2" :name "password" :value "")) (defvar *form-widget* (let ((text-field (make-instance ' :input-type "text" :name "text" :value "" :required t)) (choice-field (make-instance ' :name "selection" :options (list (make-instance ' :value "first") (make-instance ' :value "second" :display-value "Other"))))) (make-widget :global ' :input-fields (list text-field *password-field* choice-field) :label "Submit" :callback #'(lambda (args) (format t "received correct values: ~a -------------" args))))) (defroute "/form" () (with-html-document (doc (make-instance ')) (setf (body doc) *form-widget*))) #+END_SRC *** Protecting widgets This library also enables you to protect widgets. Each widget has an associated list of keywords which indicate the levels/circles of authorization an requester needs. #+LATEX: \\\\ By default the protection is an empty list (therefore NIL), which means that everybody can access your widget. If the protection is non-nil the non-nil value is a list of keywords which refers to a list of keywords stored in the session. So if the session contains the required keyword in its list the requester can access the widget. Otherwise he is denied (throws a 403 code). #+LATEX: \\\\ The class holds the PROTECTED slot. This slots value indicates the needed token in the session. But caveman2-widgets supplies an additional, specific *PROTECT-WIDGET* method which should be used. You can supply the following parameters: - :LOGIN :: Protects the widget by the default login-widget - A keyword in general :: Protects the widget with this keyword (adds it) - A list of keywords :: Protects the widget with this keywords (adds them) #+BEGIN_SRC lisp (defvar *specific-protected-widget* (protect-widget (make-widget :global ' :text "

This is a protected text

") :myprotection)) ;; Should throw 403 (defroute "/protected-widget" () (concatenate 'string "Will throw 403" (render-widget *specific-protected-widget*))) (defmethod on-exception ((app ) (code (eql 403))) (declare (ignore app)) "403 - The protection works.") #+END_SRC *** Login Protecting certain widgets by a login is very easy. The organizes the following things: 1. It displays a login form and logs the client in if he passes the challenge. The successful pass sets will result in an permanent non-nil value if you call "(LOGGED-IN *SESSION*)". This means that every widget that requires the authroization level :LOGIN through the PROTECT-WIDGET method can now be accessed by the user. 2. It supplies a Logout button. This button can be access through the LOGOUT-BUTTON reader. You therefore can render the button anywhere you like. Pressing the button will result in a logout and therefore in a permanent NIL for "(LOGGED-IN *SESSION*)". 3. It renders certain widgets if the login was successful. This can be either used e.g. for a success message. *The has to run in :SESSION scope!* #+LATEX: \\\\ Additionally you can specify different authentication challanges (authentication functions) if you wish. But using the and passing the challenge will *only* set the authoriatzition level to :LOGIN. This means that you need to create your own if you want some other level for different authentication functions! #+BEGIN_SRC lisp (defvar *protected-widget* (protect-widget (make-widget :global ' :text "

This is a protected text

") :login)) (defroute "/" () (with-html-document (doc (make-instance ')) (setf (body doc) (make-widget :global ' :function #'(lambda () (set-widget-for-session ;; running it in the session :login-widget (make-widget :session ' :authenticator #'(lambda (user password) (if (and (string= user "ritschmaster") (string= password "secret")) t nil)) :widgets (list *protected-widget*))) (render-widget (get-widget-for-session :login-widget))))))) #+END_SRC *** Language getting/setting To store the accpeted languages in the session there is the CHECK-AND-SET-LANGUAGE function. This function uses the value supplied through the "Accept-languages" field in the HTTP request. It gets called through the render method by any automatically. Which means that as soon as you use it you don't have to worry about getting the language. But on the other hand you have to make sure that every subclass of again uses CHECK-AND-SET-LANGUAGE in its render-method. #+LATEX: \\\\ You can access the currently accepted languages through the ACCEPTED-LANGUAGES. #+LATEX: \\\\ If you rather use a manual language chooser you can supply AUTOMATICALLY-SET-LANGUAGES as NIL to the INIT-WIDGETS function. Please then use the setf method for ACCEPTED-LANGUAGES to set the language. *** Translations Most strings that are rendered human readable get translated through a special function. You can specify your own translation function by passing it to INIT-WIDGETS as :TRANSLATION-FUNCTION. The function header should look like this: #+BEGIN_SRC lisp (defvar *my-translation-function* #'(lambda (text &key plural-p genitive-form-p items-count accusative-form-p language &allow-other-keys) text)) #+END_SRC Strings that are translated: - The page names of a navigation Strings that are definitely *not* translated: - The TEXT of a - The return value of a *** Development hooks In case you want to do things at compile time (e.g. calling DEFROUTE) whe INIT-WIDGETS is evaluated there is the variable *INIT-WIDGETS-HOOKS*. Just append new functions as you wish. #+BEGIN_SRC lisp (setf *init-widgets-hooks* (append *init-widgets-hooks* (list #'(lambda () (defroute "/something" () ;; Accessing the user supplied object: (describe caveman2-widgets::*web*) "something"))))) #+END_SRC ** Important notes/Things that happen automatically The following things you should keep in mind when using caveman2-widgets. *** Automatically REST API creation If you create a widget then routes for a REST API will be added automatically. Suppose you subclass with the class , then you will get the path "/rest/my-widget" which you can access. #+BEGIN_SRC lisp (defclass () ()) (defmethod render-widget ((this )) "my-widget representation for the website") (defmethod render-widget-rest ((this ) (method (eql :get)) (args t)) "my-widget representation for the REST.") (defmethod render-widget-rest ((this ) (method (eql :post)) (args t)) (render-widget this)) #+END_SRC Buttons and Links are *not* accessed through the REST path (see the section above). Widgets that are not accessible through the REST: - - *** Encapsulating widgets with divs Each widget gets wrapped in a div automatically. Every widget will get its entire class heritage included in the CSS class attribute. Therefore you can access every widget (and derived widget) very easily with CSS. *** JavaScript dependencies When is used all JavaScript dependencies are added automatically. Please notice that these dependecies are needed to ensure that the widgets work properly. If you don't want to use you have to manually add jQuery and all the JavaScript Code supplied/needed by caveman2-widgets. The routes for the JavaScript files (which have to be included in each HTML file) are: - /widgets/js/widgets.js The jQuery-Version used is 2.2.2 minified. If you want another jQuery file you can specify it with the variable \*jquery-cdn-link\* (should be an URL). *If you forget to use the JavaScript-files widgets might not work or even break. Most likely all dynamic content just won't work (automatically fallback to non-JS)* *** CSS dependencies As with JavaScript, stylesheets are added in the automatically too. The routes you need in your head tag are: - /widgets/css/widgets.css *** Session values This section should inform you about keywords in the session variable which you should absolutely not modify. - :WIDGET-HOLDER :: object. It holds all the session scoped widgets. - :DIRTY-OBJECT-IDS :: The name says it all. - :JAVASCRIPT-AVAILABLE :: Holds a boolean value if JavaScript is available or not. - :ACCEPT-LANGUAGE :: Holds the languages accepted by the client. ** Author + Richard Paul Bäck (richard.baeck@free-your-pc.com) ** Copyright Copyright (c) 2016 Richard Paul Bäck (richard.baeck@free-your-pc.com) ** License Licensed under the LLGPL License.

Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 caveman2-widgets

Author

Richard Paul Bäck

License

LLGPL

Description

Weblocks like widgets for caveman2.

Long Description

* caveman2-widgets
** What is it
caveman2-widgets is an extension library to [[https://github.com/fukamachi/caveman][caveman2]]. It is influenced
by [[https://github.com/skypher/weblocks][Weblocks]] and introduces its widget system for the developer. By
only using its widget concept it does not control the developer as
much as Weblocks itself. For people who don’t now Weblocks’ approach:
the developer can create web applications (more) like a normal GUI
application by using subclassable widgets which can have callbacks and
their like. Each Widget is only responsible for its own content but
might interfere with other objects through a given context.
#+LATEX: \\\\
But the really cool part is that the framework automatically creates
your site for dynamically (JavaScript based) access *and* normal
access. For the dynamic approach this means that you don’t have to
manage or even care to refresh parts of your website, because widgets
can do that by themselves!

#+CAPTION: Quick overview where caveman2-widgets is in the caveman2 ecosystem
#+ATTR_LATEX: :width 10cm
#+LABEL: fig:overview
[[overview.jpg]]

** Installation
You can use caveman2-widgets with Quicklisp!
#+BEGIN_SRC lisp
(ql:quickload :caveman2-widgets)
#+END_SRC

If you want to contribute or be always up to date you can clone this
git-repository into "~/quicklisp/local-projects" or (if you are using
[[https://github.com/roswell/roswell][Roswell]]) "~/.roswell/local-projects" to QUICKLOAD it.
** See also
- [[https://github.com/ritschmaster/caveman2-widgets-bootstrap][caveman2-widgets-bootstrap]] :: Introduces new widgets that use [[https://getbootstrap.com/][Bootstrap]].
- [[https://github.com/ritschmaster/caveman2-widgets-blog][caveman2-widgets-blog]] :: An example application to demonstrate caveman2-widgets

** Websites running caveman2-widgets
- [[https://free-your-pc.com][Free-your-PC]] :: My personal website where I have among others a web
shop

Let me know if you use it too, to include you here!
** Contributions
You are very welcomed to contribute to this project! You can contribute by:
- Using it and spreading the word!
- Finding flaws and submitting [[https://github.com/ritschmaster/caveman2-widgets/issues][Issues]].
- Finding flaws and removing them (as [[https://github.com/ritschmaster/caveman2-widgets/pulls][Pull-requests]]).
- Adding new features (as [[https://github.com/ritschmaster/caveman2-widgets/pulls][Pull-requests]]). Before shooting in the dark create either an [[https://github.com/ritschmaster/caveman2-widgets/issues][Issues]] or mail me. Maybe your feature is on my agenda too.
- Showing your appreciation through a donation (please mail me for my
IBAN). It may be a donation in kind too! Via PayPal you can donate
to: richard.baeck@free-your-pc.com

If you add new features, please document them. Otherwise other
developers will have a hard time using this framework.
** Usage
*** General
The only important thing is to run the function INIT-WIDGETS with an
<APP>. If you use caveman’s MAKE-PROJECT function you will get file
called "src/web.lisp". In this file you can adapt the following:
#+BEGIN_SRC lisp

(defpackage my-caveman2-webapp.web
(:use :cl
:caveman2
:caveman2-widgets ;; easy use of the external symbols of this project
:my-caveman2-webapp.config
:my-caveman2-webapp.view
:my-caveman2-webapp.db
:datafly
:sxql)
(:export :*web*))

;; some other code

;; the following will be generated through MAKE-PROJECT but is very important:
(defclass <web> (<app>) ())
(defvar *web* (make-instance ’<web>))
(clear-routing-rules *web*)

;; the neccessary call to initialize the widgets:
(init-widgets *web*)

;; from now on you can do whatever you want
#+END_SRC

*If you create objects from your widget classes, then please always
use the MAKE-WIDGET function!* This method should be used, since it
does all the background stuff for you.

*** Global scope
There are two scopes: /global/ and /session/. The global scope
"limits" the widget to *all* users. Therefore if you create a stateful
widget the state will be displayed to all users of your site. Use
MAKE-WIDGET with :GLOBAL to get a globally scoped widget.
#+LATEX: \\\\
A very simple example of what you can do with it:
#+BEGIN_SRC lisp
(defclass <global-widget> (<widget>)
((enabled
:initform nil
:accessor enabled)))

(defmethod render-widget ((this <global-widget>))
(if (enabled this)
"<h1>enabled!</h1>"
"<h1>not enabled</h1>"))

(defvar *global-widget* (make-widget :global ’<global-widget>))

(defroute "/" ()
(render-widget *global-widget*))

(defroute "/disable" ()
(setf (enabled *global-widget*) nil)
"disabled it")

(defroute "/enable" ()
(setf (enabled *global-widget*) t)
"enabled it")
#+END_SRC

A good practice to create disposable widgets is to mark
them :GLOBAL. In the following example the widget will be created when
a user connects and will afterwards immediately be destroyed again by
the garbage collector.
#+BEGIN_SRC lisp
(defroute "/" ()
(render-widget
(make-widget :global ’<string-widget>
:text "Hello world!"))
#+END_SRC

*** Session scope
The other option is to use a /session/ scope. This is a bit more
tricky because all your /session/ widgets must be stored within the
session (but not as user of this framework). :SESSION is the keyword
for MAKE-WIDGET to get a /session/ widget. Of course you only need to
save the top level (highest) widget of a widget tree in the session
(the children will be saved where the parent is). A short overview of
the functions:
- SET-WIDGET-FOR-SESSION :: Saves a widget in the session
variable. This should be considered ONLY for session scoped
widgets.
- GET-WIDGET-FOR-SESSION :: Gets a previously saved widget from the
session variable (e.g. to render it).
- REMOVE-WIDGET-FOR-SESSION :: Removes a saved widget from the session
variable.

An example (with children):
#+BEGIN_SRC lisp
(defclass <display-id-widget> (<widget>)
())

(defmethod render-widget ((this <display-id-widget>))
(concatenate ’string
"<h3>display-id-widget id: <a href=\"/rest/display-id-widget?id="
(caveman2-widgets.widget::id this)
"\">"
(caveman2-widgets.widget::id this)
"</a></h3>"))

(defclass <session-widget> (<widget>)
((id-widget
:initform (make-widget :session ’<display-id-widget>)
:reader id-widget)))

(defmethod render-widget ((this <session-widget>))
(concatenate ’string
"<h1>The id of your widget</h1>"
"<h2>It should be different for each session</h2>"
"<p>My id: <a href=\"/rest/session-widget?id="
(caveman2-widgets.widget::id this)
"\">"
(caveman2-widgets.widget::id this)
"</a></p>"
(render-widget (id-widget this))))

(defroute "/" ()
(set-widget-for-session :session-widget
(make-widget :session ’<session-widget>))
(concatenate ’string
"<head>
<script src=\"https://code.jquery.com/jquery-2.2.2.min.js\" type=\"text/javascript\"></script>
<script src=\"/widgets/js/widgets.js\" type=\"text/javascript\"></script>
</head>"

(render-widget
(get-widget-for-session :session-widget))
(render-widget
(make-widget :global ’<button-widget>
:label "Reset session"
:callback #’(lambda ()
(remove-widget-for-session :session-widget))))))

(defroute "/reset-session" ()
(remove-widget-for-session :session-widget)
"reset your session")
#+END_SRC

*** Some default widgets and layouts
There are some helpful default widgets which may help you with your
code organisation. These are:
- <COMPOSITE-WIDGET> :: A layout which contains widgets that will be rendered
vertically.
- <HCOMPOSITE-WIDGET> :: A layout like the <COMPOSITE-WIDGET> but renders the
widgets horizontally.
- <BORDER-WIDGET> :: A layout which features sections to put widgets
in. Please note that this widget has styles in
*/static/css/widgets.css*.
- <STRING-WIDGET> :: A widget which renders only a string.
- <FUNCTION-WIDGET> :: A widget which uses a supplied function for
rendering. Therefore the supplied function has to return a
string!

A simple example:
#+BEGIN_SRC lisp
(defroute "/composite" ()
(with-html-document
(doc
(make-instance ’<header-widget>))
(setf (body doc)
(make-widget
:global ’<border-widget>
:east (make-widget :global ’<string-widget>
:text "<h2>Hello from east</h2>")
:center
(make-widget
:global ’<hcomposite-widget>
:widgets (list
(make-widget :global ’<string-widget>
:text "<h1>Hello from left</h1>")
(make-widget :global ’<function-widget>
:function
#’(lambda ()
"<h1>Hello from the mid</h1>"))
(make-widget :global ’<string-widget>
:text "<h1>Hello from right</h1>")))
:west (make-widget :global ’<string-widget>
:text "<h2>Hello from west</h2>")))))
#+END_SRC
*** Buttons and links
You can use buttons and links that call specific functions. When you
create a button/link only for a session the created route will be
guarded. Therefore only the user with the associated route may
actually access his button.
#+LATEX: \\\\
For each button there will be an URI like "/buttons/BUTTONID". You can
access buttons via POST only. Links get a URI like "/links/LINKID" and
can be accessed either by GET (get a redirect to the stored link) or
by POST (return only the value of the link). In any case the callback
function gets called - please keep that in mind.
#+LATEX: \\\\
If the return value of the link matches the current path then the side
will be reloaded entirely or, if JavaScript is enabled, the dirty
widgets will be reloaded. Please leave out the starting "/" If you
want to address a target on the localhost. E.g. you are on the page
"/test", then return "test" if you want to stay on it.
#+LATEX: \\\\
The BUTTONID and LINKID are the ID slots of the widget - which is
default a symbol generated by GENSYM. But you can change that by
giving your <CALLBACK-WIDGET> a specific ID (like in the example
below). This will ensure that the route will persist otherwise the
route for the <CALLBACK-WIDGET> will change with every restart of your
website or with every new session (depends on the scope). *Be careful,
the ID must be unique on object level, otherwise you overwrite
routes!*
#+LATEX: \\\\
An example:
#+BEGIN_SRC lisp
(defvar *got-here-by-link* nil)

(defroute "/otherpage" ()
(if *got-here-by-link*
(progn
(setf *got-here-by-link* nil)
"<h1>Got here by pressing the link</h2>")
"<h1>Got here by yourself</h2>"))

(defroute "/link-test" ()
(concatenate ’string
(render-widget
(make-widget :global ’<link-widget>
:label "Github"
:callback #’(lambda (args)
(format t "LOG: Link clicked!") "http://github.com/ritschmaster")
:target-foreign-p t ;; The link goes out of this domain
))
(render-widget
(make-widget :global ’<link-widget>
:label "Otherpage"
:id "otherpage" ;; href="/links/otherpage"
:callback #’(lambda (args)
(setf *got-here-by-link* t) "/otherpage")
:target-foreign-p t ;; The link goes out of this domain
))
(render-widget
(make-widget :global ’<button-widget>
:label "Button"
:callback #’(lambda (args)
(format t
"LOG: Button clicked!"))))))
#+END_SRC

You can create your own callback widgets too. Just look at the
<CALLBACK-WIDGET>, <BUTTON-WIDGET> classes for that.

*** Use caveman2-widgets for your entire HTML document
To make your life really easy you can create an entire HTML
document. You can either tinker your own widgets or whatever with the
<HMTL-DOCUMENT-WIDGET> and the <HEADER-WIDGET> or you can use the
handy WITH-HTML-DOCUMENT macro.

#+BEGIN_SRC lisp
(defclass <root-widget> (<body-widget>)
())

(defmethod render-widget ((this <root-widget>))
"Hello world!")

(defclass <otherpage-widget> (<body-widget>)
())

(defmethod render-widget ((this <otherpage-widget>))
"Hello from the other page!")

(defvar *header-widget* (make-instance ’<header-widget>
;; the title when this header is used
:title "Widgets test"

;; the icon when this header is used
:icon-path "/images/icon.png"

;; the following lines will be rendered in the header: :other-header-content
’("<meta name=\"author\" content=\"Richard Bäck\">"))
(defvar *root-widget* (make-widget :global ’<root-widget>))
(defvar *otherpage-widget* (make-widget :global ’<otherpage-widget>))

(defroute "/" ()
;; The *root-widget* can be accessed under:
;; /rest/root-widget?id=(caveman2-widgets.widget::id *root-widget*)
(render-widget
(make-instance ’<html-document-widget>
;; sets this specific header for this page
:header *header-widget*
:body *root-widget*)))
(defroute "/otherpage" ()
(with-html-document (doc
*header-widget*)
(setf (body doc)
*otherpage-widget*)))

#+END_SRC

*** Marking widgets dirty
You can mark specific widgets as dirty with the function
MARK-DIRTY. This means that they will be reloaded dynamically (if the
user has JavaScript is enabled). Please notice that you can mark *any*
widget as dirty. Therefore you can order JavaScript to reload global
widgets and sessioned widgets.
#+LATEX: \\\\
An example:
#+BEGIN_SRC lisp
(defclass <sessioned-widget> (<widget>)
((enabled
:initform nil
:accessor enabled)))

(defmethod render-widget ((this <sessioned-widget>))
(concatenate ’string
"<h2>Sessioned-widget:</h2>"
(if (enabled this)
"<h3>enabled!</h3>"
"<h3>not enabled</h3>")))

(defclass <my-body-widget> (<widget>)
())

(defmethod render-widget ((this <my-body-widget>))
(concatenate ’string
"<h1>MARK-DIRTY test</h1>"
(render-widget
(get-widget-for-session :sessioned-widget))
(render-widget
(make-widget
:global ’<button-widget>
:label "Enable"
:callback #’(lambda ()
(let ((sessioned-widget
(get-widget-for-session :sessioned-widget)))
(when sessioned-widget
(setf (enabled sessioned-widget) t)
(mark-dirty sessioned-widget))))))
(render-widget
(make-widget
:global ’<button-widget>
:label "Disable"
:callback #’(lambda ()
(let ((sessioned-widget
(get-widget-for-session :sessioned-widget)))
(when sessioned-widget
(setf (enabled sessioned-widget) nil)
(mark-dirty sessioned-widget))))))))

(defvar *header-widget* (make-instance ’<header-widget>
:title "Mark-dirty test"))
(defvar *my-body-widget* (make-widget :global ’<my-body-widget>))

(defroute "/mark-dirty-test" ()
(set-widget-for-session :sessioned-widget (make-widget :session ’<sessioned-widget>))
(render-widget
(make-instance ’<html-document-widget>
:header *header-widget*
:body *my-body-widget*)))
#+END_SRC

*** Navigation objects
You can create navigation objects too! The purpose of navigation
objects is that you don’t have to manage a navigation ever again!
Each navigation object contains another widget which displays the
currently selected path. If you click on a navigation link that object
is changed and refreshed (either via JavaScript or through the
link). Please keep in mind that navigation objects are *session
stateful widgets*.
#+LATEX: \\\\
Paths are only created automatically by the DEFNAV macro. The first
item in the list is the widget which will be displayed at the base
path of the navigation. You can use any string as path but be careful
to not interfere with the special paths of NINGLE
(e.g. "/:some-path"). Do not use those. The only special path you can
use is the wildcard (e.g "/*/").
#+LATEX: \\\\
A very basic example:
#+BEGIN_SRC lisp
(defvar *first-widget*
(make-widget :global ’<string-widget>
:text "<h1>Hello world from first</h1>"))

(defvar *second-widget*
(make-widget :global ’<string-widget>
:text "<h1>Hello world from second</h1>"))

(defclass <proxy-widget> (<widget>)
()
(:documentation "This class enables session based widgets for a
navigation."))

(defmethod render-widget ((this <proxy-widget>))
(set-widget-for-session :string-widget
(make-widget :session ’<string-widget>
:text "hello world"))
(render-widget (get-widget-for-session :string-widget)))

(defnav "/sophisticated/path"
((make-instance ’<header-widget>
:title "Navigation test")
(list
(list "First widget" "first" *first-widget*)
(list "Second widget" "second" *second-widget*)
(list "Third widget" "third" (make-widget :global
’<proxy-widget>))
(list "Hidden widget" "hidden"
(make-widget :global ’<string-widget>
:text "<h1>You have accessed a hidden widget!</h1>")
:hidden))
:kind ’<menu-navigation-widget>))
#+END_SRC

If the default navigation object doesn’t render as you wish, you can
subclass it and overwrite the RENDER-WIDGET method. Please notice that
you can actually very easily adjust the path where the navigation and
its widgets get rendered. The slot BASE-PATH is created for that.
#+LATEX: \\\\
There are two default navigation widgets:
- <MENU-NAVIGATION-WIDGET> :: A navigation with a menu. You can change
the menu appearance with CSS. With the :HIDDEN keyword you can
hide a path from the navigation list.
- <BLANK-NAVIGATION-WIDGET> :: A navigation without any menu. It is
controlled by the URL only - or by other widgets.
*** Table objects
You can create a table very simple. A <TABLE-WIDGET> displays *all*
items which are supplied through the PRODUCER function.
#+LATEX: \\\\
Important for the usage of tables is that you supply a PRODUCER
function. The function should return a list of <TABLE-ITEM>
objects. This function can be anything but it has to take the key
arguments:
- AMOUNT :: Tells how many items to get
- ALREADY :: Tells how many items already received
- LENGTH-P :: A flag which should tell the function to return the
available items if active.
AMOUNT and ALREADY can be seen as synonyms for FROM and TO.
#+LATEX: \\\\
A <TABLE-ITEM> object is needed for tables. The essence of those
objects is that they can be translated to lists through the generic
function GET-AS-LIST. Therefore you don’t have to subclass
<TABLE-ITEM> at all just to add an implementation of GET-AS-LIST for
your used class.
#+LATEX: \\\\
For the <TABLE-Widget> consider the following example:
#+BEGIN_SRC lisp
(defclass <my-item> (<table-item>)
((id
:initarg :id
:reader id)
(name
:initarg :name
:reader name)
(description
:initarg :description
:reader description)))

(defmethod get-as-list ((this <my-item>))
(list :id (id this)
:name (name this)
:description (description this)))

(defun producer (&key
amount
(already 0)
(length-p nil))
(if (null length-p)
(let ((all ’()))
(if (null amount)
(loop for x from 1 to 1000 do
(setf all
(append all
(list
(make-instance ’<my-item>
:id x
:name (format nil "~a" x)
:description (format nil "The ~a. item." x))))))
(loop for x from (+ already 1) to (+ already amount) do
(setf all
(append all
(list
(make-instance ’<my-item>
:id x
:name (format nil "~a" x)
:description (format nil "The ~a. item." x)))))))
all)
1000))

(defvar *table-widget*
(make-widget :global ’<table-widget>
:producer ’producer
:column-descriptions (list
(list :name "Name")
(list :description "Description"))))

(defroute "/table" ()
(with-html-document (doc
(make-instance ’<header-widget>))
(setf (body doc)
*table-widget*)))
#+END_SRC

*** Viewgrids
The <VIEWGRID-WIDGET> is used to display a bulk of heterogenous
items. The items must implement the RENDER-AS method. The
<VIEWGRID-WIDGET> calls RENDER-AS with its VIEW slot. Therefore you
have provide an implementation for the keyword supplied by VIEW in
your <VIEWGRID-WIDGET>.
#+LATEX: \\\\
You can limit the displayed items with the MAX-ITEMS-TO-DISPLAY
slot. If this slot is active the items are delivered on several pages
instead on only one. If you supply additionally the DISPLAY-SELECTOR
with the URI path on which the <VIEWGRID-WIDGET> object is rendered,
then selectable page numbers are displayed on the bottom too.
#+LATEX: \\\\
Each item can be accessed. When accessing the item a specific
given function is called with the item as parameter.
#+LATEX: \\\\
The following example covers all functionality:
#+BEGIN_SRC lisp
(defclass <my-viewgrid-item> (<viewgrid-item>)
((id
:initarg :id
:reader id)
(name
:initarg :name
:reader name)
(description
:initarg :description
:reader description)))

(defmethod render-as ((this <my-viewgrid-item>) (view (eql :short)))
(format nil "<div style=\"padding-bottom:30px\">id: ~a<br>name: ~a<br>desc: ~a<div>"
(id this) (name this) (description this)))

(defun producer (&key
(from 0)
(to nil)
(length-p nil))
(let ((all ’()))
(loop for x from 1 to 35 do
(setf all
(append all
(list
(make-instance ’<my-viewgrid-item>
:id x
:name (format nil "~a" x)
:description (format nil "The ~a. item." x))))))
(cond
(length-p
(length all))
((and from (not to))
(mapcan #’(lambda (item)
(if (>= (id item) from)
(list item)
nil))
all))
((and from to)
(mapcan #’(lambda (item)
(if (and (>= (id item) from) (< (id item) to))
(list item)
nil))
all)))))

(defroute "/viewgrid" ()
(with-html-document (doc
(make-instance ’<header-widget>))
(set-widget-for-session
:viewgrid
(make-widget :session ’<viewgrid-widget>
:producer #’producer
:view :short
:max-items-to-display 11
:display-selector "viewgrid"
:on-view #’(lambda (item)
(format t
(render-as item :short))
"viewgrid")))
(setf (body doc)
(get-widget-for-session :viewgrid))))
#+END_SRC
*** Forms
Forms can be pretty annoying but with the <FORM-WIDGET> you don’t have
to care for anything but for the naming of the inputs ever again. Each
<FORM-WIDGET> consists of 0 to n <FORM-FIELD> objects. If you have 0
<FORM-FIELD> objects it essentially only behaves like a
<BUTTON-WIDGET>.
#+LATEX: \\\\
<FORM-FIELD> is the base class for fields. Fields can be:
- <INPUT-FIELD> :: Is basically an abstraction of the HTML input-tag.
- <SELECT-FIELD> :: Consists of <OPTION-FIELD> objects.

Of course you can implement your own <FORM-FIELD> classes too! But
keep in mind that *the default <FORM-FIELD> already implements
constraints*.
#+LATEX: \\\\
To understand how constraints for forms work an examination of the
available slots for <FORM-FIELD> objects is necessary:
- REQUIRED :: A non-nil value indicates that this field has to have
some value.
- SUPPLIED :: Will be set NIL by SET-REQUIRED-PRESENT and set T by
RENDER-WIDGET. It is NIL if the field is not supplied
and is therefore not dependent on REQUIRED. It should
tell the server whether an parameter was passed or not.
- CHECK-FUNCTION :: Will be called by SET-REQUIRED-PRESENT and check
if the passed value by the client is "correct". It
is a lambda with one argument, which is the passed
string from the client. Should return NIL if the
passed string was not correct and a non-nil value
otherwise.
- ERROR-HAPPENED :: Will be set to T by SET-REQUIRED-PRESENT if the
CHECK-FUNCTION did not succeed. The rendering the
form will set it to NIL again.
- ERROR-MESSAGE :: The message that will be displayed if
ERROR-HAPPENED is T.

You don’t have to actually care for that procedure as the
<FORM-WIDGET> calls this the SET-REQUIRED-PRESENT by itself. But it
can be helpful to understand the entire process of checking the user
input. The only thing to really memorize here is that *the given
callback only gets called if all required fields where supplied and
those fields where supplied correctly*.
#+LATEX: \\\\
Consider the following example for additional help:
#+BEGIN_SRC lisp
(defvar *password-field*
(make-instance ’<input-field>
:input-type "password"
:check-function
#’(lambda (pass)
(if (<= (length pass)
2)
nil
t))
:error-message "Has to be longer than 2"
:name "password"
:value ""))

(defvar *form-widget*
(let ((text-field (make-instance ’<input-field>
:input-type "text"
:name "text"
:value ""
:required t))
(choice-field (make-instance
’<select-field>
:name "selection"
:options
(list (make-instance ’<option-field>
:value "first")
(make-instance ’<option-field>
:value "second"
:display-value "Other")))))
(make-widget :global ’<form-widget>
:input-fields (list
text-field
*password-field*
choice-field)
:label "Submit"
:callback
#’(lambda (args)
(format t "received correct values:
~a
————-"
args)))))

(defroute "/form" ()
(with-html-document (doc
(make-instance ’<header-widget>))
(setf (body doc)
*form-widget*)))
#+END_SRC
*** Protecting widgets
This library also enables you to protect widgets. Each widget has an
associated list of keywords which indicate the levels/circles of
authorization an requester needs.
#+LATEX: \\\\
By default the protection is an empty list (therefore NIL), which
means that everybody can access your widget. If the protection is
non-nil the non-nil value is a list of keywords which refers to a list
of keywords stored in the session. So if the session contains the
required keyword in its list the requester can access the
widget. Otherwise he is denied (throws a 403 code).
#+LATEX: \\\\
The <WIDGET> class holds the PROTECTED slot. This slots value
indicates the needed token in the session. But caveman2-widgets
supplies an additional, specific *PROTECT-WIDGET* method which should be
used. You can supply the following parameters:
- :LOGIN :: Protects the widget by the default login-widget
- A keyword in general :: Protects the widget with this keyword (adds
it)
- A list of keywords :: Protects the widget with this keywords (adds
them)

#+BEGIN_SRC lisp
(defvar *specific-protected-widget*
(protect-widget
(make-widget :global ’<string-widget>
:text "<h1>This is a protected text</h1>")
:myprotection))

;; Should throw 403
(defroute "/protected-widget" ()
(concatenate ’string
"<a href=\"/rest/string-widget?id="
(id *specific-protected-widget*)
"\">Will throw 403</a>"

(render-widget *specific-protected-widget*)))

(defmethod on-exception ((app <web>) (code (eql 403)))
(declare (ignore app))
"403 - The protection works.")
#+END_SRC

*** Login
Protecting certain widgets by a login is very easy. The <LOGIN-WIDGET>
organizes the following things:
1. It displays a login form and logs the client in if he passes the
challenge. The successful pass sets will result in an permanent
non-nil value if you call "(LOGGED-IN *SESSION*)". This means that
every widget that requires the authroization level :LOGIN through
the PROTECT-WIDGET method can now be accessed by the user.
2. It supplies a Logout button. This button can be access through the
LOGOUT-BUTTON reader. You therefore can render the button anywhere
you like. Pressing the button will result in a logout and therefore
in a permanent NIL for "(LOGGED-IN *SESSION*)".
3. It renders certain widgets if the login was successful. This can be
either used e.g. for a success message.

*The <LOGIN-WIDGET> has to run in :SESSION scope!*
#+LATEX: \\\\
Additionally you can specify different authentication challanges
(authentication functions) if you wish. But using the <LOGIN-WIDGET>
and passing the challenge will *only* set the authoriatzition level
to :LOGIN. This means that you need to create your own <LOGIN-WIDGET>
if you want some other level for different authentication functions!

#+BEGIN_SRC lisp
(defvar *protected-widget*
(protect-widget
(make-widget :global ’<string-widget>
:text "<h1>This is a protected text</h1>")
:login))

(defroute "/" ()
(with-html-document (doc
(make-instance ’<header-widget>))
(setf (body doc)
(make-widget
:global ’<function-widget>
:function
#’(lambda ()
(set-widget-for-session ;; running it in the session
:login-widget
(make-widget :session ’<login-widget>
:authenticator
#’(lambda (user password)
(if (and (string= user "ritschmaster")
(string= password "secret"))
t
nil))
:widgets
(list
*protected-widget*)))
(render-widget
(get-widget-for-session :login-widget)))))))
#+END_SRC
*** Language getting/setting
To store the accpeted languages in the session there is the
CHECK-AND-SET-LANGUAGE function. This function uses the value supplied
through the "Accept-languages" field in the HTTP request. It gets
called through the render method by any <HTML-DOCUMENT-WIDGET>
automatically. Which means that as soon as you use it you don’t have
to worry about getting the language. But on the other hand you have to
make sure that every subclass of <HTML-DOCUMENT-WIDGET> again uses
CHECK-AND-SET-LANGUAGE in its render-method.
#+LATEX: \\\\
You can access the currently accepted languages through the
ACCEPTED-LANGUAGES.
#+LATEX: \\\\
If you rather use a manual language chooser you can supply
AUTOMATICALLY-SET-LANGUAGES as NIL to the INIT-WIDGETS
function. Please then use the setf method for ACCEPTED-LANGUAGES to
set the language.
*** Translations
Most strings that are rendered human readable get translated through a
special function. You can specify your own translation function by
passing it to INIT-WIDGETS as :TRANSLATION-FUNCTION. The function
header should look like this:
#+BEGIN_SRC lisp
(defvar *my-translation-function*
#’(lambda (text
&key
plural-p
genitive-form-p
items-count
accusative-form-p
language
&allow-other-keys)
text))
#+END_SRC

Strings that are translated:
- The page names of a navigation

Strings that are definitely *not* translated:
- The TEXT of a <STRING-WIDGET>
- The return value of a <FUNCTION-WIDGET>

*** Development hooks
In case you want to do things at compile time (e.g. calling DEFROUTE)
whe INIT-WIDGETS is evaluated there is the variable
*INIT-WIDGETS-HOOKS*. Just append new functions as you wish.

#+BEGIN_SRC lisp
(setf *init-widgets-hooks*
(append
*init-widgets-hooks*
(list
#’(lambda ()
(defroute "/something" ()
;; Accessing the user supplied <APP> object:
(describe caveman2-widgets::*web*)
"something")))))
#+END_SRC
** Important notes/Things that happen automatically
The following things you should keep in mind when using
caveman2-widgets.

*** Automatically REST API creation
If you create a widget then routes for a REST API will be added
automatically. Suppose you subclass <WIDGET> with the class
<MY-WIDGET>, then you will get the path "/rest/my-widget" which you
can access.

#+BEGIN_SRC lisp
(defclass <my-widget> (<widget>)
())

(defmethod render-widget ((this <my-widget>))
"my-widget representation for the website")

(defmethod render-widget-rest ((this <my-widget>) (method (eql :get)) (args t))
"my-widget representation for the REST.")

(defmethod render-widget-rest ((this <my-widget>) (method (eql :post)) (args t))
(render-widget this))
#+END_SRC

Buttons and Links are *not* accessed through the REST path (see the
section above).

Widgets that are not accessible through the REST:
- <HTML-DOCUMENT-WIDGET>
- <HEADER-WIDGET>

*** Encapsulating widgets with divs
Each widget gets wrapped in a div automatically. Every widget will get
its entire class heritage included in the CSS class
attribute. Therefore you can access every widget (and derived widget)
very easily with CSS.

*** JavaScript dependencies
When <HEADER-WIDGET> is used all JavaScript dependencies are added
automatically. Please notice that these dependecies are needed to
ensure that the widgets work properly. If you don’t want to use
<HEADER-WIDGET> you have to manually add jQuery and all the JavaScript
Code supplied/needed by caveman2-widgets.

The routes for the JavaScript files (which have to be included in each
HTML file) are:
- /widgets/js/widgets.js

The jQuery-Version used is 2.2.2 minified. If you want another jQuery
file you can specify it with the variable \*jquery-cdn-link\* (should be
an URL).

*If you forget to use the JavaScript-files widgets might not work or
even break. Most likely all dynamic content just won’t work
(automatically fallback to non-JS)*

*** CSS dependencies
As with JavaScript, stylesheets are added in the <HEADER-WIDGET> automatically
too. The routes you need in your head tag are:
- /widgets/css/widgets.css

*** Session values
This section should inform you about keywords in the session variable
which you should absolutely not modify.
- :WIDGET-HOLDER :: <WIDGET-HOLDER> object. It holds all the session
scoped widgets.
- :DIRTY-OBJECT-IDS :: The name says it all.
- :JAVASCRIPT-AVAILABLE :: Holds a boolean value if JavaScript is
available or not.
- :ACCEPT-LANGUAGE :: Holds the languages accepted by the client.

** Author

+ Richard Paul Bäck (richard.baeck@free-your-pc.com)

** Copyright

Copyright (c) 2016 Richard Paul Bäck (richard.baeck@free-your-pc.com)

** License

Licensed under the LLGPL License.

Version

0.5

Dependencies
Source

caveman2-widgets.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 caveman2-widgets/src

Parent

caveman2-widgets (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 caveman2-widgets.asd

Location

caveman2-widgets.asd

Systems

caveman2-widgets (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 caveman2-widgets/src/util.lisp

Parent

src (module)

Location

src/util.lisp

Packages

caveman2-widgets.util

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 caveman2-widgets/src/widget.lisp

Parent

src (module)

Location

src/widget.lisp

Packages

caveman2-widgets.widget

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 caveman2-widgets/src/callback-widget.lisp

Parent

src (module)

Location

src/callback-widget.lisp

Packages

caveman2-widgets.callback-widget

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 caveman2-widgets/src/default-widgets.lisp

Parent

src (module)

Location

src/default-widgets.lisp

Packages

caveman2-widgets.default-widgets

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 caveman2-widgets/src/login.lisp

Parent

src (module)

Location

src/login.lisp

Packages

caveman2-widgets.login

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 caveman2-widgets/src/document.lisp

Parent

src (module)

Location

src/document.lisp

Packages

caveman2-widgets.document

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 caveman2-widgets/src/navigation.lisp

Parent

src (module)

Location

src/navigation.lisp

Packages

caveman2-widgets.navigation

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.9 caveman2-widgets/src/caveman2-widgets.lisp

Parent

src (module)

Location

src/caveman2-widgets.lisp

Packages

caveman2-widgets

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 caveman2-widgets.util

Source

util.lisp (file)

Use List
Used By List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 caveman2-widgets.widget

Source

widget.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 caveman2-widgets.login

Source

login.lisp (file)

Use List
Used By List

caveman2-widgets

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.6 caveman2-widgets.document

Source

document.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.7 caveman2-widgets.navigation

Source

navigation.lisp (file)

Use List
Used By List

caveman2-widgets

Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.8 caveman2-widgets

Source

caveman2-widgets.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *application-root*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *automatically-set-languages*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *button-call-path*
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Special Variable: *css-directory*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *css-path*

An absolute route where caveman2-widgets’ CSS files can be accessed.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *dirty-objects-uri-path*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *init-widgets-hooks*

This variable holds a list of functions which will be called when INIT-WIDGETS is evaluated. You add any function you like but the main idea was to add functions from caveman2-widgets based libraries/applications that need those variables at compile time.

Package

caveman2-widgets

Source

caveman2-widgets.lisp (file)

Special Variable: *javascript-checker-path*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *javascript-path*

An absolute path where caveman2-widgets’ JavaScript files can be accessed.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *jquery-cdn-link*

The URL to access jQuery.

Package

caveman2-widgets.document

Source

document.lisp (file)

Special Variable: *js-directory*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *language-key-in-session*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *link-call-path*
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Special Variable: *login-authentication-keyword*

This variable holds the keyword which is used within the session to indicated that a session holder is logged in (or not).

Package

caveman2-widgets.login

Source

login.lisp (file)

Special Variable: *port*
Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Special Variable: *protection-circles-session-key*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *rest-path*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *static-directory*
Package

caveman2-widgets.util

Source

util.lisp (file)

Special Variable: *web*

An <app>-instance

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *widgets-css-filename*

The filename of the CSS file which manages all standard widget styles.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *widgets-js-filename*

The filename of the JavaScript file which manages all standard widget functionality.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: +translate+

This should be a function which should translate a given text. You can modify it to your needs. By default this function does nothing.

@param plural-p
@param genitive-form-p
@param items-count
@param accusative-form-p
@param language

Package

caveman2-widgets.util

Source

util.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: defnav BASE-PATH (HEADER-WIDGET PAGES &key KIND BOTTOM-WIDGET SESSION-KEY)

@param base-path The path for the navigation. Should have a starting "/". @param header-widget A <HEADER-WIDGET> for the navigation and it’s children. @param pages A list of lists.

Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Macro: make-widget SCOPE CLASS &rest OBJ-ARGS

@param obj-args The parameter which are passed to the constructor for the new widget.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Macro: with-html-document (DOCUMENT-SYMBOL HEADER &key DOC-KIND) &rest BODY

@param document-symbol The symbol name to access the document. @param doc-kind The class which is used as HTML document. @param header A <HEADER-WIDGET> for this document.

Package

caveman2-widgets.document

Source

document.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: add-authorization CIRCLE &optional SESSION
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: authorized WIDGET &optional SESSION
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: check-and-set-language REQUEST SESSION
Package

caveman2-widgets.util

Source

util.lisp (file)

Function: clean-list-of-broken-links SOME-LIST
Package

caveman2-widgets.util

Source

util.lisp (file)

Function: defroute-static URI-PATH PATH APP CONTENT-TYPE
Package

caveman2-widgets.util

Source

util.lisp (file)

Function: get-from-callback-args KEY ARGS

@param key A string which might be in the args
@param args The value passed by a <CALLBACK-WIDGET> in its callback function.

Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Function: get-trimmed-class-name OBJ &key GET-ALL

@param obj The object of which the name is required @param get-all-self If non-nil returns the entire hierarchy.

Package

caveman2-widgets.util

Source

util.lisp (file)

Function: get-value-for-cons-list SOME-LIST KEY
Package

caveman2-widgets.util

Source

util.lisp (file)

Function: get-widget-for-session SESSION-TAG &optional SESSION

Gets a previously saved widget from the session variable (e.g. to render it).

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: has-trailing-slash STR
Package

caveman2-widgets.util

Source

util.lisp (file)

Function: init-mark-dirty WEB &optional URI-PATH
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: init-widgets WEBAPP &key PORT TRANSLATION-FUNCTION JAVASCRIPT-PATH CSS-PATH REST-PATH BUTTON-CALL-PATH LINK-CALL-PATH DIRTY-OBJECTS-URI-PATH LOGIN-AUTHENTICATION-KEYWORD AUTOMATICALLY-SET-LANGUAGES
Package

caveman2-widgets

Source

caveman2-widgets.lisp (file)

Function: mark-dirty WIDGET &optional SESSION

Marks a widget that it should be rendered ASAP.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: remove-authorization CIRCLE &optional SESSION
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: remove-widget-for-session SESSION-TAG &optional SESSION

Removes a saved widget from the session variable.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: set-widget-for-session SESSION-TAG WIDGET &optional SESSION &key FORCE

Saves a widget in the session variable. This should be considered ONLY for session scoped widgets. Only adds WIDGET if there is no widget at SESSION-TAG already.

@param force If non-nil overwrites the already stored value.

@return The current value in the SESSION at position SESSION-TAG.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: string-case-insensitive= STR1 STR2
Package

caveman2-widgets.util

Source

util.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: accepted-languages SESSION
Generic Function: (setf accepted-languages) VALUE SESSION
Package

caveman2-widgets.util

Source

util.lisp (file)

Methods
Method: accepted-languages (SESSION hash-table)
Method: (setf accepted-languages) VALUE (SESSION hash-table)
Generic Function: append-item THIS ITEM
Package

caveman2-widgets.util

Source

util.lisp (file)

Methods
Method: append-item (THIS <navigation-widget>) (ITEM list)

@param item This should be a list which should looke like that: (list "pagetitle" "uri-path" <widget-for-pagetitle>).

Source

navigation.lisp (file)

Method: append-item (THIS <header-widget>) (ITEM string)

The given item will be added to the <head> tag as given.

Source

document.lisp (file)

Method: append-item (THIS <header-widget>) (ITEM <css-file>)
Source

document.lisp (file)

Method: append-item (THIS <header-widget>) (ITEM <js-file>)
Source

document.lisp (file)

Method: append-item (THIS <table-widget>) (ITEM cons)

@param item Must not have more than two values. The first value is the keyword which should be displayed when a <TABLE-ITEM> object is accessed. The second value is the header text for the column.

Source

default-widgets.lisp (file)

Method: append-item (THIS <composite-widget>) (ITEM <widget>)
Source

default-widgets.lisp (file)

Method: append-item (THIS <form-widget>) (ITEM <form-field>)
Source

callback-widget.lisp (file)

Method: append-item (THIS <radio-field>) (ITEM string)
Source

callback-widget.lisp (file)

Method: append-item (THIS <select-field>) (ITEM <option-field>)
Source

callback-widget.lisp (file)

Method: append-item (THIS <dirty-widget-holder>) (ITEM <widget>)
Source

widget.lisp (file)

Method: append-item (THIS <widget-holder>) (ITEM <widget>)
Source

widget.lisp (file)

Method: append-item THIS ITEM
Generic Function: base-path OBJECT
Generic Function: (setf base-path) NEW-VALUE OBJECT
Package

caveman2-widgets.navigation

Methods
Method: base-path (<NAVIGATION-WIDGET> <navigation-widget>)
Method: (setf base-path) NEW-VALUE (<NAVIGATION-WIDGET> <navigation-widget>)

Determines the path for this navigation. It does not need an initial or trailing forward slash.

Source

navigation.lisp (file)

Generic Function: body OBJECT
Generic Function: (setf body) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: body (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf body) NEW-VALUE (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: bottom OBJECT
Generic Function: (setf bottom) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: bottom (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf bottom) NEW-VALUE (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: callback OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: callback (<CALLBACK-WIDGET> <callback-widget>)
Source

callback-widget.lisp (file)

Generic Function: charset OBJECT
Generic Function: (setf charset) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: charset (<HEADER-WIDGET> <header-widget>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf charset) NEW-VALUE (<HEADER-WIDGET> <header-widget>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: check-function OBJECT
Generic Function: (setf check-function) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: check-function (<FORM-FIELD> <form-field>)
Method: (setf check-function) NEW-VALUE (<FORM-FIELD> <form-field>)

Checks the user input for flaws. Takes one
argument - the string passed by the user. Should return non-nil if everything is correct.

Source

callback-widget.lisp (file)

Generic Function: checked-option OBJECT
Generic Function: (setf checked-option) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: checked-option (<RADIO-FIELD> <radio-field>)
Method: (setf checked-option) NEW-VALUE (<RADIO-FIELD> <radio-field>)

The option which is checked. Must be a number. Start with 0.

Source

callback-widget.lisp (file)

Generic Function: classes OBJECT
Generic Function: (setf classes) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: classes (<CALLBACK-WIDGET> <callback-widget>)

automatically generated reader method

Source

callback-widget.lisp (file)

Method: (setf classes) NEW-VALUE (<CALLBACK-WIDGET> <callback-widget>)

automatically generated writer method

Source

callback-widget.lisp (file)

Generic Function: column-descriptions OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: column-descriptions (<TABLE-WIDGET> <table-widget>)

This is a list of cons which where the cons is one column. The first value of the cons is the keyword to display. The second value of the cons is the table header for that column. For the header (second value) you can use HTML code!

Example:
(list (list :firstcolumn "First column"))

Source

default-widgets.lisp (file)

Generic Function: composite OBJECT
Generic Function: (setf composite) NEW-VALUE OBJECT
Package

caveman2-widgets.navigation

Methods
Method: composite (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated reader method

Source

navigation.lisp (file)

Method: (setf composite) NEW-VALUE (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated writer method

Source

navigation.lisp (file)

Generic Function: crossorigin OBJECT
Generic Function: (setf crossorigin) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: crossorigin (<FILE> <file>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf crossorigin) NEW-VALUE (<FILE> <file>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: current-page OBJECT
Package

caveman2-widgets.navigation

Writer

(setf current-page) (generic function)

Methods
Method: current-page (<NAVIGATION-WIDGET> <navigation-widget>)

The name for the current page to display.

Source

navigation.lisp (file)

Generic Function: (setf current-page) VALUE THIS
Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Reader

current-page (generic function)

Methods
Method: (setf current-page) VALUE (THIS <navigation-widget>)

@param value Must be an uri path string

Generic Function: delete-item THIS ITEM
Package

caveman2-widgets.util

Source

util.lisp (file)

Methods
Method: delete-item (THIS <dirty-widget-holder>) (ITEM <widget>)
Source

widget.lisp (file)

Method: delete-item (THIS <widget-holder>) (ITEM <widget>)
Source

widget.lisp (file)

Method: delete-item THIS ITEM
Generic Function: east OBJECT
Generic Function: (setf east) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: east (<BORDER-WIDGET> <border-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf east) NEW-VALUE (<BORDER-WIDGET> <border-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: error-happened OBJECT
Generic Function: (setf error-happened) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: error-happened (<FORM-FIELD> <form-field>)
Method: (setf error-happened) NEW-VALUE (<FORM-FIELD> <form-field>)

A highly frequented slot. Non-nil indicates that an error occurred.

Source

callback-widget.lisp (file)

Generic Function: error-message OBJECT
Generic Function: (setf error-message) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: error-message (<FORM-FIELD> <form-field>)
Method: (setf error-message) NEW-VALUE (<FORM-FIELD> <form-field>)

The error message that will be displayed if
ERROR-HAPPENED is non-nil. The error message will be translated before rendered.

Source

callback-widget.lisp (file)

Generic Function: find-item THIS TO-FIND
Package

caveman2-widgets.util

Source

util.lisp (file)

Methods
Method: find-item (THIS <navigation-widget>) (ITEM string)

@param item The URI path as string.

Source

navigation.lisp (file)

Method: find-item (THIS <widget-holder>) (TO-FIND string)
Source

widget.lisp (file)

Method: find-item THIS ITEM
Generic Function: fn OBJECT
Generic Function: (setf fn) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: fn (<FUNCTION-WIDGET> <function-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf fn) NEW-VALUE (<FUNCTION-WIDGET> <function-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: get-as-list THIS

This generic method should return the entire object
as cons-list. If you want to hide certain slots, just keep them out of the list!

Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Methods
Method: get-as-list (THIS <table-item>)
Generic Function: header OBJECT
Generic Function: (setf header) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: header (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf header) NEW-VALUE (<HTML-DOCUMENT-WIDGET> <html-document-widget>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: http-method OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: http-method (<CALLBACK-WIDGET> <callback-widget>)

This slot should be one of the HTTP methods as keyword (e.g. :post or :get

Source

callback-widget.lisp (file)

Generic Function: icon-path OBJECT
Generic Function: (setf icon-path) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: icon-path (<HEADER-WIDGET> <header-widget>)
Method: (setf icon-path) NEW-VALUE (<HEADER-WIDGET> <header-widget>)

The path to a specific image to use as icon for page.

Source

document.lisp (file)

Generic Function: id OBJECT
Package

caveman2-widgets.widget

Methods
Method: id (<WIDGET> <widget>)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: input-fields OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: input-fields (<FORM-WIDGET> <form-widget>)

A list of <FORM-FIELD> objects.

Source

callback-widget.lisp (file)

Generic Function: input-type OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: input-type (<INPUT-FIELD> <input-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Generic Function: javascript-available SESSION
Generic Function: (setf javascript-available) VALUE SESSION
Package

caveman2-widgets.util

Source

util.lisp (file)

Methods
Method: javascript-available (SESSION hash-table)
Method: (setf javascript-available) VALUE (SESSION hash-table)
Generic Function: label OBJECT
Generic Function: (setf label) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: label (<FORM-FIELD> <form-field>)
Method: (setf label) NEW-VALUE (<FORM-FIELD> <form-field>)

The label which will be placed before the <input> tag.

Source

callback-widget.lisp (file)

Method: label (<CALLBACK-WIDGET> <callback-widget>)

automatically generated reader method

Source

callback-widget.lisp (file)

Generic Function: logged-in SESSION
Generic Function: (setf logged-in) VALUE SESSION
Package

caveman2-widgets.login

Source

login.lisp (file)

Methods
Method: logged-in (SESSION hash-table)
Method: (setf logged-in) VALUE (SESSION hash-table)
Generic Function: login-authenticator OBJECT
Package

caveman2-widgets.login

Methods
Method: login-authenticator (<LOGIN-WIDGET> <login-widget>)

Must be a function that takes two parameters. The first is the username and the second is the password.

Source

login.lisp (file)

Generic Function: login-form OBJECT
Package

caveman2-widgets.login

Methods
Method: login-form (<LOGIN-WIDGET> <login-widget>)

automatically generated reader method

Source

login.lisp (file)

Generic Function: logout-button OBJECT
Package

caveman2-widgets.login

Methods
Method: logout-button (<LOGIN-WIDGET> <login-widget>)

automatically generated reader method

Source

login.lisp (file)

Generic Function: max-items-to-display OBJECT
Generic Function: (setf max-items-to-display) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: max-items-to-display (<VIEWGRID-WIDGET> <viewgrid-widget>)
Method: (setf max-items-to-display) NEW-VALUE (<VIEWGRID-WIDGET> <viewgrid-widget>)

Non-nil value must be a number which describes how many items will be displayed on each viewgrid page.

Source

default-widgets.lisp (file)

Generic Function: multiple OBJECT
Generic Function: (setf multiple) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: multiple (<SELECT-FIELD> <select-field>)
Method: (setf multiple) NEW-VALUE (<SELECT-FIELD> <select-field>)

Non-nil allows multiple choices.

Source

callback-widget.lisp (file)

Generic Function: name OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: name (<FORM-FIELD> <form-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Generic Function: north OBJECT
Generic Function: (setf north) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: north (<BORDER-WIDGET> <border-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf north) NEW-VALUE (<BORDER-WIDGET> <border-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: on-view OBJECT
Generic Function: (setf on-view) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: on-view (<VIEWGRID-WIDGET> <viewgrid-widget>)
Method: (setf on-view) NEW-VALUE (<VIEWGRID-WIDGET> <viewgrid-widget>)

Must either be NIL or a function which takes one
argument. The passed argument is the item in the viewgrid which is viewed. If the value is NIL the client can’t view a specific item.

Source

default-widgets.lisp (file)

Generic Function: on-view-label OBJECT
Generic Function: (setf on-view-label) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: on-view-label (<VIEWGRID-WIDGET> <viewgrid-widget>)
Method: (setf on-view-label) NEW-VALUE (<VIEWGRID-WIDGET> <viewgrid-widget>)

The text which should be displayed on the button for the ON-VIEW callback.

Source

default-widgets.lisp (file)

Generic Function: options OBJECT
Generic Function: (setf options) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: options (<RADIO-FIELD> <radio-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Method: (setf options) NEW-VALUE (<RADIO-FIELD> <radio-field>)

automatically generated writer method

Source

callback-widget.lisp (file)

Method: options (<SELECT-FIELD> <select-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Method: (setf options) NEW-VALUE (<SELECT-FIELD> <select-field>)

automatically generated writer method

Source

callback-widget.lisp (file)

Generic Function: other-header-content OBJECT
Package

caveman2-widgets.document

Methods
Method: other-header-content (<HEADER-WIDGET> <header-widget>)

A list of strings that will be directly put in the header tag.

Source

document.lisp (file)

Generic Function: pages OBJECT
Package

caveman2-widgets.navigation

Methods
Method: pages (<NAVIGATION-WIDGET> <navigation-widget>)

A list of cons. This slot holds all possible pages
and it should look like: (list (list "pagetitle" "uri-path" <widget>))

Source

navigation.lisp (file)

Generic Function: path OBJECT
Package

caveman2-widgets.document

Methods
Method: path (<FILE> <file>)

automatically generated reader method

Source

document.lisp (file)

Generic Function: protect-widget WIDGET FOR

@return The WIDGET object.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Methods
Method: protect-widget (WIDGET <widget>) (FOR symbol)

@param for A keyword

Method: protect-widget (WIDGET <widget>) (FOR list)

@param for A list of keywords

Generic Function: protected OBJECT
Package

caveman2-widgets.widget

Methods
Method: protected (<WIDGET> <widget>)

This is a list of protection circles. If NIL (or
an empty list) the widget is not procted. If non-nil it should be a list of keywords. That list indicates which keywords (or authorized circles) the requester has in his session. Use PROTECT-WIDGET to use this slot.

Source

widget.lisp (file)

Generic Function: render-as THIS VIEW
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Methods
Method: render-as (THIS <viewgrid-item>) (VIEW (eql oneline))
Method: render-as (THIS <viewgrid-item>) (VIEW (eql short))
Method: render-as (THIS <viewgrid-item>) (VIEW (eql full))
Generic Function: render-widget THIS

@return Returns the HTML representation of the
widget as string. It is intended to use this within a simple HTML transfer or embedded in another page.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Methods
Method: render-widget (THIS <blank-navigation-widget>)
Source

navigation.lisp (file)

Method: render-widget (THIS <menu-navigation-widget>)
Source

navigation.lisp (file)

Method: render-widget (THIS <html-document-widget>)
Source

document.lisp (file)

Method: render-widget (THIS <header-widget>)
Source

document.lisp (file)

Method: render-widget (THIS <css-file>)
Source

document.lisp (file)

Method: render-widget (THIS <js-file>)
Source

document.lisp (file)

Method: render-widget (THIS <login-widget>)
Source

login.lisp (file)

Method: render-widget (THIS <border-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <viewgrid-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <table-widget>) around
Source

default-widgets.lisp (file)

Method: render-widget (THIS <table-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <function-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <hcomposite-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <composite-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <string-widget>)
Source

default-widgets.lisp (file)

Method: render-widget (THIS <form-widget>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <radio-field>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <select-field>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <option-field>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <input-field>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <form-field>) around
Source

callback-widget.lisp (file)

Method: render-widget (THIS <form-field>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <link-widget>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <button-widget>)
Source

callback-widget.lisp (file)

Method: render-widget (THIS <widget>) around
Generic Function: render-widget-body THIS
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Methods
Method: render-widget-body (THIS <table-widget>)
Source

default-widgets.lisp (file)

Generic Function: render-widget-header THIS
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Methods
Method: render-widget-header (THIS <table-widget>)
Source

default-widgets.lisp (file)

Generic Function: render-widget-rest THIS METHOD ARGS

@return Returns the HTML representation of the
widget as string. To generate a method for a specific HTTP method you can do the following:

(defmethod render-widget-rest ((this <widget>) (method (eql :get)) (args t)) "HTML output for the REST when GET.")

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Methods
Method: render-widget-rest (THIS <widget>) METHOD ARGS around
Method: render-widget-rest (THIS <widget>) METHOD ARGS
Generic Function: required OBJECT
Generic Function: (setf required) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: required (<FORM-FIELD> <form-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Method: (setf required) NEW-VALUE (<FORM-FIELD> <form-field>)

automatically generated writer method

Source

callback-widget.lisp (file)

Generic Function: session-tag OBJECT
Generic Function: (setf session-tag) NEW-VALUE OBJECT
Package

caveman2-widgets.navigation

Methods
Method: session-tag (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated reader method

Source

navigation.lisp (file)

Method: (setf session-tag) NEW-VALUE (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated writer method

Source

navigation.lisp (file)

Generic Function: signout-hook OBJECT
Generic Function: (setf signout-hook) NEW-VALUE OBJECT
Package

caveman2-widgets.login

Methods
Method: signout-hook (<LOGIN-WIDGET> <login-widget>)
Method: (setf signout-hook) NEW-VALUE (<LOGIN-WIDGET> <login-widget>)

A functions which will be called after signing out.

Source

login.lisp (file)

Generic Function: south OBJECT
Generic Function: (setf south) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: south (<BORDER-WIDGET> <border-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf south) NEW-VALUE (<BORDER-WIDGET> <border-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: supplied OBJECT
Generic Function: (setf supplied) NEW-VALUE OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: supplied (<FORM-FIELD> <form-field>)
Method: (setf supplied) NEW-VALUE (<FORM-FIELD> <form-field>)

A highly frequented slot. It tells if the form field was filled by the client.

Source

callback-widget.lisp (file)

Generic Function: text OBJECT
Generic Function: (setf text) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: text (<STRING-WIDGET> <string-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf text) NEW-VALUE (<STRING-WIDGET> <string-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: title OBJECT
Generic Function: (setf title) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: title (<HEADER-WIDGET> <header-widget>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf title) NEW-VALUE (<HEADER-WIDGET> <header-widget>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: uri-path OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: uri-path (<CALLBACK-WIDGET> <callback-widget>)

This slot should give the exact path to access this widget.

Source

callback-widget.lisp (file)

Generic Function: value OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: value (<OPTION-FIELD> <option-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Method: value (<INPUT-FIELD> <input-field>)

automatically generated reader method

Source

callback-widget.lisp (file)

Generic Function: view OBJECT
Generic Function: (setf view) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: view (<VIEWGRID-WIDGET> <viewgrid-widget>)
Method: (setf view) NEW-VALUE (<VIEWGRID-WIDGET> <viewgrid-widget>)

The value of this slot is passed to the RENDER-AS
method. Therefore you can use an arbitary value but you have to provide an according method for that value!

Source

default-widgets.lisp (file)

Generic Function: west OBJECT
Generic Function: (setf west) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: west (<BORDER-WIDGET> <border-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf west) NEW-VALUE (<BORDER-WIDGET> <border-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: widget-scope OBJECT
Package

caveman2-widgets.widget

Methods
Method: widget-scope (<WIDGET> <widget>)

automatically generated reader method

Source

widget.lisp (file)

Generic Function: widgets OBJECT
Generic Function: (setf widgets) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: widgets (<COMPOSITE-WIDGET> <composite-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf widgets) NEW-VALUE (<COMPOSITE-WIDGET> <composite-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Classes

Class: <blank-navigation-widget> ()
Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Direct superclasses

<navigation-widget> (class)

Direct methods

render-widget (method)

Class: <border-widget> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<widget> (class)

Direct methods
Direct slots
Slot: north
Initargs

:north

Readers

north (generic function)

Writers

(setf north) (generic function)

Slot: east
Initargs

:east

Readers

east (generic function)

Writers

(setf east) (generic function)

Slot: south
Initargs

:south

Readers

south (generic function)

Writers

(setf south) (generic function)

Slot: west
Initargs

:west

Readers

west (generic function)

Writers

(setf west) (generic function)

Slot: center
Initargs

:center

Readers

center (generic function)

Writers

(setf center) (generic function)

Class: <button-widget> ()

The callback function will be called when the user presses the button.

Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<callback-widget> (class)

Direct subclasses

<form-widget> (class)

Direct methods
Direct Default Initargs
InitargValue
:uri-path""
:http-method:post
Class: <callback-widget> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<widget> (class)

Direct subclasses
Direct methods
Direct slots
Slot: label
Initargs

:label

Readers

label (generic function)

Slot: callback
Initargs

:callback

Initform

(function (lambda (caveman2-widgets.callback-widget::args) ""))

Readers

callback (generic function)

Slot: uri-path

This slot should give the exact path to access this widget.

Initargs

:uri-path

Initform

(error "must supply an uri-path to access the widget.")

Readers

uri-path (generic function)

Slot: http-method

This slot should be one of the HTTP methods as keyword (e.g. :post or :get

Initargs

:http-method

Initform

(error "must supply a method to access the http url.")

Readers

http-method (generic function)

Slot: classes
Initargs

:classes

Readers

classes (generic function)

Writers

(setf classes) (generic function)

Class: <composite-widget> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<widget> (class)

Direct subclasses
Direct methods
Direct slots
Slot: widgets
Initargs

:widgets

Initform

(quote nil)

Readers

widgets (generic function)

Writers

(setf widgets) (generic function)

Class: <css-file> ()
Package

caveman2-widgets.document

Source

document.lisp (file)

Direct superclasses

<file> (class)

Direct methods
Class: <form-field> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Initargs

:name

Initform

(error "must specify a name for the form field.")

Readers

name (generic function)

Slot: label

The label which will be placed before the <input> tag.

Initargs

:label

Initform

""

Readers

label (generic function)

Writers

(setf label) (generic function)

Slot: supplied

A highly frequented slot. It tells if the form field was filled by the client.

Initform

t

Readers

supplied (generic function)

Writers

(setf supplied) (generic function)

Slot: required
Initargs

:required

Readers

required (generic function)

Writers

(setf required) (generic function)

Slot: check-function

Checks the user input for flaws. Takes one
argument - the string passed by the user. Should return non-nil if everything is correct.

Initargs

:check-function

Initform

(function (lambda (caveman2-widgets.callback-widget::str) t))

Readers

check-function (generic function)

Writers

(setf check-function) (generic function)

Slot: error-happened

A highly frequented slot. Non-nil indicates that an error occurred.

Readers

error-happened (generic function)

Writers

(setf error-happened) (generic function)

Slot: error-message

The error message that will be displayed if
ERROR-HAPPENED is non-nil. The error message will be translated before rendered.

Initargs

:error-message

Initform

""

Readers

error-message (generic function)

Writers

(setf error-message) (generic function)

Class: <form-widget> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<button-widget> (class)

Direct methods
Direct slots
Slot: input-fields

A list of <FORM-FIELD> objects.

Initargs

:input-fields

Initform

(quote nil)

Readers

input-fields (generic function)

Class: <function-widget> ()

Uses a fucntion for rendering. The given function should return a string which will then be rendered.

Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<widget> (class)

Direct methods
Direct slots
Slot: fn
Initargs

:function

Initform

(function (lambda nil ""))

Readers

fn (generic function)

Writers

(setf fn) (generic function)

Class: <hcomposite-widget> ()

This is a Horizontal composite widget. Therefore it
is essentially the same as the <COMPOSITE-WIDGET> with the difference that is displays its widgets horizontally.

Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<composite-widget> (class)

Direct methods

render-widget (method)

Class: <header-widget> ()
Package

caveman2-widgets.document

Source

document.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: css-files
Initform

(list (make-instance (quote caveman2-widgets.document:<css-file>) :path (concatenate (quote string) caveman2-widgets.widget:*css-path* "/" caveman2-widgets.widget:*widgets-css-filename*)))

Readers

css-files (generic function)

Slot: js-files
Initform

(list (make-instance (quote caveman2-widgets.document:<js-file>) :path caveman2-widgets.document:*jquery-cdn-link*) (make-instance (quote caveman2-widgets.document:<js-file>) :path (concatenate (quote string) caveman2-widgets.widget:*javascript-path* "/" caveman2-widgets.widget:*widgets-js-filename*)))

Readers

js-files (generic function)

Slot: title
Initargs

:title

Readers

title (generic function)

Writers

(setf title) (generic function)

Slot: icon-path

The path to a specific image to use as icon for page.

Initargs

:icon-path

Readers

icon-path (generic function)

Writers

(setf icon-path) (generic function)

Slot: charset
Initargs

:charset

Initform

"utf-8"

Readers

charset (generic function)

Writers

(setf charset) (generic function)

Slot: other-header-content

A list of strings that will be directly put in the header tag.

Initargs

:other-header-content

Initform

(quote nil)

Readers

other-header-content (generic function)

Class: <html-document-widget> ()

The body-widget will be wrapped in a div with the
id "body" automatically. Rendering this widget automatically sets the language!

Package

caveman2-widgets.document

Source

document.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

<navigation-widget> (class)

Direct methods
Direct slots
Slot: header
Initargs

:header

Readers

header (generic function)

Writers

(setf header) (generic function)

Slot: body
Initargs

:body

Readers

body (generic function)

Writers

(setf body) (generic function)

Slot: bottom
Initargs

:bottom

Readers

bottom (generic function)

Writers

(setf bottom) (generic function)

Class: <input-field> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<form-field> (class)

Direct methods
Direct slots
Slot: input-type
Initargs

:input-type

Initform

(error "must specify an input type.")

Readers

input-type (generic function)

Slot: value
Initargs

:value

Initform

(error "must specify an input value.")

Readers

value (generic function)

Class: <js-file> ()
Package

caveman2-widgets.document

Source

document.lisp (file)

Direct superclasses

<file> (class)

Direct methods
Class: <link-widget> ()

The callback function will be called when the user
clickes the link. The function must return a string. The returned string should be an URL to which the server should redirect.

Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<callback-widget> (class)

Direct methods
Direct slots
Slot: target-foreign-p

When the given link redirects absolute (like http://...).

Initargs

:target-foreign-p

Direct Default Initargs
InitargValue
:uri-path""
:http-method:get
Class: <login-widget> ()
Package

caveman2-widgets.login

Source

login.lisp (file)

Direct superclasses

<composite-widget> (class)

Direct methods
Direct slots
Slot: login-authenticator

Must be a function that takes two parameters. The first is the username and the second is the password.

Initargs

:authenticator

Initform

(function (lambda (caveman2-widgets.login::user caveman2-widgets.login::password) nil))

Readers

login-authenticator (generic function)

Slot: signout-hook

A functions which will be called after signing out.

Initargs

:signout-hook

Readers

signout-hook (generic function)

Writers

(setf signout-hook) (generic function)

Slot: login-failed

For internal use only. This slot is used to indicate that the login procedure did not work.

Readers

login-failed (generic function)

Writers

(setf login-failed) (generic function)

Slot: login-form
Readers

login-form (generic function)

Slot: logout-button
Readers

logout-button (generic function)

Class: <menu-navigation-widget> ()
Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Direct superclasses

<navigation-widget> (class)

Direct methods

render-widget (method)

Class: <option-field> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: value
Initargs

:value

Initform

(error "must supply a value.")

Readers

value (generic function)

Slot: display-value

If NIL then the displayed value will equal the used value.

Initargs

:display-value

Readers

display-value (generic function)

Class: <radio-field> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<form-field> (class)

Direct methods
Direct slots
Slot: options
Initargs

:options

Initform

(quote nil)

Readers

options (generic function)

Writers

(setf options) (generic function)

Slot: checked-option

The option which is checked. Must be a number. Start with 0.

Initargs

:checked-option

Readers

checked-option (generic function)

Writers

(setf checked-option) (generic function)

Class: <select-field> ()
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Direct superclasses

<form-field> (class)

Direct methods
Direct slots
Slot: options
Initargs

:options

Initform

(quote nil)

Readers

options (generic function)

Writers

(setf options) (generic function)

Slot: multiple

Non-nil allows multiple choices.

Initargs

:multiple

Readers

multiple (generic function)

Writers

(setf multiple) (generic function)

Class: <string-widget> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<widget> (class)

Direct methods
Direct slots
Slot: text
Initargs

:text

Initform

""

Readers

text (generic function)

Writers

(setf text) (generic function)

Class: <table-item> ()

This class is used to display items in a widget. It essentially is only relevant for the GET-AS-LIST method which is used by the <TABLE-WIDGET>.

Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

get-as-list (method)

Class: <table-widget> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<composite-widget> (class)

Direct methods
Direct slots
Slot: producer

A function which supplies the table with
<TABLE-ITEM> objects. It is possible to use a heterogenous list of <TABLE-ITEM> objects but it is strongly advised to watch out by doing so (accessing not available slots might cause an error!). The producer should be able to deliver a specific amount of items too (AMOUNT = m, ALREADY = n, LENGTH-P = nil => gets items from (m) to (m + n)). To know how many items are avaible please supply the key LENGTH-P which returns a number when non-nil. Consider the following lambda as producer:
(lambda (&key
amount
(already 0)
(length-p nil))
(list (make-instance ’<table-item>)))

Initargs

:producer

Initform

(error "must supply a producer.")

Readers

producer (generic function)

Slot: colum-descriptions

This is a list of cons which where the cons is one column. The first value of the cons is the keyword to display. The second value of the cons is the table header for that column. For the header (second value) you can use HTML code!

Example:
(list (list :firstcolumn "First column"))

Initargs

:column-descriptions

Initform

(quote nil)

Readers

column-descriptions (generic function)

Class: <viewgrid-item> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Class: <viewgrid-widget> ()
Package

caveman2-widgets.default-widgets

Source

default-widgets.lisp (file)

Direct superclasses

<widget> (class)

Direct methods
Direct slots
Slot: producer

A function which supplies the table with
<VIEWGRID-ITEM> objects. It is possible to use a heterogenous list of <VIEWGRID-ITEM> objects. The producer should be able to deliver a specific amount of items too (FROM = m, TO = n, LENGTH-P = nil => gets items from (m) to (m + n); FROM = m, TO = NIL, LENGTH-P = nil => gets items from (m) to LENGTH). To know how many items are avaible please supply the key LENGTH-P which returns a number when non-nil. Consider the following lambda as producer:
(lambda (&key
(from 0)
(to nil)
(length-p nil))
(list (make-instance ’<table-item>)))

Initargs

:producer

Initform

(error "must supply a producer.")

Readers

producer (generic function)

Slot: view

The value of this slot is passed to the RENDER-AS
method. Therefore you can use an arbitary value but you have to provide an according method for that value!

Initargs

:view

Initform

(error "must supply which view should be used.")

Readers

view (generic function)

Writers

(setf view) (generic function)

Slot: on-view

Must either be NIL or a function which takes one
argument. The passed argument is the item in the viewgrid which is viewed. If the value is NIL the client can’t view a specific item.

Initargs

:on-view

Readers

on-view (generic function)

Writers

(setf on-view) (generic function)

Slot: on-view-label

The text which should be displayed on the button for the ON-VIEW callback.

Initargs

:on-view-label

Initform

"view dataview item"

Readers

on-view-label (generic function)

Writers

(setf on-view-label) (generic function)

Slot: max-items-to-display

Non-nil value must be a number which describes how many items will be displayed on each viewgrid page.

Initargs

:max-items-to-display

Readers

max-items-to-display (generic function)

Writers

(setf max-items-to-display) (generic function)

Slot: display-selector

A page selector are the page numbers which the
user can click to access the page. If NIL don’t display a page selector. The non-nil value has to be the URI path in which the viewgrid is used. E.g. display-selector = "view" if the viewgrid is accessed on the page /view.

Initargs

:display-selector

Readers

display-selector (generic function)

Writers

(setf display-selector) (generic function)

Slot: current-from
Initform

0

Slot: selector
Slot: prev-button
Slot: next-button
Class: <widget> ()
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: id
Initargs

:id

Initform

(symbol-name (gensym))

Readers

id (generic function)

Slot: scope
Readers

widget-scope (generic function)

Slot: protected

This is a list of protection circles. If NIL (or
an empty list) the widget is not procted. If non-nil it should be a list of keywords. That list indicates which keywords (or authorized circles) the requester has in his session. Use PROTECT-WIDGET to use this slot.

Initargs

:protected

Initform

(quote nil)

Readers

protected (generic function)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *dirty-objects-session-key*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *global-widget-holder*
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Special Variable: *input-field-for-old-uri*
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Special Variable: *navigation-widgets*
Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Special Variable: *rest-methods*
Package

caveman2-widgets.widget

Source

widget.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Function: demark-dirty WIDGET &optional SESSION

Marks a widget as rendered.

Package

caveman2-widgets.widget

Source

widget.lisp (file)

Function: test-widget-if-session SCOPE WIDGET-ID &optional SESSION
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Generic functions

Generic Function: center OBJECT
Generic Function: (setf center) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: center (<BORDER-WIDGET> <border-widget>)

automatically generated reader method

Source

default-widgets.lisp (file)

Method: (setf center) NEW-VALUE (<BORDER-WIDGET> <border-widget>)

automatically generated writer method

Source

default-widgets.lisp (file)

Generic Function: created-paths OBJECT
Generic Function: (setf created-paths) NEW-VALUE OBJECT
Package

caveman2-widgets.navigation

Methods
Method: created-paths (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated reader method

Source

navigation.lisp (file)

Method: (setf created-paths) NEW-VALUE (<NAVIGATION-WIDGET> <navigation-widget>)

automatically generated writer method

Source

navigation.lisp (file)

Generic Function: css-files OBJECT
Package

caveman2-widgets.document

Methods
Method: css-files (<HEADER-WIDGET> <header-widget>)

automatically generated reader method

Source

document.lisp (file)

Generic Function: display-selector OBJECT
Generic Function: (setf display-selector) NEW-VALUE OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: display-selector (<VIEWGRID-WIDGET> <viewgrid-widget>)
Method: (setf display-selector) NEW-VALUE (<VIEWGRID-WIDGET> <viewgrid-widget>)

A page selector are the page numbers which the
user can click to access the page. If NIL don’t display a page selector. The non-nil value has to be the URI path in which the viewgrid is used. E.g. display-selector = "view" if the viewgrid is accessed on the page /view.

Source

default-widgets.lisp (file)

Generic Function: display-value OBJECT
Package

caveman2-widgets.callback-widget

Methods
Method: display-value (<OPTION-FIELD> <option-field>)

If NIL then the displayed value will equal the used value.

Source

callback-widget.lisp (file)

Generic Function: integrity OBJECT
Generic Function: (setf integrity) NEW-VALUE OBJECT
Package

caveman2-widgets.document

Methods
Method: integrity (<FILE> <file>)

automatically generated reader method

Source

document.lisp (file)

Method: (setf integrity) NEW-VALUE (<FILE> <file>)

automatically generated writer method

Source

document.lisp (file)

Generic Function: js-files OBJECT
Package

caveman2-widgets.document

Methods
Method: js-files (<HEADER-WIDGET> <header-widget>)

automatically generated reader method

Source

document.lisp (file)

Generic Function: login-failed OBJECT
Generic Function: (setf login-failed) NEW-VALUE OBJECT
Package

caveman2-widgets.login

Methods
Method: login-failed (<LOGIN-WIDGET> <login-widget>)
Method: (setf login-failed) NEW-VALUE (<LOGIN-WIDGET> <login-widget>)

For internal use only. This slot is used to indicate that the login procedure did not work.

Source

login.lisp (file)

Generic Function: producer OBJECT
Package

caveman2-widgets.default-widgets

Methods
Method: producer (<VIEWGRID-WIDGET> <viewgrid-widget>)

A function which supplies the table with
<VIEWGRID-ITEM> objects. It is possible to use a heterogenous list of <VIEWGRID-ITEM> objects. The producer should be able to deliver a specific amount of items too (FROM = m, TO = n, LENGTH-P = nil => gets items from (m) to (m + n); FROM = m, TO = NIL, LENGTH-P = nil => gets items from (m) to LENGTH). To know how many items are avaible please supply the key LENGTH-P which returns a number when non-nil. Consider the following lambda as producer:
(lambda (&key
(from 0)
(to nil)
(length-p nil))
(list (make-instance ’<table-item>)))

Source

default-widgets.lisp (file)

Method: producer (<TABLE-WIDGET> <table-widget>)

A function which supplies the table with
<TABLE-ITEM> objects. It is possible to use a heterogenous list of <TABLE-ITEM> objects but it is strongly advised to watch out by doing so (accessing not available slots might cause an error!). The producer should be able to deliver a specific amount of items too (AMOUNT = m, ALREADY = n, LENGTH-P = nil => gets items from (m) to (m + n)). To know how many items are avaible please supply the key LENGTH-P which returns a number when non-nil. Consider the following lambda as producer:
(lambda (&key
amount
(already 0)
(length-p nil))
(list (make-instance ’<table-item>)))

Source

default-widgets.lisp (file)

Generic Function: set-required-present THIS CONTAINER
Package

caveman2-widgets.callback-widget

Source

callback-widget.lisp (file)

Methods
Method: set-required-present (THIS <form-widget>) (CONTAINER list)

Sets the SUPPLIED slot of the INPUT-FIELDS based on a given list. Sets also the ERROR-HAPPENED slot by running the check function.

@param container Should be the ARGS parameter of the the callback
which is an ALIST.

@return Returns NIL if any requirement is not met or any . Non-nil value if all requirements are met.


Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Classes

Class: <dirty-widget-holder> ()
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: widgets

Holds the ids of all widgets that are marked as dirty.

Initform

(quote nil)

Class: <file> ()
Package

caveman2-widgets.document

Source

document.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: path
Initargs

:path

Initform

(error "must supply a path to access the file.")

Readers

path (generic function)

Slot: integrity
Initargs

:integrity

Readers

integrity (generic function)

Writers

(setf integrity) (generic function)

Slot: crossorigin
Initargs

:crossorigin

Readers

crossorigin (generic function)

Writers

(setf crossorigin) (generic function)

Class: <navigation-widget> ()

This is an abstract widget which implements all
interactions with a navigation but not the RENDER-WIDGET. Please subclass this class as you want (default implementations are <MENU-NAVIGATION-WIDGET> and <BLANK-NAVIGATION-WIDGET>.

Package

caveman2-widgets.navigation

Source

navigation.lisp (file)

Direct superclasses
Direct subclasses
Direct methods
Direct slots
Slot: created-paths
Allocation

:class

Initform

(quote nil)

Readers

created-paths (generic function)

Writers

(setf created-paths) (generic function)

Slot: pages

A list of cons. This slot holds all possible pages
and it should look like: (list (list "pagetitle" "uri-path" <widget>))

Initargs

:pages

Initform

(quote nil)

Readers

pages (generic function)

Slot: current-page

The name for the current page to display.

Type

(quote string)

Readers

current-page (generic function)

Writers

(setf current-page) (generic function)

Slot: composite
Readers

composite (generic function)

Writers

(setf composite) (generic function)

Slot: base-path

Determines the path for this navigation. It does not need an initial or trailing forward slash.

Initargs

:base-path

Initform

""

Readers

base-path (generic function)

Writers

(setf base-path) (generic function)

Slot: session-tag
Initargs

:session-tag

Initform

(error "must supply a tag for the session.")

Readers

session-tag (generic function)

Writers

(setf session-tag) (generic function)

Class: <widget-holder> ()
Package

caveman2-widgets.widget

Source

widget.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: widgets

Holds all widgets and derived widgets of a specific session. If a widget is finalized it will be removed from this list automatically. This list is neccessary for the REST API to get exactly the given widget.

Initform

(quote nil)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
caveman2-widgets.asd: The caveman2-widgets<dot>asd file
caveman2-widgets/src: The caveman2-widgets/src module
caveman2-widgets/src/callback-widget.lisp: The caveman2-widgets/src/callback-widget<dot>lisp file
caveman2-widgets/src/caveman2-widgets.lisp: The caveman2-widgets/src/caveman2-widgets<dot>lisp file
caveman2-widgets/src/default-widgets.lisp: The caveman2-widgets/src/default-widgets<dot>lisp file
caveman2-widgets/src/document.lisp: The caveman2-widgets/src/document<dot>lisp file
caveman2-widgets/src/login.lisp: The caveman2-widgets/src/login<dot>lisp file
caveman2-widgets/src/navigation.lisp: The caveman2-widgets/src/navigation<dot>lisp file
caveman2-widgets/src/util.lisp: The caveman2-widgets/src/util<dot>lisp file
caveman2-widgets/src/widget.lisp: The caveman2-widgets/src/widget<dot>lisp file

F
File, Lisp, caveman2-widgets.asd: The caveman2-widgets<dot>asd file
File, Lisp, caveman2-widgets/src/callback-widget.lisp: The caveman2-widgets/src/callback-widget<dot>lisp file
File, Lisp, caveman2-widgets/src/caveman2-widgets.lisp: The caveman2-widgets/src/caveman2-widgets<dot>lisp file
File, Lisp, caveman2-widgets/src/default-widgets.lisp: The caveman2-widgets/src/default-widgets<dot>lisp file
File, Lisp, caveman2-widgets/src/document.lisp: The caveman2-widgets/src/document<dot>lisp file
File, Lisp, caveman2-widgets/src/login.lisp: The caveman2-widgets/src/login<dot>lisp file
File, Lisp, caveman2-widgets/src/navigation.lisp: The caveman2-widgets/src/navigation<dot>lisp file
File, Lisp, caveman2-widgets/src/util.lisp: The caveman2-widgets/src/util<dot>lisp file
File, Lisp, caveman2-widgets/src/widget.lisp: The caveman2-widgets/src/widget<dot>lisp file

L
Lisp File, caveman2-widgets.asd: The caveman2-widgets<dot>asd file
Lisp File, caveman2-widgets/src/callback-widget.lisp: The caveman2-widgets/src/callback-widget<dot>lisp file
Lisp File, caveman2-widgets/src/caveman2-widgets.lisp: The caveman2-widgets/src/caveman2-widgets<dot>lisp file
Lisp File, caveman2-widgets/src/default-widgets.lisp: The caveman2-widgets/src/default-widgets<dot>lisp file
Lisp File, caveman2-widgets/src/document.lisp: The caveman2-widgets/src/document<dot>lisp file
Lisp File, caveman2-widgets/src/login.lisp: The caveman2-widgets/src/login<dot>lisp file
Lisp File, caveman2-widgets/src/navigation.lisp: The caveman2-widgets/src/navigation<dot>lisp file
Lisp File, caveman2-widgets/src/util.lisp: The caveman2-widgets/src/util<dot>lisp file
Lisp File, caveman2-widgets/src/widget.lisp: The caveman2-widgets/src/widget<dot>lisp file

M
Module, caveman2-widgets/src: The caveman2-widgets/src module

Jump to:   C   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf accepted-languages): Exported generic functions
(setf accepted-languages): Exported generic functions
(setf base-path): Exported generic functions
(setf base-path): Exported generic functions
(setf body): Exported generic functions
(setf body): Exported generic functions
(setf bottom): Exported generic functions
(setf bottom): Exported generic functions
(setf center): Internal generic functions
(setf center): Internal generic functions
(setf charset): Exported generic functions
(setf charset): Exported generic functions
(setf check-function): Exported generic functions
(setf check-function): Exported generic functions
(setf checked-option): Exported generic functions
(setf checked-option): Exported generic functions
(setf classes): Exported generic functions
(setf classes): Exported generic functions
(setf composite): Exported generic functions
(setf composite): Exported generic functions
(setf created-paths): Internal generic functions
(setf created-paths): Internal generic functions
(setf crossorigin): Exported generic functions
(setf crossorigin): Exported generic functions
(setf current-page): Exported generic functions
(setf current-page): Exported generic functions
(setf display-selector): Internal generic functions
(setf display-selector): Internal generic functions
(setf east): Exported generic functions
(setf east): Exported generic functions
(setf error-happened): Exported generic functions
(setf error-happened): Exported generic functions
(setf error-message): Exported generic functions
(setf error-message): Exported generic functions
(setf fn): Exported generic functions
(setf fn): Exported generic functions
(setf header): Exported generic functions
(setf header): Exported generic functions
(setf icon-path): Exported generic functions
(setf icon-path): Exported generic functions
(setf integrity): Internal generic functions
(setf integrity): Internal generic functions
(setf javascript-available): Exported generic functions
(setf javascript-available): Exported generic functions
(setf label): Exported generic functions
(setf label): Exported generic functions
(setf logged-in): Exported generic functions
(setf logged-in): Exported generic functions
(setf login-failed): Internal generic functions
(setf login-failed): Internal generic functions
(setf max-items-to-display): Exported generic functions
(setf max-items-to-display): Exported generic functions
(setf multiple): Exported generic functions
(setf multiple): Exported generic functions
(setf north): Exported generic functions
(setf north): Exported generic functions
(setf on-view): Exported generic functions
(setf on-view): Exported generic functions
(setf on-view-label): Exported generic functions
(setf on-view-label): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf options): Exported generic functions
(setf required): Exported generic functions
(setf required): Exported generic functions
(setf session-tag): Exported generic functions
(setf session-tag): Exported generic functions
(setf signout-hook): Exported generic functions
(setf signout-hook): Exported generic functions
(setf south): Exported generic functions
(setf south): Exported generic functions
(setf supplied): Exported generic functions
(setf supplied): Exported generic functions
(setf text): Exported generic functions
(setf text): Exported generic functions
(setf title): Exported generic functions
(setf title): Exported generic functions
(setf view): Exported generic functions
(setf view): Exported generic functions
(setf west): Exported generic functions
(setf west): Exported generic functions
(setf widgets): Exported generic functions
(setf widgets): Exported generic functions

A
accepted-languages: Exported generic functions
accepted-languages: Exported generic functions
add-authorization: Exported functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
append-item: Exported generic functions
authorized: Exported functions

B
base-path: Exported generic functions
base-path: Exported generic functions
body: Exported generic functions
body: Exported generic functions
bottom: Exported generic functions
bottom: Exported generic functions

C
callback: Exported generic functions
callback: Exported generic functions
center: Internal generic functions
center: Internal generic functions
charset: Exported generic functions
charset: Exported generic functions
check-and-set-language: Exported functions
check-function: Exported generic functions
check-function: Exported generic functions
checked-option: Exported generic functions
checked-option: Exported generic functions
classes: Exported generic functions
classes: Exported generic functions
clean-list-of-broken-links: Exported functions
column-descriptions: Exported generic functions
column-descriptions: Exported generic functions
composite: Exported generic functions
composite: Exported generic functions
created-paths: Internal generic functions
created-paths: Internal generic functions
crossorigin: Exported generic functions
crossorigin: Exported generic functions
css-files: Internal generic functions
css-files: Internal generic functions
current-page: Exported generic functions
current-page: Exported generic functions

D
defnav: Exported macros
defroute-static: Exported functions
delete-item: Exported generic functions
delete-item: Exported generic functions
delete-item: Exported generic functions
delete-item: Exported generic functions
demark-dirty: Internal functions
display-selector: Internal generic functions
display-selector: Internal generic functions
display-value: Internal generic functions
display-value: Internal generic functions

E
east: Exported generic functions
east: Exported generic functions
error-happened: Exported generic functions
error-happened: Exported generic functions
error-message: Exported generic functions
error-message: Exported generic functions

F
find-item: Exported generic functions
find-item: Exported generic functions
find-item: Exported generic functions
find-item: Exported generic functions
fn: Exported generic functions
fn: Exported generic functions
Function, add-authorization: Exported functions
Function, authorized: Exported functions
Function, check-and-set-language: Exported functions
Function, clean-list-of-broken-links: Exported functions
Function, defroute-static: Exported functions
Function, demark-dirty: Internal functions
Function, get-from-callback-args: Exported functions
Function, get-trimmed-class-name: Exported functions
Function, get-value-for-cons-list: Exported functions
Function, get-widget-for-session: Exported functions
Function, has-trailing-slash: Exported functions
Function, init-mark-dirty: Exported functions
Function, init-widgets: Exported functions
Function, mark-dirty: Exported functions
Function, remove-authorization: Exported functions
Function, remove-widget-for-session: Exported functions
Function, set-widget-for-session: Exported functions
Function, string-case-insensitive=: Exported functions
Function, test-widget-if-session: Internal functions

G
Generic Function, (setf accepted-languages): Exported generic functions
Generic Function, (setf base-path): Exported generic functions
Generic Function, (setf body): Exported generic functions
Generic Function, (setf bottom): Exported generic functions
Generic Function, (setf center): Internal generic functions
Generic Function, (setf charset): Exported generic functions
Generic Function, (setf check-function): Exported generic functions
Generic Function, (setf checked-option): Exported generic functions
Generic Function, (setf classes): Exported generic functions
Generic Function, (setf composite): Exported generic functions
Generic Function, (setf created-paths): Internal generic functions
Generic Function, (setf crossorigin): Exported generic functions
Generic Function, (setf current-page): Exported generic functions
Generic Function, (setf display-selector): Internal generic functions
Generic Function, (setf east): Exported generic functions
Generic Function, (setf error-happened): Exported generic functions
Generic Function, (setf error-message): Exported generic functions
Generic Function, (setf fn): Exported generic functions
Generic Function, (setf header): Exported generic functions
Generic Function, (setf icon-path): Exported generic functions
Generic Function, (setf integrity): Internal generic functions
Generic Function, (setf javascript-available): Exported generic functions
Generic Function, (setf label): Exported generic functions
Generic Function, (setf logged-in): Exported generic functions
Generic Function, (setf login-failed): Internal generic functions
Generic Function, (setf max-items-to-display): Exported generic functions
Generic Function, (setf multiple): Exported generic functions
Generic Function, (setf north): Exported generic functions
Generic Function, (setf on-view): Exported generic functions
Generic Function, (setf on-view-label): Exported generic functions
Generic Function, (setf options): Exported generic functions
Generic Function, (setf required): Exported generic functions
Generic Function, (setf session-tag): Exported generic functions
Generic Function, (setf signout-hook): Exported generic functions
Generic Function, (setf south): Exported generic functions
Generic Function, (setf supplied): Exported generic functions
Generic Function, (setf text): Exported generic functions
Generic Function, (setf title): Exported generic functions
Generic Function, (setf view): Exported generic functions
Generic Function, (setf west): Exported generic functions
Generic Function, (setf widgets): Exported generic functions
Generic Function, accepted-languages: Exported generic functions
Generic Function, append-item: Exported generic functions
Generic Function, base-path: Exported generic functions
Generic Function, body: Exported generic functions
Generic Function, bottom: Exported generic functions
Generic Function, callback: Exported generic functions
Generic Function, center: Internal generic functions
Generic Function, charset: Exported generic functions
Generic Function, check-function: Exported generic functions
Generic Function, checked-option: Exported generic functions
Generic Function, classes: Exported generic functions
Generic Function, column-descriptions: Exported generic functions
Generic Function, composite: Exported generic functions
Generic Function, created-paths: Internal generic functions
Generic Function, crossorigin: Exported generic functions
Generic Function, css-files: Internal generic functions
Generic Function, current-page: Exported generic functions
Generic Function, delete-item: Exported generic functions
Generic Function, display-selector: Internal generic functions
Generic Function, display-value: Internal generic functions
Generic Function, east: Exported generic functions
Generic Function, error-happened: Exported generic functions
Generic Function, error-message: Exported generic functions
Generic Function, find-item: Exported generic functions
Generic Function, fn: Exported generic functions
Generic Function, get-as-list: Exported generic functions
Generic Function, header: Exported generic functions
Generic Function, http-method: Exported generic functions
Generic Function, icon-path: Exported generic functions
Generic Function, id: Exported generic functions
Generic Function, input-fields: Exported generic functions
Generic Function, input-type: Exported generic functions
Generic Function, integrity: Internal generic functions
Generic Function, javascript-available: Exported generic functions
Generic Function, js-files: Internal generic functions
Generic Function, label: Exported generic functions
Generic Function, logged-in: Exported generic functions
Generic Function, login-authenticator: Exported generic functions
Generic Function, login-failed: Internal generic functions
Generic Function, login-form: Exported generic functions
Generic Function, logout-button: Exported generic functions
Generic Function, max-items-to-display: Exported generic functions
Generic Function, multiple: Exported generic functions
Generic Function, name: Exported generic functions
Generic Function, north: Exported generic functions
Generic Function, on-view: Exported generic functions
Generic Function, on-view-label: Exported generic functions
Generic Function, options: Exported generic functions
Generic Function, other-header-content: Exported generic functions
Generic Function, pages: Exported generic functions
Generic Function, path: Exported generic functions
Generic Function, producer: Internal generic functions
Generic Function, protect-widget: Exported generic functions
Generic Function, protected: Exported generic functions
Generic Function, render-as: Exported generic functions
Generic Function, render-widget: Exported generic functions
Generic Function, render-widget-body: Exported generic functions
Generic Function, render-widget-header: Exported generic functions
Generic Function, render-widget-rest: Exported generic functions
Generic Function, required: Exported generic functions
Generic Function, session-tag: Exported generic functions
Generic Function, set-required-present: Internal generic functions
Generic Function, signout-hook: Exported generic functions
Generic Function, south: Exported generic functions
Generic Function, supplied: Exported generic functions
Generic Function, text: Exported generic functions
Generic Function, title: Exported generic functions
Generic Function, uri-path: Exported generic functions
Generic Function, value: Exported generic functions
Generic Function, view: Exported generic functions
Generic Function, west: Exported generic functions
Generic Function, widget-scope: Exported generic functions
Generic Function, widgets: Exported generic functions
get-as-list: Exported generic functions
get-as-list: Exported generic functions
get-from-callback-args: Exported functions
get-trimmed-class-name: Exported functions
get-value-for-cons-list: Exported functions
get-widget-for-session: Exported functions

H
has-trailing-slash: Exported functions
header: Exported generic functions
header: Exported generic functions
http-method: Exported generic functions
http-method: Exported generic functions

I
icon-path: Exported generic functions
icon-path: Exported generic functions
id: Exported generic functions
id: Exported generic functions
init-mark-dirty: Exported functions
init-widgets: Exported functions
input-fields: Exported generic functions
input-fields: Exported generic functions
input-type: Exported generic functions
input-type: Exported generic functions
integrity: Internal generic functions
integrity: Internal generic functions

J
javascript-available: Exported generic functions
javascript-available: Exported generic functions
js-files: Internal generic functions
js-files: Internal generic functions

L
label: Exported generic functions
label: Exported generic functions
label: Exported generic functions
logged-in: Exported generic functions
logged-in: Exported generic functions
login-authenticator: Exported generic functions
login-authenticator: Exported generic functions
login-failed: Internal generic functions
login-failed: Internal generic functions
login-form: Exported generic functions
login-form: Exported generic functions
logout-button: Exported generic functions
logout-button: Exported generic functions

M
Macro, defnav: Exported macros
Macro, make-widget: Exported macros
Macro, with-html-document: Exported macros
make-widget: Exported macros
mark-dirty: Exported functions
max-items-to-display: Exported generic functions
max-items-to-display: Exported generic functions
Method, (setf accepted-languages): Exported generic functions
Method, (setf base-path): Exported generic functions
Method, (setf body): Exported generic functions
Method, (setf bottom): Exported generic functions
Method, (setf center): Internal generic functions
Method, (setf charset): Exported generic functions
Method, (setf check-function): Exported generic functions
Method, (setf checked-option): Exported generic functions
Method, (setf classes): Exported generic functions
Method, (setf composite): Exported generic functions
Method, (setf created-paths): Internal generic functions
Method, (setf crossorigin): Exported generic functions
Method, (setf current-page): Exported generic functions
Method, (setf display-selector): Internal generic functions
Method, (setf east): Exported generic functions
Method, (setf error-happened): Exported generic functions
Method, (setf error-message): Exported generic functions
Method, (setf fn): Exported generic functions
Method, (setf header): Exported generic functions
Method, (setf icon-path): Exported generic functions
Method, (setf integrity): Internal generic functions
Method, (setf javascript-available): Exported generic functions
Method, (setf label): Exported generic functions
Method, (setf logged-in): Exported generic functions
Method, (setf login-failed): Internal generic functions
Method, (setf max-items-to-display): Exported generic functions
Method, (setf multiple): Exported generic functions
Method, (setf north): Exported generic functions
Method, (setf on-view): Exported generic functions
Method, (setf on-view-label): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf options): Exported generic functions
Method, (setf required): Exported generic functions
Method, (setf session-tag): Exported generic functions
Method, (setf signout-hook): Exported generic functions
Method, (setf south): Exported generic functions
Method, (setf supplied): Exported generic functions
Method, (setf text): Exported generic functions
Method, (setf title): Exported generic functions
Method, (setf view): Exported generic functions
Method, (setf west): Exported generic functions
Method, (setf widgets): Exported generic functions
Method, accepted-languages: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, append-item: Exported generic functions
Method, base-path: Exported generic functions
Method, body: Exported generic functions
Method, bottom: Exported generic functions
Method, callback: Exported generic functions
Method, center: Internal generic functions
Method, charset: Exported generic functions
Method, check-function: Exported generic functions
Method, checked-option: Exported generic functions
Method, classes: Exported generic functions
Method, column-descriptions: Exported generic functions
Method, composite: Exported generic functions
Method, created-paths: Internal generic functions
Method, crossorigin: Exported generic functions
Method, css-files: Internal generic functions
Method, current-page: Exported generic functions
Method, delete-item: Exported generic functions
Method, delete-item: Exported generic functions
Method, delete-item: Exported generic functions
Method, display-selector: Internal generic functions
Method, display-value: Internal generic functions
Method, east: Exported generic functions
Method, error-happened: Exported generic functions
Method, error-message: Exported generic functions
Method, find-item: Exported generic functions
Method, find-item: Exported generic functions
Method, find-item: Exported generic functions
Method, fn: Exported generic functions
Method, get-as-list: Exported generic functions
Method, header: Exported generic functions
Method, http-method: Exported generic functions
Method, icon-path: Exported generic functions
Method, id: Exported generic functions
Method, input-fields: Exported generic functions
Method, input-type: Exported generic functions
Method, integrity: Internal generic functions
Method, javascript-available: Exported generic functions
Method, js-files: Internal generic functions
Method, label: Exported generic functions
Method, label: Exported generic functions
Method, logged-in: Exported generic functions
Method, login-authenticator: Exported generic functions
Method, login-failed: Internal generic functions
Method, login-form: Exported generic functions
Method, logout-button: Exported generic functions
Method, max-items-to-display: Exported generic functions
Method, multiple: Exported generic functions
Method, name: Exported generic functions
Method, north: Exported generic functions
Method, on-view: Exported generic functions
Method, on-view-label: Exported generic functions
Method, options: Exported generic functions
Method, options: Exported generic functions
Method, other-header-content: Exported generic functions
Method, pages: Exported generic functions
Method, path: Exported generic functions
Method, producer: Internal generic functions
Method, producer: Internal generic functions
Method, protect-widget: Exported generic functions
Method, protect-widget: Exported generic functions
Method, protected: Exported generic functions
Method, render-as: Exported generic functions
Method, render-as: Exported generic functions
Method, render-as: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget: Exported generic functions
Method, render-widget-body: Exported generic functions
Method, render-widget-header: Exported generic functions
Method, render-widget-rest: Exported generic functions
Method, render-widget-rest: Exported generic functions
Method, required: Exported generic functions
Method, session-tag: Exported generic functions
Method, set-required-present: Internal generic functions
Method, signout-hook: Exported generic functions
Method, south: Exported generic functions
Method, supplied: Exported generic functions
Method, text: Exported generic functions
Method, title: Exported generic functions
Method, uri-path: Exported generic functions
Method, value: Exported generic functions
Method, value: Exported generic functions
Method, view: Exported generic functions
Method, west: Exported generic functions
Method, widget-scope: Exported generic functions
Method, widgets: Exported generic functions
multiple: Exported generic functions
multiple: Exported generic functions

N
name: Exported generic functions
name: Exported generic functions
north: Exported generic functions
north: Exported generic functions

O
on-view: Exported generic functions
on-view: Exported generic functions
on-view-label: Exported generic functions
on-view-label: Exported generic functions
options: Exported generic functions
options: Exported generic functions
options: Exported generic functions
other-header-content: Exported generic functions
other-header-content: Exported generic functions

P
pages: Exported generic functions
pages: Exported generic functions
path: Exported generic functions
path: Exported generic functions
producer: Internal generic functions
producer: Internal generic functions
producer: Internal generic functions
protect-widget: Exported generic functions
protect-widget: Exported generic functions
protect-widget: Exported generic functions
protected: Exported generic functions
protected: Exported generic functions

R
remove-authorization: Exported functions
remove-widget-for-session: Exported functions
render-as: Exported generic functions
render-as: Exported generic functions
render-as: Exported generic functions
render-as: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget: Exported generic functions
render-widget-body: Exported generic functions
render-widget-body: Exported generic functions
render-widget-header: Exported generic functions
render-widget-header: Exported generic functions
render-widget-rest: Exported generic functions
render-widget-rest: Exported generic functions
render-widget-rest: Exported generic functions
required: Exported generic functions
required: Exported generic functions

S
session-tag: Exported generic functions
session-tag: Exported generic functions
set-required-present: Internal generic functions
set-required-present: Internal generic functions
set-widget-for-session: Exported functions
signout-hook: Exported generic functions
signout-hook: Exported generic functions
south: Exported generic functions
south: Exported generic functions
string-case-insensitive=: Exported functions
supplied: Exported generic functions
supplied: Exported generic functions

T
test-widget-if-session: Internal functions
text: Exported generic functions
text: Exported generic functions
title: Exported generic functions
title: Exported generic functions

U
uri-path: Exported generic functions
uri-path: Exported generic functions

V
value: Exported generic functions
value: Exported generic functions
value: Exported generic functions
view: Exported generic functions
view: Exported generic functions

W
west: Exported generic functions
west: Exported generic functions
widget-scope: Exported generic functions
widget-scope: Exported generic functions
widgets: Exported generic functions
widgets: Exported generic functions
with-html-document: Exported macros

Jump to:   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   O   P   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
B   C   D   E   F   H   I   J   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

*
*application-root*: Exported special variables
*automatically-set-languages*: Exported special variables
*button-call-path*: Exported special variables
*css-directory*: Exported special variables
*css-path*: Exported special variables
*dirty-objects-session-key*: Internal special variables
*dirty-objects-uri-path*: Exported special variables
*global-widget-holder*: Internal special variables
*init-widgets-hooks*: Exported special variables
*input-field-for-old-uri*: Internal special variables
*javascript-checker-path*: Exported special variables
*javascript-path*: Exported special variables
*jquery-cdn-link*: Exported special variables
*js-directory*: Exported special variables
*language-key-in-session*: Exported special variables
*link-call-path*: Exported special variables
*login-authentication-keyword*: Exported special variables
*navigation-widgets*: Internal special variables
*port*: Exported special variables
*protection-circles-session-key*: Exported special variables
*rest-methods*: Internal special variables
*rest-path*: Exported special variables
*static-directory*: Exported special variables
*web*: Exported special variables
*widgets-css-filename*: Exported special variables
*widgets-js-filename*: Exported special variables

+
+translate+: Exported special variables

B
base-path: Internal classes
body: Exported classes
bottom: Exported classes

C
callback: Exported classes
center: Exported classes
charset: Exported classes
check-function: Exported classes
checked-option: Exported classes
classes: Exported classes
colum-descriptions: Exported classes
composite: Internal classes
created-paths: Internal classes
crossorigin: Internal classes
css-files: Exported classes
current-from: Exported classes
current-page: Internal classes

D
display-selector: Exported classes
display-value: Exported classes

E
east: Exported classes
error-happened: Exported classes
error-message: Exported classes

F
fn: Exported classes

H
header: Exported classes
http-method: Exported classes

I
icon-path: Exported classes
id: Exported classes
input-fields: Exported classes
input-type: Exported classes
integrity: Internal classes

J
js-files: Exported classes

L
label: Exported classes
label: Exported classes
login-authenticator: Exported classes
login-failed: Exported classes
login-form: Exported classes
logout-button: Exported classes

M
max-items-to-display: Exported classes
multiple: Exported classes

N
name: Exported classes
next-button: Exported classes
north: Exported classes

O
on-view: Exported classes
on-view-label: Exported classes
options: Exported classes
options: Exported classes
other-header-content: Exported classes

P
pages: Internal classes
path: Internal classes
prev-button: Exported classes
producer: Exported classes
producer: Exported classes
protected: Exported classes

R
required: Exported classes

S
scope: Exported classes
selector: Exported classes
session-tag: Internal classes
signout-hook: Exported classes
Slot, base-path: Internal classes
Slot, body: Exported classes
Slot, bottom: Exported classes
Slot, callback: Exported classes
Slot, center: Exported classes
Slot, charset: Exported classes
Slot, check-function: Exported classes
Slot, checked-option: Exported classes
Slot, classes: Exported classes
Slot, colum-descriptions: Exported classes
Slot, composite: Internal classes
Slot, created-paths: Internal classes
Slot, crossorigin: Internal classes
Slot, css-files: Exported classes
Slot, current-from: Exported classes
Slot, current-page: Internal classes
Slot, display-selector: Exported classes
Slot, display-value: Exported classes
Slot, east: Exported classes
Slot, error-happened: Exported classes
Slot, error-message: Exported classes
Slot, fn: Exported classes
Slot, header: Exported classes
Slot, http-method: Exported classes
Slot, icon-path: Exported classes
Slot, id: Exported classes
Slot, input-fields: Exported classes
Slot, input-type: Exported classes
Slot, integrity: Internal classes
Slot, js-files: Exported classes
Slot, label: Exported classes
Slot, label: Exported classes
Slot, login-authenticator: Exported classes
Slot, login-failed: Exported classes
Slot, login-form: Exported classes
Slot, logout-button: Exported classes
Slot, max-items-to-display: Exported classes
Slot, multiple: Exported classes
Slot, name: Exported classes
Slot, next-button: Exported classes
Slot, north: Exported classes
Slot, on-view: Exported classes
Slot, on-view-label: Exported classes
Slot, options: Exported classes
Slot, options: Exported classes
Slot, other-header-content: Exported classes
Slot, pages: Internal classes
Slot, path: Internal classes
Slot, prev-button: Exported classes
Slot, producer: Exported classes
Slot, producer: Exported classes
Slot, protected: Exported classes
Slot, required: Exported classes
Slot, scope: Exported classes
Slot, selector: Exported classes
Slot, session-tag: Internal classes
Slot, signout-hook: Exported classes
Slot, south: Exported classes
Slot, supplied: Exported classes
Slot, target-foreign-p: Exported classes
Slot, text: Exported classes
Slot, title: Exported classes
Slot, uri-path: Exported classes
Slot, value: Exported classes
Slot, value: Exported classes
Slot, view: Exported classes
Slot, west: Exported classes
Slot, widgets: Exported classes
Slot, widgets: Internal classes
Slot, widgets: Internal classes
south: Exported classes
Special Variable, *application-root*: Exported special variables
Special Variable, *automatically-set-languages*: Exported special variables
Special Variable, *button-call-path*: Exported special variables
Special Variable, *css-directory*: Exported special variables
Special Variable, *css-path*: Exported special variables
Special Variable, *dirty-objects-session-key*: Internal special variables
Special Variable, *dirty-objects-uri-path*: Exported special variables
Special Variable, *global-widget-holder*: Internal special variables
Special Variable, *init-widgets-hooks*: Exported special variables
Special Variable, *input-field-for-old-uri*: Internal special variables
Special Variable, *javascript-checker-path*: Exported special variables
Special Variable, *javascript-path*: Exported special variables
Special Variable, *jquery-cdn-link*: Exported special variables
Special Variable, *js-directory*: Exported special variables
Special Variable, *language-key-in-session*: Exported special variables
Special Variable, *link-call-path*: Exported special variables
Special Variable, *login-authentication-keyword*: Exported special variables
Special Variable, *navigation-widgets*: Internal special variables
Special Variable, *port*: Exported special variables
Special Variable, *protection-circles-session-key*: Exported special variables
Special Variable, *rest-methods*: Internal special variables
Special Variable, *rest-path*: Exported special variables
Special Variable, *static-directory*: Exported special variables
Special Variable, *web*: Exported special variables
Special Variable, *widgets-css-filename*: Exported special variables
Special Variable, *widgets-js-filename*: Exported special variables
Special Variable, +translate+: Exported special variables
supplied: Exported classes

T
target-foreign-p: Exported classes
text: Exported classes
title: Exported classes

U
uri-path: Exported classes

V
value: Exported classes
value: Exported classes
view: Exported classes

W
west: Exported classes
widgets: Exported classes
widgets: Internal classes
widgets: Internal classes

Jump to:   *   +  
B   C   D   E   F   H   I   J   L   M   N   O   P   R   S   T   U   V   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   <  
C   P   S  
Index Entry  Section

<
<blank-navigation-widget>: Exported classes
<border-widget>: Exported classes
<button-widget>: Exported classes
<callback-widget>: Exported classes
<composite-widget>: Exported classes
<css-file>: Exported classes
<dirty-widget-holder>: Internal classes
<file>: Internal classes
<form-field>: Exported classes
<form-widget>: Exported classes
<function-widget>: Exported classes
<hcomposite-widget>: Exported classes
<header-widget>: Exported classes
<html-document-widget>: Exported classes
<input-field>: Exported classes
<js-file>: Exported classes
<link-widget>: Exported classes
<login-widget>: Exported classes
<menu-navigation-widget>: Exported classes
<navigation-widget>: Internal classes
<option-field>: Exported classes
<radio-field>: Exported classes
<select-field>: Exported classes
<string-widget>: Exported classes
<table-item>: Exported classes
<table-widget>: Exported classes
<viewgrid-item>: Exported classes
<viewgrid-widget>: Exported classes
<widget-holder>: Internal classes
<widget>: Exported classes

C
caveman2-widgets: The caveman2-widgets system
caveman2-widgets: The caveman2-widgets package
caveman2-widgets.callback-widget: The caveman2-widgets<dot>callback-widget package
caveman2-widgets.default-widgets: The caveman2-widgets<dot>default-widgets package
caveman2-widgets.document: The caveman2-widgets<dot>document package
caveman2-widgets.login: The caveman2-widgets<dot>login package
caveman2-widgets.navigation: The caveman2-widgets<dot>navigation package
caveman2-widgets.util: The caveman2-widgets<dot>util package
caveman2-widgets.widget: The caveman2-widgets<dot>widget package
Class, <blank-navigation-widget>: Exported classes
Class, <border-widget>: Exported classes
Class, <button-widget>: Exported classes
Class, <callback-widget>: Exported classes
Class, <composite-widget>: Exported classes
Class, <css-file>: Exported classes
Class, <dirty-widget-holder>: Internal classes
Class, <file>: Internal classes
Class, <form-field>: Exported classes
Class, <form-widget>: Exported classes
Class, <function-widget>: Exported classes
Class, <hcomposite-widget>: Exported classes
Class, <header-widget>: Exported classes
Class, <html-document-widget>: Exported classes
Class, <input-field>: Exported classes
Class, <js-file>: Exported classes
Class, <link-widget>: Exported classes
Class, <login-widget>: Exported classes
Class, <menu-navigation-widget>: Exported classes
Class, <navigation-widget>: Internal classes
Class, <option-field>: Exported classes
Class, <radio-field>: Exported classes
Class, <select-field>: Exported classes
Class, <string-widget>: Exported classes
Class, <table-item>: Exported classes
Class, <table-widget>: Exported classes
Class, <viewgrid-item>: Exported classes
Class, <viewgrid-widget>: Exported classes
Class, <widget-holder>: Internal classes
Class, <widget>: Exported classes

P
Package, caveman2-widgets: The caveman2-widgets package
Package, caveman2-widgets.callback-widget: The caveman2-widgets<dot>callback-widget package
Package, caveman2-widgets.default-widgets: The caveman2-widgets<dot>default-widgets package
Package, caveman2-widgets.document: The caveman2-widgets<dot>document package
Package, caveman2-widgets.login: The caveman2-widgets<dot>login package
Package, caveman2-widgets.navigation: The caveman2-widgets<dot>navigation package
Package, caveman2-widgets.util: The caveman2-widgets<dot>util package
Package, caveman2-widgets.widget: The caveman2-widgets<dot>widget package

S
System, caveman2-widgets: The caveman2-widgets system

Jump to:   <  
C   P   S