Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the caveman2-widgets Reference Manual, version 0.5, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:52:14 2018 GMT+0.
| • Introduction: | What caveman2-widgets is all about | |
| • Systems: | The systems documentation | |
| • Modules: | The modules documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
* 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: Modules, Previous: Introduction, Up: Top [Contents][Index]
2 Systems
The main system appears first, followed by any subsystem dependency.
• The caveman2-widgets system:
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
- trivial-garbage
- moptilities
- caveman2
- Source
caveman2-widgets.asd (file)
- Component
src (module)
3 Modules
Modules are listed depth-first from the system components tree.
• The caveman2-widgets/src module:
3.1 caveman2-widgets/src
- Parent
caveman2-widgets (system)
- Location
src/
- Components
- util.lisp (file)
- widget.lisp (file)
- callback-widget.lisp (file)
- default-widgets.lisp (file)
- login.lisp (file)
- document.lisp (file)
- navigation.lisp (file)
- caveman2-widgets.lisp (file)
4 Files
Files are sorted by type and then listed depth-first from the systems
components trees.
• Lisp files:
4.1 Lisp
Next: The caveman2-widgets/src/util<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
4.1.1 caveman2-widgets.asd
- Location
caveman2-widgets.asd
- Systems
caveman2-widgets (system)
Next: The caveman2-widgets/src/widget<dot>lisp file, Previous: The caveman2-widgets<dot>asd file, Up: Lisp files [Contents][Index]
4.1.2 caveman2-widgets/src/util.lisp
- Parent
src (module)
- Location
src/util.lisp
- Packages
- Exported Definitions
- *application-root* (special variable)
- *automatically-set-languages* (special variable)
- *css-directory* (special variable)
- *js-directory* (special variable)
- *language-key-in-session* (special variable)
- *static-directory* (special variable)
- +translate+ (special variable)
- accepted-languages (generic function)
- accepted-languages (method)
- (setf accepted-languages) (method)
- (setf accepted-languages) (generic function)
- append-item (generic function)
- append-item (method)
- check-and-set-language (function)
- clean-list-of-broken-links (function)
- defroute-static (function)
- delete-item (generic function)
- delete-item (method)
- find-item (generic function)
- find-item (method)
- get-trimmed-class-name (function)
- get-value-for-cons-list (function)
- has-trailing-slash (function)
- javascript-available (generic function)
- javascript-available (method)
- (setf javascript-available) (method)
- (setf javascript-available) (generic function)
- string-case-insensitive= (function)
Next: The caveman2-widgets/src/callback-widget<dot>lisp file, Previous: The caveman2-widgets/src/util<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.3 caveman2-widgets/src/widget.lisp
- Parent
src (module)
- Location
src/widget.lisp
- Packages
- Exported Definitions
- *css-path* (special variable)
- *dirty-objects-uri-path* (special variable)
- *javascript-checker-path* (special variable)
- *javascript-path* (special variable)
- *protection-circles-session-key* (special variable)
- *rest-path* (special variable)
- *web* (special variable)
- *widgets-css-filename* (special variable)
- *widgets-js-filename* (special variable)
- <widget> (class)
- add-authorization (function)
- append-item (method)
- append-item (method)
- authorized (function)
- delete-item (method)
- delete-item (method)
- find-item (method)
- get-widget-for-session (function)
- id (method)
- init-mark-dirty (function)
- make-widget (macro)
- mark-dirty (function)
- protect-widget (generic function)
- protect-widget (method)
- protect-widget (method)
- protected (method)
- remove-authorization (function)
- remove-widget-for-session (function)
- render-widget (generic function)
- render-widget (method)
- render-widget-body (generic function)
- render-widget-header (generic function)
- render-widget-rest (generic function)
- render-widget-rest (method)
- render-widget-rest (method)
- set-widget-for-session (function)
- widget-scope (method)
- Internal Definitions
- *dirty-objects-session-key* (special variable)
- *global-widget-holder* (special variable)
- *rest-methods* (special variable)
- <dirty-widget-holder> (class)
- <widget-holder> (class)
- demark-dirty (function)
Next: The caveman2-widgets/src/default-widgets<dot>lisp file, Previous: The caveman2-widgets/src/widget<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.4 caveman2-widgets/src/callback-widget.lisp
- Parent
src (module)
- Location
src/callback-widget.lisp
- Packages
- Exported Definitions
- *button-call-path* (special variable)
- *link-call-path* (special variable)
- <button-widget> (class)
- <callback-widget> (class)
- <form-field> (class)
- <form-widget> (class)
- <input-field> (class)
- <link-widget> (class)
- <option-field> (class)
- <radio-field> (class)
- <select-field> (class)
- append-item (method)
- append-item (method)
- append-item (method)
- callback (method)
- check-function (method)
- (setf check-function) (method)
- checked-option (method)
- (setf checked-option) (method)
- classes (method)
- (setf classes) (method)
- error-happened (method)
- (setf error-happened) (method)
- error-message (method)
- (setf error-message) (method)
- get-from-callback-args (function)
- http-method (method)
- input-fields (method)
- input-type (method)
- label (method)
- (setf label) (method)
- label (method)
- multiple (method)
- (setf multiple) (method)
- name (method)
- options (method)
- (setf options) (method)
- options (method)
- (setf options) (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- required (method)
- (setf required) (method)
- supplied (method)
- (setf supplied) (method)
- uri-path (method)
- value (method)
- value (method)
- Internal Definitions
- *input-field-for-old-uri* (special variable)
- display-value (method)
- set-required-present (generic function)
- set-required-present (method)
- test-widget-if-session (function)
Next: The caveman2-widgets/src/login<dot>lisp file, Previous: The caveman2-widgets/src/callback-widget<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.5 caveman2-widgets/src/default-widgets.lisp
- Parent
src (module)
- Location
src/default-widgets.lisp
- Packages
- Exported Definitions
- <border-widget> (class)
- <composite-widget> (class)
- <function-widget> (class)
- <hcomposite-widget> (class)
- <string-widget> (class)
- <table-item> (class)
- <table-widget> (class)
- <viewgrid-item> (class)
- <viewgrid-widget> (class)
- append-item (method)
- append-item (method)
- column-descriptions (method)
- east (method)
- (setf east) (method)
- fn (method)
- (setf fn) (method)
- get-as-list (generic function)
- get-as-list (method)
- max-items-to-display (method)
- (setf max-items-to-display) (method)
- north (method)
- (setf north) (method)
- on-view (method)
- (setf on-view) (method)
- on-view-label (method)
- (setf on-view-label) (method)
- render-as (generic function)
- render-as (method)
- render-as (method)
- render-as (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget-body (method)
- render-widget-header (method)
- south (method)
- (setf south) (method)
- text (method)
- (setf text) (method)
- view (method)
- (setf view) (method)
- west (method)
- (setf west) (method)
- widgets (method)
- (setf widgets) (method)
- Internal Definitions
- center (method)
- (setf center) (method)
- display-selector (method)
- (setf display-selector) (method)
- producer (method)
- producer (method)
Next: The caveman2-widgets/src/document<dot>lisp file, Previous: The caveman2-widgets/src/default-widgets<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.6 caveman2-widgets/src/login.lisp
- Parent
src (module)
- Location
src/login.lisp
- Packages
- Exported Definitions
- *login-authentication-keyword* (special variable)
- <login-widget> (class)
- logged-in (generic function)
- logged-in (method)
- (setf logged-in) (method)
- (setf logged-in) (generic function)
- login-authenticator (method)
- login-form (method)
- logout-button (method)
- render-widget (method)
- signout-hook (method)
- (setf signout-hook) (method)
- Internal Definitions
- login-failed (method)
- (setf login-failed) (method)
Next: The caveman2-widgets/src/navigation<dot>lisp file, Previous: The caveman2-widgets/src/login<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.7 caveman2-widgets/src/document.lisp
- Parent
src (module)
- Location
src/document.lisp
- Packages
- Exported Definitions
- *jquery-cdn-link* (special variable)
- <css-file> (class)
- <header-widget> (class)
- <html-document-widget> (class)
- <js-file> (class)
- append-item (method)
- append-item (method)
- append-item (method)
- body (method)
- (setf body) (method)
- bottom (method)
- (setf bottom) (method)
- charset (method)
- (setf charset) (method)
- crossorigin (method)
- (setf crossorigin) (method)
- header (method)
- (setf header) (method)
- icon-path (method)
- (setf icon-path) (method)
- other-header-content (method)
- path (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- title (method)
- (setf title) (method)
- with-html-document (macro)
- Internal Definitions
- <file> (class)
- css-files (method)
- integrity (method)
- (setf integrity) (method)
- js-files (method)
Next: The caveman2-widgets/src/caveman2-widgets<dot>lisp file, Previous: The caveman2-widgets/src/document<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.8 caveman2-widgets/src/navigation.lisp
- Parent
src (module)
- Location
src/navigation.lisp
- Packages
- Exported Definitions
- *port* (special variable)
- <blank-navigation-widget> (class)
- <menu-navigation-widget> (class)
- append-item (method)
- base-path (method)
- (setf base-path) (method)
- composite (method)
- (setf composite) (method)
- current-page (method)
- (setf current-page) (generic function)
- (setf current-page) (method)
- defnav (macro)
- find-item (method)
- pages (method)
- render-widget (method)
- render-widget (method)
- session-tag (method)
- (setf session-tag) (method)
- Internal Definitions
- *navigation-widgets* (special variable)
- <navigation-widget> (class)
- created-paths (method)
- (setf created-paths) (method)
Previous: The caveman2-widgets/src/navigation<dot>lisp file, Up: Lisp files [Contents][Index]
4.1.9 caveman2-widgets/src/caveman2-widgets.lisp
- Parent
src (module)
- Location
src/caveman2-widgets.lisp
- Packages
- Exported Definitions
- *init-widgets-hooks* (special variable)
- init-widgets (function)
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
5 Packages
Packages are listed by definition order.
Next: The caveman2-widgets<dot>widget package, Previous: Packages, Up: Packages [Contents][Index]
5.1 caveman2-widgets.util
- Source
util.lisp (file)
- Use List
- caveman2
- metabang.moptilities
- common-lisp
- Used By List
-
- Exported Definitions
- *application-root* (special variable)
- *automatically-set-languages* (special variable)
- *css-directory* (special variable)
- *js-directory* (special variable)
- *language-key-in-session* (special variable)
- *static-directory* (special variable)
- +translate+ (special variable)
- accepted-languages (generic function)
- accepted-languages (method)
- (setf accepted-languages) (method)
- (setf accepted-languages) (generic function)
- append-item (generic function)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- append-item (method)
- check-and-set-language (function)
- clean-list-of-broken-links (function)
- defroute-static (function)
- delete-item (generic function)
- delete-item (method)
- delete-item (method)
- delete-item (method)
- find-item (generic function)
- find-item (method)
- find-item (method)
- find-item (method)
- get-trimmed-class-name (function)
- get-value-for-cons-list (function)
- has-trailing-slash (function)
- javascript-available (generic function)
- javascript-available (method)
- (setf javascript-available) (method)
- (setf javascript-available) (generic function)
- string-case-insensitive= (function)
Next: The caveman2-widgets<dot>callback-widget package, Previous: The caveman2-widgets<dot>util package, Up: Packages [Contents][Index]
5.2 caveman2-widgets.widget
- Source
widget.lisp (file)
- Use List
- caveman2-widgets.util
- caveman2
- common-lisp
- Used By List
-
- Exported Definitions
- *css-path* (special variable)
- *dirty-objects-uri-path* (special variable)
- *javascript-checker-path* (special variable)
- *javascript-path* (special variable)
- *protection-circles-session-key* (special variable)
- *rest-path* (special variable)
- *web* (special variable)
- *widgets-css-filename* (special variable)
- *widgets-js-filename* (special variable)
- <widget> (class)
- add-authorization (function)
- authorized (function)
- get-widget-for-session (function)
- id (generic function)
- id (method)
- init-mark-dirty (function)
- make-widget (macro)
- mark-dirty (function)
- protect-widget (generic function)
- protect-widget (method)
- protect-widget (method)
- protected (generic function)
- protected (method)
- remove-authorization (function)
- remove-widget-for-session (function)
- render-widget (generic function)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget (method)
- render-widget-body (generic function)
- render-widget-body (method)
- render-widget-header (generic function)
- render-widget-header (method)
- render-widget-rest (generic function)
- render-widget-rest (method)
- render-widget-rest (method)
- set-widget-for-session (function)
- widget-scope (generic function)
- widget-scope (method)
- Internal Definitions
- *dirty-objects-session-key* (special variable)
- *global-widget-holder* (special variable)
- *rest-methods* (special variable)
- <dirty-widget-holder> (class)
- <widget-holder> (class)
- demark-dirty (function)
Next: The caveman2-widgets<dot>default-widgets package, Previous: The caveman2-widgets<dot>widget package, Up: Packages [Contents][Index]
5.3 caveman2-widgets.callback-widget
- Source
callback-widget.lisp (file)
- Use List
- caveman2-widgets.widget
- caveman2-widgets.util
- caveman2
- common-lisp
- Used By List
-
- Exported Definitions
- *button-call-path* (special variable)
- *link-call-path* (special variable)
- <button-widget> (class)
- <callback-widget> (class)
- <form-field> (class)
- <form-widget> (class)
- <input-field> (class)
- <link-widget> (class)
- <option-field> (class)
- <radio-field> (class)
- <select-field> (class)
- callback (generic function)
- callback (method)
- check-function (generic function)
- check-function (method)
- (setf check-function) (method)
- (setf check-function) (generic function)
- checked-option (generic function)
- checked-option (method)
- (setf checked-option) (method)
- (setf checked-option) (generic function)
- classes (generic function)
- classes (method)
- (setf classes) (method)
- (setf classes) (generic function)
- error-happened (generic function)
- error-happened (method)
- (setf error-happened) (method)
- (setf error-happened) (generic function)
- error-message (generic function)
- error-message (method)
- (setf error-message) (method)
- (setf error-message) (generic function)
- get-from-callback-args (function)
- http-method (generic function)
- http-method (method)
- input-fields (generic function)
- input-fields (method)
- input-type (generic function)
- input-type (method)
- label (generic function)
- label (method)
- (setf label) (method)
- label (method)
- (setf label) (generic function)
- multiple (generic function)
- multiple (method)
- (setf multiple) (method)
- (setf multiple) (generic function)
- name (generic function)
- name (method)
- options (generic function)
- options (method)
- (setf options) (method)
- options (method)
- (setf options) (method)
- (setf options) (generic function)
- required (generic function)
- required (method)
- (setf required) (method)
- (setf required) (generic function)
- supplied (generic function)
- supplied (method)
- (setf supplied) (method)
- (setf supplied) (generic function)
- uri-path (generic function)
- uri-path (method)
- value (generic function)
- value (method)
- value (method)
- Internal Definitions
- *input-field-for-old-uri* (special variable)
- display-value (generic function)
- display-value (method)
- set-required-present (generic function)
- set-required-present (method)
- test-widget-if-session (function)
Next: The caveman2-widgets<dot>login package, Previous: The caveman2-widgets<dot>callback-widget package, Up: Packages [Contents][Index]
5.4 caveman2-widgets.default-widgets
- Source
default-widgets.lisp (file)
- Use List
- caveman2-widgets.callback-widget
- caveman2-widgets.widget
- caveman2-widgets.util
- caveman2
- common-lisp
- Used By List
-
- Exported Definitions
- <border-widget> (class)
- <composite-widget> (class)
- <function-widget> (class)
- <hcomposite-widget> (class)
- <string-widget> (class)
- <table-item> (class)
- <table-widget> (class)
- <viewgrid-item> (class)
- <viewgrid-widget> (class)
- column-descriptions (generic function)
- column-descriptions (method)
- east (generic function)
- east (method)
- (setf east) (method)
- (setf east) (generic function)
- fn (generic function)
- fn (method)
- (setf fn) (method)
- (setf fn) (generic function)
- get-as-list (generic function)
- get-as-list (method)
- max-items-to-display (generic function)
- max-items-to-display (method)
- (setf max-items-to-display) (method)
- (setf max-items-to-display) (generic function)
- north (generic function)
- north (method)
- (setf north) (method)
- (setf north) (generic function)
- on-view (generic function)
- on-view (method)
- (setf on-view) (method)
- (setf on-view) (generic function)
- on-view-label (generic function)
- on-view-label (method)
- (setf on-view-label) (method)
- (setf on-view-label) (generic function)
- render-as (generic function)
- render-as (method)
- render-as (method)
- render-as (method)
- south (generic function)
- south (method)
- (setf south) (method)
- (setf south) (generic function)
- text (generic function)
- text (method)
- (setf text) (method)
- (setf text) (generic function)
- view (generic function)
- view (method)
- (setf view) (method)
- (setf view) (generic function)
- west (generic function)
- west (method)
- (setf west) (method)
- (setf west) (generic function)
- widgets (generic function)
- widgets (method)
- (setf widgets) (method)
- (setf widgets) (generic function)
- Internal Definitions
- center (generic function)
- center (method)
- (setf center) (method)
- (setf center) (generic function)
- display-selector (generic function)
- display-selector (method)
- (setf display-selector) (method)
- (setf display-selector) (generic function)
- producer (generic function)
- producer (method)
- producer (method)
Next: The caveman2-widgets<dot>document package, Previous: The caveman2-widgets<dot>default-widgets package, Up: Packages [Contents][Index]
5.5 caveman2-widgets.login
- Source
login.lisp (file)
- Use List
-
- Used By List
- Exported Definitions
- *login-authentication-keyword* (special variable)
- <login-widget> (class)
- logged-in (generic function)
- logged-in (method)
- (setf logged-in) (method)
- (setf logged-in) (generic function)
- login-authenticator (generic function)
- login-authenticator (method)
- login-form (generic function)
- login-form (method)
- logout-button (generic function)
- logout-button (method)
- signout-hook (generic function)
- signout-hook (method)
- (setf signout-hook) (method)
- (setf signout-hook) (generic function)
- Internal Definitions
- login-failed (generic function)
- login-failed (method)
- (setf login-failed) (method)
- (setf login-failed) (generic function)
Next: The caveman2-widgets<dot>navigation package, Previous: The caveman2-widgets<dot>login package, Up: Packages [Contents][Index]
5.6 caveman2-widgets.document
- Source
document.lisp (file)
- Use List
- caveman2-widgets.widget
- caveman2-widgets.util
- caveman2
- common-lisp
- Used By List
-
- Exported Definitions
- *jquery-cdn-link* (special variable)
- <css-file> (class)
- <header-widget> (class)
- <html-document-widget> (class)
- <js-file> (class)
- body (generic function)
- body (method)
- (setf body) (method)
- (setf body) (generic function)
- bottom (generic function)
- bottom (method)
- (setf bottom) (method)
- (setf bottom) (generic function)
- charset (generic function)
- charset (method)
- (setf charset) (method)
- (setf charset) (generic function)
- crossorigin (generic function)
- crossorigin (method)
- (setf crossorigin) (method)
- (setf crossorigin) (generic function)
- header (generic function)
- header (method)
- (setf header) (method)
- (setf header) (generic function)
- icon-path (generic function)
- icon-path (method)
- (setf icon-path) (method)
- (setf icon-path) (generic function)
- other-header-content (generic function)
- other-header-content (method)
- path (generic function)
- path (method)
- title (generic function)
- title (method)
- (setf title) (method)
- (setf title) (generic function)
- with-html-document (macro)
- Internal Definitions
- <file> (class)
- css-files (generic function)
- css-files (method)
- integrity (generic function)
- integrity (method)
- (setf integrity) (method)
- (setf integrity) (generic function)
- js-files (generic function)
- js-files (method)
Next: The caveman2-widgets package, Previous: The caveman2-widgets<dot>document package, Up: Packages [Contents][Index]
5.7 caveman2-widgets.navigation
- Source
navigation.lisp (file)
- Use List
-
- Used By List
- Exported Definitions
- *port* (special variable)
- <blank-navigation-widget> (class)
- <menu-navigation-widget> (class)
- base-path (generic function)
- base-path (method)
- (setf base-path) (method)
- (setf base-path) (generic function)
- composite (generic function)
- composite (method)
- (setf composite) (method)
- (setf composite) (generic function)
- current-page (generic function)
- current-page (method)
- (setf current-page) (generic function)
- (setf current-page) (method)
- defnav (macro)
- pages (generic function)
- pages (method)
- session-tag (generic function)
- session-tag (method)
- (setf session-tag) (method)
- (setf session-tag) (generic function)
- Internal Definitions
- *navigation-widgets* (special variable)
- <navigation-widget> (class)
- created-paths (generic function)
- created-paths (method)
- (setf created-paths) (method)
- (setf created-paths) (generic function)
Previous: The caveman2-widgets<dot>navigation package, Up: Packages [Contents][Index]
5.8 caveman2-widgets
- Source
caveman2-widgets.lisp (file)
- Use List
-
- Exported Definitions
- *init-widgets-hooks* (special variable)
- init-widgets (function)
6 Definitions
Definitions are sorted by export status, category, package, and then by
lexicographic order.
• Exported definitions:
• Internal definitions:
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
6.1 Exported definitions
• Exported special variables:
• Exported macros:
• Exported functions:
• Exported generic functions:
• Exported classes:
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
6.1.1 Special variables
- Special Variable: *application-root*
-
- Package
- Source
util.lisp (file)
- Special Variable: *automatically-set-languages*
-
- Package
- Source
util.lisp (file)
- Special Variable: *button-call-path*
-
- Package
- Source
callback-widget.lisp (file)
- Special Variable: *css-directory*
-
- Package
- Source
util.lisp (file)
- Special Variable: *css-path*
-
An absolute route where caveman2-widgets’ CSS files can be accessed.
- Package
- Source
widget.lisp (file)
- Special Variable: *dirty-objects-uri-path*
-
- Package
- 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
- Source
caveman2-widgets.lisp (file)
- Special Variable: *javascript-checker-path*
-
- Package
- Source
widget.lisp (file)
- Special Variable: *javascript-path*
-
An absolute path where caveman2-widgets’ JavaScript files can be accessed.
- Package
- Source
widget.lisp (file)
- Special Variable: *jquery-cdn-link*
-
The URL to access jQuery.
- Package
- Source
document.lisp (file)
- Special Variable: *js-directory*
-
- Package
- Source
util.lisp (file)
- Special Variable: *language-key-in-session*
-
- Package
- Source
util.lisp (file)
- Special Variable: *link-call-path*
-
- Package
- 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
- Source
login.lisp (file)
- Special Variable: *port*
-
- Package
- Source
navigation.lisp (file)
- Special Variable: *protection-circles-session-key*
-
- Package
- Source
widget.lisp (file)
- Special Variable: *rest-path*
-
- Package
- Source
widget.lisp (file)
- Special Variable: *static-directory*
-
- Package
- Source
util.lisp (file)
- Special Variable: *web*
-
An <app>-instance
- Package
- Source
widget.lisp (file)
- Special Variable: *widgets-css-filename*
-
The filename of the CSS file which manages all standard widget
styles.
- Package
- Source
widget.lisp (file)
- Special Variable: *widgets-js-filename*
-
The filename of the JavaScript file which manages all standard widget
functionality.
- Package
- 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
- Source
util.lisp (file)
Next: Exported functions, Previous: Exported special variables, 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
- 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
- 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
- Source
document.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
6.1.3 Functions
- Function: add-authorization CIRCLE &optional SESSION
-
- Package
- Source
widget.lisp (file)
- Function: authorized WIDGET &optional SESSION
-
- Package
- Source
widget.lisp (file)
- Function: check-and-set-language REQUEST SESSION
-
- Package
- Source
util.lisp (file)
- Function: clean-list-of-broken-links SOME-LIST
-
- Package
- Source
util.lisp (file)
- Function: defroute-static URI-PATH PATH APP CONTENT-TYPE
-
- Package
- 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
- 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
- Source
util.lisp (file)
- Function: get-value-for-cons-list SOME-LIST KEY
-
- Package
- 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
- Source
widget.lisp (file)
- Function: has-trailing-slash STR
-
- Package
- Source
util.lisp (file)
- Function: init-mark-dirty WEB &optional URI-PATH
-
- Package
- 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
- Source
caveman2-widgets.lisp (file)
- Function: mark-dirty WIDGET &optional SESSION
-
Marks a widget that it should be rendered ASAP.
- Package
- Source
widget.lisp (file)
- Function: remove-authorization CIRCLE &optional SESSION
-
- Package
- Source
widget.lisp (file)
- Function: remove-widget-for-session SESSION-TAG &optional SESSION
-
Removes a saved widget from the session variable.
- Package
- 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
- Source
widget.lisp (file)
- Function: string-case-insensitive= STR1 STR2
-
- Package
- Source
util.lisp (file)
Next: Exported classes, Previous: Exported functions, Up: Exported definitions [Contents][Index]
6.1.4 Generic functions
- Generic Function: accepted-languages SESSION
-
- Generic Function: (setf accepted-languages) VALUE SESSION
-
- Package
- Source
util.lisp (file)
- Methods
-
- Generic Function: append-item THIS ITEM
-
- Package
- 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)
- Generic Function: base-path OBJECT
-
- Generic Function: (setf base-path) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- Methods
- Method: callback (<CALLBACK-WIDGET> <callback-widget>)
-
- Source
callback-widget.lisp (file)
- Generic Function: charset OBJECT
-
- Generic Function: (setf charset) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- Source
navigation.lisp (file)
- Reader
current-page (generic function)
- Methods
-
- Generic Function: delete-item THIS ITEM
-
- Package
- 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)
- Generic Function: east OBJECT
-
- Generic Function: (setf east) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- 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)
- Generic Function: fn OBJECT
-
- Generic Function: (setf fn) NEW-VALUE OBJECT
-
- Package
- 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
- Source
default-widgets.lisp (file)
- Methods
-
- Generic Function: header OBJECT
-
- Generic Function: (setf header) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- Methods
- Method: id (<WIDGET> <widget>)
-
automatically generated reader method
- Source
widget.lisp (file)
- Generic Function: input-fields OBJECT
-
- Package
- 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
- 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
- Source
util.lisp (file)
- Methods
-
- Generic Function: label OBJECT
-
- Generic Function: (setf label) NEW-VALUE OBJECT
-
- Package
- 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
- Source
login.lisp (file)
- Methods
-
- Generic Function: login-authenticator OBJECT
-
- Package
- 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
- Methods
- Method: login-form (<LOGIN-WIDGET> <login-widget>)
-
automatically generated reader method
- Source
login.lisp (file)
- Generic Function: logout-button OBJECT
-
- Package
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- Methods
- Method: path (<FILE> <file>)
-
automatically generated reader method
- Source
document.lisp (file)
- Generic Function: protect-widget WIDGET FOR
-
@return The WIDGET object.
- Package
- Source
widget.lisp (file)
- Methods
-
- Generic Function: protected OBJECT
-
- Package
- 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
- Source
default-widgets.lisp (file)
- Methods
-
- 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
- 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)
- Generic Function: render-widget-body THIS
-
- Package
- Source
widget.lisp (file)
- Methods
- Method: render-widget-body (THIS <table-widget>)
-
- Source
default-widgets.lisp (file)
- Generic Function: render-widget-header THIS
-
- Package
- 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
- Source
widget.lisp (file)
- Methods
-
- Generic Function: required OBJECT
-
- Generic Function: (setf required) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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: Exported generic functions, Up: Exported definitions [Contents][Index]
6.1.5 Classes
- Class: <blank-navigation-widget> ()
-
- Package
- Source
navigation.lisp (file)
- Direct superclasses
<navigation-widget> (class)
- Direct methods
render-widget (method)
- Class: <border-widget> ()
-
- Package
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<callback-widget> (class)
- Direct subclasses
<form-widget> (class)
- Direct methods
- render-widget (method)
- initialize-instance (method)
- Direct Default Initargs
Initarg Value :uri-path "" :http-method :post
- Class: <callback-widget> ()
-
- Package
- Source
callback-widget.lisp (file)
- Direct superclasses
<widget> (class)
- Direct subclasses
- <button-widget> (class)
- <link-widget> (class)
- Direct methods
- classes (method)
- classes (method)
- http-method (method)
- uri-path (method)
- callback (method)
- label (method)
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
<widget> (class)
- Direct subclasses
- <hcomposite-widget> (class)
- <table-widget> (class)
- <login-widget> (class)
- Direct methods
- render-widget (method)
- append-item (method)
- widgets (method)
- widgets (method)
- Direct slots
- Slot: widgets
-
- Initargs
:widgets
- Initform
(quote nil)
- Readers
widgets (generic function)
- Writers
(setf widgets) (generic function)
- Class: <css-file> ()
-
- Package
- Source
document.lisp (file)
- Direct superclasses
<file> (class)
- Direct methods
- append-item (method)
- render-widget (method)
- Class: <form-field> ()
-
- Package
- Source
callback-widget.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
- <input-field> (class)
- <select-field> (class)
- <radio-field> (class)
- Direct methods
- append-item (method)
- render-widget (method)
- render-widget (method)
- error-message (method)
- error-message (method)
- error-happened (method)
- error-happened (method)
- check-function (method)
- check-function (method)
- required (method)
- required (method)
- supplied (method)
- supplied (method)
- label (method)
- label (method)
- name (method)
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<button-widget> (class)
- Direct methods
- render-widget (method)
- set-required-present (method)
- append-item (method)
- initialize-instance (method)
- input-fields (method)
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
<widget> (class)
- Direct methods
- render-widget (method)
- fn (method)
- fn (method)
- Direct slots
-
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
<composite-widget> (class)
- Direct methods
render-widget (method)
- Class: <header-widget> ()
-
- Package
- Source
document.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
- append-item (method)
- append-item (method)
- append-item (method)
- render-widget (method)
- other-header-content (method)
- charset (method)
- charset (method)
- icon-path (method)
- icon-path (method)
- title (method)
- title (method)
- js-files (method)
- css-files (method)
- 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
- Source
document.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
<navigation-widget> (class)
- Direct methods
- render-widget (method)
- bottom (method)
- bottom (method)
- body (method)
- body (method)
- header (method)
- header (method)
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<form-field> (class)
- Direct methods
- render-widget (method)
- value (method)
- input-type (method)
- 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
- Source
document.lisp (file)
- Direct superclasses
<file> (class)
- Direct methods
- append-item (method)
- render-widget (method)
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<callback-widget> (class)
- Direct methods
- render-widget (method)
- initialize-instance (method)
- Direct slots
-
- Direct Default Initargs
Initarg Value :uri-path "" :http-method :get
- Class: <login-widget> ()
-
- Package
- Source
login.lisp (file)
- Direct superclasses
<composite-widget> (class)
- Direct methods
- render-widget (method)
- initialize-instance (method)
- logout-button (method)
- login-form (method)
- login-failed (method)
- login-failed (method)
- signout-hook (method)
- signout-hook (method)
- login-authenticator (method)
- 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
- Source
navigation.lisp (file)
- Direct superclasses
<navigation-widget> (class)
- Direct methods
render-widget (method)
- Class: <option-field> ()
-
- Package
- Source
callback-widget.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
- append-item (method)
- render-widget (method)
- display-value (method)
- value (method)
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<form-field> (class)
- Direct methods
- render-widget (method)
- append-item (method)
- checked-option (method)
- checked-option (method)
- options (method)
- options (method)
- 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
- Source
callback-widget.lisp (file)
- Direct superclasses
<form-field> (class)
- Direct methods
- render-widget (method)
- append-item (method)
- multiple (method)
- multiple (method)
- options (method)
- options (method)
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
<widget> (class)
- Direct methods
- render-widget (method)
- text (method)
- text (method)
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
get-as-list (method)
- Class: <table-widget> ()
-
- Package
- Source
default-widgets.lisp (file)
- Direct superclasses
<composite-widget> (class)
- Direct methods
- render-widget (method)
- render-widget (method)
- render-widget-body (method)
- render-widget-header (method)
- append-item (method)
- column-descriptions (method)
- producer (method)
- 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
- Source
default-widgets.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
-
- Class: <viewgrid-widget> ()
-
- Package
- Source
default-widgets.lisp (file)
- Direct superclasses
<widget> (class)
- Direct methods
- render-widget (method)
- display-selector (method)
- display-selector (method)
- max-items-to-display (method)
- max-items-to-display (method)
- on-view-label (method)
- on-view-label (method)
- on-view (method)
- on-view (method)
- view (method)
- view (method)
- producer (method)
- 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)
- Class: <widget> ()
-
- Package
- Source
widget.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
- <callback-widget> (class)
- <string-widget> (class)
- <composite-widget> (class)
- <function-widget> (class)
- <viewgrid-widget> (class)
- <border-widget> (class)
- <navigation-widget> (class)
- Direct methods
- append-item (method)
- delete-item (method)
- append-item (method)
- render-widget-rest (method)
- render-widget-rest (method)
- render-widget (method)
- initialize-instance (method)
- protect-widget (method)
- protect-widget (method)
- delete-item (method)
- append-item (method)
- protected (method)
- widget-scope (method)
- id (method)
- 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: Exported definitions, Up: Definitions [Contents][Index]
6.2 Internal definitions
• Internal special variables:
• Internal functions:
• Internal generic functions:
• Internal classes:
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
6.2.1 Special variables
- Special Variable: *dirty-objects-session-key*
-
- Package
- Source
widget.lisp (file)
- Special Variable: *global-widget-holder*
-
- Package
- Source
widget.lisp (file)
- Special Variable: *input-field-for-old-uri*
-
- Package
- Source
callback-widget.lisp (file)
- Special Variable: *navigation-widgets*
-
- Package
- Source
navigation.lisp (file)
- Special Variable: *rest-methods*
-
- Package
- Source
widget.lisp (file)
Next: Internal generic functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
6.2.2 Functions
- Function: demark-dirty WIDGET &optional SESSION
-
Marks a widget as rendered.
- Package
- Source
widget.lisp (file)
- Function: test-widget-if-session SCOPE WIDGET-ID &optional SESSION
-
- Package
- Source
callback-widget.lisp (file)
Next: Internal classes, Previous: Internal functions, Up: Internal definitions [Contents][Index]
6.2.3 Generic functions
- Generic Function: center OBJECT
-
- Generic Function: (setf center) NEW-VALUE OBJECT
-
- Package
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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: Internal generic functions, Up: Internal definitions [Contents][Index]
6.2.4 Classes
- Class: <dirty-widget-holder> ()
-
- Package
- Source
widget.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
- delete-item (method)
- append-item (method)
- Direct slots
-
- Class: <file> ()
-
- Package
- Source
document.lisp (file)
- Direct superclasses
standard-object (class)
- Direct subclasses
- <js-file> (class)
- <css-file> (class)
- Direct methods
- crossorigin (method)
- crossorigin (method)
- integrity (method)
- integrity (method)
- path (method)
- 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
- Source
navigation.lisp (file)
- Direct superclasses
- <widget> (class)
- <html-document-widget> (class)
- Direct subclasses
- <menu-navigation-widget> (class)
- <blank-navigation-widget> (class)
- Direct methods
- append-item (method)
- find-item (method)
- (setf current-page) (method)
- session-tag (method)
- session-tag (method)
- base-path (method)
- base-path (method)
- composite (method)
- composite (method)
- current-page (method)
- pages (method)
- created-paths (method)
- created-paths (method)
- 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
- Source
widget.lisp (file)
- Direct superclasses
standard-object (class)
- Direct methods
- find-item (method)
- delete-item (method)
- append-item (method)
- Direct slots
-
Previous: Definitions, Up: Top [Contents][Index]
Appendix A Indexes
• Concept index:
• Function index:
• Variable index:
• Data type index:
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
A.1 Concepts
Jump to: C
F
L
M
Jump to: C
F
L
M
Next: Variable index, Previous: Concept index, 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
Jump to: (
A
B
C
D
E
F
G
H
I
J
L
M
N
O
P
R
S
T
U
V
W
Next: Data type index, Previous: Function index, 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
Jump to: *
+
B
C
D
E
F
H
I
J
L
M
N
O
P
R
S
T
U
V
W
Previous: Variable index, Up: Indexes [Contents][Index]
A.4 Data types
Jump to: <
C
P
S
Jump to: <
C
P
S