New patches:

[Adding tal and ajax features.
burban@opopop.net**20090504203906] {
adddir ./src/ucw-ajax
adddir ./src/ucw-tal
hunk ./src/backend/mod-lisp.lisp 3
-(in-package :it.bese.ucw) 
+(in-package :it.bese.ucw.core) 
hunk ./src/backend/mod-lisp.lisp 45
-        (setf (remote-address request) value))
+	(setf (remote-address request) 
+	      (let ((ip-as-string value))
+          (when ip-as-string
+            (let* ((real-remote-address (first (cl-ppcre:split "," ip-as-string :sharedp t)))
+                   (pieces (cl-ppcre:split "\\." real-remote-address :sharedp t)))
+              (declare (type list pieces))
+              (if (= (length pieces) 4)
+                  (iter (with result = (make-array 4 :element-type '(unsigned-byte 8)))
+                        (for idx :from 0 :below 4)
+                        (for ip-address-part = (parse-integer (pop pieces)))
+                        (assert (<= 0 ip-address-part 255))
+                        (setf (aref result idx) ip-address-part)
+                        (finally (return result)))
+                  (progn
+                    (ucw.backend.info "Returning NIL instead of an invalid ip address: ~S" ip-as-string)
+                    nil)))))
+	))
hunk ./src/core-package.lisp 149
+   #:visiblep
+   #:dirtyp
hunk ./src/rerl/request-loop-error.lisp 152
-                  (format-rfc3339-timestring nil (now))
+                  (format-rfc3339-timestring (now))
hunk ./src/rerl/standard-session-frame.lisp 41
-
-(defmacro register-ajax-action ((&rest args &key (class ''ajax-action) &allow-other-keys) &body body)
-  (remf-keywords args :class)
-  `(register-action (:class ,class ,@args)
-    ,@body))
addfile ./src/ucw-ajax/ajax-actions.lisp
hunk ./src/ucw-ajax/ajax-actions.lisp 1
+;; -*- lisp -*-
+
+(in-package :ucw-ajax)
+
+(enable-bracket-syntax)
+
+(declaim (inline action-ajax-p))
+(defun action-ajax-p (action)
+  (typep action 'ajax-action))
+
+(defmethod compute-url ((action ajax-action) (app application))
+  (let ((uri (call-next-method)))
+    (setf (uri.path uri) (strcat (uri.path uri) it.bese.ucw.core::+ajax-action-dispatcher-url+))
+    uri))
+
+(defmethod handle-toplevel-condition ((application application) (error serious-condition) (action ajax-action))
+  ;;(log-error-with-backtrace error)
+  (abort-action "Internal server error"))
+
+(defmacro handle-ajax-request ((&key (succesful-when-finishes t) (output-yaclml-stream-on-failure nil)) &body body)
+  (with-unique-names (yaclml-body)
+    `(progn
+      (setf (get-header *response* "Status") +http-ok+
+            (get-header *response* "Content-Type") "text/xml")
+      (<:as-is #.(format nil "<?xml version=\"1.0\" encoding=\"UTF-8\"?>~%"))
+      {with-xml-syntax
+        <answer
+          (let ((-successp- nil) ; we leave these variables visible, which is hackish, but this is an internal macro anyway
+                (-message- nil)
+                (,yaclml-body))
+            (unwind-protect
+                 (setf ,yaclml-body
+                       (with-yaclml-output-to-string
+                         ,@body
+                         ,(when succesful-when-finishes
+                            `(setf -successp- t))))
+              (if -successp-
+                  (progn
+                    (it.bese.ucw.core::ucw.rerl.ajax.debug "Successfully rendered ajax answer, body length is ~S" (length ,yaclml-body))
+                    (it.bese.ucw.core::ucw.rerl.ajax.dribble "The following ajax answer body will be sent:~%~A" ,yaclml-body)
+                    (<:as-is ,yaclml-body)
+                    <result "success">)
+                  (progn
+                    (it.bese.ucw.core::ucw.rerl.ajax.debug "Failed to render ajax answer, error message is ~S" -message-)
+                    ,(when output-yaclml-stream-on-failure
+                       `(<:as-is ,yaclml-body))
+                    <result "failure">
+                    (when -message-
+                      <error-message (<:as-is :quotedp t -message-)>)))))>})))
+
+(defmethod call-action ((action ajax-action) application session frame)
+  "Wrap the ajax action's output in an XML document. The action is free to render
+any valid XML body that can be processed on the client side."
+  ;; TODO, attila: the encoding in the default xml header should be taken from (encoding (context.response *context*))
+  ;; is there a function that converts to the appropiate format?
+  (handle-ajax-request (:succesful-when-finishes nil)
+    (restart-case
+         (let ((swank::*sldb-quit-restart* 'abort-action))
+           (call-next-method)
+           (it.bese.ucw.core::ucw.rerl.actions.debug "The body of CALL-ACTION for AJAX-ACTION was successful, calling SEND-EVENTS-TO-THE-CLIENT")
+           ;; make sure we don't send partial content in case of an error
+           (<:as-is
+            ;; TODO there could be a more efficient construct in yaclml for this based on (setf (fill-pointer ...) ...)
+            (with-yaclml-output-to-string
+              (when (has-events-for-the-client session)
+                (send-events-to-the-client session))))
+           (setf -successp- t))
+      (abort-action (&optional (failure-message "Internal server error"))
+        :report "Abort processing this ajax action"
+        (it.bese.ucw.core::ucw.rerl.actions.debug "Ajax ABORT-ACTION restart invoked with FAILURE-MESSAGE ~S" failure-message)
+        (if failure-message
+            (setf -message- failure-message)
+            (setf -successp- t))))))
+
+(defmethod call-action :around ((action ajax-action) application session frame)
+  (let ((form (creation-time-current-form-of action)))
+    (if (and form
+             (parent form))
+        (let ((*current-form* form))
+          (it.bese.ucw.core::ucw.rerl.actions.dribble "Restored *CURRENT-FORM* to ~A from CALL-ACTION of AJAX-ACTION" *current-form*)
+          (call-next-method))
+        (call-next-method))))
+
+;; Copyright (c) 2003-2005 Edward Marco Baringer
+;; All rights reserved. 
+;; 
+;; Redistribution and use in source and binary forms, with or without
+;; modification, are permitted provided that the following conditions are
+;; met:
+;; 
+;;  - Redistributions of source code must retain the above copyright
+;;    notice, this list of conditions and the following disclaimer.
+;; 
+;;  - Redistributions in binary form must reproduce the above copyright
+;;    notice, this list of conditions and the following disclaimer in the
+;;    documentation and/or other materials provided with the distribution.
+;; 
+;;  - Neither the name of Edward Marco Baringer, nor BESE, nor the names
+;;    of its contributors may be used to endorse or promote products
+;;    derived from this software without specific prior written permission.
+;; 
+;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+;; A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
+;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
addfile ./src/ucw-ajax/ajax-application.lisp
hunk ./src/ucw-ajax/ajax-application.lisp 1
+;; See the file LICENCE for licence information.
+(in-package :ucw-ajax)
+
+;;(enable-sharpquote<>-syntax)
+(enable-bracket-syntax)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; dirty-component-tracking
+
+(defclass dirty-component-tracking-application-mixin ()
+  ()
+  (:documentation "Application mixin that enables the tracking of dirty components."))
+
+(defclass dirty-component-tracking-session (standard-session)
+  ((dirty-components :initform (make-hash-table :weakness :key :test #'eq)
+                     :accessor dirty-components-of)))
+
+(defmethod session-class list ((app dirty-component-tracking-application-mixin))
+  'dirty-component-tracking-session)
+
+(defmethod has-events-for-the-client ((session dirty-component-tracking-session))
+  (if (next-method-p)
+      (call-next-method)
+      (iterate-visible-dirty-components
+       (lambda (component)
+         (declare (ignore component))
+         (return-from has-events-for-the-client t)))))
+
+;;;;;;;;;;;;;;;;;;;
+;; ajax-application
+
+(defclass ajax-application-mixin (dirty-component-tracking-application-mixin)
+  ())
+
+(defclass standard-session (basic-session)
+  ())
+
+(defclass ajax-session (dirty-component-tracking-session standard-session)
+  ((event-condition-variable :accessor event-condition-variable-of
+                             :initform (when *supports-threads-p*
+                                         (make-condition-variable)))
+   (latest-polling-thread :accessor latest-polling-thread-of :initform nil)))
+
+(defmethod session-class list ((app ajax-application-mixin))
+  'ajax-session)
+
+(defgeneric notify-session-event (session)
+  (:method ((session ajax-session))
+    (when *supports-threads-p*
+      (it.bese.ucw.core::ucw.rerl.ajax.debug "notify-session-event for session ~S in thread ~S" session (thread-name (current-thread)))
+      (condition-notify (event-condition-variable-of session)))))
+
+(defgeneric wait-for-session-event (session)
+  (:method ((session standard-session))
+    (when *supports-threads-p*
+      (it.bese.ucw.core::ucw.rerl.ajax.debug "wait-for-session-event for session ~S, in thread ~S" session (thread-name (current-thread)))
+      (condition-wait (event-condition-variable-of session) (lock-of session)))))
+
+(defmethod send-events-to-the-client ((session ajax-session))
+  (ajax-render-dirty-components))
+
+
+;;;
+;;; Dirty stuff
+;;;
+(defvar %disable-dirtyness-tracking%)
+
+(defun it.bese.ucw.core::register-dirty-component (component)
+  (unless (boundp '%disable-dirtyness-tracking%)
+    (let ((session (session-of component)))
+      (when (typep session 'dirty-component-tracking-session)
+        (let ((table (dirty-components-of session)))
+          (it.bese.ucw.core::assert-session-lock-held session)
+          (when table
+            (it.bese.ucw.core::ucw.rerl.ajax.debug "About to register dirty component ~S, the session has ~S dirty components currently"
+                                 component (hash-table-count table))
+            (setf (gethash component table) t)
+            (notify-session-event session)))))))
+
+(defun it.bese.ucw.core::unregister-dirty-component (component)
+  (let ((session (session-of component)))
+    (when (typep session 'dirty-component-tracking-session)
+      (let ((table (dirty-components-of session)))
+        (it.bese.ucw.core::assert-session-lock-held session)
+        (when table
+          (remhash component table)
+          (it.bese.ucw.core::ucw.rerl.ajax.debug "Component ~S is not dirty anymore, the session has ~S dirty components currently"
+                               component (hash-table-count table)))))))
+
+(defmacro without-dirtyness-tracking (&body body)
+  "Disable dirtyness tracking. IOW, register-dirty-component will have no effects
+while in the dynamic scope of without-dirtyness-tracking."
+  `(let ((%disable-dirtyness-tracking% t))
+    ,@body))
+
+(defun mark-dirty (component)
+  "It's a (setf (dirtyp component) t) inside a with-lock-held-on-session for convenience."
+  ;; TODO assert that locking another session is unsafe
+  (with-lock-held-on-session (session-of component)
+    (setf (dirtyp component) t)))
+
+(defun iterate-visible-dirty-components (visitor)
+  (it.bese.ucw.core::ucw.rerl.ajax.dribble "iterate-visible-dirty-components entered with visitor ~S" visitor)
+  (when-bind table (dirty-components-of (context.session *context*))
+    (let ((components (hash-table-keys table)))
+      (it.bese.ucw.core::ucw.rerl.ajax.dribble "List of dirty components before collecting ~S" components)
+      (setf components (iter (for component in components)
+                             (it.bese.ucw.core::ucw.rerl.ajax.dribble "Checking component ~S" component)
+                             (unless (dirtyp component)
+                               (it.bese.ucw.core::ucw.rerl.ajax.dribble "Component ~S is not dirty anymore, unregistering" component)
+                               (it.bese.ucw.core::unregister-dirty-component component)
+                               (next-iteration))
+                             (when (and (typep component 'ajax-component-mixin)
+                                        (not (has-ever-been-rendered-p component)))
+                               (it.bese.ucw.core::ucw.rerl.ajax.dribble "The ajax component ~S has not been rendered, skipping it" component)
+                               (next-iteration))
+                             (for (values visiblep distance) = (visiblep component))
+                             (if visiblep
+                                 (collect (cons component distance))
+                                 (it.bese.ucw.core::ucw.rerl.ajax.dribble "Component ~S is not visible, dropping from the list" component))))
+      (it.bese.ucw.core::ucw.rerl.ajax.dribble "List of dirty components before sorting ~S" components)
+      (setf components (sort components #'< :key #'cdr))
+      (it.bese.ucw.core::ucw.rerl.ajax.dribble "List of dirty components after sorting ~S" components)
+      (iter (for (component . nil) in components)
+            (it.bese.ucw.core::ucw.rerl.ajax.debug "iterate-visible-dirty-components visiting component ~S, dirtyp? ~S"
+                                 component (dirtyp component))
+            ;; need to check for dirtyness again, it might have been rendered meanwhile
+            (when (dirtyp component)
+              (it.bese.ucw.core::ucw.rerl.ajax.debug "iterate-visible-dirty-components calling visitor with component ~S" component)
+              (funcall visitor component))))))
+
+(defmethod delete-session :after (application (session ajax-session))
+  ;; abort the client poller, if there's any
+  (it.bese.ucw.core::assert-session-lock-held session)
+  (setf (latest-polling-thread-of session) nil)
+  (notify-session-event session))
+
+;; (defvar *default-polling-delay* 3000
+;;   "The default delay in ms to wait before the client connects the server again for new events.")
+;; (defvar *max-number-of-live-polling-connections* 30
+;;   "While there are less then this many polling connections, they are blocked on the server and woke up when an event is available.")
+;; (defparameter *current-number-of-live-polling-connections* 0)
+
+;; (defun calculate-client-polling-delay ()
+;;   (if (and *supports-threads-p*
+;;            (< *current-number-of-live-polling-connections*
+;;               *max-number-of-live-polling-connections*))
+;;       0
+;;       *default-polling-delay*))
+
+;; (defgeneric handle-polling-of-session (application session frame)
+;;   (:documentation "Called by the polling-dispatcher. SESSION and FRAME may be nil
+;; when a polling request was received in an unknown session.")
+;;   (:method ((application ajax-application-mixin) session frame)
+;;     (if (and session frame)
+;;         (with-lock-held-on-session session
+;;           (ucw.rerl.ajax.debug "handle-polling-of-session entered while there are ~S alive pollers"
+;;                                *current-number-of-live-polling-connections*)
+;;           (incf *current-number-of-live-polling-connections*)
+;;           (unwind-protect
+;;                (progn
+;;                  (let ((current-thread (current-thread)))
+;;                    (setf (latest-polling-thread-of session) current-thread)
+;;                    (notify-session-event session) ; wake up any previous pollers to make them quit
+;;                    (when (and *supports-threads-p*
+;;                               (not (has-events-for-the-client session)))
+;;                      (ucw.rerl.ajax.debug "client-polling-handler got nil from has-events-for-the-client, falling asleep")
+;;                      (loop named waiting do
+;;                            (wait-for-session-event session) ; we release the session lock and wait for a notification
+;;                            (unless (eq (latest-polling-thread-of session)
+;;                                        current-thread)
+;;                              (ucw.rerl.ajax.debug "client-poller aborting because there's a newer polling thread")
+;;                              (notify-session-event session) ; wake up any other (possible poller) threads waiting
+;;                              (return-from handle-polling-of-session))
+;;                            (when (has-events-for-the-client session)
+;;                              (return-from waiting))))
+;;                    (ucw.rerl.ajax.debug "client-poller woke up, sending back the ajax answer")
+;;                    ;; go through the public protocol, so transactions and stuff is alive while serving polling requests
+;;                    (handle-action (make-action
+;;                                    (lambda ()
+;;                                      (<ucw:script :toplevelp t
+;;                                                   `(ucw.io.polling.set-delay ,(calculate-client-polling-delay))))
+;;                                    :class 'ajax-action)
+;;                                   application session frame)))
+;;             (decf *current-number-of-live-polling-connections*)))
+;;         (handle-action (make-action
+;;                         (lambda ()
+;;                           (<ucw:script :toplevelp t
+;;                                        `(progn
+;;                                          (ucw.io.polling.stop)
+;;                                          (ucw.load-relative-url ,(application.url-prefix application)))))
+;;                         :class 'ajax-action)
+;;                                   application session frame))))
+
+;; ;; TODO FIXME does not evaluate values part
+;; (defmacro js-to-lisp-rpc ((&rest options &key
+;;                            (invocation-isolated nil)
+;;                            (sync 'true)
+;;                            handler
+;;                            &allow-other-keys)
+;;                           args
+;;                           values
+;;                           &body body)
+;;   "This macro generates the necessary js to call unnamed server Remote Procedure Calls in parenscript bodies.
+;; WARNING: Due to a current limitation in dojo, the return value from lisp is not propagated back to the js side."
+;;   (assert (not (find '&optional args)) () "Only mandatory and keyword arguments are supported in JS-TO-LISP-RPC")
+;;   (let ((action-args nil))
+;;     (push* action-args invocation-isolated :invocation-isolated)
+;;     (remf-keywords options :invocation-isolated :sync :handler)
+;;     ``((lambda ()
+;;          (let ((evaluated-js-values (array ,@',(mapcar (lambda (arg)
+;;                                                            (if (keywordp arg)
+;;                                                                (string-downcase arg)
+;;                                                                arg))
+;;                                                          values))))
+;;             (log.debug "Triggering server RPC with values " evaluated-js-values)
+;;             (return
+;;               (ucw.io.execute-ajax-action
+;;                (create
+;;                 :url ,(action-href
+;;                        (register-ajax-action (,@action-args)
+;;                          ,(with-unique-names (lisp-result compiled-js)
+;;                             `(let* ((,lisp-result
+;;                                      ,(if args
+;;                                           `(with-request-params (values) *request*
+;;                                             (ucw.rerl.ajax.debug "Calling unnamed server RPC with js values: ~S" values)
+;;                                             ;; TODO convert js true/false/undefined to lisp?
+;;                                             (destructuring-bind ,args (ensure-list values)
+;;                                               ,@body))
+;;                                           `(progn
+;;                                             (ucw.rerl.ajax.debug "Calling unnamed, arg-less server RPC")
+;;                                             ,@body)))
+;;                                     (,compiled-js (js:js-to-statement-strings
+;;                                                    (js:js-compile ,lisp-result)
+;;                                                    0)))
+;;                               (assert (= (length ,compiled-js) 1) () "A JS-TO-LISP-RPC body returned with something that compiled into multiple js statements")
+;;                               {with-xml-syntax
+;;                                 <return-value
+;;                                   (<:as-html (first ,compiled-js))>}))))
+;;                 :sync ,',sync
+;;                 :handler ,,(if handler
+;;                                handler
+;;                                ``ucw.io.default-js-to-lisp-rpc-handler)
+;;                 :content (create :values evaluated-js-values)
+;;                 ,,@options))))))))
+
+;; (defmacro js-to-lisp-rpc* (options args &body body)
+;;   "Just like js-to-lisp-rpc but the arguments are transferred to lisp as-is. IOW, you can't give a js expression
+;; that evaluates to the argument, but rather the named js variable will be visible on the lisp side."
+;;   `(js-to-lisp-rpc ,options ,args ,args ,@body))
addfile ./src/ucw-ajax/ajax-dispatchers.lisp
hunk ./src/ucw-ajax/ajax-dispatchers.lisp 1
+;; -*- lisp -*-
+
+(in-package :ucw-ajax)
+
+;;;; ajax-action-dispatcher
+
+(defconstant +ajax-action-dispatcher-default-priority+  (- most-positive-fixnum 1001))
+
+(defclass ajax-action-dispatcher (action-dispatcher ucw-standard::starts-with-matcher)
+  ()
+  (:default-initargs :priority +ajax-action-dispatcher-default-priority+
+                     :url-string it.bese.ucw.core::+ajax-action-dispatcher-url+)
+  (:documentation "This is a specialized action dispatcher to handle ajax requests."))
+
+(defmethod matcher-match ((matcher ajax-action-dispatcher)
+                          (application basic-application)
+                          (context standard-request-context))
+  (it.bese.ucw.core::ucw.rerl.dispatcher.dribble "~S trying to match as ajax-action-dispatcher" matcher)
+  (when (starts-with (query-path-sans-prefix context) (url-string matcher))
+    (multiple-value-bind (matchesp session frame action) (call-next-method)
+      (declare (ignore matchesp))
+      (values t session frame action))))
+
+(defmethod handler-handle ((dispatcher ajax-action-dispatcher)
+                           (application basic-application)
+                           (context standard-request-context)
+                           matcher-result)
+  (destructuring-bind (session frame action) matcher-result
+    (disallow-response-caching (context.response context))
+    (if (and session frame action)
+        (progn
+          (ensure-session application context session)
+          (handle-action action application session frame))
+        (send-ajax-answer-to-expired-session))))
+
+;; (defun send-ajax-answer-to-expired-session ()
+;;   (handle-ajax-request (:succesful-when-finishes nil :output-yaclml-stream-on-failure t)
+;;     (within-xhtml-tag "error-handler"
+;;       ;; <ucw:script is not yet available here while loading. TODO fix this, it's ugly.
+;;       (<:script :type "text/javascript"
+;;                 (<:as-is #\Newline "// <![CDATA[" #\Newline
+;;                          (js:js* `(when (confirm ,#"ucw.session-expired-approve-redirect-message")
+;;                                     (window.location.reload)))
+;;                          #\Newline "// ]]>" #\Newline)))))
+
addfile ./src/ucw-ajax/ajax-package.lisp
hunk ./src/ucw-ajax/ajax-package.lisp 1
+(in-package #:common-lisp-user)
+
+(defpackage #:ucw-ajax
+  (:use :ucw-core :ucw-standard :cl :yaclml :arnesi :js :iterate :bordeaux-threads)
+  (:shadowing-import-from :ucw-core :parent)
+  (:shadowing-import-from :js :new)
+  (:shadowing-import-from :iterate :in)
+  (:shadowing-import-from :iterate :with)
+  (:shadowing-import-from :iterate :while)
+  (:export
+   #:ajax-component-mixin
+   #:ajax-action
+   #:register-ajax-action
+   #:ajax-session
+   ;; ajax application
+   #:ajax-application-mixin
+   #:register-dirty-component
+   #:unregister-dirty-component
+   #:iterate-visible-dirty-components
+   ))
+
addfile ./src/ucw-ajax/ajax.lisp
hunk ./src/ucw-ajax/ajax.lisp 1
+(in-package :ucw-ajax)
+
+(defun current-form ()
+  (when (and (boundp 'it.bese.ucw.core::*current-form*)
+             it.bese.ucw.core::*current-form*)
+    it.bese.ucw.core::*current-form*))
+
+;;;; ** The rendering protocol
+
+(defgeneric call-in-rendering-environment (trunk component)
+  (:documentation "This method can be used to set up the dynamic environment needed to render a component and all its children.
+When ajax rendering all the parents are called with this method to get a chance to restore the dynamic environment.")
+  (:method-combination wrapping-standard))
+
+(defmethod call-in-rendering-environment (trunk (component component))
+  (funcall trunk))
+
+(defmethod render :wrap-around ((component component))
+  (call-in-rendering-environment #'call-next-method component)
+  (values))
+
+(enable-bracket-syntax)
+
+(defmacro within-xhtml-tag (tag-name &body body)
+  "Execute BODY and wrap its yaclml output in a TAG-NAME xml node
+with \"http://www.w3.org/1999/xhtml\" xml namespace."
+  `{with-xml-syntax
+     <(progn ,tag-name) :id "ucw-ajax" ;;:xmlns #.+xhtml-namespace-uri+
+                        ;;(@ "xmlns:dojo" #.+dojo-namespace-uri+)
+       ,@body>})
+
+(defmacro within-dom-replacements-tag (&body body)
+  "Execute BODY and wrap its yaclml output in a dom-replacements xml node
+with \"http://www.w3.org/1999/xhtml\" xml namespace. Client side js
+iterates the elements of this node and replaces their counterparts
+in the DOM tree with them."
+  `(within-xhtml-tag "div"
+     ,@body))
+
+(defclass ajax-action (standard-action)
+  ((creation-time-current-form
+    :initform (current-form)
+    :accessor creation-time-current-form-of))
+  (:metaclass mopp:funcallable-standard-class)
+  (:default-initargs :make-new-frame nil :call-render nil)
+  (:documentation "An ajax action in UCW is a raw action that renders an
+XML document which is then processed by the client side js. The action
+body may use yaclml tags and the WITH-XML-SYNTAX of yaclml to render
+into the answer XML."))
+
+(defmacro register-ajax-action ((&rest args &key (class ''ajax-action) &allow-other-keys) &body body)
+  (remf-keywords args :class)
+  `(register-action (:class ,class ,@args)
+    ,@body))
+
+(defvar *ajax-component-being-rendered*)
+
+;; TODO get rid of this if/when the forthcoming dojo refactor makes it pointless
+(defun currently-ajax-rendered-component ()
+  (when (boundp '*ajax-component-being-rendered*)
+    *ajax-component-being-rendered*))
+
+(defun ajax-rendering-in-progress-p ()
+  (boundp '*ajax-component-being-rendered*))
+
+;; all subclasses must be standard-component's because the dirtyp slot is needed by the ajax algorithms
+(defcomponent ajax-component-mixin (html-element-mixin standard-component)
+  ((ucw-standard::dom-id :initform (js:gen-js-name-string :prefix "ajax")) ; override the initform of the inherited slot
+   (has-ever-been-rendered :initform nil :accessor has-ever-been-rendered-p)
+   (forbid-ajax-rendering :initform nil :accessor forbid-ajax-rendering-p :initarg :forbid-ajax-rendering-p
+                          :documentation "This predicate my forbid AJAX rendering from this component and instruct the renderer to look further on the parent chain. The primary use of this is that sometimes (mostly due to browser rendring bugs) it's better to render bigger chunks of the page."))
+  (:documentation "This is a marker class that marks a point in the component
+chain from where a partial (AJAX) render may be started. The component
+must render exactly one top-level DOM node and it must have an ID attribute.
+The client side js will look up the DOM node identified by ID and replace it
+with the freshly rendered one.
+
+Please note that this component in itself is not suitable for ajax
+DOM node replacements because it does not render any wrapper nodes.
+See WIDGET-COMPONENT for an ajax component that works on its own."))
+
+(defparameter %ajax-stub-rendering-in-progress% nil
+  "Marks that we are going to render only a stub, so bail out in render :wrapping ajax-component-mixin.")
+
+(defgeneric render-ajax-stub (ajax-component-mixin)
+  (:method :around ((self ajax-component-mixin))
+           (let ((%ajax-stub-rendering-in-progress% t))
+             (call-next-method)))
+  (:method ((self ajax-component-mixin))
+           (render self))
+  (:documentation "Start rendering and stop at ajax-component-mixin boundaries. Only render a stub at those points (usually a <:div with an id) that can be later lazily replaced with an AJAX request."))
+
+(defmethod render :after ((self ajax-component-mixin))
+  (setf (has-ever-been-rendered-p self) t))
+
+(defmethod render :wrapping ((self ajax-component-mixin))
+  (unless %ajax-stub-rendering-in-progress%
+    (call-next-method)))
+
+(defgeneric ajax-render (component)
+  (:documentation "This method is called when we are rendering parts of the component hierarchy with AJAX.
+By default it simply calls render after marking this fact on the ajax-component-mixin.")
+  (:method :around ((self ajax-component-mixin))
+           (let ((*ajax-component-being-rendered* self))
+             (call-next-method)))
+  (:method ((self ajax-component-mixin))
+           (render self)))
+
+(defmacro in-restored-rendering-environment (component &body body)
+  `(call-in-restored-rendering-environment ,component
+                                           (lambda ()
+                                             ,@body)))
+
+(defun call-in-restored-rendering-environment (component trunk)
+  (let ((parents))
+    (iter (for parent :first component :then (parent parent))
+          (while parent)
+          (push parent parents))
+    (labels ((restorer ()
+               ;; this is a nasty trick here: RESTORER is continously passed to the nested calls to
+               ;; CALL-IN-RENDERING-ENVIRONMENT until it pop'ped all the parents. then it finally calls
+               ;; AJAX-RENDER when all the parents have had a chance to restore the rendering environment.
+               (aif (pop parents)
+                    (progn
+                      (it.bese.ucw.core::ucw.rerl.info "Calling call-in-rendering-environment for ~S" it)
+                      (call-in-rendering-environment #'restorer it))
+                    (progn
+                      (it.bese.ucw.core::ucw.rerl.info "Environment of the parents is set up, calling trunk")
+                      (call-in-rendering-environment trunk component)))))
+      (call-in-rendering-environment #'restorer (pop parents)))))
+
+(defun render-nearest-ajax-component (component)
+  (it.bese.ucw.core::ucw.rerl.debug "render-nearest-ajax-component from ~S" component)
+  (let ((ajax-component (iter (for current :first component :then (parent current))
+                              (while current)
+                              (it.bese.ucw.core::ucw.rerl.info "Checking ~S" current)
+                              (when (and (typep current 'ajax-component-mixin)
+					 (not (forbid-ajax-rendering-p current)))
+                                (return current))
+                              (while (slot-boundp current 'parent))
+                              (finally (return nil)))))
+    (it.bese.ucw.core::ucw.rerl.debug "render-nearest-ajax-component ended up at ~S" ajax-component)
+    (unless ajax-component
+      (error "No suitable ajax-component-mixin was found while walking the parent slots of ~A, unable to render AJAX answer" component))
+    ;; we restore the env only up til the parent, because AJAX-RENDER
+    ;; calls RENDER which sets up the env of ajax-component itself.
+    (aif (parent ajax-component)
+         (call-in-restored-rendering-environment it (lambda ()
+                                                      (ajax-render ajax-component)))
+         (ajax-render ajax-component))))
+
+(define-condition visible-dirty-component-remained (error)
+  ((component :initarg :component :accessor component-of))
+  (:report (lambda (c stream)
+             (format stream "A visible dirty component ~A remained in session ~A after calling ajax-render-dirty-components. This would lead to a constant ajax rerendering in the poller. Make sure you either render all connected components or detach them!"
+                     (component-of c) (session-of (component-of c))))))
+
+(defmethod handle-toplevel-condition :around (application
+                                              (error visible-dirty-component-remained)
+                                              (action ajax-action))
+  (when (debug-on-error application)
+    (invoke-slime-debugger-if-possible error))
+  ;; when we are not debugging, just remove dirtyness and continue normal operation
+  (continue))
+
+(defun ajax-render-dirty-components ()
+  (within-dom-replacements-tag
+    (flet ((render-dirty-ajax-component (component)
+             (it.bese.ucw.core::ucw.rerl.debug "ajax-render-dirty-components at component ~S" component)
+             (render-nearest-ajax-component component)))
+      (iterate-visible-dirty-components #'render-dirty-ajax-component))
+    (flet ((check-for-remained-dirty-component (c)
+             (when (visiblep c)
+               (restart-case
+                    (error 'visible-dirty-component-remained :component c)
+                (continue ()
+                  :report "Remove dirtyness and leave me alone..."
+                  (setf (dirtyp c) nil))))))
+      (iterate-visible-dirty-components #'check-for-remained-dirty-component))))
+
hunk ./src/ucw-standard/standard-tags.lisp 95
-  (let ((reader (or reader accessor))
-	(writer (or writer `(lambda (v)
+  (let ((writer (or writer `(lambda (v)
addfile ./src/ucw-tal/tal-package.lisp
hunk ./src/ucw-tal/tal-package.lisp 1
+(in-package #:common-lisp-user)
+
+(defpackage #:ucw-tal
+  (:use :ucw-core :cl :yaclml :arnesi)
+  (:shadowing-import-from :ucw-core :parent)
+  (:export
+   #:application-with-tal-support-mixin
+   #:template-component
+   #:render-template))
+
addfile ./src/ucw-tal/template.lisp
hunk ./src/ucw-tal/template.lisp 1
+;; -*- lisp -*-
+
+(in-package :ucw-tal)
+
+(defclass application-with-tal-support-mixin (application)
+  ((tal-generator :accessor application.tal-generator
+                  :initarg :tal-generator
+                  :documentation "A tal-generator object used to
+lookup and compile tal pages for template-components.")))
+
+;;;; ** Template
+
+(defclass template-component (component)
+  ((template-name :accessor template-component.template-name
+                  :initarg :template-name
+                  :initform nil))
+  (:documentation "Component which is rendered via a TAL template."))
+
+(defgeneric template-component-environment (component)
+  (:documentation "Create the TAL environment for rendering COMPONENT's template.
+
+Methods defined on this generic function must return a TAL
+environment: a list of TAL binding sets (see the documentation
+for YACLML:MAKE-STANDARD-TAL-ENVIRONMENT for details on TAL
+environments.)")
+  (:method-combination nconc))
+
+(defmethod template-component-environment nconc ((component template-component))
+  "Create the basic TAL environment.
+
+Binds the symbol ucw:component to the component object itself,
+also puts the object COMPONENT on the environment (after the
+binding of ucw:component) so that slots are, by default,
+visable."
+  (make-standard-tal-environment `((component . ,component)) component))
+
+(defmethod render :around ((component template-component))
+  "Render a template based component.
+
+The name of the template is the value returned by the generic function
+TEMPLATE-COMPONENT.TEMPLATE-NAME, the template will be rendered
+in the environment returned by the generic function
+TEMPLATE-COMPONENT-ENVIRONMENT."
+  (aif (template-component.template-name component)
+       (render-template *context*
+                        it
+                        (list* `((next-method-of-render . ,#'call-next-method))
+                               (template-component-environment component)))
+       (call-next-method)))
+
+(defcomponent standard-template-component (simple-template-component
+                                           widget-component)
+  ())
+
+(defcomponent standard-template-component-with-body (standard-template-component
+                                                     component-body-mixin)
+  ())
+
+(defcomponent simple-template-component (template-component)
+  ((environment :initarg :environment :initform nil)))
+
+(defcomponent simple-template-component-with-body (simple-template-component component-body-mixin)
+  ())
+
+(defmethod template-component-environment nconc ((component simple-template-component))
+  (copy-list (slot-value component 'environment)))
+
+;; TODO these should be moved somewhere, renamed, or deleted completly
+(defmacro show (page-name &rest environment)
+  `(call 'simple-template-component
+         :template-name ,page-name
+         :environment (tal-env ,@environment)))
+
+(defmacro show-window (page-name &rest environment)
+  `(call 'basic-window-template-component
+         :template-name ,page-name
+         :environment (tal-env ,@environment)))
+
+;; Copyright (c) 2003-2005 Edward Marco Baringer
+;; All rights reserved. 
+;; 
+;; Redistribution and use in source and binary forms, with or without
+;; modification, are permitted provided that the following conditions are
+;; met:
+;; 
+;;  - Redistributions of source code must retain the above copyright
+;;    notice, this list of conditions and the following disclaimer.
+;; 
+;;  - Redistributions in binary form must reproduce the above copyright
+;;    notice, this list of conditions and the following disclaimer in the
+;;    documentation and/or other materials provided with the distribution.
+;; 
+;;  - Neither the name of Edward Marco Baringer, nor BESE, nor the names
+;;    of its contributors may be used to endorse or promote products
+;;    derived from this software without specific prior written permission.
+;; 
+;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+;; A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
+;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
addfile ./src/ucw-tal/yaclml.lisp
hunk ./src/ucw-tal/yaclml.lisp 1
+;;;; -*- lisp -*-
+
+(in-package :ucw-tal)
+
+(defmethod render-template ((context request-context) template-name environment)
+  (let ((*print-pretty* nil)) 
+    (it.bese.ucw.core::ucw.component.render.dribble ;;it.bese.ucw.core::ucw.rerl.info
+     "Rendering template ~S in environment ~S" template-name environment))
+  (if-bind generator
+      (application.tal-generator (context.application context))
+    (if-bind truename
+        (template-truename generator template-name)
+      (%render-template context generator truename environment)
+      (progn
+        (cerror "Retry rendering the template." "Can't find a template named ~S." template-name)
+        (render-template context template-name environment)))
+    (error "No known generator for the current application.")))
+
+(defun %render-template (context generator truename environment)
+  (let ((yaclml:*uri-to-package* (cons (cons "http://common-lisp.net/project/ucw/core"
+                                             (find-package :it.bese.ucw.tags))
+                                       yaclml:*uri-to-package*)))
+    (restart-case
+        (funcall (load-tal generator truename) environment generator)
+      (retry ()
+        :report (lambda (stream)
+                  (format stream "Retry rendering ~A." truename))
+        (return-from %render-template (%render-template context generator truename environment)))))
+           (it.bese.ucw.core::ucw.component.render.dribble "Template rendered."))
+
+(defmethod preprocess-template (template-name environment &optional (application *default-application*))
+  (aif (application.tal-generator application)
+       (if-bind truename (template-truename it template-name)
+           (let ((yaclml:*uri-to-package* (cons (cons "http://common-lisp.net/project/ucw/core"
+                                                      (find-package :it.bese.ucw.tags))
+                                                yaclml:*uri-to-package*)))
+             (yaclml::preprocess-tal it truename))
+           (progn
+             (cerror "Retry rendering the template." "Can't find a template named ~S." template-name)
+             (render-template *context* template-name environment)))
+       (error "No known generator for the current application.")))
+
+;; TODO unused, delme?
+(defun add-session-id (url)
+  "Add a session-id parametet to URL unless one is already present."
+  (when (position #\# url)
+    (error "Can't handle ~S.
+
+Adding session ids to links with section parts is not yet supported."
+           url))
+  (flet ((already-have-session-id ()
+           (let ((param-name-offset (search +session-parameter-name+ url)))
+             (if param-name-offset
+                 (let ((=-offset (+ param-name-offset
+                                    (length +session-parameter-name+))))
+                   (and (< =-offset (length url))
+                        (char= #\= (aref url =-offset))))
+                 nil))))
+    (if (already-have-session-id)
+        url
+        (with-output-to-string (new-url)
+          (write-sequence url new-url)
+          (if (position #\? url)
+              (write-char #\& new-url)
+              (write-char #\? new-url))
+          (write-sequence +session-parameter-name+ new-url)
+          (write-char #\= new-url)
+          (write-sequence (session.id (context.session *context*)) new-url)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Copyright (c) 2003-2005 Edward Marco Baringer
+;;; All rights reserved. 
+;;; 
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions are
+;;; met:
+;;; 
+;;;  - Redistributions of source code must retain the above copyright
+;;;    notice, this list of conditions and the following disclaimer.
+;;; 
+;;;  - Redistributions in binary form must reproduce the above copyright
+;;;    notice, this list of conditions and the following disclaimer in the
+;;;    documentation and/or other materials provided with the distribution.
+;;; 
+;;;  - Neither the name of Edward Marco Baringer, nor BESE, nor the names
+;;;    of its contributors may be used to endorse or promote products
+;;;    derived from this software without specific prior written permission.
+;;; 
+;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+;;; A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
+;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
hunk ./ucw.asd 46
+(defsystem* :ucw-tal
+  :description "UncommonWeb : Tal Components"
+  :long-description "Contains the tal template extension."
+  :author "Marco Baringer <mb@bese.it>"
+  :maintainer "Drew Crampsie <drewc@tech.coop>"
+  :licence "BSD (sans advertising clause)"
+  :version "0.9"
+  :class ucw-system
+  :components
+  ((:module :src
+    :components 
+    ((:module :ucw-tal
+      :components ((:file "tal-package")
+		   (:file "template" :depends-on ("tal-package"))
+		   (:file "yaclml" :depends-on ("template")))))))
+  :properties ((version "0.9"))
+  :depends-on (:ucw))
hunk ./ucw.asd 64
+(defsystem* :ucw-ajax
+  :description "UncommonWeb : Ajax Components"
+  :long-description "Contains the ajax extension."
+  :author "Marco Baringer <mb@bese.it>"
+  :maintainer "Drew Crampsie <drewc@tech.coop>"
+  :licence "BSD (sans advertising clause)"
+  :version "0.9"
+  :class ucw-system
+  :components
+  ((:module :src
+    :components 
+    ((:module :ucw-ajax
+      :components ((:file "ajax-package")
+		   (:file "ajax" :depends-on ("ajax-package"))
+		   (:file "ajax-application" :depends-on ("ajax"))
+		   (:file "ajax-dispatchers" :depends-on ("ajax-application"))
+		   (:file "ajax-actions" :depends-on ("ajax-dispatchers"))
+		   )))))
+  :properties ((version "0.9"))
+  :depends-on (:ucw :parenscript))
}

Context:

[M-q FTW!
drewc@tech.coop**20090103194106] 
[Adding example code
drewc@tech.coop**20090102234730] 
[Changes for new manual .. and manual itself-ish
drewc@tech.coop**20090102234551] 
[emo fixes and more manual.
drewc@tech.coop**20081204044706] 
[Add demo fixes. preliminary manual, nuck some old unused files.
drewc@tech.coop**20081203012326] 
[Prepend url-prefix to window external stylesheets
clinton@unknownlamer.org**20081202212435] 
[Move APPLICATION-WITH-WWW-ROOTS-MIXIN to ucw-standard
clinton@unknownlamer.org**20081202095203
 * Creates static file entry points at application init rather than
   relying upon the backend to have special file serving handler code
] 
[Import container classes into ucw-standard
clinton@unknownlamer.org**20081202092252] 
[Move SERVE-{SEQUENCE|STREAM|FILE} to ucw-standard
clinton@unknownlamer.org**20081202091517
 * Export more of the response protocol
 * SERVE-FILE now returns a 404 page if the file does not exist
] 
[Reimplement starts-with-dispatcher
clinton@unknownlamer.org**20081202090909
 Uses ARNESI:STARTS-WITH to match a prefix; the suffix is available
 within the dispatcher body as *DISPATCHER-URL-SUFFIX*
] 
[Clean up core package definition
clinton@unknownlamer.org**20081202073148
 * Duplicated symbols removed
 * Symbols for things no longer in ucw-core removed
 * Export list is now coherently sorted; some additional sorting would
   be useful
] 
[Export http status codes from ucw-core
clinton@unknownlamer.org**20081202064725] 
[Move JUMP and CALL-AS-WINDOW into ucw-standard
clinton@unknownlamer.org**20081202041645] 
[Remove obsolete call macros
clinton@unknownlamer.org**20081202041601] 
[Port html-element and widget-component to ucw-standard
clinton@unknownlamer.org**20081126203441
 * html-element -> html-element-mixin
 * Prefixed accessors with `html-element.'
 * widget[-inline]-component -> html-{block|inline}-element-mixin
 * Add UNIQUE-DOM-KEY to generate dom-ids as a drop-in replacement for
   js:gen-js-name-string
] 
[Remove ajax-appliction-mixin
clinton@unknownlamer.org**20081126202754] 
[Port cookie-session-application-mixin to ucw-standard
clinton@unknownlamer.org**20081126202737] 
[Remove some obsolete exports from core-package
clinton@unknownlamer.org**20081126202444] 
[Port regexp and simple dispatcher to ucw-standard
clinton@unknownlamer.org**20081126202054
 * Export matcher/handler/dispatcher protocol from ucw-core
 * Remove ajax/parenscript/etc. dispatchers
] 
[Update iolib backend for more modern net.sockets
clinton@unknownlamer.org**20081126063127] 
[Export MAKE-PLACE
clinton@unknownlamer.org**20081126045512] 
[Remove CALL-IN-RENDERING-ENVIRONMENT
clinton@unknownlamer.org**20081126042008
 This would be useful in a theoretical future ucw-ajax extension, but
 is not useful for anything in the core or standard packages.
] 
[Remove obsolete constants
clinton@unknownlamer.org**20081126041632] 
[Export REFRESH-COMPONENT
clinton@unknownlamer.org**20081126041615] 
[Export CREATE-SERVER
clinton@unknownlamer.org**20081126041608] 
[Nickname ucw-standard package ucw
clinton@unknownlamer.org**20081124214150] 
[Initial exports for ucw-standard package
clinton@unknownlamer.org**20081124214126] 
[Properly call with format-rfc3339-timestring with destination argument
clinton@unknownlamer.org**20081124214013] 
[Fix invalid html and html escape arguments in send-redirect
clinton@unknownlamer.org**20081124074610] 
[Added forgotten demo 
drewc@tech.coop**20081127210055
 
 This is the demo. It will eventually be a demonstration of all the ucw components, and also serve as the example code 
 for documentation purposes.
] 
[I forgot the .asd ... not the best start!
drewc@tech.coop**20081118222013] 
[Remove outdated files no longer relevant for ucw-core.
drewc@tech.coop**20081118214724] 
[Adding new files for ucw-core split.
drewc@tech.coop**20081118211410] 
[UCW-CORE fork part 1.
drewc@tech.coop**20081103191746
 
 This patch is the start of the ucw-core fork, done in parts to appease 
 the darcs gods.
] 
[add safari support to import-ajax-received-xhtml-node
Sasha Kovar <sasha-lisp@arcocene.org>**20080419055600] 
[follow bind's values -> :values changes
attila.lendvai@gmail.com**20080415155617] 
[fix lang:timestamp
attila.lendvai@gmail.com**20080415155606] 
[temp fix for ip-address= until iolib's infrastructure is used
attila.lendvai@gmail.com**20080415155521] 
[fix corner case in lang:timestamp
attila.lendvai@gmail.com**20080208125533] 
[lang:timestamp is not in relative-mode by default
attila.lendvai@gmail.com**20080208125401] 
[fix: added missing setup-readtable call to l10n.lisp
attila.lendvai@gmail.com**20080207112636] 
[fix up ucw.lang:timestamp
attila.lendvai@gmail.com**20080205233800] 
[fix cache purging of i18n-parenscript-dispatcher
attila.lendvai@gmail.com**20080204234112] 
[support :relative-mode in lang::timestamp<>
attila.lendvai@gmail.com**20080204233729] 
[follow iolib changes. patch by the man himself: Stelian Ionescu! :)
attila.lendvai@gmail.com**20080202213406] 
[cleanup temp file handling, make sure no file is overridden
attila.lendvai@gmail.com**20080123084343] 
[Make file upload root configurable
clinton@unknownlamer.org**20080117023522] 
[Update iolib backend startup code
clinton@unknownlamer.org**20080130222426] 
[weak try to fix the bitrotten examples
attila.lendvai@gmail.com**20080111064758] 
[Add maxlength attribute to in-field-string-field render method.
Sasha Kovar <sasha-lisp@arcocene.org>**20071228024947] 
[Add hidden-field html form field type.
Sasha Kovar <sasha-lisp@arcocene.org>**20071228030046] 
[fix: (lang::timestamp ... :relative-mode #f)
attila.lendvai@gmail.com**20071214150456] 
[Fix logging the backtrace of errors of ajax actions
attila.lendvai@gmail.com**20071115211841] 
[Change make-new-session so that it calls make-instance with the :id initarg, so the name of the session's lock contains the session id.
attila.lendvai@gmail.com**20071115211643] 
[change call-in-rendering-environment's arg order to follow the call-* conventions
attila.lendvai@gmail.com**20071110145556] 
[add with-thread-name to handle-action
attila.lendvai@gmail.com**20071105123555] 
[send a start message to the new acceptor
attila.lendvai@gmail.com**20071105093338] 
[KLUDGE: do not read the request if the server is overloaded
attila.lendvai@gmail.com**20071105093332] 
[prefix the various urls of window with the application's url-prefix
attila.lendvai@gmail.com**20071102112232] 
[added with-session-specific-temporary-file and open-session-specific-temporary-file
attila.lendvai@gmail.com**20071101151614] 
[added download-action-href-body
attila.lendvai@gmail.com**20071101123136] 
[added bind dependency
attila.lendvai@gmail.com**20071101123114] 
[more cl-def usage
attila.lendvai@gmail.com**20071101122942] 
[added assert to find-session
attila.lendvai@gmail.com**20071101034315] 
[more lock-held asserts
attila.lendvai@gmail.com**20071031231609] 
[added log-ignorable-error-backtrace
attila.lendvai@gmail.com**20071031231600] 
[housekeeping
attila.lendvai@gmail.com**20071031231318] 
[rename httpd threads
attila.lendvai@gmail.com**20071031231233] 
[refactor app/session locking and session expiration.
attila.lendvai@gmail.com**20071031230717
 
 TODO left: sessions are not purged, user code must call remove-expired-sessions periodically for now
] 
[invert the default value of call-as-response-handler
attila.lendvai@gmail.com**20071031161408] 
[turn the assert-application-lock-held into a with-lock-held-on-application in delete-session
attila.lendvai@gmail.com*-20071031005222] 
[housekeeping
attila.lendvai@gmail.com**20071030163423] 
[fix importing toplevel script nodes from ajax answers
attila.lendvai@gmail.com**20071031013401] 
[turn the assert-application-lock-held into a with-lock-held-on-application in delete-session
attila.lendvai@gmail.com**20071031005222] 
[rework remove-expired-sessions a bit
attila.lendvai@gmail.com**20071030211425] 
[added maybe-remove-expired-sessions
attila.lendvai@gmail.com**20071030202921] 
[added clear-session-frame-history
attila.lendvai@gmail.com**20071030200920] 
[also log the thread name in when the backtrace is logged
attila.lendvai@gmail.com**20071030192729] 
[more fine-grained locking on the app/sessions when removing expired sessions
attila.lendvai@gmail.com**20071030192337] 
[more usage of with-thread-name
attila.lendvai@gmail.com**20071030163207] 
[renamed collapsible's "body" css class to "collapsible-body"
attila.lendvai@gmail.com**20071029221941] 
[added a serve-stream and implemented serve-file using it
attila.lendvai@gmail.com**20071029221842] 
[clear the request/response variables before trying to close the socket
attila.lendvai@gmail.com**20071029140901] 
[use cl-def's with-macro for the with-*-lock-held macros to leave a function on the stack for easier debugging
attila.lendvai@gmail.com**20071027142715] 
[fix define-js-resources C-cC-c'ing
attila.lendvai@gmail.com**20071027000315] 
[drop single threaded httpd backend
attila.lendvai@gmail.com**20071026193910] 
[drop aserve and araneida backends
attila.lendvai@gmail.com**20071026191818] 
[drop araneida and aserve backends
attila.lendvai@gmail.com**20071026190855] 
[baby steps towards dojo 0.9
attila.lendvai@gmail.com**20071026190751] 
[drop threaded-lisp-p and start-swank
attila.lendvai@gmail.com**20071026190508] 
[use cl-def
attila.lendvai@gmail.com**20071026190139] 
[renamed to *js-resource-registry-last-modified-at*
attila.lendvai@gmail.com**20071026185951] 
[added cl-def dependency
attila.lendvai@gmail.com**20071026184945] 
[drop the remainings of the old config stuff.
attila.lendvai@gmail.com**20071026184851] 
[TAG before-controversial-refactor
attila.lendvai@gmail.com**20071026182616] 
[disable file logging by default
attila.lendvai@gmail.com**20071027003844] 
[added js side warning at 2/3 of the session timeout
attila.lendvai@gmail.com**20071027000415] 
[change with-thread-name so that it appends to the current name
attila.lendvai@gmail.com**20071026172638] 
[send a content-disposition by default in serve-file
attila.lendvai@gmail.com**20071026172613] 
[clean up response sending in basic backend
attila.lendvai@gmail.com**20071026165103] 
[use with-thread-name in call-with-ucw-error-handler
attila.lendvai@gmail.com**20071026001437] 
[added with-thread-name, use it in the multithreaded-http-backend
attila.lendvai@gmail.com**20071026000416] 
[make the progress indicator less opaque on first display
attila.lendvai@gmail.com**20071025211356] 
[fix error handling related to raw requests. use the new headers-are-sent-p
attila.lendvai@gmail.com**20071025211248] 
[added headers-are-sent-p
attila.lendvai@gmail.com**20071025210053] 
[delete the session if it's found expired, add comment what's going on there
attila.lendvai@gmail.com**20071024203306] 
[clean up error handling: when nested errors happen try to log it but let it go through for the upper levels
attila.lendvai@gmail.com**20071024195032] 
[fix error handling
attila.lendvai@gmail.com**20071024084530] 
[refactor session purging so that expired-p is only called from inside handle-action (so that use customizations on it are in effect)
attila.lendvai@gmail.com**20071023203520] 
[added assert-session-lock-held
attila.lendvai@gmail.com**20071023203433] 
[add the dojo debug container and the progress-container at on-load, so they get at the end of the doc. this makes it more google-friendly.
attila.lendvai@gmail.com**20071023115001] 
[housekeeping
attila.lendvai@gmail.com**20071022005238] 
[clean up script tag eval'ing in ajax answers
attila.lendvai@gmail.com**20071021224724] 
[make <ucw:a more accepting when using an onclick and a href at the same time
attila.lendvai@gmail.com**20071021204009] 
[make error reporting for raw requests more flexible when using handle-raw-request
attila.lendvai@gmail.com**20071021203006] 
[fix client side switching-container: try loading ajax children each time it's requested until it is successful
attila.lendvai@gmail.com**20071019150722] 
[Wrap delete-sessions with handler-case to be more robust.
levente.meszaros@gmail.com**20071019114521] 
[make defentry-point more fool-proof
attila.lendvai@gmail.com**20071018231407] 
[compile time debug level based on *load-as-production-p*
attila.lendvai@gmail.com**20071018223818] 
[move error logging into handle-toplevel-condition, extend it
attila.lendvai@gmail.com**20071017232031] 
[bah, refix the flicker patch
attila.lendvai@gmail.com**20071017221127] 
[fix client-side switching-container flickering at page load with non-ajax children
attila.lendvai@gmail.com**20071017203820] 
[be more strict in http header parsing: there's no point in trying anything else then ascii for the uri
attila.lendvai@gmail.com**20071017191238
 
 and ie 6 is just simply buggy when sending iso-8859-? encoded stuff there with unicode urls and ajax requests. 
] 
[disallow-response-caching for serve-file and serve-sequence
attila.lendvai@gmail.com**20071017182746] 
[return nil when X-Forwarded-For is not a simple ip address
attila.lendvai@gmail.com**20071017182417] 
[tolerate strange X-Forwarded-For values
attila.lendvai@gmail.com**20071017120610] 
[write out the strange ip addresses of "X-Forwarded-For"
attila.lendvai@gmail.com**20071017111803] 
[no need for a weak pointer when pointing to the session
attila.lendvai@gmail.com**20071017111232] 
[revive backtrace logging
attila.lendvai@gmail.com**20071017101602] 
[housekeeping
attila.lendvai@gmail.com**20071017011942] 
[drop read-from-client-string, add internal read-number with a KLUDGE comment
attila.lendvai@gmail.com**20071016212407] 
[fix: sessions were not properly purged
attila.lendvai@gmail.com**20071016185851] 
[fix: missing symbol export for timestamp stuff
attila.lendvai@gmail.com**20071016161513] 
[factored out render-url-to-file-with-modification-timestamp
attila.lendvai@gmail.com**20071016160642] 
[added some timestamp related utils:
attila.lendvai@gmail.com**20071016145835
 
  ucw.lang:timestamp and ucw.lang:timestamp<> that renders a localized representation of a local-time (using cl-l10n)
  <ucw::file-modification-time
  <ucw::url-to-file-with-modification-timestamp
] 
[delay ajax requests a bit to give a chance for the progress display to appear
attila.lendvai@gmail.com**20071015233410] 
[progress indicator style
attila.lendvai@gmail.com**20071015232022] 
[get rid of the animation on the progress label to behave better with large/slow/cpu-heavy requests
attila.lendvai@gmail.com**20071015204659] 
[housekeeping
attila.lendvai@gmail.com**20071015160945] 
[keep the app locked while accessing its session table
attila.lendvai@gmail.com**20071015015246] 
[added ip address utils and types
attila.lendvai@gmail.com**20071014215954] 
[use *request* when ignoring stream errors coming from the network stream, it's available sooner.
attila.lendvai@gmail.com**20071014183145] 
[enable the faster script tag search for ie. seems to work fine...
attila.lendvai@gmail.com**20071014182516] 
[added on-load js macro to shortcut dojo.add-on-load and the lambda it needs. use it.
attila.lendvai@gmail.com**20071014154618] 
[small fix to actions in tal files
attila.lendvai@gmail.com**20071013014521] 
[remove the _ prefix from session and frame values, so the +session-id-length+ gets back its meaning
attila.lendvai@gmail.com**20071013014336] 
[display errors on the js side only once
attila.lendvai@gmail.com**20071011164131] 
[Leave alone *default-timezone* and bind the client timezone to *client-timezone*
attila.lendvai@gmail.com**20071008185643] 
[added encoding-type slot to form component
attila.lendvai@gmail.com**20070921141049] 
[fix the previous ajax script tag lookup optimization
attila.lendvai@gmail.com**20071005143833] 
[Follow rfc2388-binary changes (added an abort-callback to delete temp files, optimize file writing)
attila.lendvai@gmail.com**20071005140404] 
[speed up script tag evaluating in ajax answers on mozilla by using .get-elements-by-tag-name
attila.lendvai@gmail.com**20071005103607] 
[add a few args to serve-file
attila.lendvai@gmail.com**20071004160856] 
[fix: rerl-error only captures *context* when it's bound
attila.lendvai@gmail.com**20071004100147] 
[housekeeping
attila.lendvai@gmail.com**20071003164336] 
[render more info when errors happen
attila.lendvai@gmail.com**20071003164242] 
[added effective-window-stylesheets which is an nconc method that lets users customize the stylesheet list dynamically
attila.lendvai@gmail.com**20071001124158] 
[component-body-mixin tolerates nil body in which case it just doesn't render anything.
attila.lendvai@gmail.com**20071001124109] 
[Added support for extracting X-Forwarded-For header in a proxy setup to see the real remote address.
attila.lendvai@gmail.com**20070928162659] 
[add "form" css class to forms by default because ajax-rendered forms are rendered with a DIV
attila.lendvai@gmail.com**20070928111846] 
[housekeeping
attila.lendvai@gmail.com**20070922154733] 
[move the default js-to-lisp-rpc-handler into per-application
attila.lendvai@gmail.com**20070924195225] 
[send down parenscript-dispatcher's result as utf-8, so that it's possible to use unicode (in the js names)
attila.lendvai@gmail.com**20070922154250] 
[fix importing of tr nodes on the ie side when received through an ajax request
attila.lendvai@gmail.com**20070922153428] 
[small cleanup in file upload
attila.lendvai@gmail.com**20070921140915] 
[bind *request* as early as possible
attila.lendvai@gmail.com**20070921140834] 
[added some todo notes
attila.lendvai@gmail.com**20070921140725] 
[Added *request-content-length-limit*
attila.lendvai@gmail.com**20070921140555] 
[make the mod_lisp apache config for the examples a little more clear, added create-links.sh into the example's wwwroot
attila.lendvai@gmail.com**20070920084621] 
[a little bit kludgy fix for ajax requests to timed out sessions. ajax answer processing still needs a cleanup.
attila.lendvai@gmail.com**20070918223622] 
[deajaxify the dynamic form example's menu item to restore its usability. ajax-rendered forms need ajax actions, too.
attila.lendvai@gmail.com**20070917171231] 
[l10n-app's default-locale(s) are always appended to the locale precedence list
attila.lendvai@gmail.com**20070914212708] 
[small cleanup in ajax-differences.text
attila.lendvai@gmail.com**20070914180850] 
[renamed *load-with-debug-p* to *load-as-production-p*
attila.lendvai@gmail.com**20070914170714] 
[fix counter example (tal/action stuff still needs a proper cleanup)
attila.lendvai@gmail.com**20070914165930] 
[follow cl-l10n typo fix
attila.lendvai@gmail.com**20070914165835] 
[Clean up cookie handling. WARNING: api changed
attila.lendvai@gmail.com**20070913231700
 
 Added a separate cookies slot for both the request and the response with the
 approriate helper methods.
] 
[ucw.widget.switching-container.clear-selected-child
attila.lendvai@gmail.com**20070913225945] 
[housekeeping
attila.lendvai@gmail.com**20070913225928] 
[added :log-to-console-p to create-server
attila.lendvai@gmail.com**20070913211647] 
[Added wrap for textarea. Patch by Sasha Kovar.
attila.lendvai@gmail.com**20070909095448] 
[add missing cl-ppcre dependency to the asd
attila.lendvai@gmail.com**20070909002633] 
[fix: make render-nearest-ajax-component more tolerant for toplevel/detached ajax component setups
attila.lendvai@gmail.com**20070906130355] 
[Added in-restored-rendering-environment
attila.lendvai@gmail.com**20070905140911] 
[<ucw:localized just got smarter
attila.lendvai@gmail.com**20070831005237] 
[fix operation of the js side without cl-l10n being loaded
attila.lendvai@gmail.com**20070827141709] 
[small change create-server to make the boxset's start.lisp happy
attila.lendvai@gmail.com**20070827121955] 
[Added call-in-restored-rendering-environment; renamed to call-in-rendering-environment
attila.lendvai@gmail.com**20070824190617] 
[rename funcall-as- to call-as-
attila.lendvai@gmail.com**20070824190559] 
[Fix client side collapsible pane onclick js
attila.lendvai@gmail.com**20070824190411] 
[housekeeping
attila.lendvai@gmail.com**20070820170509] 
[fix: drop registered form fields when they are not in the DOM anymore (to fix form dirtyness checking)
attila.lendvai@gmail.com**20070820100543] 
[trivial changes to the examples
attila.lendvai@gmail.com**20070820093833] 
[refactor ajax rendering to use call-with-rendering-environment on the parent chain before calling ajax-render on the component to be ajax rendered.
attila.lendvai@gmail.com**20070820093715] 
[<ucw:form is only nested if the supplied html-form is not alread bound to *current-form*
attila.lendvai@gmail.com**20070820092818
 
 it's needed because call-with-rendering-environment of html-form needs to bind *current-form* but it does not mean that
 we are in a nested form when we reach the rendering of the <ucw:form tag.
] 
[added call-with-rendering-environment
attila.lendvai@gmail.com**20070820092436] 
[use call-with-rendering-environment where apropriate
attila.lendvai@gmail.com**20070820092256] 
[funcall-with- was renamed to call-with-
attila.lendvai@gmail.com**20070814123738] 
[added support to use a different js handler in js-to-lisp-rpc
attila.lendvai@gmail.com**20070814122245] 
[fix upload example to follow <ucw:form related changes
attila.lendvai@gmail.com**20070814122105] 
[Updated dojo to 9882
attila.lendvai@gmail.com**20070731234229] 
[switching-container-selector-js now works with component keys, too
attila.lendvai@gmail.com**20070810132430] 
[rename to iterate-visible-dirty-components and record a TODO related to them
attila.lendvai@gmail.com**20070809222007] 
[:remember-selected-child-p for client-side switching-container
attila.lendvai@gmail.com**20070808192443] 
[housekeeping
attila.lendvai@gmail.com**20070802155209] 
[Added support for setting the client timezone on the session
attila.lendvai@gmail.com**20070802144334] 
[rename l10n logger
attila.lendvai@gmail.com**20070802144002] 
[Annotate some optimizations on parse-accept-language-header
attila.lendvai@gmail.com**20070731234253] 
[Fix: properly drop expired sessions
attila.lendvai@gmail.com**20070724203452] 
[ajax-action's are not invocation isolated by default
attila.lendvai@gmail.com**20070724123053] 
[The indirection action of :through-redirect t actions do not need a new frame
attila.lendvai@gmail.com**20070724111138] 
[Export session symbols
attila.lendvai@gmail.com**20070723111521] 
[Some localization changes
attila.lendvai@gmail.com**20070723111502] 
[Hardcode utf-8 as encoding for some types in serve-file (and add a TODO note)
attila.lendvai@gmail.com**20070722193830] 
[Fix: added missing enable-sharpquote<>-syntax to container.lisp
attila.lendvai@gmail.com**20070709124550] 
[Fix current-form
attila.lendvai@gmail.com**20070709120804] 
[Housekeeping
attila.lendvai@gmail.com**20070709120750] 
[Change default :invocation-isolated of actions to be true 
attila.lendvai@gmail.com**20070709120705] 
[Fix decorate-with-invocation-id for url's without any parameters
attila.lendvai@gmail.com**20070709120634] 
[Client-side mode for switching-container
attila.lendvai@gmail.com**20070709120530] 
[Client side operation for collapsible-pane
attila.lendvai@gmail.com**20070709120519] 
[Follow iolib changes in the iolib backend; added worker thread starting up to a max limit
attila.lendvai@gmail.com**20070706235950] 
[Fix minor issues in the tests
attila.lendvai@gmail.com**20070706235650] 
[Added with-unique-dom-ids
attila.lendvai@gmail.com**20070706152552] 
[Fix :through-redirect of register-action when used with invocation isolated actions
attila.lendvai@gmail.com**20070704225247] 
[Fix some #"" reader bugs
attila.lendvai@gmail.com**20070704225142] 
[Move the render :wrap-around of template-component to simple :around for better customizability
attila.lendvai@gmail.com**20070704224956] 
[Fix some issues with js-to-lisp-rpc
attila.lendvai@gmail.com**20070704224814] 
[Export some cookie helpers, escape cookie values as uri, so you can have unicode stuff and cookie control chars in the value
attila.lendvai@gmail.com**20070629231431
 
    #:add-set-cookie-header
    #:cookie-value
    #:make-cookie
] 
[Fix uri escaping, the path was not propertly escaped causing problems with unicode url-prefix
attila.lendvai@gmail.com**20070628163714] 
[Added make-cookie that calls escape-as-uri on the supplied path. This fixes session-cookie-application with unicode url-prefix.
attila.lendvai@gmail.com**20070628163611] 
[Fix: bind *dispatcher-registers* as documented (but dispatchers needs a cleanup, probably based on lambda's and capturing)
attila.lendvai@gmail.com**20070704193315] 
[Follow iolib changes (credit goes to Stelian Ionescu)
attila.lendvai@gmail.com**20070629095410] 
[Added captcha support, which is a custom application that keeps an LRU queue of registered captchas and needs a captcha factory function
attila.lendvai@gmail.com**20070625222440] 
[Housekeeping
attila.lendvai@gmail.com**20070625221845] 
[Use -foo- naming convention for non-hygienic macro variables
attila.lendvai@gmail.com**20070625221748] 
[Follow yaclml tal changes
attila.lendvai@gmail.com**20070625221619] 
[Fix some dojo-widget stuff
attila.lendvai@gmail.com**20070625220850] 
[Form field registration needs less js
attila.lendvai@gmail.com**20070624191622] 
[Fix checkbox, add ucw-checkbox class to it
attila.lendvai@gmail.com**20070624191611] 
[Follow iolib changes in the iolib backend, fix graceful shutdown of the backend
attila.lendvai@gmail.com**20070624135356] 
[Fix even more issues with the l10n split. It turned out to be more headache then expected...
attila.lendvai@gmail.com**20070622130815] 
[widget-component must be a full standard-component. use html-element and with-html-element-wrapper if you need a barebone class.
attila.lendvai@gmail.com**20070622130602] 
[Fix start.lisp after the l10n split
attila.lendvai@gmail.com**20070622104857] 
[Fix even more issues with the l10n split
attila.lendvai@gmail.com**20070622104457] 
[Fix l10n separation
attila.lendvai@gmail.com**20070622094959] 
[Use the ...-syntax naming convention
attila.lendvai@gmail.com**20070622085859] 
[Finish the previous weak try to move l10n stuff into a system connection
attila.lendvai@gmail.com**20070622085420
 
 Move around some l10n definitions and add some dummies that are available
 even without l10n being loaded.
] 
[Mainly comments to some of the backend code
attila.lendvai@gmail.com**20070622085310] 
[Move cl-l10n dependency into an asdf-system-connection
attila.lendvai@gmail.com**20070621104846] 
[Make the test more iolib friendly
attila.lendvai@gmail.com**20070618213713] 
[Added missing iolib backend stuff to the asd
attila.lendvai@gmail.com**20070618213029] 
[Added an iolib backend
attila.lendvai@gmail.com**20070618212142] 
[Make backend locking use a recursive lock
attila.lendvai@gmail.com**20070618212120] 
[Renamed peer-address to remote-address as suggested by Cyrus Harmon
attila.lendvai@gmail.com**20070618211655] 
[Fix the add some numbers example, follow form changes
attila.lendvai@gmail.com**20070617134517] 
[Added dojo inline edit box example
attila.lendvai@gmail.com**20070617134450] 
[Housekeeping
attila.lendvai@gmail.com**20070617134339] 
[Support rendering a <ucw:form as a non-<form even without nesting or ajax
attila.lendvai@gmail.com**20070617134306] 
[Fix abort-action
attila.lendvai@gmail.com**20070617134105] 
[Added dojo-inline-edit-box
attila.lendvai@gmail.com**20070617133858] 
[Dropped the kludgy js-server-callback, added a more generic js-to-lisp-rpc
attila.lendvai@gmail.com**20070617133727] 
[Updated the tests
attila.lendvai@gmail.com**20070616173408] 
[Split out minimal-application from basic-application
attila.lendvai@gmail.com**20070616172823] 
[Added an ABORT-ACTION that can be used any time to abort further processing of the action
attila.lendvai@gmail.com**20070616172641] 
[Added a :length argument for length-validator that checks for an exact length
attila.lendvai@gmail.com**20070616172347] 
[Factored out a basic-backend, prepare for an iolib backend that will share most of the code
attila.lendvai@gmail.com**20070616171801] 
[Renamed to accept-headers.lisp
attila.lendvai@gmail.com**20070616165710] 
[Drop split-sequence dependency, we already need cl-ppcre
attila.lendvai@gmail.com**20070616160345] 
[Follow the rename of rfc2388 to rfc2388-binary
attila.lendvai@gmail.com**20070616123931] 
[Make the apache2 example config more newbie friendly
attila.lendvai@gmail.com**20070615075006] 
[Err, really fix false 503's with multithreaded httpd backend
attila.lendvai@gmail.com**20070614063949] 
[Support specifying the :wrapper-tag-name for <ucw:form
attila.lendvai@gmail.com**20070613210215] 
[Revive ajax stuff on ie
attila.lendvai@gmail.com**20070613203854] 
[Smarter way to get out the data from dojo widgets
attila.lendvai@gmail.com**20070613203523] 
[Fix removal of progress label if there's an error before firing the request
attila.lendvai@gmail.com**20070613203453] 
[Follow changes in the examples
attila.lendvai@gmail.com**20070613203327] 
[Submit callbacks are cleared after each render and need to be re-registered (similarly to actions)
attila.lendvai@gmail.com**20070613173849] 
[Fix some issues in the new form code
attila.lendvai@gmail.com**20070612200134] 
[Fix some bitrot
attila.lendvai@gmail.com**20070612195620] 
[secure app tinkering
elliott@iparadigms.com**20070612155159
 
 I've created a few modifications to the secure app code.
 
   * fixed an error in (setf %session-user) in which a "default" value
     was passed (nil).  The setf version of GET-SESSION-VALUE doesn't 
     have a need for the default value.
 
   * changed the user-login component to be a subclass of html-form.
     This corrects the unbound *current-form* variable error.
 
   * Moved the window-component stuff (and the status bar stuff) into
     a new component called user-login-window.  I've not tested this as
     much as I'd like, but I don't have much time in the next few days.
 
   * redefined the SUBMIT and CANCLE actions to answer the user-login-window
     component rather than the user-login component, so that it's results
     can be passed back to the secure-application-mixin code.
 
 PS- I think the secure-application class can be fully depreciated.  I don't
     see any mention of modular-application any where else in ucw_ajax :)
 
 
] 
[Some changes to the exports
attila.lendvai@gmail.com**20070612175945] 
[Delete *ucw-tal-root*, use (make-standard-ucw-tal-dir-list) instead
attila.lendvai@gmail.com**20070612175900] 
[Fix multithreaded httpd false 503 reporting
attila.lendvai@gmail.com**20070612090946] 
[Don't rely on weak pointers for backtracked places, it's too expensive and we can manage it ourselves
attila.lendvai@gmail.com**20070608183647] 
[Fix some asdf dependencies
attila.lendvai@gmail.com**20070609121820] 
[Drop accidentally comitted defcomponent* usage
attila.lendvai@gmail.com**20070609002043] 
[Only get a backtrace when we need it, it's expensive
attila.lendvai@gmail.com**20070608175604] 
[Fix dojo widget inheritance, dojo-widget is important, put it first
attila.lendvai@gmail.com**20070608175534] 
[Added +http... status code constants
attila.lendvai@gmail.com**20070608175523] 
[Housekeeping
attila.lendvai@gmail.com**20070608175301] 
[close-request is the responsibility of the backend, don't call it from random places
attila.lendvai@gmail.com**20070608175013] 
[Make the threaded httpd backend more roboust
attila.lendvai@gmail.com**20070608174850
 
 Now it can stay alive with siege -c32 -t600S http://localhost/ even though it renders a few 503's
] 
[Fix defserve 304 not modified response sending
attila.lendvai@gmail.com**20070607140016] 
[Move response handling into the app's service call, so that it's more customizable at the app level
attila.lendvai@gmail.com**20070607133145] 
[Added a *maximum-number-of-sessions*, render unavailable page when going above this
attila.lendvai@gmail.com**20070607133047] 
[Clean up l10n application locale handling
attila.lendvai@gmail.com**20070607132955] 
[By default leave alone the loggers when starting up a server; renamed ucw-logger to ucw and all loggers inherit from it
attila.lendvai@gmail.com**20070607132827] 
[Use the internal _real_ time when logging how much time the serve took
attila.lendvai@gmail.com**20070607132751] 
[Fix network stream error ignoring
attila.lendvai@gmail.com**20070607132704] 
[Cleanup threading: implement threading using bordeaux-threads instead of the swank primitives.
attila.lendvai@gmail.com**20070607132243] 
[Revive the admin application, change the url-prefix to "/ucw/"
attila.lendvai@gmail.com**20070607131747] 
[Added TODO note about how ajax communication should work
attila.lendvai@gmail.com**20070607131459] 
[Preliminary dijit support (too early, many widgets are not yet ported from dojo)
attila.lendvai@gmail.com**20070607130604] 
[Renamed to dojo-html-text-editor
attila.lendvai@gmail.com**20070606095835] 
[Do not alter *random-state*
attila.lendvai@gmail.com**20070606084059] 
[Added +xhtml-namespace-uri+ and +dojo-namespace-uri+
attila.lendvai@gmail.com**20070605153120] 
[Fix serve-sequence/-file, mark the response as unmanaged
attila.lendvai@gmail.com**20070605150907] 
[Added .binaries, mark dojo stuff as binary
attila.lendvai@gmail.com**20070605115046] 
[Fix: ajax answer status and content-type headers
attila.lendvai@gmail.com**20070605112737] 
[Update examples with the new form stuff, added a nested form
attila.lendvai@gmail.com**20070604115649] 
[Change the default listening port to 0.0.0.0
attila.lendvai@gmail.com**20070604115610] 
[Revised form handling
attila.lendvai@gmail.com**20070604115228
 
 Nesting of form tags is not allowed, therefore don't use form tags when ajax rendering and/or
 rendering a nested <ucw:form tag. In those situations the client side js takes care of gathering
 the data to be posted. Now ajax rendering can happen indepened from the form boundaries.
] 
[Added a callback-dispatcher whose sole purpose is to accept ajax-posted form data
attila.lendvai@gmail.com**20070604005728] 
[Signal an error when an action was not found and its id was specified
attila.lendvai@gmail.com**20070530235342] 
[Fix response flushing and therefore 404 rendering
attila.lendvai@gmail.com**20070530230759] 
[Fix ajax-action-dispatcher, reintroduce the (now internal) handle-ajax-request macro
attila.lendvai@gmail.com**20070530094938] 
[Get rid of the handle-ajax-request, move it into the call-action :around of ajax-action
attila.lendvai@gmail.com**20070525000338] 
[Housekeeping
attila.lendvai@gmail.com**20070525000303] 
[The araneida and the aserve backends are dead, comment them out until revival
attila.lendvai@gmail.com**20070524233816] 
[Various small changes
attila.lendvai@gmail.com**20070524154005] 
[Cleaned up error handling, and threading in httpd backend
attila.lendvai@gmail.com**20070524153955] 
[Include the session id in the name of the session lock
attila.lendvai@gmail.com**20070524133942] 
[Generated a dojoDebug div when debug is enabled and there's not any
attila.lendvai@gmail.com**20070524133859] 
[Assorted fixes
attila.lendvai@gmail.com**20070521175504] 
[Revive the examples
attila.lendvai@gmail.com**20070521175457] 
[Drop unused funcall-with-request-context
attila.lendvai@gmail.com**20070521175438] 
[Clean up backend error handling, introduce an abort-backend-request semi-public function
attila.lendvai@gmail.com**20070521174923] 
[Made parse-request-body more tolerant to things like "text/plain" content-type requests
attila.lendvai@gmail.com**20070521163729] 
[Fix action isolation support that broke in the cleanup
attila.lendvai@gmail.com**20070521163052] 
[Added with-html-element-wrapper, export it
attila.lendvai@gmail.com**20070521154358] 
[Added stress test for call/answer/backtracking/frames
attila.lendvai@gmail.com**20070521134742] 
[Fix backtracking
attila.lendvai@gmail.com**20070520152505
 
 Backtracking was leaking memory until the entire session was expired. Now each frame keeps track of both
 its own allocated and the effective backtracked places. The first is a collection of hard references
 while the latter is a collection of weak references.
] 
[Split session handling into a mixin, purge sessions in given time periods
attila.lendvai@gmail.com**20070520094736] 
[Clean up css files, ucw.css is a bare minimum that all applications should include
attila.lendvai@gmail.com**20070519210843] 
[Fix some dojo widget related js bugs
attila.lendvai@gmail.com**20070519192528] 
[Export action and basic-action
attila.lendvai@gmail.com**20070519192512] 
[Added a :send-client-events to handle-ajax-request
attila.lendvai@gmail.com**20070519192402] 
[Fix swank:*readtable-alist* setup
attila.lendvai@gmail.com**20070519192238] 
[Added support to disable escaping for uri printing, export uri helpers
attila.lendvai@gmail.com**20070518102122] 
[Added a :action-options for defentry-point
attila.lendvai@gmail.com**20070517233708] 
[Fix: do not skip make-new-frame if there's no frame at all yet
attila.lendvai@gmail.com**20070517233611] 
[standard-template-compoennt is a simple-template-component
attila.lendvai@gmail.com**20070517233208] 
[Added missing dojo files
attila.lendvai@gmail.com**20070516135917] 
[Added missing files
attila.lendvai@gmail.com**20070516131848] 
[Added make-horizontal-list-container and make-vertical-list-container and exported them.
levente.meszaros@gmail.com**20070516134317] 
[TAG 2007-05-16
attila.lendvai@gmail.com**20070516130438] 
Patch bundle hash:
bcc4fa908c8cb1f1b2a850a800ad986962e97b38