anchor.diff:               (cond ((and (string= "QColor" (first args)) (find (length args) '(4 5)))
                       (list (format nil "(qfun \"QColor\" \"fromRgb\"~{ ~A~})" (rest args))))
                      (t
  -                    (let ((args* (copy-list args)))
  +                    (let ((args* (copy-list args))
  +                          variant variant-type)
                         (dotimes (i (length args))
                           (x:when-it (and (string= "(qfun" (nth i args))
                                           (find-qt-method (nth (1+ i) args) (nth (+ i 2) args)))
                             (setf (nth (+ i 2) args*) x:it)))
                         (mapcar (lambda (arg)
  -                                (cond ((> (count #\| arg) 2)
  +                                (cond (variant
  +                                       (setf variant nil)
  +                                       (if (char= #\Q (char arg 0))
  +                                           (progn
  +                                             (setf variant-type arg)
  +                                             "")
  +                                           (let ((type (cond ((find* arg '("t" "nil"))
  +                                                              "bool")
  +                                                             (t (error "QVariant type not implemented for: ~A" arg)))))
  +                                             (format nil "(qnew \"QVariant(~A)\" ~A)" type arg))))
  +                                      (variant-type
  +                                       (prog1
  +                                           (format nil "(qnew \"QVariant(~A)\" ~S)"
  +                                                   variant-type
  +                                                   (if (string= "QChar" variant-type)
  +                                                       (code-char (parse-integer arg))
  +                                                       arg))
  +                                         (setf variant-type nil)))
  +                                      ((string= "QVariant" arg)
  +                                       (setf variant t)
  +                                       "")
  +                                      ((> (count #\| arg) 2)
                                          (format nil "(logior |~A|)" (string-trim " |" (string-substitute "| |" "|" arg))))
                                         (t
                                          (if (string= "QString" arg)
  
positive.code:         (coerce (nreverse line*) 'string))))
  
  (defun insert-tr (line string-lines-pos)
    (let* ((pos (position-if (lambda (x) (search ".translate" x)) line))
           (tr-string (if pos (nth (+ 2 pos) line) "\"\""))
           line*)
      (if pos
          (let ((start (eql :start string-lines-pos)))
            (dotimes (n (length line))
              (cond ((= n pos)
                     (push (format nil "(tr ~A~A"
                                   (if start (string-right-trim "\"\\n" tr-string) tr-string)
                                   (if start "" ")"))
                           line*))
                    ((or (< n pos)
                         (> n (+ 4 pos)))
  
negative.code: ;;; copyright (c) 2012 Polos Ruetz
  ;;;
  ;;; user interface compiler
  
  (defpackage :quic
    (:use :common-lisp :eql)
  