anchor.diff:        (setf gfs (append gfs (x-specializer-direct-generic-functions x))))
       (remove-duplicates gfs)))
   
  -;; Oops, guess this isn't really comparing symbols anymore. What to call it, then?
  -(defun symbol< (a b)
  +(defun not-really-symbol< (a b)
     (when (and (consp a)
                (second a)
                (symbolp (second a)))
  
positive.code:                                  (with-drawing-options (stream :ink normal-ink
  							       :text-style text-style)
                                     (with-output-as-presentation (stream (clim-mop:class-name class) 'class-name)
                                       (surrounding-output-with-border (stream :shape :drop-shadow)
  				       (princ (clim-mop:class-name class))))))
  			     inferior-fun
  			     :stream stream
                               :merge-duplicates T
  
negative.code: 
  ;; FIXME: Make this a present method specialzed on a view?
  
  (defun apropos-present-symbol (symbol &optional (stream *standard-output*) show-package)
    (multiple-value-bind (style ink)
        (values
         (if (or (fboundp symbol)
                 (boundp  symbol)
                 (find-class symbol nil))
             (make-text-style *apropos-symbol-bound-family*
                              *apropos-symbol-unbound-face*
                              :normal)
             (make-text-style *apropos-symbol-unbound-family*
                              *apropos-symbol-bound-face*
                              :normal))
         (cond ((eql (symbol-package symbol)
                     (find-package "KEYWORD"))
                (make-rgb-color 0.46 0.0 0.0))
               ((fboundp symbol)
                (make-rgb-color 0.0 0.0 0.3))
               ((find-class symbol nil)
                (make-rgb-color 0.03 0.35 0.48))
               ((boundp symbol)
                (make-rgb-color 0.0 0.0 0.0))
               (t (make-rgb-color 0.6 0.6 0.6))))
      (with-drawing-options (stream :ink ink :text-style style)
        (with-output-as-presentation (stream symbol 'clim:symbol)
          (if show-package
              (let ((*package* (find-package :common-lisp-user)))
                (format stream "~W" symbol))
              (princ (symbol-name symbol) stream)))
        (when (boundp symbol)
          (format stream " = ")
          (with-drawing-options (stream :ink +olivedrab+ ;; XXX
                                        :text-style (make-text-style :fixed :roman :small))
            (let ((object (symbol-value symbol)))
              (present object (presentation-type-of object) :stream stream)))))))
  
  ;; These are used by com-apropos to filter the list of symbols according to the domain keyword
  (defgeneric apropos-applicable-p (spec symbol))
  
  (defmethod apropos-applicable-p ((spec (eql 'symbols)) symbol) t)
  
  (defmethod apropos-applicable-p ((spec (eql 'classes)) symbol)
    (find-class symbol nil))  
  
  (defmethod apropos-applicable-p ((spec (eql 'functions)) symbol)
    (fboundp symbol))
  
  (defmethod apropos-applicable-p ((spec (eql 'variables)) symbol)
    (boundp symbol))
  
  (defmethod apropos-applicable-p ((spec (eql 'command-tables)) symbol)
    (find-command-table symbol :errorp nil))
  
  ;(defmethod apropos-applicable-p ((spec (eql 'presentation-type)) symbol)
  ;  (find-presentation-type-class symbol nil))
  
  (define-command (com-apropos :name "Apropos"
  			     :command-table dev-commands
  			     :provide-output-destination-keyword t)
      ((string 'clim:string :prompt "string")
       &key
       (package '(or package-name package) :prompt "in package" :default nil)
       (domain '(member symbols classes functions variables command-tables) :prompt "domain" :default 'symbols))
    (let ((real-package (when package
                          (if (typep package 'package)
                              package
                              (find-package package)))))
      (when (and package (not real-package))
        (cerror "Search all packages instead" "No package specified by ~A could be found." package))
      (let ((symbols (remove-if-not (lambda (sym) (apropos-applicable-p domain sym))
                                    (apropos-list string real-package))))
        (dolist (sym symbols)
          (apropos-present-symbol sym *standard-output* T)
          (terpri))
        (setf *apropos-list* symbols)
        (note "Results have been saved to ~W~%" '*APROPOS-LIST*))))
  
  (define-command (com-trace :name "Trace"
  			   :command-table dev-commands
  