;;; movie.el --- playing movies
;; Copyright (C) 2004 Free Software Foundation, Inc.

;; Author: Lars Magne Ingebrigtsen <lmi@gnus.org>
;; Keywords: extensions, processes

;; This file is not part of GNU Emacs.

;; movie.el 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 2, or (at your option)
;; any later version.

;; movie.el 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 GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;;; Code:

(require 'time-date)

(defvar movie-files "\\.\\(mpg\\|avi\\)$"
  "Regexp to match movie files.")

(defvar movie-player '("mplayer" "-framedrop" "-vo" "directfb" "-quiet")
  "Command to play a file.")

(defun movie-browse (directory &optional order)
  "Browse DIRECTORY."
  (interactive "DDirectory: ")
  (setq directory (file-truename directory))
  (let ((files (movie-get-files directory)))
    (switch-to-buffer (directory-file-name directory))
    (erase-buffer)
    (movie-mode)
    (setq movie-order order)
    (movie-generate-buffer files order)
    (setq default-directory directory)
    (goto-char (point-min))))

(defun movie-get-files (directory)
  (let ((files (directory-files directory t))
	(data nil)
	stats)
    (dolist (file files)
      (setq stats (file-attributes file))
      (when (or (string-match movie-files (file-name-nondirectory file))
		(and (eq (car stats) t)
		     (not (member (file-name-nondirectory file) '("." "..")))))
	(push (list file (nth 5 stats) (nth 7 stats) (nth 0 stats))
	      data)))
    data))

(defun movie-generate-buffer (files &optional order)
  (when (not order)
    (setq order 'alphabetical))
  (setq files (movie-sort files order))
  (insert "    ..\n")
  (dolist (file files)
    (insert (format "%3d %s%s\n"
		    (round (/ (nth 2 file) 1024 1024))
		    (file-name-nondirectory (nth 0 file))
		    (if (eq (nth 0 file) t) "/" "")))))

(defun movie-sort (files order)
  (let ((predicate
	 (cond
	  ((eq order 'alphabetical)
	   (lambda (f1 f2)
	     (string< (car f1) (car f2))))
	  ((eq order 'chronological)
	   (lambda (f1 f2)
	     (time-less-p (nth 1 f1) (nth 1 f2))))
	  (t
	   (error "No such order %s" order)))))
    (sort files predicate)))

(defvar movie-mode-map nil)
(unless movie-mode-map
  (setq movie-mode-map (make-sparse-keymap))
  (suppress-keymap movie-mode-map)
  (define-key movie-mode-map "\r" 'movie-find-file)
  (define-key movie-mode-map [delete] 'movie-delete-file)
  (define-key movie-mode-map [del] 'movie-delete-file)
  (define-key movie-mode-map [backspace] 'movie-delete-file)
  (define-key movie-mode-map [deletechar] 'movie-delete-file)
  (define-key movie-mode-map "d" 'movie-delete-file)
  (define-key movie-mode-map "q" 'bury-buffer)
  (define-key movie-mode-map "g" 'movie-rescan)
  (define-key movie-mode-map "s" 'movie-toggle-sort)
  )

(defvar movie-mode nil
  "Mode for Movie buffers.")

(defvar movie-mode-hook nil
  "Hook run in Movie mode buffers.")

(defun movie-mode (&optional arg)
  "Mode for Movie mode buffers.

\\{movie-mode-map}"
  (interactive (list current-prefix-arg))
  (make-local-variable 'movie-mode)
  (setq movie-mode
	(if (null arg) (not movie-mode)
	  (> (prefix-numeric-value arg) 0)))
  (setq major-mode 'movie-mode)
  (setq mode-name "Movie")
  (use-local-map movie-mode-map)
  (set (make-local-variable 'movie-order) nil)
  (setq mode-line-buffer-identification
	'("Movie: " default-directory))
  (setq truncate-lines t)
  (run-hooks 'movie-mode-hook))

(defun movie-find-file (file)
  "Find or play the file under point."
  (interactive (list (movie-current-file)))
  (if (file-directory-p file)
      (movie-browse file)
    (movie-play file)))

(defun movie-play (file)
  (let ((player (append movie-player (list file))))
    (apply 'call-process (car player) nil
	   (get-buffer-create "*mplayer*")
	   nil (cdr player))))

(defun movie-delete-file (file)
  "Delete the file under point."
  (interactive (list (movie-current-file)))
  (when (y-or-n-p (format "Really delete %s? " file))
    (delete-file file)
    (movie-rescan)))

(defun movie-current-file ()
  (save-excursion
    (beginning-of-line)
    (forward-char 4)
    (concat default-directory "/"
	    (buffer-substring (point) (line-end-position)))))

(defun movie-rescan (&optional order)
  "Update the current buffer."
  (interactive)
  (let ((lines (count-lines (point-min) (point))))
    (movie-browse default-directory order)
    (forward-line lines)))

(defun movie-toggle-sort ()
  "Toggle sorting by time."
  (interactive)
  (if (eq movie-order nil)
      (setq movie-order 'chronological)
    (setq movie-order nil))
  (movie-rescan movie-order))

;;; movie.el ends here