remove all defsetf

source/clog-base.lisp

@@ -378,15 +378,14 @@ result or if time out DEFAULT-ANSWER. see JQUERY-QUERY (Internal)"))
   (jquery-query obj (format nil "prop('~A')" property-name)
                 :default-answer default-answer))
 
-(defgeneric set-property (clog-obj property-name value)
+(defgeneric (setf property) (value clog-obj property-name)
   (:documentation "Set html property."))
 
-(defmethod set-property ((obj clog-obj) property-name value)
+(defmethod (setf property) (value (obj clog-obj) property-name)
   (jquery-execute obj (format nil "prop('~A','~A')"
                               property-name
                               (escape-string value)))
   value)
-(defsetf property set-property)
 
 ;;;;;;;;;;;;
 ;; height ;;
@@ -398,13 +397,12 @@ result or if time out DEFAULT-ANSWER. see JQUERY-QUERY (Internal)"))
 (defmethod height ((obj clog-obj))
   (parse-integer (jquery-query obj "height()" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-height (clog-obj value)
+(defgeneric (setf height) (value clog-obj)
   (:documentation "Set height VALUE for CLOG-OBJ"))
 
-(defmethod set-height ((obj clog-obj) value)
+(defmethod (setf height) (value (obj clog-obj))
   (jquery-execute obj (format nil "height('~A')" (escape-string value)))
   value)
-(defsetf height set-height)
 
 ;;;;;;;;;;;
 ;; width ;;
@@ -416,13 +414,12 @@ result or if time out DEFAULT-ANSWER. see JQUERY-QUERY (Internal)"))
 (defmethod width ((obj clog-obj))
   (parse-integer (jquery-query obj "width()" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-width (clog-obj value)
+(defgeneric (setf width) (value clog-obj)
   (:documentation "Set width VALUE for CLOG-OBJ"))
 
-(defmethod set-width ((obj clog-obj) value)
+(defmethod (setf width) (value (obj clog-obj))
   (jquery-execute obj (format nil "width('~A')" (escape-string value)))
   value)
-(defsetf width set-width)
 
 ;;;;;;;;;;;
 ;; focus ;;
@@ -504,24 +501,23 @@ an application share per connection the same queue of serialized events."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defgeneric connection-data-item (clog-obj item-name)
-  (:documentation "Get/Setf from connection-data the item-name in hash."))
+  (:documentation "Get/Setf item-name from connection-data."))
 
 (defmethod connection-data-item ((obj clog-obj) item-name)
   (ignore-errors
    (gethash item-name (connection-data obj))))
 
-(defgeneric set-connection-data-item (clog-obj item-name value)
+(defgeneric (setf connection-data-item) (value clog-obj item-name)
-  (:documentation "Set in connection-data the item-name with value."))
+  (:documentation "Set connection-data item-name with value."))
 
-(defmethod set-connection-data-item ((obj clog-obj) item-name value)
+(defmethod (setf connection-data-item) (value (obj clog-obj) item-name)
   (bordeaux-threads:with-lock-held ((connection-data-mutex obj))
     (ignore-errors
      (setf (gethash item-name (connection-data obj)) value)))
   value)
-(defsetf connection-data-item set-connection-data-item)
 
 (defgeneric remove-connection-data-item (clog-obj item-name)
-  (:documentation "Remove from connection-data the item-name in hash."))
+  (:documentation "Remove item-name from connection-data."))
 
 (defmethod remove-connection-data-item ((obj clog-obj) item-name)
   (bordeaux-threads:with-lock-held ((connection-data-mutex obj))

source/clog-document.lisp

@@ -119,13 +119,12 @@ clog-document object. (Private)"))
 (defmethod title ((obj clog-document))
   (query obj "title"))
 
-(defgeneric set-title (clog-document value))
+(defgeneric (setf title) (value clog-document))
 
-(defmethod set-title ((obj clog-document) value)
+(defmethod (setf title) (value (obj clog-document))
   (execute obj
            (format nil "title='~A'" (clog-connection:escape-string value)))
   value)
-(defsetf title set-title)
 
 ;;;;;;;;;;;;;;;;;;
 ;; document-url ;;

source/clog-element-common.lisp

@@ -65,12 +65,11 @@ place-inside-bottom-of CLOG-OBJ.
 (defmethod link ((obj clog-a))
   (property obj "href"))
 
-(defgeneric set-link (clog-a value)
+(defgeneric (setf link) (value clog-a)
   (:documentation "Set link VALUE for CLOG-A"))
 
-(defmethod set-link ((obj clog-a) value)
+(defmethod (setf link) (value (obj clog-a))
   (setf (property obj "href") value))
-(defsetf link set-link)
 
 ;;;;;;;;;;;;
 ;; target ;;
@@ -82,12 +81,11 @@ place-inside-bottom-of CLOG-OBJ.
 (defmethod target ((obj clog-a))
   (property obj "target"))
 
-(defgeneric set-target (clog-a value)
+(defgeneric (setf target) (value clog-a)
   (:documentation "Set target VALUE for CLOG-A"))
 
-(defmethod set-target ((obj clog-a) value)
+(defmethod (setf targe)t (value (obj clog-a))
   (setf (property obj "target") value))
-(defsetf target set-target)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-br
@@ -167,14 +165,13 @@ CLOG-OBJ"))
 (defmethod disabledp ((obj clog-button))
   (js-true-p (property obj "disabled")))
 
-(defgeneric set-disabledp (clog-button value)
+(defgeneric (setf disabledp) (value clog-button)
   (:documentation "Set editable VALUE for CLOG-BUTTON"))
 
-(defmethod set-disabledp ((obj clog-button) value)
+(defmethod (setf disabledp) (value (obj clog-button))
   (if value
       (setf (property obj "disabled") (p-true-js value))
       (remove-attribute obj "disabled")))
-(defsetf disabledp set-editable)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-div
@@ -259,12 +256,11 @@ firefox and dialog does not work at all on IE."))
 (defmethod return-value ((obj clog-dialog))
   (property obj "returnValue"))
 
-(defgeneric set-return-value (clog-dialog value)
+(defgeneric (setf return-value) (value clog-dialog)
   (:documentation "Set return-value VALUE for CLOG-DIALOG"))
 
-(defmethod set-return-value ((obj clog-dialog) value)
+(defmethod (setf return-value) (value (obj clog-dialog))
   (setf (property obj "returnValue") value))
-(defsetf return-value set-return-value)
 
 ;;;;;;;;;;;;;;;;;;
 ;; dialog-openp ;;
@@ -277,14 +273,13 @@ firefox and dialog does not work at all on IE."))
   (unless (equalp (attribute obj "open") "undefined")
     t))
 
-(defgeneric set-dialog-openp (clog-dialog value)
+(defgeneric (setf dialog-openp) (value clog-dialog)
   (:documentation "Set dialog-openp VALUE for CLOG-DIALOG"))
 
-(defmethod set-dialog-openp ((obj clog-dialog) value)
+(defmethod (setf dialog-openp) (value (obj clog-dialog))
   (if value
       (setf (attribute obj "open") t)
       (remove-attribute obj "open")))
-(defsetf dialog-openp set-dialog-openp)
 
 ;;;;;;;;;;;;;;;;;
 ;; show-dialog ;;
@@ -393,12 +388,11 @@ placing image to constrain image size."))
 (defmethod url-src ((obj clog-img))
   (property obj "src"))
 
-(defgeneric set-url-src (clog-img value)
+(defgeneric (setf url-src) (value clog-img)
   (:documentation "Set url-src VALUE for CLOG-IMG"))
 
-(defmethod set-url-src ((obj clog-img) value)
+(defmethod (setf url-src) (value (obj clog-img))
   (setf (property obj "src") value))
-(defsetf url-src set-url-src)
 
 ;;;;;;;;;;;;;;
 ;; alt-text ;;
@@ -410,12 +404,11 @@ placing image to constrain image size."))
 (defmethod alt-text ((obj clog-img))
   (attribute obj "alt"))
 
-(defgeneric set-alt-text (clog-img value)
+(defgeneric (setf alt-text) (value clog-img)
   (:documentation "Set alt-text VALUE for CLOG-IMG"))
 
-(defmethod set-alt-text ((obj clog-img) value)
+(defmethod (setf alt-text) (value (obj clog-img))
   (setf (attribute obj "alt") value))
-(defsetf alt-text set-alt-text)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-meter
@@ -472,9 +465,8 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod value ((obj clog-meter))
   (property obj "value"))
 
-(defmethod set-value ((obj clog-meter) value)
+(defmethod (setf value) (value (obj clog-meter))
   (setf (property obj "value") value))
-(defsetf value set-value)
 
 ;;;;;;;;;;;;;;;;
 ;; text-value ;;
@@ -496,12 +488,11 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod high ((obj clog-meter))
   (property obj "high"))
 
-(defgeneric set-high (clog-meter high)
+(defgeneric (setf high) (high clog-meter)
-  (:documentation "Set high HIGH for CLOG-METER"))
+  (:documentation "Set HIGH for CLOG-METER"))
 
-(defmethod set-high ((obj clog-meter) high)
+(defmethod (setf high) (high (obj clog-meter))
   (setf (property obj "high") high))
-(defsetf high set-high)
 
 ;;;;;;;;;
 ;; low ;;
@@ -513,12 +504,11 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod low ((obj clog-meter))
   (property obj "low"))
 
-(defgeneric set-low (clog-meter low)
+(defgeneric (setf low) (low clog-meter)
-  (:documentation "Set low LOW for CLOG-METER"))
+  (:documentation "Set LOW for CLOG-METER"))
 
-(defmethod set-low ((obj clog-meter) low)
+(defmethod (setf low) (low (obj clog-meter))
   (setf (property obj "low") low))
-(defsetf low set-low)
 
 ;;;;;;;;;;;;;
 ;; maximum ;;
@@ -530,12 +520,11 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod maximum ((obj clog-meter))
   (property obj "max"))
 
-(defgeneric set-maximum (clog-meter maximum)
+(defgeneric (setf maximum) (maximum clog-meter)
   (:documentation "Set maximum MAXIMUM for CLOG-METER"))
 
-(defmethod set-maximum ((obj clog-meter) maximum)
+(defmethod (setf maximum) (maximum (obj clog-meter))
   (setf (property obj "max") maximum))
-(defsetf maximum set-maximum)
 
 ;;;;;;;;;;;;;
 ;; minimum ;;
@@ -547,12 +536,12 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod minimum ((obj clog-meter))
   (property obj "min"))
 
-(defgeneric set-minimum (clog-meter minimum)
+(defgeneric (setf minimum) (minimum clog-meter)
   (:documentation "Set minimum MINIMUM for CLOG-METER"))
 
-(defmethod set-minimum ((obj clog-meter) minimum)
+(defmethod (setf minimum) (minimum (obj clog-meter))
   (setf (property obj "min") minimum))
-(defsetf minimum set-minimum)
+
 
 ;;;;;;;;;;;;;
 ;; optimum ;;
@@ -564,12 +553,11 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod optimum ((obj clog-meter))
   (property obj "optimum"))
 
-(defgeneric set-optimum (clog-meter optimum)
+(defgeneric (setf optimum) (optimum clog-meter)
   (:documentation "Set optimum OPTIMUM for CLOG-METER"))
 
-(defmethod set-optimum ((obj clog-meter) optimum)
+(defmethod (setf optimum) (optimum (obj clog-meter))
   (setf (property obj "optimum") optimum))
-(defsetf optimum set-optimum)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-progress-bar
@@ -616,9 +604,8 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod value ((obj clog-progress-bar))
   (property obj "value"))
 
-(defmethod set-value ((obj clog-progress-bar) value)
+(defmethod (setf value) (value (obj clog-progress-bar))
   (setf (property obj "value") value))
-(defsetf value set-value)
 
 ;;;;;;;;;;;;;;;;
 ;; text-value ;;
@@ -640,12 +627,11 @@ place-inside-bottom-of CLOG-OBJ."))
 (defmethod maximum ((obj clog-progress-bar))
   (property obj "max"))
 
-(defgeneric set-maximum (clog-progress-bar maximum)
+(defgeneric (setf maximum) (maximum clog-progress-bar)
   (:documentation "Set maximum MAXIMUM for CLOG-PROGRESS-BAR"))
 
-(defmethod set-maximum ((obj clog-progress-bar) maximum)
+(defmethod (setf maximum) (maximum (obj clog-progress-bar))
   (setf (property obj "max") maximum))
-(defsetf maximum set-maximum)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-p
@@ -877,12 +863,11 @@ LIST-KIND-TYPE -
 (defmethod list-kind ((obj clog-ordered-list))
   (style obj "list-style-type"))
 
-(defgeneric set-list-kind (clog-ordered-list value)
+(defgeneric (setf list-kind) (value clog-ordered-list)
   (:documentation "Set list-kind VALUE for  CLOG-ORDERED-LIST"))
 
-(defmethod set-list-kind ((obj clog-ordered-list) value)
+(defmethod (setf list-kind) (value (obj clog-ordered-list))
   (setf (style obj "list-style-type") value))
-(defsetf list-kind set-list-kind)
 
 ;;;;;;;;;;;;;;;;;;;
 ;; list-location ;;
@@ -897,12 +882,11 @@ Default is outside."))
 (defmethod list-location ((obj clog-ordered-list))
   (style obj "list-style-position"))
 
-(defgeneric set-list-location (clog-ordered-list value)
+(defgeneric (setf list-location) (value clog-ordered-list)
   (:documentation "Set list-location VALUE for CLOG-ORDERED-LIST"))
 
-(defmethod set-list-location ((obj clog-ordered-list) value)
+(defmethod (setf list-location) (value (obj clog-ordered-list))
   (setf (style obj "list-style-position") value))
-(defsetf list-location set-list-location)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-unordered-list
@@ -982,12 +966,11 @@ and if :AUTO-PLACE (default t) place-inside-bottom-of CLOG-OBJ"))
 (defmethod item-value ((obj clog-list-item))
   (property obj "value"))
 
-(defgeneric set-item-value (clog-list-item value)
+(defgeneric (setf item-value) (value clog-list-item)
   (:documentation "Set item-value VALUE for  CLOG-LIST-ITEM"))
 
-(defmethod set-item-value ((obj clog-list-item) value)
+(defmethod (setf item-value) (value (obj clog-list-item))
   (setf (property obj "value") value))
-(defsetf item-value set-item-value)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-definition-list
@@ -1494,14 +1477,13 @@ CLOG-OBJ. If hidden is true visiblep is set to nil."))
   (unless (equalp (attribute obj "open") "undefined")
     t))
 
-(defgeneric set-details-openp (clog-details value)
+(defgeneric (setf details-openp) (value clog-details)
   (:documentation "Set details-openp VALUE for CLOG-DETAILS"))
 
-(defmethod set-details-openp ((obj clog-details) value)
+(defmethod (setf details-openp) (value (obj clog-details))
   (if value
       (setf (attribute obj "open") t)
       (remove-attribute obj "open")))
-(defsetf details-openp set-details-openp)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-summary

source/clog-form.lisp

@@ -142,14 +142,13 @@ doing file upload use multipart/form-data"))
 (defmethod autocompletep ((obj clog-form))
   (js-on-p (property obj "autocompletep")))
 
-(defgeneric set-autocompletep (clog-form autocompletep)
+(defgeneric (setf autocompletep) (autocompletep clog-form)
   (:documentation "Set autocompletep for CLOG-FORM"))
 
-(defmethod set-autocompletep ((obj clog-form) autocompletep)
+(defmethod (setf autocompletep) (autocompletep (obj clog-form))
   (if autocompletep
       (setf (attribute obj "autocomplete") "true")
       (remove-attribute obj "autocomplete")))
-(defsetf autocompletep set-autocompletep)
 
 ;;;;;;;;;;;;;;
 ;; encoding ;;
@@ -164,12 +163,11 @@ doing file upload use multipart/form-data"))
 (defmethod encoding ((obj clog-form))
   (property obj "encoding"))
 
-(defgeneric set-encoding (clog-form encoding)
+(defgeneric (setf encoding) (encoding clog-form)
   (:documentation "Set encoding for CLOG-FORM"))
 
-(defmethod set-encoding ((obj clog-form) encoding)
+(defmethod (setf encoding) (encoding (obj clog-form))
   (setf (property obj "encoding") encoding))
-(defsetf encoding set-encoding)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;
 ;; validate-on-submit ;;
@@ -181,14 +179,13 @@ doing file upload use multipart/form-data"))
 (defmethod validate-on-submit ((obj clog-form))
   (not (js-true-p (property obj "noValidate"))))
 
-(defgeneric set-validate-on-submit (clog-form value)
+(defgeneric (setf validate-on-submit) (value clog-form)
   (:documentation "Set VALIDATE-ON-SUBMIT for CLOG-FORM"))
 
-(defmethod set-validate-on-submit ((obj clog-form) value)
+(defmethod (setf validate-on-submit) (value (obj clog-form))
   (if (not value)
       (setf (attribute obj "noValidate") "true")
       (remove-attribute obj "noValidate")))
-(defsetf validate-on-submit set-validate-on-submit)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-form-clement
@@ -252,14 +249,13 @@ clog-form in the DOM. The radio ELEMENT-TYPE groups by NAME."))
 (defmethod autocomplete ((obj clog-form-element))
   (property obj "autocomplete"))
 
-(defgeneric set-autocomplete (clog-form-element value)
+(defgeneric (setf autocomplete) (value clog-form-element)
   (:documentation "Set autocomplete AUTOCOMPLETE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-autocomplete ((obj clog-form-element) value)
+(defmethod (setf autocomplete) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "autocomplete") "true")
       (remove-attribute obj "autocomplete")))
-(defsetf autocomplete set-autocomplete)
 
 ;;;;;;;;;;;;;;;;
 ;; autofocusp ;;
@@ -272,14 +268,13 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod autofocusp ((obj clog-form-element))
   (js-true-p (attribute obj "autofocus")))
 
-(defgeneric set-autofocusp (clog-form-element value)
+(defgeneric (setf autofocusp) (value clog-form-element)
   (:documentation "Set autofocusp AUTOFOCUSP for CLOG-FORM-ELEMENT"))
 
-(defmethod set-autofocusp ((obj clog-form-element) value)
+(defmethod (setf autofocusp) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "autofocus") "true")
       (remove-attribute obj "autofocus")))
-(defsetf autofocusp set-autofocusp)
 
 ;;;;;;;;;;;;;;;;;;
 ;; place-holder ;;
@@ -291,12 +286,11 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod place-holder ((obj clog-form-element))
   (property obj "placeholder"))
 
-(defgeneric set-place-holder (clog-form-element value)
+(defgeneric (setf place-holder) (value clog-form-element)
   (:documentation "Set placeholder PLACE-HOLDER for CLOG-FORM-ELEMENT"))
 
-(defmethod set-place-holder ((obj clog-form-element) value)
+(defmethod (setf place-holder) (value (obj clog-form-element))
   (setf (property obj "placeholder") value))
-(defsetf place-holder set-place-holder)
 
 ;;;;;;;;;;;;;;;
 ;; disabledp ;;
@@ -308,14 +302,13 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod disabledp ((obj clog-form-element))
   (js-true-p (property obj "disabled")))
 
-(defgeneric set-disabledp (clog-form-element value)
+(defgeneric (setf disabledp) (value clog-form-element)
   (:documentation "Set disabledp DISABLEDP for CLOG-FORM-ELEMENT"))
 
-(defmethod set-disabledp ((obj clog-form-element) value)
+(defmethod (setf disabledp) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "disabled") "true")
       (remove-attribute obj "disabled")))
-(defsetf disabledp set-disabledp)
 
 ;;;;;;;;;;;;;;;;;
 ;; read-only-p ;;
@@ -327,14 +320,13 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod read-only-p ((obj clog-form-element))
   (js-true-p (property obj "readonly")))
 
-(defgeneric set-read-only-p (clog-form-element value)
+(defgeneric (setf read-only-p) (value clog-form-element)
   (:documentation "Set read-only-p READ-ONLY-P for CLOG-FORM-ELEMENT"))
 
-(defmethod set-read-only-p ((obj clog-form-element) value)
+(defmethod (setf read-only-p) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "readonly") "true")
       (remove-attribute obj "readonly")))
-(defsetf read-only-p set-read-only-p)
 
 ;;;;;;;;;;;;;;;
 ;; requiredp ;;
@@ -346,14 +338,13 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod requiredp ((obj clog-form-element))
   (js-true-p (property obj "required")))
 
-(defgeneric set-requiredp (clog-form-element value)
+(defgeneric (setf requiredp) (value clog-form-element)
   (:documentation "Set requiredp REQUIREDP for CLOG-FORM-ELEMENT"))
 
-(defmethod set-requiredp ((obj clog-form-element) value)
+(defmethod (setf requiredp) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "required") "true")
       (remove-attribute obj "required")))
-(defsetf requiredp set-requiredp)
 
 ;;;;;;;;;;;;;;;
 ;; multiplep ;;
@@ -365,14 +356,13 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod multiplep ((obj clog-form-element))
   (js-true-p (property obj "multiple")))
 
-(defgeneric set-multiplep (clog-form-element value)
+(defgeneric (setf multiplep) (value clog-form-element)
   (:documentation "Set multiplep MULTIPLEP for CLOG-FORM-ELEMENT"))
 
-(defmethod set-multiplep ((obj clog-form-element) value)
+(defmethod (setf multiplep) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "multiple") "true")
       (remove-attribute obj "multiple")))
-(defsetf multiplep set-multiplep)
 
 ;;;;;;;;;;
 ;; name ;;
@@ -388,12 +378,11 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod name ((obj clog-form-element))
   (property obj "name"))
 
-(defgeneric set-name (clog-form-element value)
+(defgeneric (setf name) (value clog-form-element)
   (:documentation "Set name VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-name ((obj clog-form-element) value)
+(defmethod (setf name) (value (obj clog-form-element))
   (setf (property obj "name") value))
-(defsetf name set-name)
 
 ;;;;;;;;;;;;;;;;;;;
 ;; default-value ;;
@@ -407,12 +396,11 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod default-value ((obj clog-form-element))
   (property obj "defaultValue"))
 
-(defgeneric set-default-value (clog-form-element value)
+(defgeneric (setf default-value) (value clog-form-element)
   (:documentation "Set default-value VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-default-value ((obj clog-form-element) value)
+(defmethod (setf default-value) (value (obj clog-form-element))
   (setf (property obj "defaultValue") value))
-(defsetf default-value set-default-value)
 
 ;;;;;;;;;;;
 ;; value ;;
@@ -426,12 +414,11 @@ have this set true ever. Autofocus on element when form loaded."))
 (defmethod value ((obj clog-form-element))
   (property obj "value"))
 
-(defgeneric set-value (clog-form-element value)
+(defgeneric (setf value) (value clog-form-element)
   (:documentation "Set value VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-value ((obj clog-form-element) value)
+(defmethod (setf value) (value (obj clog-form-element))
   (setf (property obj "value") value))
-(defsetf value set-value)
 
 ;; overloading of text-value to equal value on forms
 
@@ -506,12 +493,11 @@ be unique name on entire document."))
 (defmethod pattern ((obj clog-form-element))
   (property obj "pattern"))
 
-(defgeneric set-pattern (clog-form-element value)
+(defgeneric (setf pattern) (value clog-form-element)
   (:documentation "Set pattern VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-pattern ((obj clog-form-element) value)
+(defmethod (setf pattern) (value (obj clog-form-element))
   (setf (property obj "pattern") value))
-(defsetf pattern set-pattern)
 
 ;;;;;;;;;;;;;
 ;; minimum ;;
@@ -523,12 +509,11 @@ be unique name on entire document."))
 (defmethod minimum ((obj clog-form-element))
   (property obj "min"))
 
-(defgeneric set-minimum (clog-form-element value)
+(defgeneric (setf minimum) (value clog-form-element)
   (:documentation "Set minimum VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-minimum ((obj clog-form-element) value)
+(defmethod (setf minimum) (value (obj clog-form-element))
   (setf (property obj "min") value))
-(defsetf minimum set-minimum)
 
 ;;;;;;;;;;;;;
 ;; maximum ;;
@@ -540,12 +525,11 @@ be unique name on entire document."))
 (defmethod maximum ((obj clog-form-element))
   (property obj "max"))
 
-(defgeneric set-maximum (clog-form-element value)
+(defgeneric (setf maximum) (value clog-form-element)
   (:documentation "Set maximum VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-maximum ((obj clog-form-element) value)
+(defmethod (setf maximum) (value (obj clog-form-element))
   (setf (property obj "max") value))
-(defsetf maximum set-maximum)
 
 ;;;;;;;;;;;;;;;;;;
 ;; element-step ;;
@@ -557,12 +541,11 @@ be unique name on entire document."))
 (defmethod element-step ((obj clog-form-element))
   (property obj "step"))
 
-(defgeneric set-element-step (clog-form-element value)
+(defgeneric (setf element-step) (value clog-form-element)
   (:documentation "Set element-step VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-element-step ((obj clog-form-element) value)
+(defmethod (setf element-step) (value (obj clog-form-element))
   (setf (property obj "step") value))
-(defsetf element-step set-element-step)
 
 ;;;;;;;;;;
 ;; size ;;
@@ -574,12 +557,11 @@ be unique name on entire document."))
 (defmethod size ((obj clog-form-element))
   (property obj "size"))
 
-(defgeneric set-size (clog-form-element value)
+(defgeneric (setf size) (value clog-form-element)
   (:documentation "Set size VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-size ((obj clog-form-element) value)
+(defmethod (setf size) (value (obj clog-form-element))
   (setf (property obj "size") value))
-(defsetf size set-size)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; minimum-length ;;
@@ -591,12 +573,11 @@ be unique name on entire document."))
 (defmethod minimum-length ((obj clog-form-element))
   (property obj "minlength"))
 
-(defgeneric set-minimum-length (clog-form-element value)
+(defgeneric (setf minimum-length) (value clog-form-element)
   (:documentation "Set minimum-length VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-minimum-length ((obj clog-form-element) value)
+(defmethod (setf minimum-length) (value (obj clog-form-element))
   (setf (property obj "minlength") value))
-(defsetf minimum-length set-minimum-length)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; maximum-length ;;
@@ -608,12 +589,11 @@ be unique name on entire document."))
 (defmethod maximum-length ((obj clog-form-element))
   (property obj "maxlength"))
 
-(defgeneric set-maximum-length (clog-form-element value)
+(defgeneric (setf maximum-length) (value clog-form-element)
   (:documentation "Set maximum-length VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-maximum-length ((obj clog-form-element) value)
+(defmethod (setf maximum-length) (value (obj clog-form-element))
   (setf (property obj "maxlength") value))
-(defsetf maximum-length set-maximum-length)
 
 ;;;;;;;;;;;;
 ;; select ;;
@@ -657,12 +637,11 @@ the File form element type.
 (defmethod file-accept ((obj clog-form-element))
   (attribute obj "accept"))
 
-(defgeneric set-file-accept (clog-form-element value)
+(defgeneric (setf file-accept) (value clog-form-element)
   (:documentation "Set file-accept VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-file-accept ((obj clog-form-element) value)
+(defmethod (setf file-accept) (value (obj clog-form-element))
   (setf (attribute obj "accept") value))
-(defsetf file-accept set-file-accept)
 
 ;;;;;;;;;;;;;
 ;; url-src ;;
@@ -674,12 +653,11 @@ the File form element type.
 (defmethod url-src ((obj clog-form-element))
   (property obj "src"))
 
-(defgeneric set-url-src (clog-form-element value)
+(defgeneric (setf url-src) (value clog-form-element)
   (:documentation "Set url-src VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-url-src ((obj clog-form-element) value)
+(defmethod (setf url-src) (value (obj clog-form-element))
   (setf (property obj "src") value))
-(defsetf url-src set-url-src)
 
 ;;;;;;;;;;;;;;
 ;; alt-text ;;
@@ -691,12 +669,11 @@ the File form element type.
 (defmethod alt-text ((obj clog-form-element))
   (attribute obj "alt"))
 
-(defgeneric set-alt-text (clog-form-element value)
+(defgeneric (setf alt-text) (value clog-form-element)
   (:documentation "Set alt-text VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-alt-text ((obj clog-form-element) value)
+(defmethod (setf alt-text) (value (obj clog-form-element))
   (setf (attribute obj "alt") value))
-(defsetf alt-text set-alt-text)
 
 ;;;;;;;;;;;;;;
 ;; checkedp ;;
@@ -708,14 +685,13 @@ the File form element type.
 (defmethod checkedp ((obj clog-form-element))
   (js-true-p (property obj "checked")))
 
-(defgeneric set-checkedp (clog-form-element value)
+(defgeneric (setf checkedp) (value clog-form-element)
   (:documentation "Set VALUE if checkedp for CLOG-FORM-ELEMENT"))
 
-(defmethod set-checkedp ((obj clog-form-element) value)
+(defmethod (setf checkedp) (value (obj clog-form-element))
   (if value
       (setf (attribute obj "checked") "true")
       (remove-attribute obj "checked")))
-(defsetf checkedp set-checkedp)
 
 ;;;;;;;;;;;;;;;;
 ;; input-mode ;;
@@ -731,12 +707,11 @@ virtual keyboards."))
 (defmethod input-mode ((obj clog-form-element))
   (attribute obj "inputmode"))
 
-(defgeneric set-input-mode (clog-form-element value)
+(defgeneric (setf input-mode) (value clog-form-element)
   (:documentation "Set input-mode VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-input-mode ((obj clog-form-element) value)
+(defmethod (setf input-mode) (value (obj clog-form-element))
   (setf (attribute obj "inputmode") value))
-(defsetf input-mode set-input-mode)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-label
@@ -878,12 +853,11 @@ virtual keyboards."))
 (defmethod word-wrap ((obj clog-text-area))
   (property obj "wrap"))
 
-(defgeneric set-word-wrap (clog-text-area value)
+(defgeneric (setf word-wrap) (value clog-text-area)
   (:documentation "Set word-wrap WORD-WRAP for CLOG-TEXT-AREA"))
 
-(defmethod set-word-wrap ((obj clog-text-area) value)
+(defmethod (setf word-wrap) (value (obj clog-text-area))
   (setf (property obj "wrap") value))
-(defsetf word-wrap set-word-wrap)
 
 ;;;;;;;;;;;;;;;
 ;; word-wrap ;;
@@ -895,12 +869,11 @@ virtual keyboards."))
 (defmethod word-wrap ((obj clog-text-area))
   (property obj "wrap"))
 
-(defgeneric set-word-wrap (clog-text-area value)
+(defgeneric (setf word-wrap) (value clog-text-area)
   (:documentation "Set word-wrap WORD-WRAP for CLOG-TEXT-AREA"))
 
-(defmethod set-word-wrap ((obj clog-text-area) value)
+(defmethod (setf word-wrap) (value (obj clog-text-area))
   (setf (property obj "wrap") value))
-(defsetf word-wrap set-word-wrap)
 
 ;;;;;;;;;;;;;
 ;; columns ;;
@@ -912,12 +885,11 @@ virtual keyboards."))
 (defmethod columns ((obj clog-text-area))
   (property obj "cols"))
 
-(defgeneric set-columns (clog-text-area value)
+(defgeneric (setf columns) (value clog-text-area)
   (:documentation "Set columns COLUMNS for CLOG-TEXT-AREA"))
 
-(defmethod set-columns ((obj clog-text-area) value)
+(defmethod (setf columns) (value (obj clog-text-area))
   (setf (property obj "cols") value))
-(defsetf columns set-columns)
 
 ;;;;;;;;;;
 ;; rows ;;
@@ -929,12 +901,11 @@ virtual keyboards."))
 (defmethod rows ((obj clog-text-area))
   (property obj "rows"))
 
-(defgeneric set-rows (clog-text-area value)
+(defgeneric (setf rows) (value clog-text-area)
   (:documentation "Set rows ROWS for CLOG-TEXT-AREA"))
 
-(defmethod set-rows ((obj clog-text-area) value)
+(defmethod (setf rows) (value (obj clog-text-area))
   (setf (property obj "rows") value))
-(defsetf rows set-rows)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; disable-resize ;;
@@ -1172,12 +1143,11 @@ or CLOG Data-List objects."));
 (defmethod selectedp ((obj clog-form-element))
   (js-true-p (property obj "selected")))
 
-(defgeneric set-selectedp (clog-form-element value)
+(defgeneric (setf selectedp) (value clog-form-element)
   (:documentation "Set selectedp VALUE for CLOG-FORM-ELEMENT"))
 
-(defmethod set-selectedp ((obj clog-form-element) value)
+(defmethod (setf selectedp) (value (obj clog-form-element))
   (setf (property obj "selected") (p-true-js value)))
-(defsetf selectedp set-selectedp)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-optgroup

source/clog-gui.lisp

@@ -219,13 +219,12 @@ create-gui-menu-bar."))
   (let ((app (connection-data-item obj "clog-gui")))
     (menu app)))
 
-(defgeneric set-menu-bar (clog-obj value)
+(defgeneric (setf menu-bar) (value clog-obj)
   (:documentation "Set window menu-bar"))
 
-(defmethod set-menu-bar ((obj clog-obj) value)
+(defmethod (setf menu-bar) (value (obj clog-obj))
   (let ((app (connection-data-item obj "clog-gui")))
     (setf (menu app) value)))
-(defsetf menu-bar set-menu-bar)
 
 ;;;;;;;;;;;;;;;;;;;;;
 ;; menu-bar-height ;;
@@ -827,14 +826,13 @@ the window will be set to keep-on-top always."))
 (defmethod window-title ((obj clog-gui-window))
   (inner-html (win-title obj)))
 
-(defgeneric set-window-title (clog-gui-window value)
+(defgeneric (setf window-title) (value clog-gui-window)
   (:documentation "Set window title"))
 
-(defmethod set-window-title ((obj clog-gui-window) value)
+(defmethod (setf window-title) (value (obj clog-gui-window))
   (when (window-select-item obj)
     (setf (inner-html (window-select-item obj)) value))
   (setf (inner-html (win-title obj)) value))
-(defsetf window-title set-window-title)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; window-content ;;

source/clog-location.lisp

@@ -8,7 +8,6 @@
 
 (cl:in-package :clog)
 
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Implementation - clog-location
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -34,12 +33,11 @@
 (defmethod url ((obj clog-location))
   (property obj "href"))
 
-(defgeneric set-url (clog-location value)
+(defgeneric (setf url) (value clog-location)
   (:documentation "Set url VALUE for CLOG-LOCATION"))
 
-(defmethod set-url ((obj clog-location) value)
+(defmethod (setf url) (value (obj clog-location))
   (setf (property obj "href") value))
-(defsetf url set-url)
 
 ;;;;;;;;;;
 ;; hash ;;
@@ -51,12 +49,11 @@
 (defmethod hash ((obj clog-location))
   (property obj "hash"))
 
-(defgeneric set-hash (clog-location value)
+(defgeneric (setf hash) (value clog-location)
   (:documentation "Set hash VALUE for CLOG-LOCATION"))
 
-(defmethod set-hash ((obj clog-location) value)
+(defmethod (setf hash) (value (obj clog-location))
   (setf (property obj "hash") value))
-(defsetf hash set-hash)
 
 ;;;;;;;;;;
 ;; host ;;
@@ -68,12 +65,11 @@
 (defmethod host ((obj clog-location))
   (property obj "host"))
 
-(defgeneric set-host (clog-location value)
+(defgeneric (setf host) (value clog-location)
   (:documentation "Set host VALUE for CLOG-LOCATION"))
 
-(defmethod set-host ((obj clog-location) value)
+(defmethod (setf host) (value (obj clog-location))
   (setf (property obj "host") value))
-(defsetf host set-host)
 
 ;;;;;;;;;;;;;;;
 ;; host-name ;;
@@ -85,12 +81,11 @@
 (defmethod host-name ((obj clog-location))
   (property obj "hostname"))
 
-(defgeneric set-host-name (clog-location value)
+(defgeneric (setf host-name) (value clog-location)
   (:documentation "Set host-name VALUE for CLOG-LOCATION"))
 
-(defmethod set-host-name ((obj clog-location) value)
+(defmethod (setf host-name) (value (obj clog-location))
   (setf (property obj "hostname") value))
-(defsetf host-name set-host-name)
 
 ;;;;;;;;;;;;
 ;; origin ;;
@@ -112,12 +107,11 @@
 (defmethod path-name ((obj clog-location))
   (property obj "pathname"))
 
-(defgeneric set-path-name (clog-location value)
+(defgeneric (setf path-name) (value clog-location)
   (:documentation "Set path-name VALUE for CLOG-LOCATION"))
 
-(defmethod set-path-name ((obj clog-location) value)
+(defmethod (setf path-name) (value (obj clog-location))
   (setf (property obj "pathname") value))
-(defsetf path-name set-path-name)
 
 ;;;;;;;;;;
 ;; port ;;
@@ -129,12 +123,11 @@
 (defmethod port ((obj clog-location))
   (property obj "port"))
 
-(defgeneric set-port (clog-location value)
+(defgeneric (setf port) (value clog-location)
   (:documentation "Set port VALUE for CLOG-LOCATION"))
 
-(defmethod set-port ((obj clog-location) value)
+(defmethod (setf port) (value (obj clog-location))
   (setf (property obj "port") value))
-(defsetf port set-port)
 
 ;;;;;;;;;;;;;;
 ;; protocol ;;
@@ -146,12 +139,11 @@
 (defmethod protocol ((obj clog-location))
   (property obj "protocol"))
 
-(defgeneric set-protocol (clog-location value)
+(defgeneric (setf protocol) (value clog-location)
   (:documentation "Set protocol VALUE for CLOG-LOCATION"))
 
-(defmethod set-protocol ((obj clog-location) value)
+(defmethod (setf protocol) (value (obj clog-location))
   (setf (property obj "protocol") value))
-(defsetf protocol set-protocol)
 
 ;;;;;;;;;;;;;;;;
 ;; url-search ;;
@@ -163,12 +155,11 @@
 (defmethod url-search ((obj clog-location))
   (property obj "search"))
 
-(defgeneric set-url-search (clog-location value)
+(defgeneric (setf url-search) (value clog-location)
   (:documentation "Set url-search VALUE for CLOG-LOCATION"))
 
-(defmethod set-url-search ((obj clog-location) value)
+(defmethod (setf url-search) (value (obj clog-location))
   (setf (property obj "search") value))
-(defsetf url-search set-url-search)
 
 ;;;;;;;;;;;;
 ;; reload ;;

source/clog-multimedia.lisp

@@ -29,12 +29,11 @@
 (defmethod loop-mediap ((obj clog-multimedia))
   (js-true-p (property obj "loop")))
 
-(defgeneric set-loop-mediap (clog-multimedia value)
+(defgeneric (setf loop-mediap) (value clog-multimedia)
   (:documentation "Set loop-media VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-loop-mediap ((obj clog-multimedia) value)
+(defmethod (setf loop-mediap) (value (obj clog-multimedia))
   (setf (property obj "loop") (p-true-js value)))
-(defsetf loop-mediap set-loop-mediap)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; media-duration ;;
@@ -56,12 +55,11 @@
 (defmethod media-source ((obj clog-multimedia))
   (property obj "src"))
 
-(defgeneric set-media-source (clog-multimedia value)
+(defgeneric (setf media-source) (value clog-multimedia)
   (:documentation "Set media source VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-media-source ((obj clog-multimedia) value)
+(defmethod (setf media-source) (value (obj clog-multimedia))
   (setf (property obj "src") value))
-(defsetf media-source set-media-source)
 
 ;;;;;;;;;;;;;;;;;;;;
 ;; media-position ;;
@@ -73,12 +71,11 @@
 (defmethod media-position ((obj clog-multimedia))
   (parse-float (property obj "currentTime" :default-answer 0) :type 'double-float :junk-allowed t))
 
-(defgeneric set-media-position (clog-multimedia value)
+(defgeneric (setf media-position) (value clog-multimedia)
   (:documentation "Set media source VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-media-position ((obj clog-multimedia) value)
+(defmethod (setf media-position) (value (obj clog-multimedia))
   (setf (property obj "currentTime") value))
-(defsetf media-position set-media-position)
 
 ;;;;;;;;;;;;
 ;; mutedp ;;
@@ -90,12 +87,11 @@
 (defmethod mutedp ((obj clog-multimedia))
   (js-true-p (property obj "muted")))
 
-(defgeneric set-mutedp (clog-multimedia value)
+(defgeneric (setf mutedp) (value clog-multimedia)
   (:documentation "Set muted VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-mutedp ((obj clog-multimedia) value)
+(defmethod (setf mutedp) (value (obj clog-multimedia))
   (setf (property obj "muted") (p-true-js value)))
-(defsetf mutedp set-mutedp)
 
 ;;;;;;;;;;;;;
 ;; pausedp ;;
@@ -139,12 +135,11 @@ Common values - 1.0 normal, 0.5 half speed, -1.0 reverse"))
 (defmethod playback-rate ((obj clog-multimedia))
   (property obj "playbackRate"))
 
-(defgeneric set-playback-rate (clog-multimedia value)
+(defgeneric (setf playback-rate) (value clog-multimedia)
   (:documentation "Set media source VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-playback-rate ((obj clog-multimedia) value)
+(defmethod (setf playback-rate) (value (obj clog-multimedia))
   (setf (property obj "playbackRate") value))
-(defsetf playback-rate set-playback-rate)
 
 ;;;;;;;;;;;;;;;;;;;;;
 ;; ready-to-play-p ;;
@@ -167,12 +162,11 @@ duration."))
 (defmethod media-volume ((obj clog-multimedia))
   (parse-float (property obj "volume" :default-answer 0) :type 'double-float :junk-allowed t))
 
-(defgeneric set-media-volume (clog-multimedia value)
+(defgeneric (setf media-volume) (value clog-multimedia)
   (:documentation "Set media source VALUE for CLOG-MULTIMEDIA"))
 
-(defmethod set-media-volume ((obj clog-multimedia) value)
+(defmethod (setf media-volume) (value (obj clog-multimedia))
   (setf (property obj "volume") value))
-(defsetf media-volume set-media-volume)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Methods - clog-multimedia

source/clog-web.lisp

@@ -172,13 +172,12 @@ create-web-menu-bar."))
   (let ((app (connection-data-item obj "clog-web")))
     (web-menu app)))
 
-(defgeneric set-web-menu-bar (clog-obj value)
+(defgeneric (setf web-menu-bar) (value clog-obj)
   (:documentation "Set window web-menu-bar"))
 
-(defmethod set-web-menu-bar ((obj clog-obj) value)
+(defmethod (setf web-menu-bar) (value (obj clog-obj))
   (let ((app (connection-data-item obj "clog-web")))
     (setf (web-menu app) value)))
-(defsetf web-menu-bar set-web-menu-bar)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; web-menu-bar-height ;;

source/clog-window.lisp

@@ -34,12 +34,11 @@ window."))
 (defmethod window-name ((obj clog-window))
   (query obj "name"))
 
-(defgeneric set-window-name (clog-window value))
+(defgeneric (setf window-name) (value clog-window))
 
-(defmethod set-window-name ((obj clog-window) value)
+(defmethod (setf window-name) (value (obj clog-window))
   (execute obj (format nil "name='~A'" (escape-string value)))
   value)
-(defsetf window-name set-window-name)
 
 ;;;;;;;;;;;;;;;;
 ;; status-bar ;;
@@ -51,12 +50,11 @@ window."))
 (defmethod status-bar ((obj clog-window))
   (query obj "status"))
 
-(defgeneric set-status-bar (clog-window value))
+(defgeneric (setf status-bar) (value clog-window))
 
-(defmethod set-status-bar ((obj clog-window) value)
+(defmethod (setf status-bar) (value (obj clog-window))
   (execute obj (format nil "status='~A'" (escape-string value)))
   value)
-(defsetf status-bar set-status-bar)
 
 ;;;;;;;;;;;;;;;;;;
 ;; inner-height ;;
@@ -68,12 +66,11 @@ window."))
 (defmethod inner-height ((obj clog-window))
   (parse-integer (query obj "innerHeight" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-inner-height (clog-window value))
+(defgeneric (setf inner-height) (value clog-window))
 
-(defmethod set-inner-height ((obj clog-window) value)
+(defmethod (setf inner-height) (value (obj clog-window))
   (execute obj (format nil "innerHeight='~A'" (escape-string value)))
   value)
-(defsetf inner-height set-inner-height)
 
 ;;;;;;;;;;;;;;;;;
 ;; inner-width ;;
@@ -85,12 +82,11 @@ window."))
 (defmethod inner-width ((obj clog-window))
   (parse-integer (query obj "innerWidth" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-inner-width (clog-window value))
+(defgeneric (setf inner-width) (value clog-window))
 
-(defmethod set-inner-width ((obj clog-window) value)
+(defmethod (setf inner-width) (value (obj clog-window))
   (execute obj (format nil "innerWidth='~A'" (escape-string value)))
   value)
-(defsetf inner-width set-inner-width)
 
 ;;;;;;;;;;;;;;;;;;
 ;; outer-height ;;
@@ -102,12 +98,11 @@ window."))
 (defmethod outer-height ((obj clog-window))
   (parse-integer (query obj "outerHeight" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-outer-height (clog-window value))
+(defgeneric (setf outer-height) (value clog-window))
 
-(defmethod set-outer-height ((obj clog-window) value)
+(defmethod (setf outer-height) (value (obj clog-window))
   (execute obj (format nil "outerHeight='~A'" (escape-string value)))
   value)
-(defsetf outer-height set-outer-height)
 
 ;;;;;;;;;;;;;;;;;
 ;; outer-width ;;
@@ -119,12 +114,11 @@ window."))
 (defmethod outer-width ((obj clog-window))
   (parse-integer (query obj "outerWidth" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-outer-width (clog-window value))
+(defgeneric (setf outer-width) (value clog-window))
 
-(defmethod set-outer-width ((obj clog-window) value)
+(defmethod (setf outer-width) (value (obj clog-window))
   (execute obj (format nil "outerWidth='~A'" (escape-string value)))
   value)
-(defsetf outer-width set-outer-width)
 
 ;;;;;;;;;;;;;;
 ;; x-offset ;;
@@ -136,12 +130,11 @@ window."))
 (defmethod x-offset ((obj clog-window))
   (parse-integer (query obj "pageXOffset" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-x-offset (clog-window value))
+(defgeneric (setf x-offset) (value clog-window))
 
-(defmethod set-x-offset ((obj clog-window) value)
+(defmethod (setf x-offset) (value (obj clog-window))
   (execute obj (format nil "pageXOffset='~A'" (escape-string value)))
   value)
-(defsetf x-offset set-x-offset)
 
 ;;;;;;;;;;;;;;
 ;; y-offset ;;
@@ -153,12 +146,11 @@ window."))
 (defmethod y-offset ((obj clog-window))
   (parse-integer (query obj "pageYOffset" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-y-offset (clog-window value))
+(defgeneric (setf y-offset) (value clog-window))
 
-(defmethod set-y-offset ((obj clog-window) value)
+(defmethod (setf y-offset) (value (obj clog-window))
   (execute obj (format nil "pageYOffset='~A'" (escape-string value)))
   value)
-(defsetf y-offset set-y-offset)
 
 ;;;;;;;;;
 ;; top ;;
@@ -170,12 +162,11 @@ window."))
 (defmethod top ((obj clog-window))
   (parse-integer (query obj "screenY" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-top (clog-window value))
+(defgeneric (setf top) (value clog-window))
 
-(defmethod set-top ((obj clog-window) value)
+(defmethod (setf top) (value (obj clog-window))
   (execute obj (format nil "screenY='~A'" (escape-string value)))
   value)
-(defsetf top set-top)
 
 ;;;;;;;;;;
 ;; left ;;
@@ -187,12 +178,11 @@ window."))
 (defmethod left ((obj clog-window))
   (parse-integer (query obj "screenX" :default-answer 0) :junk-allowed t))
 
-(defgeneric set-left (clog-window value))
+(defgeneric (setf left) (value clog-window))
 
-(defmethod set-left ((obj clog-window) value)
+(defmethod (setf left) (value (obj clog-window))
   (execute obj (format nil "screenX='~A'" (escape-string value)))
   value)
-(defsetf left set-left)
 
 ;;;;;;;;;;;;;;;;;
 ;; pixel-ratio ;;
@@ -544,13 +534,12 @@ STORAGE-TYPE. (local = persistant or session)"))
                      storage-type
                      (escape-string key-name))))
 
-(defgeneric set-storage-element (clog-window storage-type key-name value)
+(defgeneric (setf storage-element) (value clog-window storage-type key-name)
   (:documentation "Set storage-element."))
 
-(defmethod set-storage-element ((obj clog-window) storage-type key-name value)
+(defmethod (setf storage-element) (value (obj clog-window) storage-type key-name)
   (execute obj (format nil "~(~a~)Storage.setItem('~A','~A')"
                        storage-type
                        (escape-string key-name)
                        (escape-string value)))
   value)
-(defsetf storage-element set-storage-element)