* Hackery to get Python to build on Cygwin.

svn path=/nixpkgs/branches/modular-python/; revision=26694

VERSION

@@ -1 +1 @@
-0.13
+0.14

doc/stdenv.xml

@@ -470,7 +470,7 @@ Additional file types can be supported by setting the
 <section><title>The configure phase</title>
 
 <para>The configure phase prepares the source tree for building.  The
-default <function>unpackPhase</function> runs
+default <function>configurePhase</function> runs
 <filename>./configure</filename> (typically an Autoconf-generated
 script) if it exists.</para>
 

maintainers/docs/update-upstream-data.txt

@@ -0,0 +1,14 @@
+Semi-automatic source information updating using "update-upstream-data.sh" script and "src-{,info-}for-*.nix"
+
+1. Recognizing when a pre-existing package uses this mechanism.
+
+Packages using this automatical update mechanism have src-info-for-default.nix and src-for-default.nix next to default.nix. src-info-for-default.nix describes getting the freshest source from upstream web site; src-for-default.nix is a generated file with the current data about used source. Both files define a simple attrSet. 
+
+src-info-for-default.nix (for a file grabbed via http) contains at least downloadPage attribute - it is the page we need to look at to find out the latest version. It also contains baseName that is used for automatical generation of package name containing version. It can contain extra data for trickier cases.
+
+src-for-default.nix will contain advertisedUrl (raw URL chosen on the site; its change prompts regeneration of source data), url for fetchurl, hash, version retrieved from the download URL and suggested package name.
+
+2. Updating a package
+
+nixpkgs/pkgs/build-support/upstream-updater directory contains some scripts. The worker script is called update-upstream-data.sh. This script requires main expression name (e.g. default.nix). It can optionally accpet a second parameter, URL which will be used instead of getting one by parsing the downloadPage (version extraction, mirror URL creation etc. will still be run). After running the script, check src-for-default.nix (or replace default.nix with expression name, if there are seceral expressions in the directory) for new version information.
+

maintainers/scripts/eval-release.nix

@@ -6,9 +6,13 @@ let
 
   lib = (import ../.. {}).lib;
 
-  rel = removeAttrs (import ../../pkgs/top-level/release.nix) ["tarball"];
+  rel = removeAttrs (import ../../pkgs/top-level/release.nix) [ "tarball" "xbursttools" ];
 
-  maybe = x: let y = builtins.tryEval x; in if y.success then y.value else null;
+  seqList = xs: res: lib.fold (x: xs: lib.seq x xs) res xs;
+  
+  strictAttrs = as: seqList (lib.attrValues as) as;
+
+  maybe = as: let y = builtins.tryEval (strictAttrs as); in if y.success then y.value else builtins.trace "FAIL" null;
 
   call = attrs: lib.flip lib.mapAttrs attrs
     (n: v: builtins.trace n (

maintainers/scripts/gnu/gnupdate

@@ -0,0 +1,901 @@
+#!/bin/sh
+# This is actually -*- mode: scheme; coding: utf-8; -*- text.
+main='(module-ref (resolve-module '\''(gnupdate)) '\'gnupdate')'
+exec ${GUILE-guile} -L "$PWD" -l "$0"    \
+         -c "(apply $main (command-line))" "$@"
+!#
+;;; GNUpdate -- Update GNU packages in Nixpkgs.
+;;; Copyright (C) 2010, 2011  Ludovic Courtès <ludo@gnu.org>
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation, either version 3 of the License, or
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+(cond-expand (guile-2 #t)
+             (else (error "GNU Guile 2.0 is required")))
+
+(define-module (gnupdate)
+  #:use-module (sxml ssax)
+  #:use-module (ice-9 popen)
+  #:use-module (ice-9 match)
+  #:use-module (ice-9 rdelim)
+  #:use-module (ice-9 regex)
+  #:use-module (ice-9 vlist)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-9)
+  #:use-module (srfi srfi-11)
+  #:use-module (srfi srfi-26)
+  #:use-module (srfi srfi-37)
+  #:use-module (system foreign)
+  #:use-module (rnrs bytevectors)
+  #:export (gnupdate))
+
+
+;;;
+;;; SNix.
+;;;
+
+(define-record-type <location>
+  (make-location file line column)
+  location?
+  (file          location-file)
+  (line          location-line)
+  (column        location-column))
+
+(define (->loc line column path)
+  (and line column path
+       (make-location path (string->number line) (string->number column))))
+
+;; Nix object types visible in the XML output of `nix-instantiate' and
+;; mapping to S-expressions (we map to sexps, not records, so that we
+;; can do pattern matching):
+;;
+;;   at               (at varpat attrspat)
+;;   attr             (attribute loc name value)
+;;   attrs            (attribute-set attributes)
+;;   attrspat         (attribute-set-pattern patterns)
+;;   bool             #f|#t
+;;   derivation       (derivation drv-path out-path attributes)
+;;   ellipsis         '...
+;;   expr             (snix loc body ...)
+;;   function         (function loc at|attrspat|varpat)
+;;   int              int
+;;   list             list
+;;   null             'null
+;;   path             string
+;;   string           string
+;;   unevaluated      'unevaluated
+;;   varpat           (varpat name)
+;;
+;; Initially ATTRIBUTES in `derivation' and `attribute-set' was a promise;
+;; however, handling `repeated' nodes makes it impossible to do anything
+;; lazily because the whole SXML tree has to be traversed to maintain the
+;; list of known derivations.
+
+(define (xml-element->snix elem attributes body derivations)
+  ;; Return an SNix element corresponding to XML element ELEM.
+
+  (define (loc)
+    (->loc (assq-ref attributes 'line)
+           (assq-ref attributes 'column)
+           (assq-ref attributes 'path)))
+
+  (case elem
+    ((at)
+     (values `(at ,(car body) ,(cadr body)) derivations))
+    ((attr)
+     (let ((name (assq-ref attributes 'name)))
+       (cond ((null? body)
+              (values `(attribute-pattern ,name) derivations))
+             ((and (pair? body) (null? (cdr body)))
+              (values `(attribute ,(loc) ,name ,(car body))
+                      derivations))
+             (else
+              (error "invalid attribute body" name (loc) body)))))
+    ((attrs)
+     (values `(attribute-set ,(reverse body)) derivations))
+    ((attrspat)
+     (values `(attribute-set-pattern ,body) derivations))
+    ((bool)
+     (values (string-ci=? "true" (assq-ref attributes 'value))
+             derivations))
+    ((derivation)
+     (let ((drv-path (assq-ref attributes 'drvPath))
+           (out-path (assq-ref attributes 'outPath)))
+       (if (equal? body '(repeated))
+           (let ((body (vhash-assoc drv-path derivations)))
+             (if (pair? body)
+                 (values `(derivation ,drv-path ,out-path ,(cdr body))
+                         derivations)
+                 (error "no previous occurrence of derivation"
+                        drv-path)))
+           (values `(derivation ,drv-path ,out-path ,body)
+                   (vhash-cons drv-path body derivations)))))
+    ((ellipsis)
+     (values '... derivations))
+    ((expr)
+     (values `(snix ,(loc) ,@body) derivations))
+    ((function)
+     (values `(function ,(loc) ,body) derivations))
+    ((int)
+     (values (string->number (assq-ref attributes 'value))
+             derivations))
+    ((list)
+     (values body derivations))
+    ((null)
+     (values 'null derivations))
+    ((path)
+     (values (assq-ref attributes 'value) derivations))
+    ((repeated)
+     (values 'repeated derivations))
+    ((string)
+     (values (assq-ref attributes 'value) derivations))
+    ((unevaluated)
+     (values 'unevaluated derivations))
+    ((varpat)
+     (values `(varpat ,(assq-ref attributes 'name)) derivations))
+    (else (error "unhandled Nix XML element" elem))))
+
+(define xml->snix
+  ;; Return the SNix represention of TREE, an SXML tree as returned by
+  ;; parsing the XML output of `nix-instantiate' on Nixpkgs.
+  (let ((parse
+         (ssax:make-parser NEW-LEVEL-SEED
+                           (lambda (elem-gi attributes namespaces expected-content
+                                    seed)
+                             (cons '() (cdr seed)))
+
+                           FINISH-ELEMENT
+                           (lambda (elem-gi attributes namespaces parent-seed
+                                            seed)
+                             (let ((snix        (car seed))
+                                   (derivations (cdr seed)))
+                               (let-values (((snix derivations)
+                                             (xml-element->snix elem-gi
+                                                                attributes
+                                                                snix
+                                                                derivations)))
+                                 (cons (cons snix (car parent-seed))
+                                       derivations))))
+
+                           CHAR-DATA-HANDLER
+                           (lambda (string1 string2 seed)
+                             ;; Discard inter-node strings, which are blanks.
+                             seed))))
+    (lambda (port)
+      ;; Discard the second value returned by the parser (the derivation
+      ;; vhash).
+      (caar (parse port (cons '() vlist-null))))))
+
+(define (call-with-package snix proc)
+  (match snix
+    (('attribute _ (and attribute-name (? string?))
+                 ('derivation _ _ body))
+     ;; Ugly pattern matching.
+     (let ((meta
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "meta" ('attribute-set metas)) metas)
+                     (_ #f)))
+                 body))
+           (package-name
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "name" (and name (? string?)))
+                      name)
+                     (_ #f)))
+                 body))
+           (location
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute loc "name" (? string?))
+                      loc)
+                     (_ #f)))
+                 body))
+           (src
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "src" src)
+                      src)
+                     (_ #f)))
+                 body)))
+       (proc attribute-name package-name location meta src)))))
+
+(define (call-with-src snix proc)
+  ;; Assume SNIX contains the SNix expression for the value of an `src'
+  ;; attribute, as returned by `call-with-package', and call PROC with the
+  ;; relevant SRC information, or #f if SNIX doesn't match.
+  (match snix
+    (('derivation _ _ body)
+     (let ((name
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "name" (and name (? string?)))
+                      name)
+                     (_ #f)))
+                 body))
+           (output-hash
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "outputHash" (and hash (? string?)))
+                      hash)
+                     (_ #f)))
+                 body))
+           (urls
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "urls" (and urls (? pair?)))
+                      urls)
+                     (_ #f)))
+                 body)))
+       (proc name output-hash urls)))
+    (_ (proc #f #f #f))))
+
+(define (src->values snix)
+  (call-with-src snix values))
+
+(define (attribute-value attribute)
+  ;; Return the value of ATTRIBUTE.
+  (match attribute
+    (('attribute _ _ value) value)))
+
+(define (derivation-source derivation)
+  ;; Return the "src" attribute of DERIVATION or #f if not found.
+  (match derivation
+    (('derivation _ _ (attributes ...))
+     (find-attribute-by-name "src" attributes))))
+
+(define (derivation-output-path derivation)
+  ;; Return the output path of DERIVATION.
+  (match derivation
+    (('derivation _ out-path _)
+     out-path)
+    (_ #f)))
+
+(define (source-output-path src)
+  ;; Return the output path of SRC, the "src" attribute of a derivation.
+  (derivation-output-path (attribute-value src)))
+
+(define (derivation-source-output-path derivation)
+  ;; Return the output path of the "src" attribute of DERIVATION or #f if
+  ;; DERIVATION lacks an "src" attribute.
+  (and=> (derivation-source derivation) source-output-path))
+
+(define (open-nixpkgs nixpkgs)
+  (let ((script  (string-append nixpkgs
+                                "/maintainers/scripts/eval-release.nix")))
+    (open-pipe* OPEN_READ "nix-instantiate"
+                "--strict" "--eval-only" "--xml"
+                script)))
+
+(define (pipe-failed? pipe)
+  "Close pipe and return its status if it failed."
+  (let ((status (close-pipe pipe)))
+    (if (or (status:term-sig status)
+            (not (= (status:exit-val status) 0)))
+        status
+        #f)))
+
+(define (nix-prefetch-url url)
+  ;; Download URL in the Nix store and return the base32-encoded SHA256 hash
+  ;; of the file at URL
+  (let* ((pipe (open-pipe* OPEN_READ "nix-prefetch-url" url))
+         (hash (read-line pipe)))
+    (if (or (pipe-failed? pipe)
+            (eof-object? hash))
+        (values #f #f)
+        (let* ((pipe (open-pipe* OPEN_READ "nix-store" "--print-fixed-path"
+                                   "sha256" hash (basename url)))
+               (path (read-line pipe)))
+          (if (or (pipe-failed? pipe)
+                  (eof-object? path))
+              (values #f #f)
+              (values (string-trim-both hash) (string-trim-both path)))))))
+
+(define (update-nix-expression file
+                               old-version old-hash
+                               new-version new-hash)
+  ;; Modify FILE in-place.  Ugly: we call out to sed(1).
+  (let ((cmd (format #f "sed -i \"~a\" -e 's/~A/~a/g ; s/~A/~A/g'"
+                     file
+                     (regexp-quote old-version) new-version
+                     old-hash
+                     (or new-hash "new hash not available, check the log"))))
+    (format #t "running `~A'...~%" cmd)
+    (system cmd)))
+
+(define (find-attribute-by-name name attributes)
+  ;; Return attribute NAME in ATTRIBUTES, a list of SNix attributes, or #f if
+  ;; NAME cannot be found.
+  (find (lambda (a)
+          (match a
+            (('attribute _ (? (cut string=? <> name)) _)
+             a)
+            (_ #f)))
+        attributes))
+
+(define (find-package-by-attribute-name name packages)
+  ;; Return the package bound to attribute NAME in PACKAGES, a list of
+  ;; packages (SNix attributes), or #f if NAME cannot be found.
+  (find (lambda (package)
+          (match package
+            (('attribute _ (? (cut string=? <> name))
+                         ('derivation _ _ _))
+             package)
+            (_ #f)))
+        packages))
+
+(define (stdenv-package packages)
+  ;; Return the `stdenv' package from PACKAGES, a list of SNix attributes.
+  (find-package-by-attribute-name "stdenv" packages))
+
+(define (package-requisites package)
+  ;; Return the list of derivations required to build PACKAGE (including that
+  ;; of PACKAGE) by recurring into its derivation attributes.
+  (let loop ((snix   package)
+             (result '()))
+    (match snix
+      (('attribute _ _ body)
+       (loop body result))
+      (('derivation _ out-path body)
+       (if (any (lambda (d)
+                  (match d
+                    (('derivation _ (? (cut string=? out-path <>)) _) #t)
+                    (_ #f)))
+                result)
+           result
+           (loop body (cons snix result))))
+      ((things ...)
+       (fold loop result things))
+      (_ result))))
+
+(define (package-source-output-path package)
+  ;; Return the output path of the "src" derivation of PACKAGE.
+  (derivation-source-output-path (attribute-value package)))
+
+
+;;;
+;;; FTP client.
+;;;
+
+(define-record-type <ftp-connection>
+  (%make-ftp-connection socket addrinfo)
+  ftp-connection?
+  (socket    ftp-connection-socket)
+  (addrinfo  ftp-connection-addrinfo))
+
+(define %ftp-ready-rx
+  (make-regexp "^([0-9]{3}) (.+)$"))
+
+(define (%ftp-listen port)
+  (let loop ((line (read-line port)))
+    (cond ((eof-object? line) (values line #f))
+          ((regexp-exec %ftp-ready-rx line)
+           =>
+           (lambda (match)
+             (values (string->number (match:substring match 1))
+                     (match:substring match 2))))
+          (else
+           (loop (read-line port))))))
+
+(define (%ftp-command command expected-code port)
+  (format port "~A~A~A" command (string #\return) (string #\newline))
+  (let-values (((code message) (%ftp-listen port)))
+    (if (eqv? code expected-code)
+        message
+        (throw 'ftp-error port command code message))))
+
+(define (%ftp-login user pass port)
+  (let ((command (string-append "USER " user (string #\newline))))
+    (display command port)
+    (let-values (((code message) (%ftp-listen port)))
+      (case code
+        ((230)  #t)
+        ((331) (%ftp-command (string-append "PASS " pass) 230 port))
+        (else  (throw 'ftp-error port command code message))))))
+
+(define (ftp-open host)
+  (catch 'getaddrinfo-error
+    (lambda ()
+      (let* ((ai (car (getaddrinfo host "ftp")))
+             (s  (socket (addrinfo:fam ai) (addrinfo:socktype ai)
+                         (addrinfo:protocol ai))))
+        (connect s (addrinfo:addr ai))
+        (setvbuf s _IOLBF)
+        (let-values (((code message) (%ftp-listen s)))
+          (if (eqv? code 220)
+              (begin
+                ;(%ftp-command "OPTS UTF8 ON" 200 s)
+                (%ftp-login "anonymous" "ludo@example.com" s)
+                (%make-ftp-connection s ai))
+              (begin
+                (format (current-error-port) "FTP to `~a' failed: ~A: ~A~%"
+                        host code message)
+                (close s)
+                #f)))))
+    (lambda (key errcode)
+      (format (current-error-port) "failed to resolve `~a': ~a~%"
+              host (gai-strerror errcode))
+      #f)))
+
+(define (ftp-close conn)
+  (close (ftp-connection-socket conn)))
+
+(define (ftp-chdir conn dir)
+  (%ftp-command (string-append "CWD " dir) 250
+                (ftp-connection-socket conn)))
+
+(define (ftp-pasv conn)
+  (define %pasv-rx
+    (make-regexp "([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+)"))
+
+  (let ((message (%ftp-command "PASV" 227 (ftp-connection-socket conn))))
+    (cond ((regexp-exec %pasv-rx message)
+           =>
+           (lambda (match)
+             (+ (* (string->number (match:substring match 5)) 256)
+                (string->number (match:substring match 6)))))
+          (else
+           (throw 'ftp-error conn "PASV" 227 message)))))
+
+
+(define* (ftp-list conn #:optional directory)
+  (define (address-with-port sa port)
+    (let ((fam  (sockaddr:fam sa))
+          (addr (sockaddr:addr sa)))
+      (cond ((= fam AF_INET)
+             (make-socket-address fam addr port))
+            ((= fam AF_INET6)
+             (make-socket-address fam addr port
+                                  (sockaddr:flowinfo sa)
+                                  (sockaddr:scopeid sa)))
+            (else #f))))
+
+  (if directory
+      (ftp-chdir conn directory))
+
+  (let* ((port (ftp-pasv conn))
+         (ai   (ftp-connection-addrinfo conn))
+         (s    (socket (addrinfo:fam ai) (addrinfo:socktype ai)
+                       (addrinfo:protocol ai))))
+    (connect s (address-with-port (addrinfo:addr ai) port))
+    (setvbuf s _IOLBF)
+
+    (dynamic-wind
+      (lambda () #t)
+      (lambda ()
+        (%ftp-command "LIST" 150 (ftp-connection-socket conn))
+
+        (let loop ((line   (read-line s))
+                   (result '()))
+          (cond ((eof-object? line) (reverse result))
+                ((regexp-exec %ftp-ready-rx line)
+                 =>
+                 (lambda (match)
+                   (let ((code (string->number (match:substring match 1))))
+                     (if (= 126 code)
+                         (reverse result)
+                         (throw 'ftp-error conn "LIST" code)))))
+                (else
+                 (loop (read-line s)
+                       (match (reverse (string-tokenize line))
+                         ((file _ ... permissions)
+                          (let ((type (case (string-ref permissions 0)
+                                        ((#\d) 'directory)
+                                        (else 'file))))
+                            (cons (list file type) result)))
+                         ((file _ ...)
+                          (cons (cons file 'file) result))))))))
+      (lambda ()
+        (close s)
+        (let-values (((code message) (%ftp-listen (ftp-connection-socket conn))))
+          (or (eqv? code 226)
+              (throw 'ftp-error conn "LIST" code message)))))))
+
+
+;;;
+;;; GNU.
+;;;
+
+(define %ignored-package-attributes
+  ;; Attribute name of packages to be ignored.
+  '("bash" "bashReal" "bashInteractive" ;; the full versioned name is incorrect
+    "autoconf213"
+    "automake17x"
+    "automake19x"
+    "automake110x"
+    "bison1875"
+    "bison23"
+    "bison" ;; = 2.3
+    "emacs22"
+    "emacsSnapshot"
+    "gcc295"
+    "gcc33"
+    "gcc34"
+    "gcc40"
+    "gcc41"
+    "gcc42"
+    "gcc43"
+    "gcc44"
+    "gcc45"
+    "gcc45_real"
+    "gcc45_realCross"
+    "glibc25"
+    "glibc27"
+    "glibc29"
+    "guile_1_8"
+    "icecat3Xul" ;; redundant with `icecat'
+    "icecatWrapper"
+    "icecatXulrunner3"
+    ))
+
+(define (gnu? package)
+  ;; Return true if PACKAGE (a snix expression) is a GNU package (according
+  ;; to a simple heuristic.)  Otherwise return #f.
+  (match package
+    (('attribute _ _ ('derivation _ _ body))
+     (any (lambda (attr)
+            (match attr
+              (('attribute _ "meta" ('attribute-set metas))
+               (any (lambda (attr)
+                      (match attr
+                        (('attribute _ "description" value)
+                         (string-prefix? "GNU" value))
+                        (('attribute _ "homepage" value)
+                         (string-contains value "www.gnu.org"))
+                        (_ #f)))
+                    metas))
+              (_ #f)))
+          body))
+    (_ #f)))
+
+(define (gnu-packages packages)
+  (fold (lambda (package gnu)
+          (match package
+            (('attribute _ "emacs23Packages" emacs-packages)
+             ;; XXX: Should prepend `emacs23Packages.' to attribute names.
+             (append (gnu-packages emacs-packages) gnu))
+            (('attribute _ attribute-name ('derivation _ _ body))
+             (if (member attribute-name %ignored-package-attributes)
+                 gnu
+                 (if (gnu? package)
+                     (cons package gnu)
+                     gnu)))
+            (_ gnu)))
+        '()
+        packages))
+
+(define (ftp-server/directory project)
+  (define quirks
+    '(("commoncpp2"   "ftp.gnu.org"   "/gnu/commoncpp" #f)
+      ("ucommon"      "ftp.gnu.org"   "/gnu/commoncpp" #f)
+      ("libzrtpcpp"   "ftp.gnu.org"   "/gnu/ccrtp" #f)
+      ("libosip2"     "ftp.gnu.org"   "/gnu/osip" #f)
+      ("libgcrypt"    "ftp.gnupg.org" "/gcrypt" #t)
+      ("libgpg-error" "ftp.gnupg.org" "/gcrypt" #t)
+      ("freefont-ttf" "ftp.gnu.org"   "/gnu/freefont" #f)
+      ("gnupg"        "ftp.gnupg.org" "/gcrypt" #t)
+      ("gnu-ghostscript" "ftp.gnu.org"  "/gnu/ghostscript" #f)
+      ("grub"         "alpha.gnu.org" "/gnu" #t)
+      ("GNUnet"       "ftp.gnu.org" "/gnu/gnunet" #f)
+      ("mit-scheme"   "ftp.gnu.org" "/gnu/mit-scheme/stable.pkg" #f)
+      ("icecat"       "ftp.gnu.org" "/gnu/gnuzilla" #f)
+      ("source-highlight" "ftp.gnu.org" "/gnu/src-highlite" #f)
+      ("TeXmacs"      "ftp.texmacs.org" "/TeXmacs/targz" #f)))
+
+  (let ((quirk (assoc project quirks)))
+    (match quirk
+      ((_ server directory subdir?)
+       (values server (if (not subdir?)
+                          directory
+                          (string-append directory "/" project))))
+      (_
+       (values "ftp.gnu.org" (string-append "/gnu/" project))))))
+
+(define (nixpkgs->gnu-name project)
+  (define quirks
+    '(("gcc-wrapper" . "gcc")
+      ("ghostscript" . "gnu-ghostscript") ;; ../ghostscript/gnu-ghoscript-X.Y.tar.gz
+      ("gnum4"       . "m4")
+      ("gnugrep"     . "grep")
+      ("gnumake"     . "make")
+      ("gnused"      . "sed")
+      ("gnutar"      . "tar")
+      ("gnunet"      . "GNUnet") ;; ftp.gnu.org/gnu/gnunet/GNUnet-x.y.tar.gz
+      ("mitscheme"   . "mit-scheme")
+      ("texmacs"     . "TeXmacs")))
+
+  (or (assoc-ref quirks project) project))
+
+(define (releases project)
+  "Return the list of releases of PROJECT as a list of release name/directory
+pairs.  Example: (\"mit-scheme-9.0.1\" . \"/gnu/mit-scheme/stable.pkg/9.0.1\"). "
+  ;; TODO: Parse something like fencepost.gnu.org:/gd/gnuorg/packages-ftp.
+  (define release-rx
+    (make-regexp (string-append "^" project
+                                "-([0-9]|[^-])*(-src)?\\.tar\\.")))
+
+  (define alpha-rx
+    (make-regexp "^.*-.*[0-9](-|~)?(alpha|beta|rc|cvs|svn|git)-?[0-9\\.]*\\.tar\\."))
+
+  (define (sans-extension tarball)
+    (let ((end (string-contains tarball ".tar")))
+      (substring tarball 0 end)))
+
+  (catch 'ftp-error
+    (lambda ()
+      (let-values (((server directory) (ftp-server/directory project)))
+        (define conn (ftp-open server))
+
+        (let loop ((directories (list directory))
+                   (result      '()))
+          (if (null? directories)
+              (begin
+                (ftp-close conn)
+                result)
+              (let* ((directory (car directories))
+                     (files     (ftp-list conn directory))
+                     (subdirs   (filter-map (lambda (file)
+                                              (match file
+                                                ((name 'directory . _) name)
+                                                (_ #f)))
+                                            files)))
+                (loop (append (map (cut string-append directory "/" <>)
+                                   subdirs)
+                              (cdr directories))
+                      (append
+                       ;; Filter out signatures, deltas, and files which are potentially
+                       ;; not releases of PROJECT (e.g., in /gnu/guile, filter out
+                       ;; guile-oops and guile-www; in mit-scheme, filter out
+                       ;; binaries).
+                       (filter-map (lambda (file)
+                                     (match file
+                                       ((file 'file . _)
+                                        (and (not (string-suffix? ".sig" file))
+                                             (regexp-exec release-rx file)
+                                             (not (regexp-exec alpha-rx file))
+                                             (let ((s (sans-extension file)))
+                                               (and (regexp-exec
+                                                     %package-name-rx s)
+                                                    (cons s directory)))))
+                                       (_ #f)))
+                                   files)
+                       result)))))))
+    (lambda (key subr message . args)
+      (format (current-error-port)
+              "failed to get release list for `~A': ~S ~S~%"
+              project message args)
+      '())))
+
+(define version-string>?
+  (let ((strverscmp
+         (let ((sym (or (dynamic-func "strverscmp" (dynamic-link))
+                        (error "could not find `strverscmp' (from GNU libc)"))))
+           (pointer->procedure int sym (list '* '*)))))
+    (lambda (a b)
+      (> (strverscmp (string->pointer a) (string->pointer b)) 0))))
+
+(define (latest-release project)
+  "Return (\"FOO-X.Y\" . \"/bar/foo\") or #f."
+  (let ((releases (releases project)))
+    (and (not (null? releases))
+         (fold (lambda (release latest)
+                 (if (version-string>? (car release) (car latest))
+                     release
+                     latest))
+               '("" . "")
+               releases))))
+
+(define %package-name-rx
+  ;; Regexp for a package name, e.g., "foo-X.Y".  Since TeXmacs uses
+  ;; "TeXmacs-X.Y-src", the `-src' suffix is allowed.
+  (make-regexp "^(.*)-(([0-9]|\\.)+)(-src)?"))
+
+(define (package/version name+version)
+  "Return the package name and version number extracted from NAME+VERSION."
+  (let ((match (regexp-exec %package-name-rx name+version)))
+    (if (not match)
+        (values name+version #f)
+        (values (match:substring match 1) (match:substring match 2)))))
+
+(define (file-extension file)
+  (let ((dot (string-rindex file #\.)))
+    (and dot (substring file (+ 1 dot) (string-length file)))))
+
+(define (packages-to-update gnu-packages)
+  (define (unpack latest)
+    (call-with-values (lambda ()
+                        (package/version (car latest)))
+      (lambda (name version)
+        (list name version (cdr latest)))))
+
+  (fold (lambda (pkg result)
+          (call-with-package pkg
+            (lambda (attribute name+version location meta src)
+              (let-values (((name old-version)
+                            (package/version name+version)))
+                (let ((latest (latest-release (nixpkgs->gnu-name name))))
+                  (if (not latest)
+                      (begin
+                        (format #t "~A [unknown latest version]~%"
+                                name+version)
+                        result)
+                      (match (unpack latest)
+                        ((_ (? (cut string=? old-version <>)) _)
+                         (format #t "~A [up to date]~%" name+version)
+                         result)
+                        ((project new-version directory)
+                         (let-values (((old-name old-hash old-urls)
+                                       (src->values src)))
+                           (format #t "~A -> ~A [~A]~%"
+                                   name+version (car latest)
+                                   (and (pair? old-urls) (car old-urls)))
+                           (let* ((url      (and (pair? old-urls)
+                                                 (car old-urls)))
+                                  (new-hash (fetch-gnu project directory
+                                                       new-version
+                                                       (if url
+                                                           (file-extension url)
+                                                           "gz"))))
+                             (cons (list name attribute
+                                         old-version old-hash
+                                         new-version new-hash
+                                         location)
+                                   result)))))))))))
+        '()
+        gnu-packages))
+
+(define (fetch-gnu project directory version archive-type)
+  (let* ((server  (ftp-server/directory project))
+         (base    (string-append project "-" version ".tar." archive-type))
+         (url     (string-append "ftp://" server "/" directory "/" base))
+         (sig     (string-append base ".sig"))
+         (sig-url (string-append url ".sig")))
+    (let-values (((hash path) (nix-prefetch-url url)))
+      (pk 'prefetch-url url hash path)
+      (and hash path
+           (begin
+             (false-if-exception (delete-file sig))
+             (system* "wget" sig-url)
+             (if (file-exists? sig)
+                 (let ((ret (system* "gpg" "--verify" sig path)))
+                   (false-if-exception (delete-file sig))
+                   (if (and ret (= 0 (status:exit-val ret)))
+                       hash
+                       (begin
+                         (format (current-error-port)
+                                 "signature verification failed for `~a'~%"
+                                 base)
+                         (format (current-error-port)
+                                 "(could be because the public key is not in your keyring)~%")
+                         #f)))
+                 (begin
+                   (format (current-error-port)
+                           "no signature for `~a'~%" base)
+                   hash)))))))
+
+
+;;;
+;;; Main program.
+;;;
+
+(define %options
+  ;; Specifications of the command-line options.
+  (list (option '(#\h "help") #f #f
+                (lambda (opt name arg result)
+                  (format #t "Usage: gnupdate [OPTIONS...]~%")
+                  (format #t "GNUpdate -- update Nix expressions of GNU packages in Nixpkgs~%")
+                  (format #t "~%")
+                  (format #t "  -x, --xml=FILE      Read XML output of `nix-instantiate'~%")
+                  (format #t "                      from FILE.~%")
+                  (format #t "  -s, --select=SET    Update only packages from SET, which may~%")
+                  (format #t "                      be either `all', `stdenv', or `non-stdenv'.~%")
+                  (format #t "  -d, --dry-run       Don't actually update Nix expressions~%")
+                  (format #t "  -h, --help          Give this help list.~%~%")
+                  (format #t "Report bugs to <ludo@gnu.org>~%")
+                  (exit 0)))
+        (option '(#\s "select") #t #f
+                (lambda (opt name arg result)
+                  (cond ((string-ci=? arg "stdenv")
+                         (alist-cons 'filter 'stdenv result))
+                        ((string-ci=? arg "non-stdenv")
+                         (alist-cons 'filter 'non-stdenv result))
+                        ((string-ci=? arg "all")
+                         (alist-cons 'filter #f result))
+                        (else
+                         (format (current-error-port)
+                                 "~A: unrecognized selection type~%"
+                                 arg)
+                         (exit 1)))))
+
+        (option '(#\d "dry-run") #f #f
+                (lambda (opt name arg result)
+                  (alist-cons 'dry-run #t result)))
+
+        (option '(#\x "xml") #t #f
+                (lambda (opt name arg result)
+                  (alist-cons 'xml-file arg result)))))
+
+(define (gnupdate . args)
+  ;; Assume Nixpkgs is under $NIXPKGS or ~/src/nixpkgs.
+
+  (define (nixpkgs->snix xml-file)
+    (format (current-error-port) "evaluating Nixpkgs...~%")
+    (let* ((home (getenv "HOME"))
+           (xml  (if xml-file
+                     (open-input-file xml-file)
+                     (open-nixpkgs (or (getenv "NIXPKGS")
+                                       (string-append home "/src/nixpkgs")))))
+           (snix (xml->snix xml)))
+      (if (not xml-file)
+          (let ((status (pipe-failed? xml)))
+            (if status
+                (begin
+                  (format (current-error-port) "`nix-instantiate' failed: ~A~%"
+                          status)
+                  (exit 1)))))
+      snix))
+
+  (let* ((opts      (args-fold (cdr args) %options
+                               (lambda (opt name arg result)
+                                 (error "unrecognized option `~A'" name))
+                               (lambda (operand result)
+                                 (error "extraneous argument `~A'" operand))
+                               '()))
+         (snix      (nixpkgs->snix (assoc-ref opts 'xml-file)))
+         (packages  (match snix
+                      (('snix _ ('attribute-set attributes))
+                       attributes)
+                      (_ #f)))
+         (stdenv    (delay
+                      ;; The source tarballs that make up stdenv.
+                      (filter-map derivation-source-output-path
+                                  (package-requisites (stdenv-package packages)))))
+         (gnu       (gnu-packages packages))
+         (gnu*      (case (assoc-ref opts 'filter)
+                      ;; Filter out packages that are/aren't in `stdenv'.  To
+                      ;; do that reliably, we check whether their "src"
+                      ;; derivation is a requisite of stdenv.
+                      ((stdenv)
+                       (filter (lambda (p)
+                                 (member (package-source-output-path p)
+                                         (force stdenv)))
+                               gnu))
+                      ((non-stdenv)
+                       (filter (lambda (p)
+                                 (not (member (package-source-output-path p)
+                                              (force stdenv))))
+                               gnu))
+                      (else gnu)))
+         (updates   (packages-to-update gnu*)))
+
+    (format #t "~%~A packages to update...~%" (length updates))
+    (for-each (lambda (update)
+                (match update
+                  ((name attribute
+                    old-version old-hash
+                    new-version new-hash
+                    location)
+                   (if (assoc-ref opts 'dry-run)
+                       (format #t "`~a' would be updated from ~a to ~a (~a -> ~a)~%"
+                               name old-version new-version
+                               old-hash new-hash)
+                       (update-nix-expression (location-file location)
+                                              old-version old-hash
+                                              new-version new-hash)))
+                  (_ #f)))
+              updates)
+    #t))
+
+;;; Local Variables:
+;;; eval: (put 'call-with-package 'scheme-indent-function 1)
+;;; End:

maintainers/scripts/hydra_eval_check

@@ -0,0 +1,13 @@
+#! /bin/sh
+
+# give absolute path of release.nix as argument
+hydra_eval_jobs \
+  --argstr system x86_64-linux \
+  --argstr system i686-linux \
+  --argstr system x86_64-darwin \
+  --argstr system i686-darwin \
+  --argstr system i686-cygwin \
+  --argstr system i686-freebsd \
+  --arg officialRelease false \
+  --arg nixpkgs "{ outPath = builtins.storePath ./. ; rev = 1234; }" \
+  $@

maintainers/scripts/nix-call-package

@@ -0,0 +1,5 @@
+#! /bin/sh
+
+echo "let pkgs = import /etc/nixos/nixpkgs$2 {}; x = pkgs.callPackage $1 { $3 }; in ${4:-x}" |
+nix-instantiate --show-trace - |
+xargs nix-store -r -K

maintainers/scripts/test-eval-release.sh

@@ -0,0 +1,3 @@
+#! /bin/sh
+
+nix-instantiate --strict --eval-only --xml --show-trace "$(dirname "$0")"/eval-release.nix 2>&1 > /dev/null

pkgs/applications/audio/abcde/default.nix

@@ -1,4 +1,4 @@
-{ stdenv, fetchurl, libcdio, cddiscid, wget, bash, vorbisTools
+{ stdenv, fetchurl, libcdio, cddiscid, wget, bash, vorbisTools, id3v2, lame
 , makeWrapper }:
 
 let version = "2.3.99.6";
@@ -40,7 +40,7 @@ in
          --replace '#!/bin/bash' '#!${bash}/bin/bash'
 
       wrapProgram "$out/bin/abcde" --prefix PATH ":" \
-        "$out/bin:${libcdio}/bin:${cddiscid}/bin:${wget}/bin:${vorbisTools}/bin"
+        "$out/bin:${libcdio}/bin:${cddiscid}/bin:${wget}/bin:${vorbisTools}/bin:${id3v2}/bin:${lame}/bin"
 
       wrapProgram "$out/bin/cddb-tool" --prefix PATH ":" \
         "${wget}/bin"
@@ -58,4 +58,4 @@ in
         format, and tags them, all in one go.
       '';
     };
-  }
+  }

pkgs/applications/audio/amarok/default.nix

@@ -0,0 +1,31 @@
+{ stdenv, fetchurl, lib, cmake, qt4, qtscriptgenerator, perl, gettext, curl
+, libxml2, mysql, taglib, taglib_extras, loudmouth , kdelibs, automoc4, phonon
+, strigi, soprano, qca2, libmtp, liblastfm, libgpod, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  pname = "amarok";
+  version = "2.4.0";
+
+  src = fetchurl {
+    url = "mirror://kde/stable/${pname}/${version}/src/${name}.tar.bz2";
+    sha256 = "52be0e926d1362828a4bf64e2a174dc009c85f6f33da4ca589f0f09ab9b7085c";
+  };
+
+  QT_PLUGIN_PATH="${qtscriptgenerator}/lib/qt4/plugins";
+  buildInputs = [ cmake qt4 qtscriptgenerator perl stdenv.gcc.libc gettext curl
+    libxml2 mysql taglib taglib_extras loudmouth kdelibs automoc4 phonon strigi
+    soprano qca2 libmtp liblastfm libgpod pkgconfig ];
+
+  postInstall = ''
+    mkdir -p $out/nix-support
+    echo ${qtscriptgenerator} > $out/nix-support/propagated-user-env-packages
+  '';
+  meta = {
+    description = "Popular music player for KDE";
+    license = "GPL";
+    homepage = http://amarok.kde.org;
+    inherit (kdelibs.meta) platforms maintainers;
+  };
+}

pkgs/applications/audio/amarok/live.nix

@@ -0,0 +1,37 @@
+{ stdenv, fetchgit, fetchgitrevision
+, lib, cmake, qt4, qtscriptgenerator, perl, gettext, curl
+, libxml2, mysql, taglib, taglib_extras, loudmouth , kdelibs, automoc4, phonon
+, strigi, soprano, qca2, libmtp, liblastfm, libgpod, pkgconfig
+, repository ? "git://git.kde.org/amarok"
+, branch ? "heads/master"
+, rev ? fetchgitrevision repository branch
+, src ? fetchgit {
+    url = repository;
+    rev = rev;
+  }
+}:
+
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  pname = "amarok";
+  version = "live";
+
+  inherit src;
+
+  QT_PLUGIN_PATH="${qtscriptgenerator}/lib/qt4/plugins";
+  buildInputs = [ cmake qt4 qtscriptgenerator perl stdenv.gcc.libc gettext curl
+    libxml2 mysql taglib taglib_extras loudmouth kdelibs automoc4 phonon strigi
+    soprano qca2 libmtp liblastfm libgpod pkgconfig ];
+
+  postInstall = ''
+    mkdir -p $out/nix-support
+    echo ${qtscriptgenerator} > $out/nix-support/propagated-user-env-packages
+  '';
+  meta = {
+    description = "Popular music player for KDE";
+    license = "GPL";
+    homepage = http://amarok.kde.org;
+    inherit (kdelibs.meta) maintainers;
+  };
+}

pkgs/applications/audio/ardour/default.nix

@@ -1,7 +1,10 @@
-args: with args;
+{ stdenv, fetchurl, scons, boost, pkgconfig, fftw, librdf_raptor
+, librdf_rasqal, jackaudio, flac, libsamplerate, alsaLib, libxml2
+, libxslt, libsndfile, libsigcxx, libusb, cairomm, glib, pango
+, gtk, glibmm, gtkmm, libgnomecanvas, librdf, liblo, aubio
+, fftwSinglePrec, libmad }:
 
 stdenv.mkDerivation {
-
   name = "ardour-2.8.2";
 
   # svn is the source to get official releases from their site?
@@ -13,11 +16,10 @@ stdenv.mkDerivation {
   };
 
   buildInputs = [
-    scons boost
-    pkgconfig fftw redland librdf_raptor librdf_rasqal jackaudio flac
-    libsamplerate alsaLib libxml2 libxslt libsndfile libsigcxx libusb cairomm
-    glib pango gtk glibmm gtkmm libgnomecanvas fftw librdf liblo aubio
-    fftw fftwSinglePrec libmad
+    scons boost pkgconfig fftw librdf_raptor librdf_rasqal jackaudio
+    flac libsamplerate alsaLib libxml2 libxslt libsndfile libsigcxx
+    libusb cairomm glib pango gtk glibmm gtkmm libgnomecanvas librdf
+    liblo aubio fftwSinglePrec libmad
   ];
 
   buildPhase = ''
@@ -25,16 +27,17 @@ stdenv.mkDerivation {
     export CXX=g++
     scons PREFIX=$out install
   '';
+  
   installPhase = ":";
 
   meta = { 
-    description = "multi-track hard disk recording software";
+    description = "Multi-track hard disk recording software";
     longDescription = ''
-      Also read "the importance of Paying Something on their homepage, pelase!"
+      Also read "The importance of Paying Something" on their homepage, please!
     '';
     homepage = http://ardour.org/;
     license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.marcweber ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/audacious/default.nix

@@ -0,0 +1,54 @@
+{ stdenv, fetchurl, pkgconfig, glib, gtk, libmowgli, libmcs
+, gettext, dbus_glib, libxml2, libmad, xlibs, alsaLib, libogg
+, libvorbis, libcdio, libcddb, flac, ffmpeg
+}:
+
+stdenv.mkDerivation rec {
+  name = "audacious-2.4.2";
+  
+  src = fetchurl {
+    url = "http://distfiles.atheme.org/${name}.tgz";
+    sha256 = "03dd0fn17znjbmnc7hiafsg1axiwysk9q4r21s6giy2yfwhi8b30";
+  };
+
+  pluginsSrc = fetchurl {
+    url = "http://distfiles.atheme.org/audacious-plugins-2.4.2.tgz";
+    sha256 = "1a2vbqyamlpvnhr3mm8b5i9304d16c796v2ycw3i396ppjvnhyxz";
+  };
+  
+  # `--enable-amidiplug' is to prevent configure from looking in /proc/asound.
+  configureFlags = "--enable-amidiplug";
+  
+  buildInputs =
+    [ gettext pkgconfig glib gtk libmowgli libmcs libxml2 dbus_glib
+      libmad xlibs.libXcomposite libogg libvorbis flac alsaLib libcdio
+      libcddb ffmpeg
+    ];
+
+  # Here we build bouth audacious and audacious-plugins in one
+  # derivations, since they really expect to be in the same prefix.
+  # This is slighly tricky.
+  builder = builtins.toFile "builder.sh"
+    ''
+      # First build audacious.
+      (
+        source $stdenv/setup
+        genericBuild
+      )
+
+      # Then build the plugins.
+      (
+        buildNativeInputs="$out $buildNativeInputs" # to find audacious
+        source $stdenv/setup
+        rm -rfv audacious-*
+        src=$pluginsSrc
+        genericBuild
+      )
+    '';
+
+  meta = {
+    description = "Audacious, a media player forked from the Beep Media Player, which was itself an XMMS fork";
+    homepage = http://audacious-media-player.org/;
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+  };
+}

pkgs/applications/audio/audacious/player.nix

@@ -1,32 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, glib, gtk, libmowgli
-, libglade, libmcs, gettext, xlibs, dbus_glib
-}:
-
-stdenv.mkDerivation {
-  name = "audacious-1.5.1";
-  
-  src = fetchurl {
-    url = http://distfiles.atheme.org/audacious-1.5.1.tbz2;
-    sha256 = "1s32pdgx85qkrq15wwmvdw7wbcbxcf3nrhqxi6y72aijqm6fjwnz";
-  };
-
-  buildInputs = [pkgconfig libglade libmcs gettext dbus_glib];
-
-  propagatedBuildInputs = [glib gtk libmowgli libmcs];
-
-  NIX_LDFLAGS = "-rpath ${xlibs.libX11}/lib";
-
-  # Otherwise we barf with "libgcc_s.so.1 must be installed for
-  # pthread_cancel to work" on exit, as it tries to find libgcc_s
-  # dynamically.
-  dontPatchELF = true;
-
-  preBuild = ''
-    ensureDir $out/lib
-  '';
-
-  meta = {
-    description = "Audacious, a media player forked from the Beep Media Player, which was itself an XMMS fork";
-    homepage = http://audacious-media-player.org/;
-  };
-}

pkgs/applications/audio/audacious/plugins.nix

@@ -1,33 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, audacious, dbus_glib, gettext
-, libmad, xlibs, alsaLib, taglib, libmpcdec, libogg, libvorbis
-, libcdio, libcddb, libxml2
-}:
-
-stdenv.mkDerivation {
-  name = "audacious-plugins-1.5.1";
-  
-  src = fetchurl {
-    url = http://distfiles.atheme.org/audacious-plugins-1.5.1.tbz2;
-    sha256 = "1ki5bd50g4vi4d0qzxynyrgaq2n4cwhbsxln9rwk8ppphvk9pawc";
-  };
-
-  buildInputs = [
-    pkgconfig audacious dbus_glib gettext libmad
-    xlibs.libXcomposite alsaLib taglib libmpcdec
-    libogg libvorbis libcdio libcddb libxml2
-  ];
-
-  preBuild = ''
-    makeFlagsArray=(pluginlibdir=$out/lib/audacious)
-  '';
-
-  NIX_LDFLAGS = "-L${audacious}/lib/audacious"; # needed because we override pluginlibdir
-
-  # `--enable-amidiplug' is to prevent configure from looking in /proc/asound.
-  configureFlags = "--enable-amidiplug";
-  
-  meta = {
-    description = "Plugins for the Audacious media player";
-    homepage = http://audacious-media-player.org/;
-  };
-}

pkgs/applications/audio/audacity/default.nix

@@ -1,22 +1,36 @@
 { stdenv, fetchurl, wxGTK, pkgconfig, gettext, gtk, glib, zlib, perl, intltool,
-  libogg, libvorbis, libmad
+  libogg, libvorbis, libmad, alsaLib, libsndfile, libsamplerate, flac, lame,
+  expat, id3lib, ffmpeg
   }:
 
-stdenv.mkDerivation {
-  name = "audacity-1.3.7";
+stdenv.mkDerivation rec {
+  version = "1.3.12";
+  name = "audacity-${version}";
 
   NIX_CFLAGS_COMPILE = "-fPIC -lgtk-x11-2.0 -lglib-2.0 -lgobject-2.0 -lz";
 
   src = fetchurl {
-    url = mirror://sourceforge/audacity/audacity-fullsrc-1.3.7.tar.bz2;
-    sha256 = "0b4arafpdyjjk52l6n7aw518hzm65iv9w5g39jqr2bmvn6a9qivi";
+    url = "mirror://sourceforge/audacity/audacity-minsrc-${version}-beta.tar.bz2";
+    sha256 = "f0f55839ca3013d2e43e5114c73d195bc34503685aeab683eafca4d1bbf3b768";
   };
   buildInputs = [ wxGTK pkgconfig gettext gtk glib zlib intltool perl 
-    libogg libvorbis libmad];
+    libogg libvorbis libmad alsaLib libsndfile libsamplerate flac lame
+    expat id3lib ffmpeg];
+
+  configureFlags = [
+    "--with-portmixer=no"
+  ];
+
+  dontDisableStatic = true;
+
+  preBuild = ''
+    (cd lib-src ; make portaudio-v19/lib/libportaudio.a ; ln -sf portaudio-v19/lib/.libs/libportaudio.a portaudio-v19/lib/libportaudio.a)
+  '';
 
   meta = {
     description = "Sound editor with graphical UI";
     homepage = http://audacity.sourceforge.net;
     license = "GPLv2+";
+    platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/audio/aumix/default.nix

@@ -5,22 +5,26 @@
 
 assert gtkGUI -> pkgconfig != null && gtk != null;
 
-stdenv.mkDerivation {
-  name = "aumix-2.8";
+stdenv.mkDerivation rec {
+  name = "aumix-2.9.1";
   src = fetchurl {
-    url = http://www.jpj.net/~trevor/aumix/aumix-2.8.tar.bz2;
-    sha256 = "636eef7f400c2f3df489c0d2fa21507e88692113561e75a40a26c52bc422d7fc";
+    url = "http://www.jpj.net/~trevor/aumix/releases/${name}.tar.bz2";
+    sha256 = "0a8fwyxnc5qdxff8sl2sfsbnvgh6pkij4yafiln0fxgg6bal7knj";
   };
 
   buildInputs = [ gettext ncurses ]
     ++ (if gtkGUI then [pkgconfig gtk] else []);
 
   meta = {
+    description = "Aumix, an audio mixer for X and the console";
     longDescription = ''
       Aumix adjusts an audio mixer from X, the console, a terminal,
       the command line or a script.
     '';
     homepage = http://www.jpj.net/~trevor/aumix.html;
-    license = "GPL";
+    license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/beast/default.nix

@@ -1,36 +1,37 @@
-args: with args;
-args.stdenv.mkDerivation {
+{ stdenv, fetchurl, zlib, guile, libart_lgpl, pkgconfig, intltool
+, gtk, glib, libogg, libvorbis, libgnomecanvas, gettext, perl }:
+
+stdenv.mkDerivation {
   name = "beast-0.7.1";
 
-  src = args.fetchurl {
+  src = fetchurl {
     url = ftp://beast.gtk.org/pub/beast/v0.7/beast-0.7.1.tar.bz2;
     sha256 = "0jyl1i1918rsn4296w07fsf6wx3clvad522m3bzgf8ms7gxivg5l";
   };
 
-  buildInputs =[zlib guile libart_lgpl pkgconfig intltool gtk glib
+  buildInputs =
+    [ zlib guile libart_lgpl pkgconfig intltool gtk glib
       libogg libvorbis libgnomecanvas gettext
-      ];
-
-  inherit bash perl;
+    ];
 
   patchPhase = ''
     unset patchPhase; patchPhase
     sed 's=-DG_DISABLE_DEPRECATED==g' -i `find -type f` # the patches didn't remove all occurences
-    sed 's=/bin/bash=/$bash/bin/bash=g' -i `find -type f`
-    sed 's=/usr/bin/perl=/$perl/bin/bash=g' -i `find -type f`
+    sed 's=/bin/bash=/${stdenv.shell}=g' -i `find -type f`
+    sed 's=/usr/bin/perl=/${perl}/bin/perl=g' -i `find -type f`
   '';
 
-  patches = [
-        (fetchurl {
-          url = mirror://gentoo/distfiles/beast-0.7.1-guile-1.8.diff.bz2;
-          sha256 = "dc5194deff4b0a0eec368a69090db682d0c3113044ce2c2ed017ddfec9d3814e";
-        })
-        ./patch.patch # patches taken from gentoo
-  ];
+  patches =
+    [ (fetchurl {
+        url = mirror://gentoo/distfiles/beast-0.7.1-guile-1.8.diff.bz2;
+        sha256 = "dc5194deff4b0a0eec368a69090db682d0c3113044ce2c2ed017ddfec9d3814e";
+      })
+      ./patch.patch # patches taken from gentoo
+    ];
 
   meta = { 
-      description = "BEAST - the Bedevilled Sound Engine";
-      homepage = http://beast.gtk.org;
-      license = ["GPL-2" "LGPL-2.1"];
+    description = "BEAST - the Bedevilled Sound Engine";
+    homepage = http://beast.gtk.org;
+    license = ["GPL-2" "LGPL-2.1"];
   };
 }

pkgs/applications/audio/bmp-plugins/musepack/builder.sh

@@ -1,6 +0,0 @@
-source $stdenv/setup
-
-ensureDir "$out/lib/bmp/Input"
-installFlags="install libdir=$out/lib/bmp/Input"
-
-genericBuild

pkgs/applications/audio/bmp-plugins/musepack/default.nix

@@ -1,11 +0,0 @@
-{stdenv, fetchurl, pkgconfig, bmp, libmpcdec, taglib}:
-
-stdenv.mkDerivation {
-  name = "bmp-plugin-musepack-1.2";
-  builder = ./builder.sh;
-  src = fetchurl {
-    url = http://files2.musepack.net/linux/plugins/bmp-musepack-1.2.tar.bz2;
-    md5 = "5fe0c9d341ca37d05c780a478f829a5f";
-  };
-  buildInputs = [pkgconfig bmp libmpcdec taglib];
-}

pkgs/applications/audio/bmp-plugins/wma/default.nix

@@ -1,19 +0,0 @@
-{stdenv, fetchurl, pkgconfig, bmp}:
-
-stdenv.mkDerivation {
-  name = "bmp-plugin-wma-1.0.5";
-  
-  src = fetchurl {
-    url = http://mcmcc.bat.ru/xmms-wma/xmms-wma-1.0.5.tar.bz2;
-    md5 = "5d62a0f969617aeb40096362c7a8a506";
-  };
-  
-  buildInputs = [pkgconfig bmp];
-
-  buildFlags = "-f Makefile.bmp";
-  
-  installPhase = ''
-    ensureDir "$out/lib/bmp/Input"
-    cp libwma.so "$out/lib/bmp/Input"
-  '';
-}

pkgs/applications/audio/bmp/default.nix

@@ -1,21 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, alsaLib, esound, libogg, libvorbis, id3lib
-, glib, gtk, libglade
-}:
-
-stdenv.mkDerivation {
-  name = "bmp-0.9.7.1";
-  src = fetchurl {
-    url = mirror://sourceforge/beepmp/bmp-0.9.7.1.tar.gz;
-    md5 = "c25d5a8d49cc5851d13d525a20023c4c";
-  };
-
-  buildInputs = [
-    pkgconfig alsaLib esound libogg libvorbis id3lib libglade
-  ];
-
-  meta = {
-    description = "Beep Media Player, an XMMS fork";
-  };
-
-  propagatedBuildInputs = [glib gtk];
-}

pkgs/applications/audio/cmus/default.nix

@@ -0,0 +1,21 @@
+{ stdenv, fetchurl, ncurses, pkgconfig, alsaLib, flac, libmad, ffmpeg, libvorbis, mpc, mp4v2 }:
+
+stdenv.mkDerivation rec {
+  name = "cmus-${version}";
+  version = "2.3.3";
+
+  configurePhase = "./configure prefix=$out";
+
+  buildInputs = [ ncurses pkgconfig alsaLib flac libmad ffmpeg libvorbis mpc mp4v2 ];
+
+  src = fetchurl {
+    url = "mirror://sourceforge/cmus/cmus-v${version}.tar.bz2";
+    sha256 = "13hc5d7h2ayjwnip345hc59rpjj9fgrp1i5spjw3s14prdqr733v";
+  };
+
+  meta = {
+    description = "cmus is a small, fast and powerful console music player for Linux and *BSD";
+    homepage = http://cmus.sourceforge.net;
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

pkgs/applications/audio/espeak/default.nix

@@ -0,0 +1,29 @@
+{stdenv, fetchurl, unzip, portaudio }:
+
+stdenv.mkDerivation {
+  name = "espeak-1.44.03";
+  src = fetchurl {
+    url = mirror://sourceforge/espeak/espeak-1.44.03-source.zip;
+    sha256 = "0lnv89xmsq3bax0qpabd0z2adaag7mdl973bkw3gdszidafmfyx4";
+  };
+
+  buildInputs = [ unzip portaudio ];
+
+  patchPhase = ''
+    sed -e s,/bin/ln,ln,g -i src/Makefile
+    sed -e 's,^CXXFLAGS=-O2,CXXFLAGS=-O2 -D PATH_ESPEAK_DATA=\\\"$(DATADIR)\\\",' -i src/Makefile
+  '' + (if portaudio.api_version == 19 then ''
+    cp src/portaudio19.h src/portaudio.h
+  '' else "");
+
+  configurePhase = ''
+    cd src
+    makeFlags="PREFIX=$out"
+  '';
+
+  meta = {
+    description = "Compact open source software speech synthesizer";
+    homepage = http://espeak.sourceforge.net/;
+    license = "GPLv3+";
+  };
+}

pkgs/applications/audio/gmu/default.nix

@@ -0,0 +1,35 @@
+{stdenv, fetchurl, SDL, SDL_gfx, SDL_image, tremor, flac, mpg123, libmikmod
+, speex
+, keymap ? "newdefault"
+, conf ? "unknown"
+}:
+
+stdenv.mkDerivation rec {
+  name = "gmu-0.7.2";
+  
+  src = fetchurl {
+    url = http://wejp.k.vu/files/gmu-0.7.2.tar.gz;
+    sha256 = "0gvhwhhlj64lc425wqch4g6v59ldd5i3rxll3zdcrdgk2vkh8nys";
+  };
+
+  buildInputs = [ SDL SDL_gfx SDL_image tremor flac mpg123 libmikmod speex ];
+
+  NIX_LDFLAGS = "-lgcc_s";
+
+  preBuild = ''
+    makeFlags="$makeFlags PREFIX=$out"
+  '';
+
+  postInstall = ''
+    cp ${keymap}.keymap $out/share/gmu/default.keymap
+    cp gmuinput.${conf}.conf $out/share/gmu/gmuinput.conf
+    ensureDir $out/etc/gmu
+    cp gmu.${conf}.conf $out/etc/gmu/gmu.conf
+  '';
+
+  meta = {
+    homepage = http://wejp.k.vu/projects/gmu;
+    description = "Open source music player for portable gaming consoles and handhelds";
+    license = "GPLv2";
+  };
+}

pkgs/applications/audio/gtkpod/default.nix

@@ -1,14 +1,16 @@
-{ stdenv, fetchurl, pkgconfig, libgpod, gtk, glib, gettext, perl, perlXMLParser, libglade, flex, libid3tag, libvorbis }:
+{ stdenv, fetchurl, pkgconfig, libgpod, gtk, glib, gettext, perl, perlXMLParser
+, libglade, flex, libid3tag, libvorbis, intltool }:
 
 stdenv.mkDerivation {
-  name = "gtkpod-0.99.14";
+  name = "gtkpod-1.0.0";
 
   src = fetchurl {
-    url = mirror://sourceforge/gtkpod/gtkpod-0.99.14.tar.gz;
-    sha256 = "0ggcfyhcdlf3br88csdki215k4clxixa192afz6f16k7h8s2iqbk";
+    url = mirror://sourceforge/gtkpod/gtkpod-1.0.0.tar.gz;
+    sha256 = "04jzybs55c27kyp7r9c58prcq0q4ssvj5iggva857f49s1ar826q";
   };
 
-  buildInputs = [ pkgconfig libgpod gettext perl perlXMLParser gtk libglade flex libid3tag libvorbis ];
+  buildInputs = [ pkgconfig libgpod gettext perl perlXMLParser gtk libglade flex
+    libid3tag libvorbis intltool ];
 
   patchPhase = ''
     sed -i 's/which/type -P/' scripts/*.sh
@@ -18,5 +20,6 @@ stdenv.mkDerivation {
     description = "GTK Manager for an Apple ipod";
     homepage = http://gtkpod.sourceforge.net;
     license = "GPLv2+";
+    platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/audio/id3v2/default.nix

@@ -0,0 +1,28 @@
+{stdenv, fetchurl, id3lib, groff}:
+
+stdenv.mkDerivation rec {
+  name = "id3v2-0.1.11";
+  src = fetchurl {
+    url = "mirror://sourceforge/id3v2/${name}.tar.gz";
+    sha256 = "00r6f9yzmkrqa62dnkm8njg5cjzhmy0l17nj1ba15nrrm0mnand4";
+  };
+
+  patches = [ ./id3v2-0.1.11-track-bad-free.patch ];
+
+  buildNativeInputs = [ groff ];
+  buildInputs = [ id3lib ];
+
+  configurePhase = ''
+    export makeFlags=PREFIX=$out
+  '';
+
+  preInstall = ''
+    ensureDir $out/bin $out/man/man1
+  '';
+
+  meta = {
+    description = "A command line editor for id3v2 tags";
+    homepage = http://id3v2.sourceforge.net/;
+    license = "GPLv2+";
+  };
+}

pkgs/applications/audio/id3v2/id3v2-0.1.11-track-bad-free.patch

@@ -0,0 +1,14 @@
+http://sourceforge.net/tracker/index.php?func=detail&aid=1252035&group_id=4193&atid=304193
+
+diff -up id3v2-0.1.11/id3v2.cpp~ id3v2-0.1.11/id3v2.cpp
+--- id3v2-0.1.11/id3v2.cpp~	2004-05-04 21:30:15.000000000 +0300
++++ id3v2-0.1.11/id3v2.cpp	2008-01-03 21:22:02.000000000 +0200
+@@ -423,7 +423,7 @@ int main( int argc, char *argv[])
+         {
+           // check if there is a total track number and if we only have 
+           // the track number for this file.  In this case combine them.
+-          char *currentTrackNum, *newTrackNum;
++          char *currentTrackNum, *newTrackNum = NULL;
+ 
+           if (pFrame != NULL) 
+           {

pkgs/applications/audio/jackmeter/default.nix

@@ -1,23 +1,20 @@
-args: with args;
+{ stdenv, fetchurl, jackaudio, pkgconfig }:
 
-let name = "jackmeter-0.3";
-in
-stdenv.mkDerivation {
-
-  inherit name;
+stdenv.mkDerivation rec {
+  name = "jackmeter-0.3";
 
   src = fetchurl {
     url = "http://www.aelius.com/njh/jackmeter/${name}.tar.gz";
     sha256 = "03siznnq3f0nnqyighgw9qdq1y4bfrrxs0mk6394pza3sz4b6sgp";
   };
 
-  buildInputs = [jackaudio pkgconfig];
+  buildInputs = [ jackaudio pkgconfig ];
 
   meta = { 
-    description = "console jack loudness meter";
+    description = "Console jack loudness meter";
     homepage = http://www.aelius.com/njh/jackmeter/;
     license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.marcweber ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/ladspa-plugins/default.nix

@@ -1,27 +1,22 @@
-args: with args;
-	let localDefs = builderDefs.passthru.function {
-		src = 
-		fetchurl {
-			url = http://plugin.org.uk/releases/0.4.15/swh-plugins-0.4.15.tar.gz;
-			sha256 = "0h462s4mmqg4iw7zdsihnrmz2vjg0fd49qxw2a284bnryjjfhpnh";
-		};
-		buildInputs = [fftw ladspaH pkgconfig];
-		configureFlags = [];
-	};
-	in with localDefs;
-let
-	postInstall = fullDepEntry ("
-		ensureDir \$out/share/ladspa/
-		ln -s \$out/lib/ladspa \$out/share/ladspa/lib
-	") [minInit defEnsureDir];
-in
+{ stdenv, fetchurl, fftw, ladspaH, pkgconfig }:
+
 stdenv.mkDerivation {
-	name = "swh-plugins-0.4.15";
-	builder = writeScript "swh-plugins-0.4.15-builder"
-		(textClosure localDefs [doConfigure doMakeInstall 
-			postInstall doForceShare]);
-	meta = {
-		description = "LADSPA format audio plugins";
-		inherit src;
-	};
+  name = "swh-plugins-0.4.15";
+
+  src = fetchurl {
+    url = http://plugin.org.uk/releases/0.4.15/swh-plugins-0.4.15.tar.gz;
+    sha256 = "0h462s4mmqg4iw7zdsihnrmz2vjg0fd49qxw2a284bnryjjfhpnh";
+  };
+  
+  buildInputs = [fftw ladspaH pkgconfig];
+
+  postInstall =
+    ''
+      ensureDir $out/share/ladspa/
+      ln -sv $out/lib/ladspa $out/share/ladspa/lib
+    '';
+
+  meta = {
+    description = "LADSPA format audio plugins";
+  };
 }

pkgs/applications/audio/ladspa-plugins/ladspah.nix

@@ -1,28 +1,28 @@
-args: with args;
+{ stdenv, fetchurl, builderDefs }:
+
 let 
-	src = 
-	fetchurl {
-		url = http://www.ladspa.org/ladspa_sdk/ladspa.h.txt;
-		sha256 = "1b908csn85ng9sz5s5d1mqk711cmawain2z8px2ajngihdrynb67";
-	};
+  src = fetchurl {
+    url = http://www.ladspa.org/ladspa_sdk/ladspa.h.txt;
+    sha256 = "1b908csn85ng9sz5s5d1mqk711cmawain2z8px2ajngihdrynb67";
+  };
 in
-	let localDefs = builderDefs.passthru.function {
-		buildInputs = [];
-		inherit src;
-	};
-	in with localDefs;
+  let localDefs = builderDefs.passthru.function {
+    buildInputs = [];
+    inherit src;
+  };
+  in with localDefs;
 let
-	copyFile = fullDepEntry ("
-		ensureDir \$out/include
-		cp ${src} \$out/include/ladspa.h
-	") [minInit defEnsureDir];
+  copyFile = fullDepEntry ("
+    ensureDir \$out/include
+    cp ${src} \$out/include/ladspa.h
+  ") [minInit defEnsureDir];
 in
 stdenv.mkDerivation {
-	name = "ladspa.h";
-	builder = writeScript "ladspa.h-builder"
-		(textClosure localDefs [copyFile]);
-	meta = {
-		description = "LADSPA format audio plugins";
-		inherit src;
-	};
+  name = "ladspa.h";
+  builder = writeScript "ladspa.h-builder"
+    (textClosure localDefs [copyFile]);
+  meta = {
+    description = "LADSPA format audio plugins";
+    inherit src;
+  };
 }

pkgs/applications/audio/lame/default.nix

@@ -1,12 +1,16 @@
-{stdenv, fetchurl}:
+{stdenv, fetchurl, nasm}:
 
-stdenv.mkDerivation {
-  name = "lame-3.98.2";
+stdenv.mkDerivation rec {
+  name = "lame-3.98.4";
   src = fetchurl {
-    url = mirror://sourceforge/lame/lame-398-2.tar.gz;
-    sha256 = "0cmgr515szd9kd19mpzvwl3cbnpfyjyi47swj4afblcfkmb2hym1";
+    url = "mirror://sourceforge/lame/${name}.tar.gz";
+    sha256 = "1j3jywv6ic2cy0x0q1a1h6rcl6xmcs5f58xawjdkl8hpcv3l8cdc";
   };
 
+  buildInputs = [ nasm ];
+
+  configureFlags = [ "--enable-nasm" ];
+
   # Either disable static, or fix the rpath of 'lame' for it to point
   # properly to the libmp3lame shared object.
   dontDisableStatic = true;

pkgs/applications/audio/mp3info/default.nix

@@ -0,0 +1,42 @@
+{ fetchurl, stdenv, ncurses, pkgconfig, gtk }:
+
+stdenv.mkDerivation rec {
+  name = "mp3info-0.8.5a";
+
+  src = fetchurl {
+    url = "ftp://ftp.ibiblio.org/pub/linux/apps/sound/mp3-utils/mp3info/${name}.tgz";
+    sha256 = "042f1czcs9n2sbqvg4rsvfwlqib2gk976mfa2kxlfjghx5laqf04";
+  };
+
+  buildInputs = [ ncurses pkgconfig gtk ];
+
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^prefix=.*$|prefix=$out|g ;
+               s|/bin/rm|rm|g ;
+               s|/usr/bin/install|install|g"
+    '';
+
+  preInstall =
+    '' ensureDir "$out/bin"
+       ensureDir "$out/man/man1"
+    '';
+
+  meta = {
+    description = "MP3Info, an MP3 technical info viewer and ID3 1.x tag editor";
+
+    longDescription =
+      '' MP3Info is a little utility used to read and modify the ID3 tags of
+         MP3 files.  MP3Info can also display various techincal aspects of an
+         MP3 file including playing time, bit-rate, sampling frequency and
+         other attributes in a pre-defined or user-specifiable output format.
+      '';
+
+    homepage = http://www.ibiblio.org/mp3info/;
+
+    license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.unix;
+  };
+}

pkgs/applications/audio/mpg123/default.nix

@@ -0,0 +1,23 @@
+{stdenv, fetchurl, alsaLib }:
+
+stdenv.mkDerivation {
+  name = "mpg123-1.12.3";
+
+  src = fetchurl {
+    url = mirror://sourceforge/mpg123/mpg123-1.12.3.tar.bz2;
+    sha256 = "1ij689s7jch3d4g0ja3jylaphallc8vgrsrm9b12254phnyy23xf";
+  };
+
+  buildInputs = [ alsaLib ];
+
+  crossAttrs = {
+    configureFlags = if stdenv.cross ? mpg123 then
+      "--with-cpu=${stdenv.cross.mpg123.cpu}" else "";
+  };
+
+  meta = {
+    description = "Command-line MP3 player";
+    homepage = http://mpg123.sourceforge.net/;
+    license = "LGPL";
+  };
+}

pkgs/applications/audio/pavucontrol/default.nix

@@ -2,11 +2,11 @@
 , libglademm, libcanberra, intltool, gettext }:
 
 stdenv.mkDerivation rec {
-  name = "pavucontrol-0.9.7";
+  name = "pavucontrol-0.9.10";
 
   src = fetchurl {
     url = "http://0pointer.de/lennart/projects/pavucontrol/${name}.tar.gz";
-    sha256 = "1a1v06hbl1j78ryqy5aiccg6w5hf1yzday2b9h31kx7vr42ir1w0";
+    sha256 = "0g2sd9smwwpnyq8yc65dl9z0iafj2rrimi8v58wkxx98vhnnvsby";
   };
 
   buildInputs = [ pkgconfig pulseaudio gtkmm libsigcxx libglademm libcanberra
@@ -26,5 +26,8 @@ stdenv.mkDerivation rec {
     homepage = http://0pointer.de/lennart/projects/pavucontrol/;
 
     license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
   };
 }

pkgs/applications/audio/qjackctl/default.nix

@@ -1,20 +1,20 @@
-args:
-args.stdenv.mkDerivation {
+{ stdenv, fetchurl, qt4, alsaLib, jackaudio }:
+
+stdenv.mkDerivation {
+  name = "qjackctl-0.3.3";
 
   # some dependencies such as killall have to be installed additionally
 
-  name = "qjackctl-0.3.3";
-
-  src = args.fetchurl {
+  src = fetchurl {
     url = http://downloads.sourceforge.net/qjackctl/qjackctl-0.3.3.tar.gz;
     sha256 = "1z9v208fs79ka6ni3p5v5xb0k5y1wqqm2a9cf903387b9p3fhpxj";
   };
 
-  buildInputs =(with args; [qt4 alsaLib jackaudio]);
+  buildInputs = [ qt4 alsaLib jackaudio ];
 
   meta = { 
-      description = "qt jackd control gui tool";
-      homepage = http://qjackctl.sourceforge.net/;
-      license = "GPL";
+    description = "qt jackd control gui tool";
+    homepage = http://qjackctl.sourceforge.net/;
+    license = "GPL";
   };
 }

pkgs/applications/audio/sonic-visualizer/default.nix

@@ -1,11 +1,10 @@
 # TODO add plugins having various licenses, see http://www.vamp-plugins.org/download.html
 
-args: with args;
+{ stdenv, fetchurl, libsndfile, qt, fftw, librdf, rubberband
+, libsamplerate, vampSDK, alsaLib, librdf_raptor, librdf_rasqal
+, redland, jackaudio, pulseaudio, libmad, libogg, liblo, bzip2 }:
 
 stdenv.mkDerivation {
-
-#TODO add plugins!
-
   name = "sonic-visualizer-1.6";
 
   src = fetchurl {
@@ -13,16 +12,17 @@ stdenv.mkDerivation {
     sha256 = "1dbqqa7anii2jnjpfwm4sr83nn4bwmz68xw4n6clycsz5iqk52f5";
   };
 
-  buildInputs = [libsndfile qt fftw /* should be fftw3f ??*/ bzip2 librdf rubberband
-    libsamplerate vampSDK alsaLib librdf_raptor librdf_rasqal redland
-    # optional
-    jackaudio
-    # portaudio
-    pulseaudio
-    libmad
-    libogg # ?
-    # fishsound
-    liblo
+  buildInputs =
+    [ libsndfile qt fftw /* should be fftw3f ??*/ bzip2 librdf rubberband
+      libsamplerate vampSDK alsaLib librdf_raptor librdf_rasqal redland
+      # optional
+      jackaudio
+      # portaudio
+      pulseaudio
+      libmad
+      libogg # ?
+      # fishsound
+      liblo
     ];
 
   buildPhase = ''
@@ -39,7 +39,7 @@ stdenv.mkDerivation {
     description = "View and analyse contents of music audio files";
     homepage = http://www.sonicvisualiser.org/;
     license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.marcweber ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/spotify/default.nix

@@ -0,0 +1,63 @@
+{ fetchurl, stdenv, dpkg, xlibs, qt4, alsaLib, makeWrapper }:
+
+assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
+
+let version = "0.4.9.302"; in
+
+stdenv.mkDerivation {
+  name = "spotify-${version}";
+
+  src =
+    if stdenv.system == "i686-linux" then 
+      fetchurl {
+        url = "http://repository.spotify.com/pool/non-free/s/spotify/spotify-client-qt_${version}.g604b4fb-1_i386.deb";
+        sha256 = "1kw3jfvz8a9v6zl3yh6f51vsick35kmcf7vkbjb6wl0nk1a8q8gg";
+      }
+    else if stdenv.system == "x86_64-linux" then 
+      fetchurl {
+        url = "http://repository.spotify.com/pool/non-free/s/spotify/spotify-client-qt_${version}.g604b4fb-1_amd64.deb";
+        sha256 = "1cghs3hwmqnd7g62g1h2bf3yvxgjq8b94vzhp1w9ysb5rswyjkyv";
+      }
+    else throw "Spotify not supported on this platform.";
+
+  buildInputs = [ dpkg makeWrapper ];
+
+  unpackPhase = "true";
+  
+  installPhase =
+    ''
+      mkdir -p $out
+      dpkg-deb -x $src $out
+      mv $out/usr/* $out/
+      rmdir $out/usr
+
+      patchelf \
+        --interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" \
+        --set-rpath ${stdenv.lib.makeLibraryPath [ xlibs.libXScrnSaver qt4 alsaLib stdenv.gcc.gcc ]}:${stdenv.gcc.gcc}/lib64 \
+        $out/bin/spotify
+
+      preload=$out/libexec/spotify/libpreload.so
+      mkdir -p $out/libexec/spotify
+      gcc -shared ${./preload.c} -o $preload -ldl -DOUT=\"$out\" -fPIC
+
+      wrapProgram $out/bin/spotify --set LD_PRELOAD $preload
+    ''; # */
+
+  dontStrip = true;
+  dontPatchELF = true;
+
+  meta = {
+    homepage = https://www.spotify.com/download/previews/;
+    description = "Spotify for Linux allows you to play music from the Spotify music service";
+    license = "unfree";
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+
+    longDescription =
+      ''
+        Spotify is a digital music streaming service.  This package
+        provides the Spotify client for Linux.  At present, it does not
+        work with free Spotify accounts; it requires a Premium or
+        Unlimited account.
+      '';
+  };
+}

pkgs/applications/audio/spotify/preload.c

@@ -0,0 +1,59 @@
+/* Spotify looks for its theme data in /usr/share/spotify/theme.  This
+   LD_PRELOAD library intercepts open() and stat() calls to redirect
+   them to the corresponding location in $out. */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <limits.h>
+
+char themeDir [] = "/usr/share/spotify/theme";
+char realThemeDir [] = OUT "/share/spotify/theme";
+
+const char * rewrite(const char * path, char * buf)
+{
+    if (strncmp(path, themeDir, sizeof(themeDir) - 1) != 0) return path;
+    if (snprintf(buf, PATH_MAX, "%s%s", realThemeDir, path + sizeof(themeDir) - 1) >= PATH_MAX)
+        abort();
+    return buf;
+}
+
+int open(const char *path, int flags, ...)
+{
+    char buf[PATH_MAX];
+    int (*_open) (const char *, int, mode_t) = dlsym(RTLD_NEXT, "open");
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = va_arg(ap, mode_t);
+        va_end(ap);
+    }
+    return _open(rewrite(path, buf), flags, mode);
+}
+
+int open64(const char *path, int flags, ...)
+{
+    char buf[PATH_MAX];
+    int (*_open64) (const char *, int, mode_t) = dlsym(RTLD_NEXT, "open64");
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = va_arg(ap, mode_t);
+        va_end(ap);
+    }
+    return _open64(rewrite(path, buf), flags, mode);
+}
+
+int __xstat64(int ver, const char *path, struct stat64 *st)
+{
+    char buf[PATH_MAX];
+    int (*___xstat64) (int ver, const char *, struct stat64 *) = dlsym(RTLD_NEXT, "__xstat64");
+    return ___xstat64(ver, rewrite(path, buf), st);
+}

pkgs/applications/display-managers/slim/default.nix

@@ -1,11 +1,11 @@
 {stdenv, fetchurl, x11, libjpeg, libpng, libXmu, freetype, pam}:
 
 stdenv.mkDerivation rec {
-  name = "slim-1.3.1";
+  name = "slim-1.3.2";
 
   src = fetchurl {
     url = "http://download.berlios.de/slim/${name}.tar.gz";
-    sha256 = "0xqgzvg6h1bd29140mcgg9r16vcmskz7zmym7i7jlz7x9c1a9mxc";
+    sha256 = "1f42skdp5k1zrb364s3i0ps5wmx9szz9h192i2dkn9az00jh2mpi";
   };
 
   patches = [

pkgs/applications/editors/bvi/default.nix

@@ -1,4 +1,5 @@
-args : with args;
+{ stdenv, fetchurl, ncurses }:
+
 stdenv.mkDerivation {
   name = "bvi-1.3.2";
 
@@ -7,11 +8,11 @@ stdenv.mkDerivation {
     sha256 = "110wxqnyianqamxq4y53drqqxb9vp4k2fcvic45qggvlqkqhlfgz";
   };
 
-  buildInputs = [ncurses];
+  buildInputs = [ ncurses ];
 
   meta = { 
-      description = "hex editor with vim style keybindings";
-      homepage = http://bvi.sourceforge.net/download.html;
-      license = "GPL2";
+    description = "Hex editor with vim style keybindings";
+    homepage = http://bvi.sourceforge.net/download.html;
+    license = "GPL2";
   };
 }

pkgs/applications/editors/eclipse/default.nix

@@ -1,24 +1,115 @@
 { stdenv, fetchurl, patchelf, makeDesktopItem, makeWrapper
 , freetype, fontconfig, libX11, libXext, libXrender, zlib
 , glib, gtk, libXtst, jre
+ # defaulting to this version because not all installable plugins work with 3.5.2 yet
+ # can also be set to "latest"
+, version ? "3.5.1"
 }:
 
+/*
+  Note: Eclipse stores various Eclipse instance specific data in ~/.eclipse/*-instance/...
+  The '*' depends on the executable location of Eclipse.
+
+  So if an Eclipse dependency such as gtk changes a different Eclipse setup directory will be used and
+  the plugins and update site list and more global settings seem to be gone.
+
+  Staring Eclipse from ~/.nix-profile/bin/eclipse doesn't help.
+
+  So I suggest copying the store path to ~/eclipse and run ~/eclipse/bin/eclipse instead.
+
+  However this still has some drawbacks: If you run nix-collect-garbage the gtk
+  libs the wrapper refers to might be gone. It should be easy for you to
+  replace the imortant lines in the wrapper.
+
+  You can also put this eclipse wrapper script (which was removed from
+  all-packages.nix -r 18458)
+  to your packageOverrides section and use that to run eclipse/eclipse.
+
+  Its parameterized by system because you may want to run both: i686 and x86_64 systems.
+
+    eclipseRunner =
+      pkgs.stdenv.mkDerivation {
+      name = "nix-eclipse-runner-script-${stdenv.system}";
+
+      phases = "installPhase";
+      installPhase = ''
+        ensureDir $out/bin
+        target=$out/bin/nix-run-eclipse-${stdenv.system}
+        cat > $target << EOF
+        #!/bin/sh
+        export PATH=${pkgs.jre}/bin:\$PATH
+        export LD_LIBRARY_PATH=${pkgs.gtkLibs216.glib}/lib:${pkgs.gtkLibs216.gtk}/lib:${pkgs.xlibs.libXtst}/lib
+        # If you run out of XX space try these? -vmargs -Xms512m -Xmx2048m -XX:MaxPermSize=256m
+        eclipse="\$1"; shift
+        exec \$eclipse -vmargs -Xms512m -Xmx2048m -XX:MaxPermSize=256m "\$@"
+        EOF
+        chmod +x $target
+      '';
+
+      meta = {
+        description = "provide environment to run Eclipse";
+        longDescription = ''
+          Is there one distribution providing support for up to date Eclipse installations?
+          There are various reasons why not.
+          Installing binaries just works. Get Eclipse binaries form eclipse.org/downloads
+          install this wrapper then run Eclipse like this:
+          nix-run-eclipse $PATH_TO_ECLIPSE/eclipse/eclipse
+          and be happy. Everything works including update sites.
+        '';
+        maintainers = [pkgs.lib.maintainers.marcweber];
+        platforms = pkgs.lib.platforms.linux;
+      };
+    };
+
+*/
+
+
+let
+
+  v = if version == "latest" then "3.5.2" else version;
+
+in
+
 assert stdenv ? glibc;
 
 stdenv.mkDerivation rec {
-  name = "eclipse-3.5.1";
+  name = "eclipse-${v}";
   
   src =
-    if stdenv.system == "x86_64-linux" then
-      fetchurl {
+    if v == "3.5.2" then
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://ftp-stud.fht-esslingen.de/pub/Mirrors/eclipse/eclipse/downloads/drops/R-3.5.2-201002111343/eclipse-SDK-3.5.2-linux-gtk-x86_64.tar.gz;
+          md5 = "54e2ce0660b2b1b0eb4267acf70ea66d";
+        }
+      else
+        fetchurl {
+          url = http://mirror.selfnet.de/eclipse/eclipse/downloads/drops/R-3.5.2-201002111343/eclipse-SDK-3.5.2-linux-gtk.tar.gz;
+          md5 = "bde55a2354dc224cf5f26e5320e72dac";
+        }
+    else if v == "3.5.1" then
+     if stdenv.system == "x86_64-linux" then
+       fetchurl {
         url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.5.1-200909170800/eclipse-SDK-3.5.1-linux-gtk-x86_64.tar.gz;
         sha256 = "132zd7q9q29h978wnlsfbrlszc85r1wj30yqs2aqbv3l5xgny1kk";
-      }
-    else
-      fetchurl {
+       }
+     else
+       fetchurl {
         url = http://mirrors.linux-bg.org/eclipse/eclipse/downloads/drops/R-3.5.1-200909170800/eclipse-SDK-3.5.1-linux-gtk.tar.gz;
         sha256 = "0a0lpa7gxg91zswpahi6fvg3csl4csvlym4z2ad5cc1d4yvicp56";
-      };
+      }
+    else if v == "3.6.1" then
+     if stdenv.system == "x86_64-linux" then
+       fetchurl {
+        url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.6.1-201009090800/eclipse-SDK-3.6.1-linux-gtk-x86_64.tar.gz;
+        sha256 = "1cg9rrb5w978sdqbzz9lnli1lds9zhb6wfsj3wp725bqf1i6v9lg";
+       }
+     else
+       fetchurl {
+        url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.6.1-201009090800/eclipse-SDK-3.6.1-linux-gtk.tar.gz;
+        sha256 = "0s48rjaswi8m5gan1zlqvfwb4l06x5nslkq41wpkrbyj9ka8gh4x";
+      }
+    else throw "no source for eclipse version ${v} known";
 
   desktopItem = makeDesktopItem {
     name = "Eclipse";
@@ -51,9 +142,12 @@ stdenv.mkDerivation rec {
     ensureDir $out/share/applications
     cp ${desktopItem}/share/applications/* $out/share/applications
   '';
-
+  
   meta = {
     homepage = http://www.eclipse.org/;
     description = "A extensible multi-language software development environment";
+    longDescription = ''
+    '';
   };
+  
 }

pkgs/applications/editors/ed/default.nix

@@ -10,6 +10,10 @@ stdenv.mkDerivation rec {
 
   doCheck = true;
 
+  crossAttrs = {
+    compileFlags = [ "CC=${stdenv.cross.config}-gcc" ];
+  };
+
   meta = {
     description = "GNU ed, an implementation of the standard Unix editor";
 

pkgs/applications/editors/emacs-22/default.nix

@@ -16,17 +16,17 @@ stdenv.mkDerivation rec {
   name = "emacs-22.3";
 
   builder = ./builder.sh;
-  
+
   src = fetchurl {
     url = "mirror://gnu/emacs/${name}.tar.gz";
     sha256 = "05hd89bchcpwzcx5la0alcp0wb7xywvnf98dxrshrqlfvccvgnbv";
   };
-  
+
   buildInputs = [ncurses x11]
     ++ stdenv.lib.optional xawSupport (if xaw3dSupport then Xaw3d else libXaw)
     ++ stdenv.lib.optional xpmSupport libXpm
     ++ stdenv.lib.optionals gtkGUI [pkgconfig gtk];
-  
+
   configureFlags =
     stdenv.lib.optional gtkGUI "--with-x-toolkit=gtk";
 
@@ -43,6 +43,6 @@ stdenv.mkDerivation rec {
     homepage = http://www.gnu.org/software/emacs/;
     license = "GPLv3+";
 
-    platforms = stdenv.lib.platforms.linux;  # GTK & co. are needed.
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/applications/editors/emacs-23/default.nix

@@ -1,46 +1,35 @@
-{ xawSupport ? true
-, xpmSupport ? true
-, dbusSupport ? true
-, xaw3dSupport ? false
-, gtkGUI ? false
-, xftSupport ? false
-, stdenv, fetchurl, ncurses, x11, libXaw ? null, libXpm ? null, Xaw3d ? null
-, pkgconfig ? null, gtk ? null, libXft ? null, dbus ? null
-, libpng, libjpeg, libungif, libtiff, texinfo
+{ stdenv, fetchurl, ncurses, x11, libXaw, libXpm, Xaw3d
+, pkgconfig, gtk, libXft, dbus, libpng, libjpeg, libungif
+, libtiff, librsvg, texinfo, gconf
 }:
 
-assert xawSupport -> libXaw != null;
-assert xpmSupport -> libXpm != null;
-assert dbusSupport -> dbus != null;
-assert xaw3dSupport -> Xaw3d != null;
-assert gtkGUI -> pkgconfig != null && gtk != null;
-assert xftSupport -> libXft != null && libpng != null; # libpng = probably a bug
-assert stdenv.system == "i686-darwin" -> xawSupport; # fails to link otherwise
+assert (gtk != null) -> (pkgconfig != null);
+assert (libXft != null) -> libpng != null;	# probably a bug
+assert stdenv.isDarwin -> libXaw != null;	# fails to link otherwise
 
 stdenv.mkDerivation rec {
-  name = "emacs-23.1";
+  name = "emacs-23.3";
 
   builder = ./builder.sh;
 
   src = fetchurl {
     url = "mirror://gnu/emacs/${name}.tar.bz2";
-    sha256 = "076b4ixdp29l4c02bwic26d14gxlj0lcqyam33wyj3ksgi2z8d9b";
+    sha256 = "0kfa546qi0idkwk29gclgi13qd8q54pcqgy9qwjknlclszprdp3a";
   };
 
-  buildInputs = [
-    ncurses x11 texinfo
-    (if xawSupport then libXaw else null)
-    (if xpmSupport then libXpm else null)
-    (if dbusSupport then dbus else null)
-    (if xaw3dSupport then Xaw3d else null)
-    libpng libjpeg libungif libtiff # maybe not strictly required?
-  ]
-  ++ (if gtkGUI then [pkgconfig gtk] else [])
-  ++ (if xftSupport then [libXft] else []);
+  buildInputs = 
+    [ ncurses x11 texinfo libXaw Xaw3d libXpm libpng libjpeg libungif
+      libtiff librsvg libXft gconf
+    ] 
+    ++ stdenv.lib.optionals (gtk != null) [ gtk pkgconfig ]
+    ++ stdenv.lib.optional stdenv.isLinux dbus;
 
-  configureFlags = "
-    ${if gtkGUI then "--with-x-toolkit=gtk --enable-font-backend --with-xft" else ""}
-  ";
+  configureFlags =
+    stdenv.lib.optionals (gtk != null) [ "--with-x-toolkit=gtk" "--with-xft"]
+
+    # On NixOS, help Emacs find `crt*.o'.
+    ++ stdenv.lib.optional (stdenv ? glibc)
+         [ "--with-crt-dir=${stdenv.glibc}/lib" ];
 
   doCheck = true;
 
@@ -67,7 +56,7 @@ stdenv.mkDerivation rec {
     homepage = http://www.gnu.org/software/emacs/;
     license = "GPLv3+";
 
-    maintainers = [ stdenv.lib.maintainers.ludo ];
-    platforms = stdenv.lib.platforms.linux;  # GTK & co. are needed.
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.simons ];
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/applications/editors/emacs-modes/emms/default.nix

@@ -1,5 +1,5 @@
 { stdenv, fetchurl, emacs, texinfo
-, mpg321, vorbisTools, taglib, alsaUtils }:
+, mpg321, vorbisTools, taglib, mp3info, alsaUtils }:
 
 # XXX: EMMS also supports Xine, MPlayer, Jack, etc.
 
@@ -36,12 +36,18 @@ stdenv.mkDerivation rec {
     # Use the libtag info back-end for MP3s since we're building it.
     sed -i "emms-setup.el" \
         -e 's|emms-info-mp3info|emms-info-libtag|g'
+
+    # But use mp3info for the tag editor.
+    sed -i "emms-info-mp3info.el" \
+        -e 's|emms-info-mp3info-program-name[[:blank:]]\+"mp3info"|emms-info-mp3info-program-name "${mp3info}/bin/mp3info"|g'
+    sed -i "emms-tag-editor.el" \
+        -e 's|"mp3info"|"${mp3info}/bin/mp3info"|g'
   '';
 
   postInstall = ''
     ensureDir "$out/bin" && cp emms-print-metadata "$out/bin"
   '';
-  
+
   meta = {
     description = "GNU EMMS, The Emacs Multimedia System";
 
@@ -57,6 +63,10 @@ stdenv.mkDerivation rec {
     '';
 
     homepage = http://www.gnu.org/software/emms/;
+
     license = "GPLv3+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;
   };
 }

pkgs/applications/editors/emacs-modes/haskell/default.nix

@@ -1,11 +1,11 @@
 {stdenv, fetchurl, emacs}:
 
 stdenv.mkDerivation rec {
-  name = "haskell-mode-2.6.1";
+  name = "haskell-mode-2.8.0";
 
   src = fetchurl {
     url = "http://projects.haskell.org/haskellmode-emacs/${name}.tar.gz";
-    sha256 = "cc33fd0d4692667a6eb56fea3dc549de3897d8dbb7b71818489760f45d564a76";
+    sha256 = "1065g4xy3ca72xhqh6hfxs5j3mls82bli8w5rhz1npzyfwlwhkb1";
   };
 
   buildInputs = [emacs];
@@ -14,4 +14,12 @@ stdenv.mkDerivation rec {
     ensureDir "$out/share/emacs/site-lisp"
     cp *.el *.elc *.hs "$out/share/emacs/site-lisp/"
   '';
+
+  meta = {
+    homepage = "http://projects.haskell.org/haskellmode-emacs/";
+    description = "Haskell mode package for Emacs";
+
+    platforms = stdenv.lib.platforms.unix;
+    maintainers = [ stdenv.lib.maintainers.simons ];
+  };
 }

pkgs/applications/editors/emacs-modes/hol_light/default.nix

@@ -0,0 +1,25 @@
+{stdenv, fetchsvn}:
+
+let
+  revision = "73";
+in
+
+stdenv.mkDerivation {
+  name = "hol_light_mode-${revision}";
+
+  src = fetchsvn {
+    url = http://seanmcl-ocaml-lib.googlecode.com/svn/trunk/workshop/software/emacs;
+    rev = revision;
+    sha256 = "3ca83098960439da149a47e1caff32536601559a77f04822be742a390c67feb7";
+  };
+
+  installPhase = ''
+    DEST=$out/share/emacs/site-lisp
+    ensureDir $DEST
+    cp -a * $DEST
+  '';
+
+  meta = {
+    description = "A HOL Light mode for emacs";
+  };
+}

pkgs/applications/editors/emacs-modes/htmlize/builder.sh

@@ -0,0 +1,4 @@
+source $stdenv/setup
+
+mkdir -p $out/share/emacs/site-lisp
+cp $src $out/share/emacs/site-lisp/htmlize.el

pkgs/applications/editors/emacs-modes/htmlize/default.nix

@@ -0,0 +1,16 @@
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation {
+  name = "htmlize-1.37";
+
+  builder = ./builder.sh;
+
+  src = fetchurl {
+    url = http://fly.srk.fer.hr/~hniksic/emacs/htmlize.el;
+    sha256 = "17sbhf4r6jh4610x8qb2y0y3hww7w33vfsjqg4vrz99pr29xffry";
+  };
+
+  meta = {
+    description = "Convert buffer text and decorations to HTML.";
+  };
+}

pkgs/applications/editors/emacs-modes/jabber/default.nix

@@ -0,0 +1,23 @@
+{ stdenv, fetchurl, emacs }:
+stdenv.mkDerivation rec {
+  pname  = "emacs-jabber";
+  version = "0.8.0";
+  name = "${pname}-${version}";
+  src = fetchurl {
+    url = "mirror://sourceforge/${pname}/${name}.tar.bz2";
+    sha256 = "75e3b7853de4783b8ab8270dcbe6a1e4f576224f77f7463116532e11c6498c26";
+  };
+  buildInputs = [ emacs ];
+  meta = {
+    description = "A Jabber client for Emacs";
+    longDescription = ''
+      jabber.el is a Jabber client for Emacs. It may seem strange to have a
+      chat client in an editor, but consider that chatting is, after all, just
+      a special case of text editing.
+    '';
+    homepage = http://emacs-jabber.sourceforge.net/;
+    license = [ "GPLv2+" ];
+    maintainers = with stdenv.lib.maintainers; [ astsmtl ];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/applications/editors/emacs-modes/jdee/default.nix

@@ -9,12 +9,13 @@ in
     # Last release is too old, so use SVN.
     # See http://www.emacswiki.org/emacs/JavaDevelopmentEnvironment .
     src = fetchsvn {
-      # Looks like they're not sure whether to put one or two `e'...
-      url = "https://jdee.svn.sourceforge.net/svnroot/jdee/trunk/jde";
+      url = "https://jdee.svn.sourceforge.net/svnroot/jdee/trunk/jdee";
       rev = revision;
-      sha256 = "0pjkbr1srx2m428xkky1csf97fr5219prs4dif7njlydyrwp0gnn";
+      sha256 = "1qj5cv74dp6nf6060jyvnlcbmc4sz8a09806gwa1zfiwz6mm9zrs";
     };
 
+    patchFlags = "-p1 --ignore-whitespace";
+
     patches = [
       ./build-properties.patch
       ./cedet-paths.patch ./elib-avltree.patch
@@ -91,5 +92,6 @@ in
       license = "GPLv2+";
 
       maintainers = [ stdenv.lib.maintainers.ludo ];
+      platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
     };
   }

pkgs/applications/editors/emacs-modes/magit/default.nix

@@ -1,17 +1,25 @@
-{stdenv, fetchurl, emacs, texinfo}:
+{ stdenv, fetchurl, emacs, texinfo }:
 
+let
+  version = "1.0.0";
+in
 stdenv.mkDerivation {
-  name = "magit-0.7";
+  name = "magit-${version}";
 
   src = fetchurl {
-    url = "http://zagadka.vm.bytemark.co.uk/magit/magit-0.7.tar.gz";
-    sha256 = "0qry1vj41pycwkf71sqrz3zgzh85zdg5acq26asscq4s7jksrjiz";
+    url = "http://github.com/downloads/philjackson/magit/magit-${version}.tar.gz";
+    sha256 = "1hfdl90d96zin31v8x4p8zx5f0x0i5i9hccysx6q3prdgw9r6wzq";
   };
 
   buildInputs = [emacs texinfo];
 
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^PREFIX=.*$|PREFIX=$out|g ; s|/etc/emacs/|$out/etc/emacs/|"
+    '';
+
   meta = {
-    description = "An an interface to Git, implemented as an extension to Emacs.";
+    description = "Magit, an Emacs interface to Git";
 
     longDescription = ''
       With Magit, you can inspect and modify your Git repositories with
@@ -26,6 +34,8 @@ stdenv.mkDerivation {
     '';
 
     license = "GPLv3+";
-    homepage = "http://zagadka.vm.bytemark.co.uk/magit/";
+    homepage = "http://github.com/philjackson/magit";
+    platforms = stdenv.lib.platforms.all;
+    maintainers = with stdenv.lib.maintainers; [ simons ludo ];
   };
 }

pkgs/applications/editors/emacs-modes/maude/default.nix

@@ -1,13 +1,20 @@
 {stdenv, fetchurl, emacs}:
 
-stdenv.mkDerivation
-{
-  name = "maude-mode-0.1";
-  src = fetchurl
-  {
-    url = "mirror://sourceforge/maude-mode/maude-mode.tar.gz";
-    sha256 = "12555j01mar48da2jy3ay93xfn7ybl23bpvhp0srzg8858gisx5g";
+stdenv.mkDerivation {
+  name = "maude-mode-0.2";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/maude-mode/maude-mode-0.2.tar.gz";
+    sha256 = "19jdd7la0bxxxnnq4ryckf63jykg0r3v92z126x6djaigi3xn1yx";
   };
+
   buildInputs = [emacs];
   configureFlags = "--with-lispdir=$$out/share/emacs/site-lisp";
+
+  meta = {
+    description = "Emacs mode for the programming language Maude";
+    license = "GPLv2";
+    platforms = stdenv.lib.platforms.all;
+    maintainers = [ stdenv.lib.maintainers.simons ];
+  };
 }

pkgs/applications/editors/emacs-modes/org/default.nix

@@ -0,0 +1,45 @@
+{ fetchurl, stdenv, emacs, texinfo, which }:
+
+stdenv.mkDerivation rec {
+  name = "org-7.4";
+
+  src = fetchurl {
+    url = "http://orgmode.org/${name}.tar.gz";
+    sha256 = "0fpzfq6jynggyw62ai1cjvdmik9jnglfwrwj3nwcmy3g8j8i86fg";
+  };
+
+  buildInputs = [ emacs texinfo ];
+
+  patchPhase =
+    '' sed -i "lisp/org-clock.el" -e's|"which"|"${which}/bin/which"|g'
+    '';
+
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^prefix=.*$|prefix=$out|g"
+    '';
+
+  installPhase =
+    '' make install install-info
+
+       ensureDir "$out/share/doc/${name}"
+       cp -v doc/orgcard*.{pdf,txt} "$out/share/doc/${name}"
+    '';
+
+  meta = {
+    description = "Org-Mode, an Emacs mode for notes, project planning, and authoring";
+
+    longDescription =
+      '' Org-mode is for keeping notes, maintaining ToDo lists, doing project
+         planning, and authoring with a fast and effective plain-text system.
+
+         This package contains a version of Org-mode typically more recent
+         than that found in GNU Emacs.
+      '';
+
+    license = "GPLv3+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+}

pkgs/applications/editors/emacs-modes/php/builder.sh

@@ -0,0 +1,7 @@
+source $stdenv/setup
+
+mkdir -p $out/share/emacs/site-lisp
+cd $out/share/emacs/site-lisp
+tar xvfz $src
+mv php-mode-*/* .
+rmdir php-mode-*

pkgs/applications/editors/emacs-modes/php/default.nix

@@ -0,0 +1,12 @@
+{stdenv, fetchurl}:
+
+stdenv.mkDerivation rec {
+  name = "php-mode-1.5.0";
+
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/php-mode/${name}.tar.gz";
+    sha256 = "1bffgg4rpiggxqc1hvjcby24sfyzj5728zg7r6f4v6a126a7kcfq";
+  };
+
+  builder = ./builder.sh;
+}

pkgs/applications/editors/emacs-modes/proofgeneral/default.nix

@@ -1,4 +1,4 @@
-{ stdenv, fetchurl, emacs, perl }:
+{ stdenv, fetchurl, emacs, texinfo, texLive, perl, which, automake }:
 
 let
   pname = "ProofGeneral";
@@ -15,28 +15,32 @@ stdenv.mkDerivation {
     sha256 = "ae430590d6763618df50a662a37f0627d3c3c8f31372f6f0bb2116b738fc92d8";
   };
 
-  buildInputs = [ emacs perl ];
-
   sourceRoot = name;
 
-  postPatch = "EMACS=emacs make clean";
+  buildInputs = [ emacs texinfo texLive perl which ];
 
-  # Skip building ...
-  buildPhase = "true";
+  patchPhase =
+    '' sed -i "Makefile" \
+           -e "s|^\(\(DEST_\)\?PREFIX\)=.*$|\1=$out|g ; \
+               s|/sbin/install-info|install-info|g"
 
-  installPhase = ''
-    DEST=$out/share/emacs/site-lisp/ProofGeneral
-    ensureDir $DEST
-    cp -a * $DEST
-  '';
+       sed -i "bin/proofgeneral" -e's/which/type -p/g'
+    '';
+
+  installPhase =
+    # Copy `texinfo.tex' in the right place so that `texi2pdf' works.
+    '' cp -v "${automake}/share/"automake-*/texinfo.tex doc
+       make install install-doc
+    '';
 
   meta = {
-    description = "A generic front-end for proof assistants";
+    description = "Proof General, an Emacs front-end for proof assistants";
     longDescription = ''
       Proof General is a generic front-end for proof assistants (also known as
       interactive theorem provers), based on the customizable text editor Emacs.
     '';
     homepage = website;
-    license = "GPL";
+    license = "GPLv2+";
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
   };
 }

pkgs/applications/editors/emacs-modes/quack/default.nix

@@ -1,12 +1,12 @@
 { fetchurl, stdenv, emacs }:
 
 stdenv.mkDerivation {
-  name = "quack-0.37";
+  name = "quack-0.39";
 
   src = fetchurl {
     # XXX: Upstream URL is not versioned, which might eventually break this.
     url = "http://www.neilvandyke.org/quack/quack.el";
-    sha256 = "1q5442cpvw2i0qhmhn7mh45jnmzg0cmd01k5zp4gvg1526c0hbcc";
+    sha256 = "1w3p03f1f3l2nldxc7dig1kkgbbvy5j7zid0cfmkcrpp1qrcsqic";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/emacs-modes/rudel/default.nix

@@ -0,0 +1,28 @@
+{stdenv, fetchurl}:
+
+let
+    version = "0.2-4";
+in
+stdenv.mkDerivation
+{
+  name = "rudel-${version}";
+  src = fetchurl
+  {
+    url = "mirror://sourceforge/rudel/rudel-${version}.tar.gz";
+    sha256 = "68247bfb702d929877f6d098932e8b0ca45c573a3510187e1ccc43e5ea194f25";
+  };
+
+  installPhase = ''
+    for n in . obby zeroconf jupiter; do
+      ensureDir "$out/share/emacs/site-lisp/$n";
+      cp $n/*.el "$out/share/emacs/site-lisp/$n/";
+    done
+    install -D -m444 doc/card.pdf "$out/share/doc/rudel/card.pdf"
+  '';
+
+  meta = {
+    homepage = "http://rudel.sourceforge.net/";
+    description = "Rudel is a collaborative editing environment for GNU Emacs";
+    license = "GPL";
+  };
+}

pkgs/applications/editors/gobby/default.nix

@@ -0,0 +1,31 @@
+{ avahiSupport ? false # build support for Avahi in libinfinity
+, gnomeSupport ? false # build support for Gnome(gnome-vfs)
+, stdenv, fetchurl, pkgconfig
+, gtkmm, gsasl, gtksourceview, libxmlxx, libinfinity, intltool
+, gnomevfs ? null}:
+
+let
+  libinf = libinfinity.override { gtkWidgets = true; inherit avahiSupport; };
+  
+in stdenv.mkDerivation rec {
+
+  name = "gobby-0.4.93";
+  src = fetchurl {
+    url = "http://releases.0x539.de/gobby/${name}.tar.gz";
+    sha256 = "1zk6p0kdp9vcvrr3kx0kw106ln309hd7bbsq8li1g0pcnkgrf4q4";
+  };
+
+  buildInputs = [ pkgconfig gtkmm gsasl gtksourceview libxmlxx libinf intltool ]
+    ++ stdenv.lib.optional gnomeSupport gnomevfs;
+  
+  configureFlags = ''
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://gobby.0x539.de/;
+    description = "A GTK-based collaborative editor supporting multiple documents in one session and a multi-user chat";
+    license = "GPLv2+";
+    maintainers = [ maintainers.phreedom ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/editors/jedit/default.nix

@@ -1,4 +1,5 @@
-args: with args;
+{ stdenv, fetchurl, ant }:
+
 stdenv.mkDerivation {
   name = "jedit-4.2";
 
@@ -18,11 +19,11 @@ stdenv.mkDerivation {
     cp modes/catalog \$out/lib/modes
   ";
 
-  buildInputs = [ant];
+  buildInputs = [ ant ];
 
   meta = { 
-      description = "really nice programmers editor written in Java. Give it a try";
-      homepage = http://www.jedit.org;
-      license = "GPL";
+    description = "really nice programmers editor written in Java. Give it a try";
+    homepage = http://www.jedit.org;
+    license = "GPL";
   };
 }

pkgs/applications/editors/kdevelop/default.nix

@@ -0,0 +1,31 @@
+{ stdenv, fetchurl, kdevplatform, cmake, pkgconfig, automoc4, shared_mime_info,
+  kdebase_workspace, gettext, perl }:
+
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+  version = "4.0.2";
+  pname = "kdevelop";
+
+  src = fetchurl {
+    url = "mirror://kde/stable/${pname}/${version}/src/${name}.tar.bz2";
+    sha256 = "1y8ydx0fcmsab31qf5id5r5fcmp3j2l8mibvbbjfy66xgxarmnpc";
+  };
+
+  buildInputs = [ kdevplatform cmake pkgconfig automoc4 shared_mime_info
+    kdebase_workspace gettext stdenv.gcc.libc perl ];
+
+  meta = with stdenv.lib; {
+    maintainers = [ maintainers.urkud ];
+    platforms = platforms.linux;
+    description = "KDE official IDE";
+    longDescription =
+      ''
+        A free, opensource IDE (Integrated Development Environment)
+        for MS Windows, Mac OsX, Linux, Solaris and FreeBSD. It is a
+        feature-full, plugin extendable IDE for C/C++ and other
+        programing languages. It is based on KDevPlatform, KDE and Qt
+        libraries and is under development since 1998.
+      '';
+    homepage = http://www.kdevelop.org;
+  };
+}

pkgs/applications/editors/leksah/default.nix

@@ -1,26 +1,27 @@
-{cabal, gtk2hs, binary, parsec, regexPosix, regexCompat, utf8String, libedit, makeWrapper}:
+{cabal, gtk, glib, binary, binaryShared, deepseq, hslogger, ltk, network, parsec,
+ leksahServer, processLeksah, regexBase, regexTDFA, utf8String, gtksourceview2,
+ makeWrapper}:
 
 cabal.mkDerivation (self : {
   pname = "leksah";
-  version = "0.6.1";
-  sha256 = "de4e0974be3df0e58fd26bfbb76594d81514f1e1d898b9f47881b42084bacf35";
+  version = "0.8.0.8";
+  sha256 = "1d6n5dlnqlqfckg9f611qf9lvi6b7ghrkk1l0myh6h667fxh8a1r";
 
-  # !!! The explicit libedit dependency shouldn't be necessary.
-  extraBuildInputs = [gtk2hs binary parsec regexPosix regexCompat utf8String libedit makeWrapper];
+  propagatedBuildInputs =
+    [gtk glib binary binaryShared deepseq hslogger ltk network parsec
+     leksahServer processLeksah regexBase regexTDFA utf8String gtksourceview2];
+  extraBuildInputs = [makeWrapper];
 
-  preConfigure =
-    ''
-      substituteInPlace leksah.cabal --replace 'Cabal ==1.6.0.1' 'Cabal >=1.6.0.1' 
-    '';
-
-  postInstall =
-    ''
-      wrapProgram $out/bin/leksah --prefix XDG_DATA_DIRS : ${gtk2hs.gtksourceview}/share
-    '';
+  # postInstall =
+  #   ''
+  #     wrapProgram $out/bin/leksah --prefix XDG_DATA_DIRS : ${gtk2hs.gtksourceview}/share
+  #   '';
   
   meta = {
     homepage = http://leksah.org/;
     description = "An Integrated Development Environment for Haskell written in Haskell";
+    license = "GPL";
+    maintainers = [self.stdenv.lib.maintainers.andres];
   };
 })  
 

pkgs/applications/editors/nano/default.nix

@@ -1,17 +1,19 @@
-args: with args;
+{ stdenv, fetchurl, ncurses, gettext }:
+
 stdenv.mkDerivation (rec {
   pname = "nano";
-  version = "2.2.1";
+  version = "2.2.3";
 
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://gnu/nano/${name}.tar.gz";
-    sha256 = "1xqldl7ipsmz5x8q3fw9s6yshxfp39kly96kb15l1kawng1wfcfq";
+    sha256 = "1vpl993xrpj8bqi1ayga8fc0j2jag90xp6rqakzwm3bxw71hmwi2";
   };
-  buildInputs = [ncurses gettext];
-#  configureFlags = "--enable-tiny";
-  configureFlags = "
+  
+  buildInputs = [ ncurses gettext ];
+  
+  configureFlags = ''
     --disable-browser 
     --disable-help 
     --disable-justify 
@@ -20,7 +22,7 @@ stdenv.mkDerivation (rec {
     --disable-speller
     --disable-tabcomp
     --disable-wrapping
-  ";
+  '';
 
   meta = {
     homepage = http://www.nano-editor.org/;

pkgs/applications/editors/nvi/default.nix

@@ -4,7 +4,11 @@ stdenv.mkDerivation rec {
   name = "nvi-1.79";
 
   src = fetchurl {
-    url = ftp://ftp.bostic.com/pub/nvi-1.79.tar.gz;
+    urls =
+      [ "ftp://ftp.eenet.ee/pub/cpan/src/misc/nvi-1.79.tar.gz"
+        "ftp://ftp.saintjoe.edu/pub/CPAN/src/misc/nvi-1.79.tar.gz"
+        "ftp://ftp.free.fr/.mirrors1/ftp.netbsd.org/packages/distfiles/nvi-1.79.tar.gz"
+      ];
     sha256 = "0cvf56rbylz7ksny6g2256sjg8yrsxrmbpk82r64rhi53sm8fnvm";
   };
 

pkgs/applications/editors/texmacs/default.nix

@@ -0,0 +1,95 @@
+{stdenv, fetchurl, guile, libX11, libXext, xmodmap, which, makeWrapper, freetype,
+ tex ? null,
+ aspell ? null,
+ ghostscriptX ? null,
+ extraFonts ? false,
+ chineseFonts ? false,
+ japaneseFonts ? false,
+ koreanFonts ? false }:
+
+let 
+  pname = "TeXmacs";
+  version = "1.0.7.10";
+  extraFontsSrc = fetchurl {
+    url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-extra-fonts-1.0-noarch.tar.gz";
+    sha256 = "0hylgjmd95y9yahbblmawkkw0i71vb145xxv2xqrmff81301n6k7";
+  };
+
+  fullFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-windows-fonts-1.0-noarch.tar.gz";
+   sha256 = "1yxzjpqpm7kvx0ly5jmfpzlfhsh41b0ibn1v84qv6xy73r2vis2f";
+  };
+
+  chineseFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-chinese-fonts.tar.gz";
+   sha256 = "0yprqjsx5mfsaxr525mcm3xqwcadzxp14njm38ir1325baada2fp";
+  };
+
+  japaneseFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-japanese-fonts.tar.gz";
+   sha256 = "1dn6zvsa7gk59d61xicwpbapab3rm6kz48rp5w1bhmihxixw21jn";
+  };
+
+  koreanFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-korean-fonts.tar.gz";
+   sha256 = "07axg57mqm3jbnm4lawx0h3r2h56xv9acwzjppryfklw4c27f5hh";
+  };
+in
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "ftp://ftp.texmacs.org/pub/${pname}/targz/${name}-src.tar.gz";
+    sha256 = "02gqalr775r4xyfy4bq3qq1h3pkarsxjb6ami7lgxfgmyg6ca5kn";
+  };
+
+  buildInputs = [ guile libX11 libXext makeWrapper ghostscriptX freetype ];
+
+  patchPhase = (if tex == null then ''
+    gunzip < ${fullFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else if extraFonts then ''
+    gunzip < ${extraFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if chineseFonts then ''
+    gunzip < ${chineseFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if japaneseFonts then ''
+    gunzip < ${japaneseFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if koreanFonts then ''
+    gunzip < ${koreanFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "");
+
+  postInstall = "wrapProgram $out/bin/texmacs --suffix PATH : " +
+        (if ghostscriptX == null then "" else "${ghostscriptX}/bin:") +
+        (if aspell == null then "" else "${aspell}/bin:") +
+        (if tex == null then "" else "${tex}/bin:") +
+        "${xmodmap}/bin:${which}/bin";
+
+  meta = {
+    description = "GNU TeXmacs, a free WYSIWYW editing platform with special features for scientists";
+    longDescription =
+      '' GNU TeXmacs is a free wysiwyw (what you see is what you want)
+         editing platform with special features for scientists.  The software
+         aims to provide a unified and user friendly framework for editing
+         structured documents with different types of content (text,
+         graphics, mathematics, interactive content, etc.).  The rendering
+         engine uses high-quality typesetting algorithms so as to produce
+         professionally looking documents, which can either be printed out or
+         presented from a laptop.
+
+         The software includes a text editor with support for mathematical
+         formulas, a small technical picture editor and a tool for making
+         presentations from a laptop.  Moreover, TeXmacs can be used as an
+         interface for many external systems for computer algebra, numerical
+         analysis, statistics, etc.  New presentation styles can be written
+         by the user and new features can be added to the editor using the
+         Scheme extension language.  A native spreadsheet and tools for
+         collaborative authoring are planned for later.
+      '';
+    homepage = http://texmacs.org/;
+    license = "GPLv2+";
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.roconnor ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+}

pkgs/applications/editors/vim/configurable.nix

@@ -4,17 +4,18 @@ args: with args;
 let inherit (args.composableDerivation) composableDerivation edf; in
 composableDerivation {} {
 
-    name = "vim_configurable-7.2";
+    name = "vim_configurable-7.3";
 
     src = args.fetchurl {
-      url = ftp://ftp.vim.org/pub/vim/unix/vim-7.2.tar.bz2;
-      sha256 = "11hxkb6r2550c4n13nwr0d8afvh30qjyr5c2hw16zgay43rb0kci";
+      url = ftp://ftp.vim.org/pub/vim/unix/vim-7.3.tar.bz2;
+      sha256 = "079201qk8g9yisrrb0dn52ch96z3lzw6z473dydw9fzi0xp5spaw";
     };
 
     configureFlags = ["--enable-gui=auto" "--with-features=${args.features}"];
 
-    buildInputs = [ncurses pkgconfig]
-      ++ [ gtk libX11 libXext libSM libXpm libXt libXaw libXau libXmu ];
+    buildNativeInputs = [ncurses pkgconfig]
+      ++ [ gtk libX11 libXext libSM libXpm libXt libXaw libXau libXmu glib 
+           libICE ];
 
     # most interpreters aren't tested yet.. (see python for example how to do it)
     flags = {
@@ -26,26 +27,33 @@ composableDerivation {} {
       // edf { name = "xsmp"; } #Disable XSMP session management
       // edf { name = "xsmp_interact"; } #Disable XSMP interaction
       // edf { name = "mzscheme"; } #Include MzScheme interpreter.
-      // edf { name = "perl"; feat = "perlinterp"; enable = { buildInputs = [perl]; };} #Include Perl interpreter.
-      // edf { name = "python"; feat = "pythoninterp"; enable = { buildInputs = [python]; }; } #Include Python interpreter.
-      // edf { name = "tcl"; enable = { buildInputs = [tcl]; }; } #Include Tcl interpreter.
-      // edf { name = "ruby"; feat = "rubyinterp"; enable = { buildInputs = [ruby]; };} #Include Ruby interpreter.
+      // edf { name = "perl"; feat = "perlinterp"; enable = { buildNativeInputs = [perl]; };} #Include Perl interpreter.
+      // edf { name = "python"; feat = "pythoninterp"; enable = { buildNativeInputs = [python]; }; } #Include Python interpreter.
+      // edf { name = "tcl"; enable = { buildNativeInputs = [tcl]; }; } #Include Tcl interpreter.
+      // edf { name = "ruby"; feat = "rubyinterp"; enable = { buildNativeInputs = [ruby]; };} #Include Ruby interpreter.
+      // edf { name = "lua" ; feat = "luainterp"; enable = { buildNativeInputs = [lua]; configureFlags = ["--with-lua-prefix=${args.lua}"];};}
       // edf { name = "cscope"; } #Include cscope interface.
       // edf { name = "workshop"; } #Include Sun Visual Workshop support.
       // edf { name = "netbeans"; } #Disable NetBeans integration support.
-      // edf { name = "sniff"; } #Include Sniff interface.
+      // edf { name = "sniff"; feat = "sniff" ; } #Include Sniff interface.
       // edf { name = "multibyte"; } #Include multibyte editing support.
-      // edf { name = "hangulinput"; } #Include Hangul input support.
-      # // edf { name = "xim"; enable = { buildInputs = [xim]; }; } #Include XIM input support.
+      // edf { name = "hangulinput"; feat = "hangulinput" ;} #Include Hangul input support.
+      // edf { name = "xim"; } #Include XIM input support.
       // edf { name = "fontset"; } #Include X fontset output support.
       // edf { name = "acl"; } #Don't check for ACL support.
       // edf { name = "gpm"; } #Don't use gpm (Linux mouse daemon).
-      // edf { name = "nls"; } #Don't support NLS (gettext()).
+      // edf { name = "nls"; enable = {buildNativeInputs = [gettext];}; } #Don't support NLS (gettext()).
       ;
 
   cfg = {
-    pythonSupport = true;
-    ftNixSupport = true; # add .nix filetype detection and minimal syntax highlighting support
+    pythonSupport    = getConfig [ "vim" "python" ] true;
+    darwinSupport    = getConfig [ "vim" "darwin" ] false;
+    nlsSupport       = getConfig [ "vim" "nls" ] false;
+    tclSupport       = getConfig [ "vim" "tcl" ] false;
+    multibyteSupport = getConfig [ "vim" "multibyte" ] false;
+    cscopeSupport    = getConfig [ "vim" "cscope" ] false;
+    # add .nix filetype detection and minimal syntax highlighting support
+    ftNixSupport     = getConfig [ "vim" "ftNix" ] true;
   };
 
   #--enable-gui=OPTS     X11 GUI default=auto OPTS=auto/no/gtk/gtk2/gnome/gnome2/motif/athena/neXtaw/photon/carbon
@@ -62,11 +70,11 @@ composableDerivation {} {
 
   postInstall = "
     rpath=`patchelf --print-rpath \$out/bin/vim`;
-    for i in $\buildInputs; do
+    for i in $\buildNativeInputs; do
       echo adding \$i/lib
       rpath=\$rpath:\$i/lib
     done
-    echo \$buildInputs
+    echo \$buildNativeInputs
     echo \$rpath
     patchelf --set-rpath \$rpath \$out/bin/{vim,gvim}
   ";

pkgs/applications/editors/vim/default.nix

@@ -1,62 +1,46 @@
-args:
-let 
-	defList = [];
-	#stdenv and fetchurl are added automatically
-	getVal = (args.lib.getValue args defList);
-	check = args.lib.checkFlag args;
-	reqsList = [
-	["gtkGUI" "glib" "gtk" "pkgconfig" "libXpm" "libXext" "x11Support"]
-	["athenaGUI" "libXau" "libXt" "libXaw" "libXpm" "libXext" "x11Support"]
-	["x11Support" "libX11"]
-	["hugeFeatures"]
-	["pythonSupport" "python"]
-	["perlSupport" "perl"]
-	["tclSupport" "tcl"]
-	["true" "ncurses"]
-	["false" "libSM"]
-	];
-	nameSuffixes = [
-	"hugeFeatures" "-huge"
-	"x11Support" "-X11"
-	"pythonSupport" "-python"
-	"perlSupport" "-perl"
-	"tclSupport" "-tcl"
-	"ximSupport" "-xim"
-	];
-	configFlags = [
-	"true" " --enable-multibyte "
-	"x11Support" " --enable-gui=auto "
-	"hugeFeatures" "--with-features=huge --enable-cscope --enable-xsmp "
-	"pythonSupport" " --enable-pythoninterp "
-	"perlSupport" " --enable-perlinterp "
-	"tclSupport" " --enable-tclinterp "
-	"ximSupport" " --enable-xim "
-	];
-	buildInputsNames = args.lib.filter (x: (null!=getVal x)) 
-		(args.lib.uniqList {inputList = 
-		(args.lib.concatLists (map 
-		(x:(if (x==[]) then [] else builtins.tail x)) 
-		reqsList));});
-in
-	assert args.lib.checkReqs args defList reqsList;
-args.stdenv.mkDerivation {
-  name = args.lib.condConcat "vim-7.2" nameSuffixes check;
+{ stdenv, fetchurl, ncurses, gettext, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "vim-7.3";
  
-  src = args.fetchurl {
-    url = ftp://ftp.vim.org/pub/vim/unix/vim-7.2.tar.bz2;
-    sha256 = "11hxkb6r2550c4n13nwr0d8afvh30qjyr5c2hw16zgay43rb0kci";
+  src = fetchurl {
+    url = "ftp://ftp.vim.org/pub/vim/unix/${name}.tar.bz2";
+    sha256 = "079201qk8g9yisrrb0dn52ch96z3lzw6z473dydw9fzi0xp5spaw";
   };
  
-  inherit (args) ncurses;
+  buildInputs = [ ncurses pkgconfig ];
+  buildNativeInputs = [ gettext ];
 
-  buildInputs = args.lib.filter (x: (x!=null)) (map getVal buildInputsNames);
+  configureFlags = [
+    "--enable-multibyte"
+    "--enable-nls"
+  ];
 
   postInstall = "ln -s $out/bin/vim $out/bin/vi";
-  preBuild="touch src/auto/link.sed";
-  configureFlags = args.lib.condConcat "" configFlags check;
 
-  NIX_LDFLAGS = "-lpthread -lutil";
+  crossAttrs = {
+    configureFlags = [
+      "vim_cv_toupper_broken=no"
+      "--with-tlib=ncurses"
+      "vim_cv_terminfo=yes"
+      "vim_cv_tty_group=tty"
+      "vim_cv_tty_mode=0660"
+      "vim_cv_getcwd_broken=no"
+      "vim_cv_stat_ignores_slash=yes"
+      "ac_cv_sizeof_int=4"
+      "vim_cv_memmove_handles_overlap=yes"
+      "vim_cv_memmove_handles_overlap=yes"
+      "STRIP=${stdenv.cross.config}-strip"
+    ];
+  };
 
+  # To fix the trouble in vim73, that it cannot cross-build with this patch
+  # to bypass a configure script check that cannot be done cross-building.
+  # http://groups.google.com/group/vim_dev/browse_thread/thread/66c02efd1523554b?pli=1
+  patchPhase = ''
+    sed -i -e 's/as_fn_error.*int32.*/:/' src/auto/configure
+  '';
+  
   meta = {
     description = "The most popular clone of the VI editor";
     homepage = http://www.vim.org;

pkgs/applications/editors/zile/default.nix

@@ -1,14 +1,15 @@
 { fetchurl, stdenv, ncurses, help2man }:
 
 stdenv.mkDerivation rec {
-  name = "zile-2.3.13";
+  name = "zile-2.3.23";
 
   src = fetchurl {
     url = "mirror://gnu/zile/${name}.tar.gz";
-    sha256 = "13nvrlns4vjngwjwg110r3djmpwq34q22crr4x8wpzf9c0chp8i4";
+    sha256 = "01vh7mar2m5p3rmfidl5g2vs86kb3iyljm345cqqh1h6bynqmbc6";
   };
 
-  buildInputs = [ ncurses help2man ];
+  buildInputs = [ ncurses ];
+  buildNativeInputs = [ help2man ];
 
   # Tests can't be run because most of them rely on the ability to
   # fiddle with the terminal.

pkgs/applications/graphics/ImageMagick/default.nix

@@ -1,34 +1,50 @@
-args: with args;
+{ stdenv
+, fetchurl
+, bzip2
+, freetype
+, graphviz
+, ghostscript
+, libjpeg
+, libpng
+, libtiff
+, libxml2
+, zlib
+, libtool
+, jasper
+, libX11
+, tetex ? null
+, librsvg ? null
+}:
 
-let version = "6.5.9-1"; in
-
-stdenv.mkDerivation (rec {
+let
+  version = "6.6.5-4";
+in
+stdenv.mkDerivation rec {
   name = "ImageMagick-${version}";
 
   src = fetchurl {
     url = "mirror://imagemagick/${name}.tar.bz2";
-    sha256 = "0a4yhhfqagz28yccydngi31050101jfmq5ljln61g69yy6m47ifg";
+    sha256 = "1s3l98xc1gnxi2wdg3sy9723f6qf5yk81wln8ghn2z9kvi09w7gw";
   };
 
   configureFlags = ''
     --with-gs-font-dir=${ghostscript}/share/ghostscript/fonts
     --with-gslib
-    ${if args ? tetex then "--with-frozenpaths" else ""}
+    --with-frozenpaths
+    ${if librsvg != null then "--with-rsvg" else ""}
   '';
 
   buildInputs =
-    [ bzip2 freetype ghostscript graphviz libjpeg libpng
-      libtiff libX11 libxml2 zlib libtool
-    ]
-    ++ stdenv.lib.optional (args ? tetex) args.tetex
-    ++ stdenv.lib.optional (args ? librsvg) args.librsvg;
+    [ bzip2 freetype graphviz ghostscript libjpeg libpng
+      libtiff libxml2 zlib tetex librsvg libtool jasper libX11
+    ];
 
-  preConfigure = if args ? tetex then
+  preConfigure = if tetex != null then
     ''
-      export DVIDecodeDelegate=${args.tetex}/bin/dvips
+      export DVIDecodeDelegate=${tetex}/bin/dvips
     '' else "";
 
   meta = {
     homepage = http://www.imagemagick.org;
   };
-})
+}

pkgs/applications/graphics/darktable/default.nix

@@ -0,0 +1,27 @@
+{ stdenv, fetchurl,
+  GConf, cairo, curl, dbus_glib, exiv2, gnome_keyring, gphoto2, gtk,
+  intltool, lcms, lensfun, libexif, libglade, libgphoto2, libjpeg,
+  libpng, libraw1394, librsvg, libtiff, openexr, pkgconfig, sqlite, }:
+
+stdenv.mkDerivation rec {
+  version = "0.7.1";
+  name = "darktable-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/darktable/darktable-${version}.tar.gz";
+    sha256 = "080gvf5gp3rb0vlsvdgnzrzky9dfpqw5cwnj6z1k8lvryd9fzahm";
+  };
+
+  patches = [ ./exif.patch ];
+
+  buildInputs = [ GConf cairo curl dbus_glib exiv2 gnome_keyring gtk
+                        intltool lcms lensfun libexif libglade
+                        libgphoto2 libjpeg libpng libraw1394 librsvg
+                        libtiff openexr pkgconfig sqlite ];
+
+  meta = {
+    description = "a virtual lighttable and darkroom for photographers";
+    homepage = http://darktable.sourceforge.net;
+    license = stdenv.lib.licenses.gpl3Plus;
+  };
+}

pkgs/applications/graphics/darktable/exif.patch

@@ -0,0 +1,11 @@
+--- darktable-0.7.1/src/common/exif.cc	2011-01-01 12:08:36.000000000 +0100
++++ darktable-0.7.1/src/common/exif.cc	2011-01-01 12:09:27.000000000 +0100
+@@ -33,7 +33,7 @@
+ #include <exiv2/error.hpp>
+ #include <exiv2/image.hpp>
+ #include <exiv2/exif.hpp>
+-#include <exiv2/canonmn.hpp>
++#include <exiv2/exiv2.hpp>
+ #include <sqlite3.h>
+ #include <iostream>
+ #include <fstream>

pkgs/applications/graphics/digikam/default.nix

@@ -1,25 +1,28 @@
-{stdenv, fetchurl, kdelibs, exiv2, libXt, libXext, zlib, libjpeg, perl, qt3, 
-  libpng, expat, cmake }:
+{ stdenv, fetchurl, cmake, qt4, kdelibs, automoc4, phonon, qimageblitz, qca2, eigen,
+kdegraphics, lcms, jasper, libgphoto2, kdepimlibs, gettext, soprano, kdeedu,
+liblqr1, lensfun, pkgconfig }:
 
-stdenv.mkDerivation {
-  name = "digikam-1.0.0";
+stdenv.mkDerivation rec {
+  name = "digikam-1.5.0";
 
   src = fetchurl {
-    url = mirror://sourceforge/digikam/digikam-1.0.0.tar.bz2;
-    sha256 = "0qblqyjn0vas8hyqn5s9rr401d93cagk53y3j8kch0mr0bk706bk";
+    url = "mirror://sourceforge/digikam/${name}.tar.bz2";
+    sha256 = "1vvzw132aw2c1z2v1zc3aqa99kvg501krr2law35ri12zkqjsvaz";
   };
 
-/*
-  configurePhase = ''
-    LDFLAGS="$LDFLAGS -ljpeg" ./configure --without-arts --prefix=$out
-    '';
-*/
+  buildInputs = [ cmake qt4 kdelibs kdegraphics automoc4 phonon qimageblitz qca2 eigen
+    lcms jasper libgphoto2 kdepimlibs gettext soprano kdeedu liblqr1 lensfun
+    pkgconfig ];
 
-  buildInputs = [ kdelibs exiv2 libXt libXext zlib libjpeg perl qt3 libpng expat cmake ];
+  KDEDIRS=kdeedu;
+
+  patches = [ ./include.diff ];
 
   meta = {
-    homepage = http://digikam.sourceforge.net/;
-    description = "KDE 3.x photo viewer";
-    # license = "GPLv2+";
+    description = "Photo Management Program";
+    license = "GPL";
+    homepage = http://www.digikam.org;
+    maintainers = with stdenv.lib.maintainers; [ viric urkud ];
+    inherit (kdelibs.meta) platforms;
   };
 }

pkgs/applications/graphics/digikam/include.diff

@@ -0,0 +1,12 @@
+diff --git a/libs/imageproperties/markerclusterholderplugin/CMakeLists.txt b/libs/imageproperties/markerclusterholderplugin/CMakeLists.txt
+index 9ee36cc..c6e5c00 100644
+--- a/libs/imageproperties/markerclusterholderplugin/CMakeLists.txt
++++ b/libs/imageproperties/markerclusterholderplugin/CMakeLists.txt
+@@ -18,6 +18,7 @@ IF(MARBLEWIDGET_SUPPORTS_PLUGINS)
+ 
+     INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/libs/imageproperties/markerclusterholderplugin/
+                          ${CMAKE_BINARY_DIR}/libs/imageproperties/markerclusterholderplugin/
++						 ${LIBMARBLEWIDGET_INCLUDE_DIR}/..
+                          ${QT_INCLUDE_DIR}
+                        )
+ 

pkgs/applications/graphics/djview/default.nix

@@ -1,4 +1,4 @@
-args: with args;
+{stdenv, fetchurl, djvulibre, qt4 }:
 
 stdenv.mkDerivation {
 	name = "djview4-4.1-2";
@@ -9,9 +9,15 @@ stdenv.mkDerivation {
 
 	buildInputs = [djvulibre qt4];
 
+  passthru = {
+    mozillaPlugin = "/lib/netscape/plugins";
+  };
+
 	meta = {
 		homepage = http://djvu.sourceforge.net/djview4.html;
 		description = "A new portable DjVu viewer and browser plugin";
 		license = "GPL2";
+    inherit (qt4.meta) platforms;
+    maintainers = [ stdenv.lib.maintainers.urkud ];
 	};
 }

pkgs/applications/graphics/exrdisplay/default.nix

@@ -1,8 +1,8 @@
-args: with args;
+{ stdenv, fetchurl, pkgconfig, fltk, openexr, mesa, which, openexr_ctl }:
 
 assert fltk.glSupport;
-stdenv.mkDerivation {
 
+stdenv.mkDerivation {
   name ="openexr_viewers-1.0.1";
 
   src = fetchurl {
@@ -10,18 +10,18 @@ stdenv.mkDerivation {
     sha256 = "1w5qbcdp7sw48z1wk2v07f7p14vqqb1m2ncxyxnbkm9f4ab0ymg6";
   };
 
-  inherit fltk mesa;
+  configurePhase =
+    ''
+      # don't know why.. adding these flags it works
+      #export CXXFLAGS=`fltk-config --use-gl --cxxflags --ldflags`
+      ./configure --prefix=$out --with-fltk-config=${fltk}/bin/fltk-config
+    '';
 
-  configurePhase = "
-    # don't know why.. adding these flags it works
-    #export CXXFLAGS=`fltk-config --use-gl --cxxflags --ldflags`
-    ./configure --prefix=\$out --with-fltk-config=\$fltk/bin/fltk-config";
-
-  buildInputs = [openexr fltk pkgconfig mesa which openexr_ctl];
+  buildInputs = [ openexr fltk pkgconfig mesa which openexr_ctl ];
 
   meta = { 
-      description = "tool to view OpenEXR images";
-      homepage = http://openexr.com;
-      license = "BSD-like";
+    description = "Tool to view OpenEXR images";
+    homepage = http://openexr.com;
+    license = "BSD-like";
   };
 }

pkgs/applications/graphics/fbida/default.nix

@@ -1,34 +1,33 @@
-a :  
-let 
-  fetchurl = a.fetchurl;
+{ stdenv, fetchurl, libjpeg, libexif, giflib, libtiff, libpng
+, pkgconfig, freetype, fontconfig
+}:
 
-  version = a.lib.attrByPath ["version"] "2.07" a; 
-  buildInputs = with a; [
-    libjpeg libexif giflib libtiff libpng
-      imagemagick ghostscript which curl 
-      pkgconfig freetype fontconfig
-  ];
-in
-rec {
+stdenv.mkDerivation rec {
+  name = "fbida-2.07";
+  
   src = fetchurl {
-    url = "http://dl.bytesex.org/releases/fbida/fbida-${version}.tar.gz";
+    url = "http://dl.bytesex.org/releases/fbida/${name}.tar.gz";
     sha256 = "0i6v3fvjc305pfw48sglb5f22lwxldmfch6mjhqbcp7lqkkxw435";
   };
 
-  inherit buildInputs;
-  configureFlags = [];
-  makeFlags = [
-    "prefix=$out"
-    "verbose=yes"
-    ];
+  preBuild =
+    ''
+      # Fetch a segfault in exiftran (http://bugs.gentoo.org/284753).
+      # `fbida' contains a copy of some internal libjpeg source files.
+      # If these do not match with the actual libjpeg, exiftran may
+      # fail.
+      tar xvf ${libjpeg.src}
+      for i in jpegint.h jpeglib.h jinclude.h transupp.c transupp.h; do
+        cp jpeg-*/$i jpeg/
+      done
+    '';
+
+  buildInputs =
+    [ pkgconfig libexif libjpeg giflib libpng giflib freetype fontconfig ];
+  
+  makeFlags = [ "prefix=$(out)" "verbose=yes" ];
 
-  /* doConfigure should be removed if not needed */
-  phaseNames = ["doMakeInstall" (a.doPatchShebangs "$out/bin")];
-      
-  name = "fbida-" + version;
   meta = {
-    description = "Framebuffer image viewing programs";
-    maintainers = [
-    ];
+    description = "Image viewing and manipulation programs";
   };
 }

pkgs/applications/graphics/feh/default.nix

@@ -1,17 +1,25 @@
-{ stdenv, fetchurl, x11, imlib2, libjpeg, libpng, giblib }:
+{ stdenv, fetchurl, x11, imlib2, libjpeg, libpng, giblib
+, libXinerama }:
 
 stdenv.mkDerivation {
-  name = "feh-1.3.4";
+  name = "feh-1.11.2";
 
   src = fetchurl {
-    url = http://linuxbrit.co.uk/downloads/feh-1.3.4.tar.gz;
-    sha256 = "091iz2id5z80vn2qxg0ipwncv5bv8i9ifw2q15ja9zazq6xz5fc1";
+    url = http://www.chaosdorf.de/~derf/feh/feh-1.11.1.tar.bz2;
+    sha256 = "1rxi0hjp8w1rga48qvq3sgsbsgs4d5q1sq59ld1f7rih1knm2v45";
   };
 
-  buildInputs = [x11 imlib2 giblib libjpeg libpng];
+  buildInputs = [x11 imlib2 giblib libjpeg libpng libXinerama];
+
+  preBuild = ''
+    makeFlags="PREFIX=$out"
+  '';
 
   meta = {
     description = "A light-weight image viewer";
-    homepage = http://linuxbrit.co.uk/feh/;
+    homepage = https://derf.homelinux.org/projects/feh/;
+    license = "BSD";
+    maintainers = with stdenv.lib.maintainers; [viric];
+    platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/graphics/freecad/cmakeinstall.patch

@@ -0,0 +1,55 @@
+Index: src/3rdParty/salomesmesh/CMakeLists.txt
+===================================================================
+--- a/src/3rdParty/salomesmesh/CMakeLists.txt	(revision 4193)
++++ a/src/3rdParty/salomesmesh/CMakeLists.txt	(working copy)
+@@ -191,7 +191,7 @@
+ INCLUDE_DIRECTORIES(src/StdMeshers)
+ 
+ ADD_LIBRARY(StdMeshers SHARED ${StdMeshers_source_files})
+-TARGET_LINK_LIBRARIES(StdMeshers SMESH TKernel TKMath TKAdvTools f2c)
++TARGET_LINK_LIBRARIES(StdMeshers SMESH TKernel TKMath TKAdvTools f2c gfortran)
+ SET(StdMeshers_CFLAGS "")
+ IF(WIN32)
+   SET(StdMeshers_CFLAGS "-DSTDMESHERS_EXPORTS -DMEFISTO2D_EXPORTS")
+@@ -218,9 +218,9 @@
+     # Libraries are installed by default in /usr/local/lib/SMESH-5.1.2.7
+     INSTALL(TARGETS SMDS Driver DriverSTL DriverDAT DriverUNV
+             SMESHDS SMESH StdMeshers
+-            DESTINATION /usr/local/lib/${INSTALL_PATH_NAME})
++            DESTINATION lib)
+     # Headers are installed by default in /usr/local/include/SMESH-5.1.2.7
+     INSTALL(DIRECTORY inc/
+-            DESTINATION /usr/local/include/${INSTALL_PATH_NAME}
++            DESTINATION include
+             FILES_MATCHING PATTERN "*.h*")
+ ENDIF(UNIX)
+Index: src/3rdParty/Pivy-0.5/CMakeLists.txt
+===================================================================
+--- a/src/3rdParty/Pivy-0.5/CMakeLists.txt	(revision 4193)
++++ a/src/3rdParty/Pivy-0.5/CMakeLists.txt	(working copy)
+@@ -56,6 +56,7 @@
+     set_target_properties(coin PROPERTIES OUTPUT_NAME "_coin")
+     set_target_properties(coin PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/pivy)
+     set_target_properties(coin PROPERTIES PREFIX "")
++    install(TARGETS coin DESTINATION bin/pivy)
+ endif(MSVC)
+ 
+ fc_copy_sources_outpath("bin/pivy" "coin"
+Index: CMakeLists.txt
+===================================================================
+--- a/CMakeLists.txt	(revision 4193)
++++ a/CMakeLists.txt	(working copy)
+@@ -57,13 +57,6 @@
+ 
+ # ================================================================================
+ 
+-
+-if(WIN32)
+-    SET(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR})
+-else(WIN32)
+-    SET(CMAKE_INSTALL_PREFIX "/usr/lib/freecad")
+-endif(WIN32)
+-
+ # ================================================================================
+ # == Win32 is default behaviour use the LibPack copied in Source tree ============
+ if(MSVC)

pkgs/applications/graphics/freecad/default.nix

@@ -0,0 +1,47 @@
+{ fetchsvn, stdenv, cmake, coin3d, xercesc, ode, eigen, qt4, opencascade, gts,
+boost, zlib,
+python, swig, gfortran, soqt, libf2c, pyqt4, makeWrapper }:
+
+# It builds but fails to install
+
+stdenv.mkDerivation rec {
+  name = "freecad-${version}";
+  version = "svn-${src.rev}";
+
+  src = fetchsvn {
+    url = https://free-cad.svn.sourceforge.net/svnroot/free-cad/trunk;
+    rev = "4184";
+    sha256 = "26bd8407ce38f070b81ef39145aed093eed3c200d165a605b8169162d66568ce";
+  };
+
+  buildInputs = [ cmake coin3d xercesc ode eigen qt4 opencascade gts boost
+    zlib python swig gfortran soqt libf2c pyqt4 makeWrapper ];
+
+  enableParallelBuilding = true;
+
+  # The freecad people are used to boost 1.42, and we have newer boost that
+  # require the -DBOOST_FILESYSTEM_VERSION=2 for freecad to build
+  # For zlib to build in i686-linux, as g++ plus glibc defines _LARGEFILE64_SOURCE,
+  # we need the -D-FILE_OFFSET_BITS=64 indication for zlib headers to work.
+  NIX_CFLAGS_COMPILE = "-DBOOST_FILESYSTEM_VERSION=2 -D_FILE_OFFSET_BITS=64";
+
+  # This should work on both x86_64, and i686 linux
+  preBuild = ''
+    export NIX_LDFLAGS="-L${gfortran.gcc}/lib64 -L${gfortran.gcc}/lib $NIX_LDFLAGS";
+  '';
+
+  postInstall = ''
+    wrapProgram $out/bin/FreeCAD --prefix PYTHONPATH : $PYTHONPATH \
+      --set COIN_GL_NO_CURRENT_CONTEXT_CHECK 1
+  '';
+
+  patches = [ ./cmakeinstall.patch ./pythonpath.patch ];
+
+  meta = {
+    homepage = http://free-cad.sourceforge.net/;
+    license = [ "GPLv2+" "LGPLv2+" ];
+    description = "General purpose Open Source 3D CAD/MCAD/CAx/CAE/PLM modeler";
+    maintainers = with stdenv.lib.maintainers; [viric];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/applications/graphics/freecad/pythonpath.patch

@@ -0,0 +1,19 @@
+http://sourceforge.net/apps/phpbb/free-cad/viewtopic.php?f=4&t=847&p=6364
+
+Index: src/Main/MainGui.cpp
+===================================================================
+--- a/src/Main/MainGui.cpp	(revision 4193)
++++ a/src/Main/MainGui.cpp	(working copy)
+@@ -149,10 +149,10 @@
+     // http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=559846
+     putenv("LANG=C");
+     putenv("LC_ALL=C");
+-    putenv("PYTHONPATH=");
++    //putenv("PYTHONPATH=");
+ #else
+     setlocale(LC_NUMERIC, "C");
+-    _putenv("PYTHONPATH=");
++    //_putenv("PYTHONPATH=");
+ #endif
+ 
+     // Name and Version of the Application

pkgs/applications/graphics/geeqie/default.nix

@@ -1,15 +1,35 @@
 { stdenv, fetchurl, pkgconfig, gtk, libpng, exiv2, lcms
-, intltool, gettext }:
+, intltool, gettext, libchamplain, fbida }:
 
 stdenv.mkDerivation rec {
-  name = "geeqie-1.0beta2";
+  name = "geeqie-1.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/geeqie/${name}.tar.gz";
-    sha256 = "13h924iykmxwgpx562lrsh2j78fnzyyfmg4w7qgj9vbjq18nq7fd";
+    sha256 = "1p8z47cqdqqkn8b0fr5bqsfinz4dgqk4353s8f8d9ha6cik69bfi";
   };
 
-  buildInputs = [ pkgconfig gtk libpng exiv2 lcms intltool gettext ];
+  preConfigure =
+    # XXX: Trick to have Geeqie use the version we have.
+    '' sed -i "configure" \
+           -e 's/champlain-0.4/champlain-0.6/g ;
+               s/champlain-gtk-0.4/champlain-gtk-0.6/g'
+    '';
+
+  configureFlags = [ "--enable-gps" ];
+
+  buildInputs =
+    [ pkgconfig gtk libpng exiv2 lcms intltool gettext
+      libchamplain
+    ];
+
+  postInstall =
+    ''
+      # Allow geeqie to find exiv2 and exiftran, necessary to
+      # losslessly rotate JPEG images.
+      sed -i $out/lib/geeqie/geeqie-rotate \
+          -e '1 a export PATH=${exiv2}/bin:${fbida}/bin:$PATH'
+    '';
 
   meta = {
     description = "Geeqie, a lightweight GTK+ based image viewer";

pkgs/applications/graphics/gimp/default.nix

@@ -4,11 +4,11 @@
 }:
 
 stdenv.mkDerivation rec {
-  name = "gimp-2.6.8";
+  name = "gimp-2.6.11";
   
   src = fetchurl {
     url = "ftp://ftp.gtk.org/pub/gimp/v2.6/${name}.tar.bz2";
-    sha256 = "0cikkb4l6psankz9yhgal934b41nwk6d5a93r9zib413fj5j3m6m";
+    sha256 = "18dhgicc3f04q0js521kq9w3gq8yqawpf6vdb7m14f9vh380hvcv";
   };
   
   buildInputs = [

pkgs/applications/graphics/gimp/plugins/default.nix

@@ -37,7 +37,7 @@ let
  libLQR = pluginDerivation {
     name = "liblqr-1-0.4.1";
     # required by lqrPlugin, you don't havet to install this lib explicitely
-    buildInputs = [ gimp ] ++ gimp.buildInputs;
+    buildInputs = [ gimp ] ++ gimp.buildNativeInputs;
     src = fetchurl {
       url = http://registry.gimp.org/files/liblqr-1-0.4.1.tar.bz2;
       sha256 = "02g90wag7xi5rjlmwq8h0qs666b1i2sa90s4303hmym40il33nlz";
@@ -46,13 +46,36 @@ let
 
 in
 rec {
+  gap = pluginDerivation {
+    /* menu:
+       Video
+    */
+    name = "gap-2.6.0";
+    buildInputs = [ gimp pkgconfig glib pkgs.intltool gimp.gtk ] ++ gimp.buildNativeInputs;
+    src = fetchurl {
+      url = ftp://ftp.gimp.org/pub/gimp/plug-ins/v2.6/gap/gimp-gap-2.6.0.tar.bz2;
+      sha256 = "1jic7ixcmsn4kx2cn32nc5087rk6g8xsrz022xy11yfmgvhzb0ql";
+    };
+    patchPhase = ''
+      sed -e 's,^\(GIMP_PLUGIN_DIR=\).*,\1'"$out/${gimp.name}-plugins", \
+       -e 's,^\(GIMP_DATA_DIR=\).*,\1'"$out/share/${gimp.name}", -i configure
+    '';
+    meta = { 
+      description = "The GIMP Animation Package";
+      homepage = http://www.gimp.org;
+      # The main code is given in GPLv3, but it has ffmpeg in it, and I think ffmpeg license
+      # falls inside "free".
+      license = [ "GPLv3" "free" ];
+    };
+  };
+
   fourier = pluginDerivation {
     /* menu:
        Filters/Generic/FFT Forward
        Filters/Generic/FFT Inverse
     */
     name = "fourier-0.3.3";
-    buildInputs = [ gimp pkgs.fftwSinglePrec  pkgconfig glib] ++ gimp.buildInputs;
+    buildInputs = [ gimp pkgs.fftwSinglePrec  pkgconfig glib] ++ gimp.buildNativeInputs;
     postInstall = "fail";
     installPhase = "installPlugins fourier";
     src = fetchurl {
@@ -69,7 +92,7 @@ rec {
       Filters/Enhance/Smart remove selection
     */
     name = "resynthesizer-0.16";
-    buildInputs = [ gimp pkgs.fftw ] ++ gimp.buildInputs;
+    buildInputs = [ gimp pkgs.fftw ] ++ gimp.buildNativeInputs;
     src = fetchurl {
       url = http://www.logarithmic.net/pfh-files/resynthesizer/resynthesizer-0.16.tar.gz;
       sha256 = "1k90a1jzswxmajn56rdxa4r60v9v34fmqsiwfdxqcvx3yf4yq96x";
@@ -83,7 +106,7 @@ rec {
 
   texturize = pluginDerivation {
     name = "texturize-2.1";
-    buildInputs = [ gimp ] ++ gimp.buildInputs;
+    buildInputs = [ gimp ] ++ gimp.buildNativeInputs;
     src = fetchurl {
       url = http://prdownloads.sourceforge.net/gimp-texturize/texturize-2.1_src.tgz;
       sha256 = "0cdjq25g3yfxx6bzx6nid21kq659s1vl9id4wxyjs2dhcv229cg3";
@@ -96,7 +119,7 @@ rec {
       Filters/Enhance/Wavelet sharpen
     */
     name = "wavelet-sharpen-0.1.2";
-    buildInputs = [ gimp ] ++ gimp.buildInputs;
+    buildInputs = [ gimp ] ++ gimp.buildNativeInputs;
     src = fetchurl {
       url = http://registry.gimp.org/files/wavelet-sharpen-0.1.2.tar.gz;
       sha256 = "0vql1k67i21g5ivaa1jh56rg427m0icrkpryrhg75nscpirfxxqw";
@@ -109,7 +132,7 @@ rec {
        Layer/Liquid Rescale
     */
     name = "lqr-plugin-0.6.1";
-    buildInputs = [ pkgconfig libLQR gimp ] ++ gimp.buildInputs;
+    buildInputs = [ pkgconfig libLQR gimp ] ++ gimp.buildNativeInputs;
     src = fetchurl {
       url = http://registry.gimp.org/files/gimp-lqr-plugin-0.6.1.tar.bz2;
       sha256 = "00hklkpcimcbpjly4rjhfipaw096cpy768g9wixglwrsyqhil7l9";
@@ -124,7 +147,7 @@ rec {
   let imagemagick = pkgs.imagemagickBig; # maybe the non big version is enough?
   in pluginDerivation {
       name = "gmic-1.3.2.0";
-      buildInputs = [ imagemagick pkgconfig gimp pkgs.fftwSinglePrec ] ++ gimp.buildInputs;
+      buildInputs = [ imagemagick pkgconfig gimp pkgs.fftwSinglePrec ] ++ gimp.buildNativeInputs;
       src = fetchurl {
         url = http://dfn.dl.sourceforge.net/sourceforge/gmic/gmic_1.3.2.0.tar.gz;
         sha256 = "0mxq664vzzc2l6k6sqm9syp34mihhi262i6fixk1g12lmc28797h";
@@ -150,7 +173,7 @@ rec {
   # or use the binary
   ufraw = pluginDerivation {
     name = "ufraw-0.15";
-    buildInputs = [pkgs.lcms gimp] ++ gimp.buildInputs;
+    buildInputs = [pkgs.lcms gimp] ++ gimp.buildNativeInputs;
       # --enable-mime - install mime files, see README for more information
       # --enable-extras - build extra (dcraw, nikon-curve) executables
       # --enable-dst-correction - enable DST correction for file timestamps.

pkgs/applications/graphics/gocr/0.44.nix

@@ -1,21 +0,0 @@
-args : with args;
-	let localDefs = builderDefs.passthru.function {
-		src = /* put a fetchurl here */
-fetchurl {
-		url = http://prdownloads.sourceforge.net/jocr/gocr-0.44.tar.gz;
-		sha256 = "0kvb7cbk6z5n4g0hhbwpdk2f3819yfamwsmkwanj99yhni6p5mr0";
-	};
-
-		buildInputs = [];
-		configureFlags = [];
-	};
-	in with localDefs;
-stdenv.mkDerivation rec {
-	name = "gocr";
-	builder = writeScript (name + "-builder")
-		(textClosure localDefs [doConfigure doMakeInstall doForceShare doPropagate]);
-	meta = {
-		description = "GPL Optical Character Recognition";
-		inherit src;
-	};
-}

pkgs/applications/graphics/gocr/default.nix

@@ -0,0 +1,14 @@
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  name = "gocr-0.44";
+
+  src = fetchurl {
+    url = http://prdownloads.sourceforge.net/jocr/gocr-0.44.tar.gz;
+    sha256 = "0kvb7cbk6z5n4g0hhbwpdk2f3819yfamwsmkwanj99yhni6p5mr0";
+  };
+
+  meta = {
+    description = "GPL Optical Character Recognition";
+  };
+}

pkgs/applications/graphics/graphicsmagick/1.3.7.nix

@@ -0,0 +1,31 @@
+{stdenv, fetchurl, bzip2, freetype, graphviz, ghostscript
+, libjpeg, libpng, libtiff, libxml2, zlib, libtool
+, libX11}:
+
+let version = "1.3.7"; in
+
+stdenv.mkDerivation {
+  name = "graphicsmagick-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/graphicsmagick/GraphicsMagick-${version}.tar.gz";
+    sha256 = "0bwyqqvajz0hi34gfbjvm9f78icxk3fb442mvn8q2rapmvfpfkgf";
+  };
+
+  configureFlags = "--enable-shared";
+
+  buildInputs =
+    [ bzip2 freetype ghostscript graphviz libjpeg libpng libtiff libX11 libxml2
+      zlib libtool
+    ];
+
+  postInstall = ''
+    sed -i 's/-ltiff.*'\'/\'/ $out/bin/*
+  '';
+
+  meta = {
+    homepage = http://www.graphicsmagick.org;
+    description = "Swiss army knife of image processing";
+    license = stdenv.lib.licenses.mit;
+  };
+}

pkgs/applications/graphics/graphicsmagick/default.nix

@@ -0,0 +1,31 @@
+{stdenv, fetchurl, bzip2, freetype, graphviz, ghostscript
+, libjpeg, libpng, libtiff, libxml2, zlib, libtool
+, libX11}:
+
+let version = "1.3.11"; in
+
+stdenv.mkDerivation {
+  name = "graphicsmagick-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/graphicsmagick/GraphicsMagick-${version}.tar.bz2";
+    sha256 = "184grcvxa5w0ghiv8zf2vdva0kgp3njf20k3h6lbylspjgd3zhxg";
+  };
+
+  configureFlags = "--enable-shared";
+
+  buildInputs =
+    [ bzip2 freetype ghostscript graphviz libjpeg libpng libtiff libX11 libxml2
+      zlib libtool
+    ];
+
+  postInstall = ''
+    sed -i 's/-ltiff.*'\'/\'/ $out/bin/*
+  '';
+
+  meta = {
+    homepage = http://www.graphicsmagick.org;
+    description = "Swiss army knife of image processing";
+    license = stdenv.lib.licenses.mit;
+  };
+}

pkgs/applications/graphics/gwenview/default.nix

@@ -1,23 +0,0 @@
-{stdenv, fetchurl, kdelibs, exiv2, libXt, libXext, zlib, libjpeg, perl, qt3, 
-  libpng, expat }:
-
-stdenv.mkDerivation {
-  name = "gwenview-1.4.2";
-
-  src = fetchurl {
-    url = mirror://sourceforge/gwenview/gwenview-1.4.2.tar.bz2;
-    sha256 = "26ec1a3f3ac7cce9584b44e6090402776fb84df3fc5f9e5aadbe66e9887851fd";
-  };
-
-  configurePhase = ''
-    LDFLAGS="$LDFLAGS -ljpeg" ./configure --without-arts --prefix=$out
-    '';
-
-  buildInputs = [ kdelibs exiv2 libXt libXext zlib libjpeg perl qt3 libpng expat ];
-
-  meta = {
-    homepage = http://gwenview.sourceforge.net/;
-    description = "KDE photo viewer";
-    license = "GPLv2+";
-  };
-}

pkgs/applications/graphics/hugin/default.nix

@@ -3,15 +3,13 @@
  glew, libXmu, libXi }:
 
 stdenv.mkDerivation rec {
-  name = "hugin-2009.4.0";
+  name = "hugin-2010.0.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/hugin/${name}.tar.gz";
-    sha256 = "1xa7rnpwlv68wfkikmlrs74hqylpkh837p3narqljr2a7fxf04r9";
+    sha256 = "08xm7ggfrh536lqvdzw7zg09p2awbclw5r7i8c59gf092w1cac7d";
   };
 
-#   patches = [ ./levmar-64-bit-alignment.patch ];
-
   NIX_CFLAGS_COMPILE = "-I${ilmbase}/include/OpenEXR";
 
   NIX_LDFLAGS = "-lrt";

pkgs/applications/graphics/hugin/levmar-64-bit-alignment.patch

@@ -1,64 +0,0 @@
-This patch fixes alignment issues on 64-bit machines.  It was taken
-from http://www.mail-archive.com/hugin-ptx@googlegroups.com/msg02976.html .
-See also http://thread.gmane.org/gmane.linux.distributions.nixos/2352 .
-
---- hugin/src/foreign/levmar/misc_core.c	2009-04-28 13:30:33.000000000 +0200 # SVN 3799
-+++ hugin/src/foreign/levmar/misc_core.c	2009-05-04 07:49:00.000000000 +0200 # Merged patch.pt and fix_alias.diff
-@@ -332,7 +332,7 @@
-   a_sz=m*m;
-   u_sz=m*m; s_sz=m; vt_sz=m*m;
- 
--  tot_sz=iworksz*sizeof(int) + (a_sz + u_sz + s_sz + vt_sz + worksz)*sizeof(LM_REAL);
-+  tot_sz=(a_sz + u_sz + s_sz + vt_sz + worksz)*sizeof(LM_REAL) + iworksz*sizeof(int); /* should be arranged in that order for proper doubles alignment */
- 
-     buf_sz=tot_sz;
-     buf=(LM_REAL *)malloc(buf_sz);
-@@ -414,25 +414,27 @@
- int buf_sz=0;
- 
- register int i, j, k, l;
--int *idx, maxi=-1, idx_sz, a_sz, x_sz, work_sz, tot_sz;
-+int *idxbuf, *idx, maxi=-1, idx_sz, a_sz, x_sz, work_sz, tot_sz;
- LM_REAL *a, *x, *work, max, sum, tmp;
- 
-   /* calculate required memory size */
-   idx_sz=m;
-+  idxbuf=(void *)malloc(idx_sz*sizeof(int));
-+
-   a_sz=m*m;
-   x_sz=m;
-   work_sz=m;
--  tot_sz=idx_sz*sizeof(int) + (a_sz+x_sz+work_sz)*sizeof(LM_REAL);
-+  tot_sz=(a_sz + x_sz + work_sz)*sizeof(LM_REAL) + idx_sz*sizeof(int); /* should be arranged in that order for proper doubles alignment */
- 
-   buf_sz=tot_sz;
-   buf=(void *)malloc(tot_sz);
--  if(!buf){
-+  if(!buf || !idxbuf){
-     fprintf(stderr, RCAT("memory allocation in ", LEVMAR_LUINVERSE) "() failed!\n");
-     exit(1);
-   }
- 
--  idx=(int *)buf;
--  a=(LM_REAL *)(idx + idx_sz);
-+  idx=(int *)idxbuf;
-+  a=(LM_REAL *)buf;
-   x=a + a_sz;
-   work=x + x_sz;
- 
-@@ -448,6 +450,7 @@
- 		  if(max==0.0){
-         fprintf(stderr, RCAT("Singular matrix A in ", LEVMAR_LUINVERSE) "()!\n");
-         free(buf);
-+	free(idxbuf);
- 
-         return 0;
-       }
-@@ -522,6 +525,7 @@
-   }
- 
-   free(buf);
-+  free(idxbuf);
- 
-   return 1;
- }

pkgs/applications/graphics/inkscape/default.nix

@@ -1,11 +1,14 @@
-args: with args;
+{ stdenv, fetchurl, pkgconfig, perl, perlXMLParser, gtk, libXft
+, libpng, zlib, popt, boehmgc, libxml2, libxslt, glib, gtkmm
+, glibmm, libsigcxx, lcms, boost, gettext, makeWrapper, intltool
+, gsl, python, pyxml, lxml, poppler }:
 
 stdenv.mkDerivation rec {
-  name = "inkscape-0.47";
+  name = "inkscape-0.48.0";
 
   src = fetchurl {
-    url = "mirror://sourceforge/inkscape/${name}.tar.gz";
-    sha256 = "15wvcllq0nj69hkyanzvxbjhlq06cwabqabaa54n5n4307hrp2g5";
+    url = "mirror://sourceforge/inkscape/${name}.tar.bz2";
+    sha256 = "0w72xf76vxpm3fpslmix0x71l2rd2sdhrvgwx2vk7hxfjqdxib1n";
   };
 
   patches = [ ./configure-python-libs.patch ]; 
@@ -19,7 +22,7 @@ stdenv.mkDerivation rec {
   buildInputs = [
     pkgconfig perl perlXMLParser gtk libXft libpng zlib popt boehmgc
     libxml2 libxslt glib gtkmm glibmm libsigcxx lcms boost gettext
-    makeWrapper intltool gsl
+    makeWrapper intltool gsl poppler
   ];
 
   configureFlags = "--with-python";
@@ -32,6 +35,7 @@ stdenv.mkDerivation rec {
        "$(toPythonPath ${pyxml}):$(toPythonPath ${lxml})" ||  \
         exit 2
     done
+    rm $out/share/icons/hicolor/icon-theme.cache
   '';
 
   NIX_LDFLAGS = "-lX11";
@@ -45,6 +49,5 @@ stdenv.mkDerivation rec {
 
       If you want to import .eps files install ps2edit.
     '';
-
   };
 }

pkgs/applications/graphics/kipi-plugins/default.nix

@@ -0,0 +1,26 @@
+{ stdenv, fetchurl, cmake, qt4, kdelibs, automoc4, phonon, qimageblitz, qca2,
+kdegraphics, kdepimlibs, libxml2, libxslt, gettext, opencv, libgpod, gtk }:
+
+stdenv.mkDerivation rec {
+  name = "kipi-plugins-1.5.0";
+
+  src = fetchurl { 
+    url = "mirror://sourceforge/kipi/${name}.tar.bz2";
+    sha256 = "1wsqh0lbsqyzdfmb9f53bmmypw00n80p62ym4pnxb8w0zwlhbkbw";
+  };
+
+  buildInputs = [ cmake qt4 kdelibs kdegraphics automoc4 phonon qimageblitz qca2 kdepimlibs 
+    libxml2 libxslt gettext opencv libgpod gtk ];
+
+  KDEDIRS = kdegraphics;
+
+  patches = [ ./find-gdk.patch ];
+
+  meta = {
+    description = "Photo Management Program";
+    license = "GPL";
+    homepage = http://www.kipi-plugins.org;
+    inherit (kdelibs.meta) platforms;
+    maintainers = with stdenv.lib.maintainers; [ viric urkud ];
+  };
+}

pkgs/applications/graphics/kipi-plugins/find-gdk.patch

@@ -0,0 +1,16 @@
+diff --git a/cmake/modules/FindGdk.cmake b/cmake/modules/FindGdk.cmake
+index 033959a..ff61961 100644
+--- a/cmake/modules/FindGdk.cmake
++++ b/cmake/modules/FindGdk.cmake
+@@ -23,8 +23,9 @@ else (GDK_INCLUDE_DIR AND GDK_LIBRARIES)
+     set(GDK_DEFINITIONS ${_GDKCflags})
+   endif(NOT WIN32)
+ 
+-  FIND_PATH(GDK_INCLUDE_DIR gdk-pixbuf/gdk-pixbuf.h /usr/include/gtk-2.0
+-    ${_GDKIncDir}
++  FIND_PATH(GDK_INCLUDE_DIR gdk-pixbuf/gdk-pixbuf.h
++    HINTS ${_GDKIncDir}
++	PATH_SUFFIXES gtk-2.0
+   )
+   
+   FIND_LIBRARY(GDK_LIBRARIES NAMES gdk_pixbuf-2.0

pkgs/applications/graphics/meshlab/default.nix

@@ -1,49 +1,37 @@
 {stdenv, fetchurl, qt, bzip2, lib3ds, levmar, muparser, unzip}:
 
 stdenv.mkDerivation rec {
-  name = "meshlab-1.2.2";
+  name = "meshlab-1.2.3a";
 
   src = fetchurl {
-    url = mirror://sourceforge/meshlab/MeshLabSrc_v122.tar.gz;
-    sha256 = "166a8mx72wf3r84pnpr0ssqkd2xw6y5brviywlj8rjk6w9cy8fdc";
+    url = mirror://sourceforge/meshlab/MeshLabSrc_AllInc_v123a.tgz;
+    sha256 = "09w42q0x1yjr7l9ng952lic7vkb1arsvqg1fld5s297zwzfmsl9v";
   };
 
-  srcGlew151 = fetchurl {
-    url = http://dfn.dl.sourceforge.net/sourceforge/glew/glew-1.5.1-src.tgz;
-    sha256 = "02n1p6s6sia92fgng9iq0kqq890rga8d8g0y34mc6qxmbh43vrl9";
-  };
-
-  srcQHull20031 = fetchurl {
-    url = http://www.qhull.org/download/qhull-2003.1.zip;
-    sha256 = "07mh371i6xs691qz6wwzkqk9h0d2dkih2q818is2b041w1l79b46";
-  };
-
-
-  patchPhase = ''
-    cd meshlab/src
-    mkdir external
-    pushd external
-    tar xf ${srcGlew151}
-    mv glew glew-1.5.1
-    unzip ${srcQHull20031}
-    popd
-  '';
+  # I don't know why I need this; without this, the rpath set at the beginning of the
+  # buildPhase gets removed from the 'meshlab' binary
+  dontPatchELF = true;
 
   buildPhase = ''
-    pwd
+    export NIX_LDFLAGS="-rpath $out/opt/meshlab $NIX_LDFLAGS"
+    cd meshlab/src
+    pushd external
+    qmake -recursive external.pro
+    make
+    popd
     qmake -recursive meshlabv12.pro
     make
   '';
 
   installPhase = ''
-    ensureDir $out/opt/meshlab $out/bin
-    pushd meshlab
-    cp -R meshlab plugins shaders* textures images $out/opt/meshlab
+    ensureDir $out/opt/meshlab $out/bin $out/lib
+    pushd distrib
+    cp -R * $out/opt/meshlab
     popd
     ln -s $out/opt/meshlab/meshlab $out/bin/meshlab
   '';
 
-  buildInputs = [ qt bzip2 lib3ds levmar muparser unzip ];
+  buildInputs = [ qt unzip ];
 
   meta = {
     description = "System for the processing and editing of unstructured 3D triangular meshes";

pkgs/applications/graphics/ocrad/default.nix

@@ -0,0 +1,34 @@
+{ fetchurl, stdenv }:
+
+stdenv.mkDerivation rec {
+  name = "ocrad-0.21";
+
+  src = fetchurl {
+    url = "mirror://gnu/ocrad/${name}.tar.gz";
+    sha256 = "1k58ha70r0cqahssx67hfgyzia9ymf691yay06n7nrkbklii3isf";
+  };
+
+  doCheck = true;
+
+  meta = {
+    description = "GNU Ocrad, optical character recognition (OCR) program & library";
+
+    longDescription =
+      '' GNU Ocrad is an OCR (Optical Character Recognition) program based on
+         a feature extraction method.  It reads images in pbm (bitmap), pgm
+         (greyscale) or ppm (color) formats and produces text in byte (8-bit)
+         or UTF-8 formats.
+
+         Also includes a layout analyser able to separate the columns or
+         blocks of text normally found on printed pages.
+
+         Ocrad can be used as a stand-alone console application, or as a
+         backend to other programs.
+      '';
+
+    license = "GPLv3+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+}

pkgs/applications/graphics/panotools/default.nix

@@ -1,24 +1,22 @@
-{stdenv, fetchsvn, libjpeg, libpng, libtiff, automake, libtool, autoconf }:
+{ fetchurl, stdenv, libjpeg, libpng, libtiff, perl }:
 
-stdenv.mkDerivation {
-  name = "panotools-r955";
+stdenv.mkDerivation rec {
+  name = "libpano13-2.9.17";
 
-  src = fetchsvn {
-    url = https://panotools.svn.sourceforge.net/svnroot/panotools/trunk/libpano;
-    rev = 955;
-    sha256 = "e896c21caa098d33f33f33f134a8c9a725686c2470fe3cd08b76cd7934a56034";
+  src = fetchurl {
+    url = "mirror://sourceforge/panotools/libpano13/${name}/${name}.tar.gz";
+    sha256 = "1zcrkw0xw11170mlhh9r8562gafwx3hd92wahl9xxaah5z4v0am2";
   };
 
-  configurePhase = ''
-    export AUTOGEN_CONFIGURE_ARGS="--prefix $out"
-    ./bootstrap
-  '';
+  buildInputs = [ perl libjpeg libpng libtiff ];
 
-  buildInputs = [ libjpeg libpng libtiff automake libtool autoconf ];
+  doCheck = true;
 
   meta = {
     homepage = http://panotools.sourceforge.net/;
     description = "Free software suite for authoring and displaying virtual reality panoramas";
-    license = "LGPL";
+    license = "GPLv2+";
+
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
   };
 }

pkgs/applications/graphics/paraview/default.nix

@@ -1,16 +1,19 @@
 { fetchurl, stdenv, cmake, qt4 }:
 
 stdenv.mkDerivation rec {
-  name = "paraview-3.6.2";
+  name = "paraview-3.8.1";
   src = fetchurl {
-    url = "http://www.paraview.org/files/v3.6/${name}.tar.gz";
-    sha256 = "017axalkiaqd13jfbb4awcxvpndnzaq35ys7svm5rnizdwd5hbq6";
+    url = "http://www.paraview.org/files/v3.8/ParaView-3.8.1.tar.gz";
+    sha256 = "0g169vc956gifkd90lcini63dkr5x3id3hkwcwxzriqamxr72r1p";
   };
 
   preConfigure = ''
-    export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/paraview-3.6"
+    export NIX_LDFLAGS="$NIX_LDFLAGS -rpath $out/lib/paraview-3.8"
   '';
 
+  # I don't enable it due to memory bounds
+  enableParallelBuilding = false;
+
   buildInputs = [ cmake qt4 ];
 
   meta = {

pkgs/applications/graphics/pinta/default.nix

@@ -0,0 +1,43 @@
+{stdenv, fetchurl, mono, gtksharp, pkgconfig}:
+
+stdenv.mkDerivation {
+  name = "pinta-0.5";
+
+  src = fetchurl {
+    url =  http://github.com/downloads/jpobst/Pinta/pinta-0.5.tar.gz; 
+    sha256 = "0qv95zswi488bkbck9b9yhmczj1sgqc96nzn4f5rwfqz516kilrl";
+  };
+
+  buildInputs = [mono gtksharp pkgconfig];
+
+  buildPhase = ''
+    # xbuild understands pkgconfig, but gtksharp does not give .pc for gdk-sharp
+    # So we have to go the GAC-way
+    export MONO_GAC_PREFIX=${gtksharp}
+    xbuild Pinta.sln
+  '';
+
+  # Very ugly - I don't know enough Mono to improve this. Isn't there any rpath in binaries?
+  installPhase = ''
+    ensureDir $out/lib/pinta $out/bin
+    cp bin/*.{dll,exe} $out/lib/pinta
+    cat > $out/bin/pinta << EOF
+    #!/bin/sh
+    export MONO_GAC_PREFIX=${gtksharp}:\$MONO_GAC_PREFIX
+    export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:${gtksharp}/lib:${gtksharp.gtk}/lib:${mono}/lib
+    exec ${mono}/bin/mono $out/lib/pinta/Pinta.exe
+    EOF
+    chmod +x $out/bin/pinta
+  '';
+
+  # Always needed on Mono, otherwise nothing runs
+  dontStrip = true; 
+
+  meta = {
+    homepage = http://www.pinta-project.com/;
+    description = "Drawing/editing program modeled after Paint.NET";
+    license = "MIT";
+    maintainers = with stdenv.lib.maintainers; [viric];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}