procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Revert changes installed by xwidgets merge

Browse source
This commit is contained in:
Paul Eggert 2015-02-01 11:39:36 -08:00
parent 1d1162479c
commit 241260cc28
34 changed files with 1184 additions and 5292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,7 +1,3 @@
2015-02-01 Joakim Verona <joakim@verona.se>
Support for the new Xwidget feature.
* configure.ac:
2015-01-28 Paul Eggert <eggert@cs.ucla.edu>
Merge from gnulib and try to repair bad merge

2
README.xwidget
View file

@ -1,2 +0,0 @@
-*-org-*-
Please see https://github.com/jave/xwidget-aux for documentation.

43
configure.ac
View file

@ -374,8 +374,6 @@ otherwise for the first of `gfile' or `inotify' that is usable.])
],
[with_file_notification=$with_features])
OPTION_DEFAULT_OFF([xwidgets],[enable use of some gtk widgets in Emacs buffers])
## For the times when you want to build Emacs but don't have
## a suitable makeinfo, and can live without the manuals.
dnl http://lists.gnu.org/archive/html/emacs-devel/2008-04/msg01844.html
@ -2529,41 +2527,6 @@ if test "${HAVE_GTK}" = "yes"; then
term_header=gtkutil.h
fi
HAVE_XWIDGETS=no
HAVE_WEBKIT=no
HAVE_GIR=no
if test "${with_xwidgets}" != "no" && test "${USE_GTK_TOOLKIT}" = "GTK3" && test "$window_system" != "none" ; then
echo "xwidgets enabled, checking webkit, and others"
HAVE_XWIDGETS=yes
AC_DEFINE(HAVE_XWIDGETS, 1, [Define to 1 if you have xwidgets support.])
dnl xwidgets
dnl - enable only if GTK3 is enabled, and we have a window system
dnl - check for webkit and gobject introspection
#webkit version for gtk3.
WEBKIT_REQUIRED=1.4.0
WEBKIT_MODULES="webkitgtk-3.0 >= $WEBKIT_REQUIRED"
if test "${with_gtk3}" = "yes"; then
PKG_CHECK_MODULES(WEBKIT, $WEBKIT_MODULES, HAVE_WEBKIT=yes, HAVE_WEBKIT=no)
if test $HAVE_WEBKIT = yes; then
AC_DEFINE(HAVE_WEBKIT_OSR, 1, [Define to 1 if you have webkit_osr support.])
fi
fi
GIR_REQUIRED=1.32.1
GIR_MODULES="gobject-introspection-1.0 >= $GIR_REQUIRED"
PKG_CHECK_MODULES(GIR, $GIR_MODULES, HAVE_GIR=yes, HAVE_GIR=no)
if test $HAVE_GIR = yes; then
AC_DEFINE(HAVE_GIR, 1, [Define to 1 if you have GIR support.])
fi
fi
CFLAGS=$OLD_CFLAGS
LIBS=$OLD_LIBS
@ -4843,7 +4806,7 @@ TOOLKIT_LIBW=
case "$USE_X_TOOLKIT" in
MOTIF) TOOLKIT_LIBW="$MOTIF_LIBW" ;;
LUCID) TOOLKIT_LIBW="$LUCID_LIBW" ;;
none) test "x$HAVE_GTK" = "xyes" && TOOLKIT_LIBW="$GTK_LIBS -lXcomposite" ;;
none) test "x$HAVE_GTK" = "xyes" && TOOLKIT_LIBW="$GTK_LIBS" ;;
esac
AC_SUBST(TOOLKIT_LIBW)
@ -5164,10 +5127,6 @@ echo " Does Emacs use -lxft? ${HAVE_XFT}"
echo " Does Emacs directly use zlib? ${HAVE_ZLIB}"
echo " Does Emacs use toolkit scroll bars? ${USE_TOOLKIT_SCROLL_BARS}"
echo " Does Emacs support Xwidgets? ${HAVE_XWIDGETS}"
echo " Does xwidgets support webkit(requires gtk3)? ${HAVE_WEBKIT}"
echo " Does xwidgets support gobject introspection? ${HAVE_GIR}"
echo
if test -n "${EMACSDATA}"; then

5
doc/lispref/ChangeLog
View file

@ -1,8 +1,3 @@
2015-02-01 Martin Rudalics <rudalics@gmx.at>
* display.texi (Size of Displayed Text): Describe optional
argument BUFFER of `window-text-pixel-size'.
2015-01-28 Eli Zaretskii <eliz@gnu.org>
* searching.texi (Regexp Search): Add a cross-reference to "Syntax

9
doc/lispref/display.texi
View file

@ -1880,7 +1880,7 @@ displayed in a given window. This function is used by
@code{fit-frame-to-buffer} (@pxref{Size and Position}) to make a window
exactly as large as the text it contains.
@defun window-text-pixel-size &optional window from to x-limit y-limit mode-and-header-line buffer
@defun window-text-pixel-size &optional window from to x-limit y-limit mode-and-header-line
This function returns the size of the text of @var{window}'s buffer in
pixels. @var{window} must be a live window and defaults to the selected
one. The return value is a cons of the maximum pixel-width of any text
@ -1919,13 +1919,6 @@ means to not include the height of the mode- or header-line of
@code{mode-line} or @code{header-line}, include only the height of that
line, if present, in the return value. If it is @code{t}, include the
height of both, if present, in the return value.
The optional argument @var{buffer} allows to specify an alternate buffer
whose text size will be calculated. If @var{buffer} is @code{nil} or
omitted, then operate on the buffer of @var{window}. If it is @code{t},
then operate on the current buffer as if it were displayed in
@var{window}. If it specifies a live buffer, then operate on that
buffer as if it were displayed in @var{window}.
@end defun

4
etc/NEWS
View file

@ -65,9 +65,7 @@ so if you want to use it, you can always take a copy from an older Emacs.
* Changes in Emacs 25.1
** Xwidgets : A new feature for embedding native widgets
inside Emacs buffers. If you have gtk3 and webkit-devel installed,
you can try the embedded webkit browser with m-x xwidget-webkit-browse-url.
** `package-install-from-buffer' and `package-install-file' work on directories.
This follows the same rules as installing from a .tar file, except the
-pkg file is optional.

9
lisp/ChangeLog
View file

@ -1,12 +1,3 @@
2015-02-01 Joakim Verona <joakim@verona.se>
Support for the new Xwidget feature.
* xwidget.el:
2015-02-01 Grégoire Jadi <daimrod@gmail.com>
Support for testing xwidgets
* emacs-parallel/parallell-remote.el, emacs-parallel/parallell-xwidget.el:
* emacs-parallel/parallell.el:
2015-01-31 Stefan Monnier <monnier@iro.umontreal.ca>
* emacs-lisp/eieio.el (defclass): Use new eieio-make-class-predicate

147
lisp/emacs-parallel/README.org
View file

@ -1,147 +0,0 @@
* Emacs Parallel
Emacs Parallel is yet another library to simulate parallel
computations in Emacs (because it lacks threads support in Elisp).
* STARTED HowTo
You can execute a simple function a retrive the result like this:
#+BEGIN_SRC emacs-lisp
(parallel-get-result (parallel-start (lambda () (* 42 42))))
⇒ 1764
#+END_SRC
Though you won't benefit from the parallelism because
~parallel-get-result~ is blocking, that is it waits for the function
to be executed.
So you can use define a callback to be called when the function is
finished:
#+BEGIN_SRC emacs-lisp
(parallel-start (lambda () (sleep-for 4.2) "Hello World")
:post-exec (lambda (results _status)
(message (first results))))
⊣ Hello World
#+END_SRC
Here, why ~(first results)~ and not ~result~? Because you can send
data from the remote instance while it's running with
~parallel-remote-send~:
#+BEGIN_SRC emacs-lisp
(parallel-start (lambda ()
(parallel-remote-send "Hello")
(sleep-for 4.2)
"World")
:post-exec (lambda (results _status)
(message "%s"
(mapconcat #'identity (reverse results) " "))))
⊣ Hello World
#+END_SRC
As you may have noticed the results are pushed in a list, so the
first element is the result returned by the function called, the
second is the last piece of data send, and so on...
And of course you can execute some code when you receive data from
the remote instance:
#+BEGIN_SRC emacs-lisp
(parallel-start (lambda ()
(parallel-remote-send 42)
(sleep-for 4.2) ; heavy computation to compute PI
pi)
:on-event (lambda (data)
(message "Received %S" data)))
⊣ Received 42
⊣ Received 3.141592653589793
#+END_SRC
Because the function is executed in another Emacs instance (in Batch
Mode by default), the environment isn't the same. However you can
send some data with the ~env~ parameter:
#+BEGIN_SRC emacs-lisp
(let ((a 42)
(b 12))
(parallel-get-result (parallel-start (lambda (a b) (+ a b))
:env (list a b))))
⇒ 54
#+END_SRC
By default, the remote Emacs instance is exited when the function is
executed, but you can keep it running with the
~:continue-when-executed~ option and send new code to be executed
with ~parellel-send~.
#+BEGIN_SRC emacs-lisp
(let ((task (parallel-start (lambda () 42)
:continue-when-executed t)))
(sleep-for 4.2)
(parallel-send task (lambda () (setq parallel-continue-when-executed nil) 12))
(parallel-get-results task))
⇒ (12 42)
#+END_SRC
As you can see, to stop the remote instance you have to set the
variable ~parallel-continue-when-executed~ to nil.
* Modules
** Parallel XWidget
[[http://www.emacswiki.org/emacs/EmacsXWidgets][Emacs XWidget]] is an experimental branch which permits to embed GTK+
widget inside Emacs buffers. For instance, it is possible to use it
to render an HTML page using the webkit engine within an Emacs
buffer.
With this module, you can configure your "main" Emacs to use
another one to render web pages.
Let's assume that you've cloned [[https://github.com/jave/xwidget-emacs][the Emacs XWidget repository]] in
~$HOME/src/emacs-xwidget/~. Once you've compiled it, an Emacs
executable is available ~$HOME/src/emacs-xwidget/src/emacs~.
Configure ~parallel-xwidget~ to use it:
#+BEGIN_SRC emacs-lisp
(setq parallel-xwidget-config (list :emacs-path
(concat (getenv "HOME")
"/src/emacs-xwidget/src/emacs")))
#+END_SRC
Then configure your current Emacs to use it:
#+BEGIN_SRC emacs-lisp
(setq browse-url-browser-function 'parallel-xwidget-browse-url)
#+END_SRC
You can check it out with M-x browse-url RET google.com RET.
* Tips & Tricks
If your windows manager is smart enough (like StumpwWM) you can use
it to move graphical windows (Emacs frames) in another desktop.
For example, I use this to move Emacs frames (with the title
"emacs-debug") to the group (aka desktop) 9:
#+BEGIN_SRC lisp
(define-frame-preference "9"
(0 nil t :title "emacs-debug"))
#+END_SRC
And this to specify the title of the frame:
#+BEGIN_SRC emacs-lisp
(parallel-start (lambda () 42)
:no-batch t
:emacs-args '("-T" "emacs-debug"))
#+END_SRC
* TODO How does it work?
* Known limitations
You can only send data to the remote (with the ~env~ parameter) or
from the remote (with ~parallel-send~ and ~parallel-remote-send~)
that have a printed representation (see [[info:elisp#Printed%20Representation][info:elisp#Printed
Representation]]).
So you can pass around numbers, symbols, strings, lists, vectors,
hash-table but you can't pass buffers, windows, frames...
It lacks documentation, tests and probably a clean API, but I'm
working on it!

81
lisp/emacs-parallel/parallel-remote.el
View file

@ -1,81 +0,0 @@
;; -*- mode: emacs-lisp; lexical-binding: t; -*-
;;; parallel-remote.el ---
;; Copyright (C) 2013 Grégoire Jadi
;; Author: Grégoire Jadi <gregoire.jadi@gmail.com>
;; 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/>.
;;; Commentary:
;;; Code:
(require 'cl)
(defvar parallel-service nil)
(defvar parallel-task-id nil)
(defvar parallel-client nil)
(defvar parallel--executed nil)
(defvar parallel-continue-when-executed nil)
(defun parallel-remote-send (data)
(process-send-string parallel-client
(format "%S " (cons parallel-task-id data))))
(defun parallel-remote--init ()
(setq parallel-client (make-network-process :name "emacs-parallel"
:buffer nil
:server nil
:service parallel-service
:host "localhost"
:family 'ipv4))
(set-process-filter parallel-client #'parallel-remote--filter)
(parallel-remote-send 'code)
(when noninteractive ; Batch Mode
;; The evaluation is done in the `parallel--filter' but in Batch
;; Mode, Emacs doesn't wait for the input, it stops as soon as
;; `parallel--init' has been executed.
(while (null parallel--executed)
(sleep-for 10)))) ; arbitrary chosen
(defun parallel-remote--filter (_proc output)
(dolist (code (parallel--read-output output))
(parallel-remote-send
(if (or noninteractive
(not debug-on-error))
(condition-case err
(eval code)
(error err))
(eval code))))
(unless parallel-continue-when-executed
(setq parallel--executed t)
(kill-emacs)))
(defun parallel--read-output (output)
"Read lisp forms from output and return them as a list."
(loop with output = (replace-regexp-in-string
"\\`[ \t\n]*" ""
(replace-regexp-in-string "[ \t\n]*\\'" "" output)) ; trim string
with start = 0
with end = (length output)
for ret = (read-from-string output start end)
for data = (first ret)
do (setq start (rest ret))
collect data
until (= start end)))
(provide 'parallel-remote)
;;; parallel-remote.el ends here

59
lisp/emacs-parallel/parallel-xwidget.el
View file

@ -1,59 +0,0 @@
;;; parallel-xwidget.el ---
;; Copyright (C) 2013 Grégoire Jadi
;; Author: Grégoire Jadi <gregoire.jadi@gmail.com>
;; 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/>.
;;; Commentary:
;;; Code:
(require 'parallel)
(require 'browse-url)
(defgroup parallel-xwidget nil
"Browse the web in another emacs instance with XWidget."
:group 'emacs)
(defvar parallel-xwidget--task nil)
(defcustom parallel-xwidget-config nil
"Parallel configuration."
:type 'alist
:group 'parallel-xwidget)
(defun parallel-xwidget--init ()
(setq parallel-xwidget--task
(parallel-start (lambda ()
(require 'xwidget))
:graphical t
:continue-when-executed t
:config parallel-xwidget-config)))
(defun parallel-xwidget-browse-url (url &optional new-session)
"Browse URL in another Emacs instance."
(interactive (browse-url-interactive-arg "xwidget-webkit URL: "))
(unless (and parallel-xwidget--task
(eq 'run (parallel-status parallel-xwidget--task)))
(parallel-xwidget--init))
(parallel-send parallel-xwidget--task
(lambda (url new-session)
(xwidget-webkit-browse-url url new-session))
(url-tidy url) new-session))
(provide 'parallel-xwidget)
;;; parallel-xwidget.el ends here

310
lisp/emacs-parallel/parallel.el
View file

@ -1,310 +0,0 @@
;; -*- lexical-binding: t; -*-
;;; parallel.el ---
;; Copyright (C) 2013 Grégoire Jadi
;; Author: Grégoire Jadi <gregoire.jadi@gmail.com>
;; 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/>.
;;; Commentary:
;;; Code:
(require 'cl)
(require 'parallel-remote)
(defgroup parallel nil
"Execute stuff in parallel"
:group 'emacs)
(defcustom parallel-sleep 0.05
"How many sec should we wait while polling."
:type 'number
:group 'parallel)
(defcustom parallel-config nil
"Global config setting to use."
:type 'plist
:group 'parallel)
(defvar parallel--server nil)
(defvar parallel--tasks nil)
(defvar parallel--tunnels nil)
;; Declare external function
(declare-function parallel-send "parallel-remote")
(defun parallel-make-tunnel (username hostname)
(parallel--init-server)
(let ((tunnel (find-if (lambda (tun)
(and (string= username
(process-get tun 'username))
(string= hostname
(process-get tun 'hostname))))
parallel--tunnels)))
(unless tunnel
(setq tunnel (start-process "parallel-ssh" nil "ssh"
"-N" "-R" (format "0:localhost:%s"
(process-contact parallel--server :service))
(format "%s@%s" username hostname)))
(process-put tunnel 'username username)
(process-put tunnel 'hostname hostname)
(set-process-filter tunnel #'parallel--tunnel-filter)
(while (null (process-get tunnel 'service))
(sleep-for 0.01))
(push tunnel parallel--tunnels))
tunnel))
(defun parallel-stop-tunnel (tunnel)
(setq parallel--tunnels (delq tunnel parallel--tunnels))
(delete-process tunnel))
(defun parallel--tunnel-filter (proc output)
(if (string-match "\\([0-9]+\\)" output)
(process-put proc 'service (match-string 1 output))))
(defmacro parallel--set-option (place config)
`(setf ,place (or ,place
(plist-get ,config ,(intern (format ":%s" (symbol-name place))))
(plist-get parallel-config ,(intern (format ":%s" (symbol-name place)))))))
(defmacro parallel--set-options (config &rest options)
`(progn
,@(loop for option in options
collect `(parallel--set-option ,option ,config))))
(defun* parallel-start (exec-fun &key post-exec env timeout
emacs-path library-path emacs-args
graphical debug on-event continue-when-executed
username hostname hostport
config)
(parallel--init-server)
;; Initialize parameters
(parallel--set-options config
post-exec
env
timeout
emacs-args
graphical
debug
on-event
continue-when-executed
username
hostname
hostport)
(setq emacs-path (or emacs-path
(plist-get config :emacs-path)
(plist-get parallel-config :emacs-path)
(expand-file-name invocation-name
invocation-directory))
library-path (or library-path
(plist-get config :library-path)
(plist-get parallel-config :library-path)
(locate-library "parallel-remote")))
(let ((task (parallel--new-task))
proc tunnel ssh-args)
(push task parallel--tasks)
(put task 'initialized nil)
(put task 'exec-fun exec-fun)
(put task 'env env)
(when (functionp post-exec)
(put task 'post-exec post-exec))
(when (functionp on-event)
(put task 'on-event on-event))
(put task 'results nil)
(put task 'status 'run)
(put task 'queue nil)
;; We need to get the tunnel if it exists so we can send the right
;; `service' to the remote.
(when (and username hostname)
(if hostport
(setq ssh-args (list "-R" (format "%s:localhost:%s" hostport
(process-contact parallel--server :service)))
tunnel t)
(setq tunnel (parallel-make-tunnel username hostname)
hostport (process-get tunnel 'service)))
(setq ssh-args (append
ssh-args
(if graphical (list "-X"))
(list (format "%s@%s" username hostname)))))
(setq emacs-args (remq nil
(list* "-Q" "-l" library-path
(if graphical nil "-batch")
"--eval" (format "(setq parallel-service '%S)"
(if tunnel
hostport
(process-contact parallel--server :service)))
"--eval" (format "(setq parallel-task-id '%S)" task)
"--eval" (format "(setq debug-on-error '%S)" debug)
"--eval" (format "(setq parallel-continue-when-executed '%S)" continue-when-executed)
"-f" "parallel-remote--init"
emacs-args)))
;; Reformat emacs-args if we use a tunnel (escape string)
(when tunnel
(setq emacs-args (list (mapconcat (lambda (string)
(if (find ?' string)
(prin1-to-string string)
string))
emacs-args " "))))
(setq proc (apply #'start-process "parallel" nil
`(,@(when tunnel
(list* "ssh" ssh-args))
,emacs-path
,@emacs-args)))
(put task 'proc proc)
(set-process-sentinel (get task 'proc) #'parallel--sentinel)
(when timeout
(run-at-time timeout nil (lambda ()
(when (memq (parallel-status task)
'(run stop))
(parallel-stop task)))))
task))
(defun parallel--new-task ()
"Generate a new task by enforcing a unique name."
(let ((symbol-name (make-temp-name "parallel-task-")))
(while (intern-soft symbol-name)
(setq symbol-name (make-temp-name "parallel-task-")))
(intern symbol-name)))
(defun parallel--init-server ()
"Initialize `parallel--server'."
(when (or (null parallel--server)
(not (eq (process-status parallel--server)
'listen)))
(setq parallel--server
(make-network-process :name "parallel-server"
:buffer nil
:server t
:host "localhost"
:service t
:family 'ipv4
:filter #'parallel--filter
:filter-multibyte t))))
(defun parallel--get-task-process (proc)
"Return the task running the given PROC."
(find-if (lambda (task)
(eq (get task 'proc) proc))
parallel--tasks))
(defun parallel--sentinel (proc _event)
"Sentinel to watch over the remote process.
This function do the necessary cleanup when the remote process is
finished."
(when (memq (process-status proc) '(exit signal))
(let* ((task (parallel--get-task-process proc))
(results (get task 'results))
(status (process-status proc)))
;; 0 means that the remote process has terminated normally (no
;; SIGNUM 0).
(if (zerop (process-exit-status proc))
(setq status 'success)
;; on failure, push the exit-code or signal number on the
;; results stack.
(push (process-exit-status proc) results))
(put task 'results results)
(put task 'status status)
(when (functionp (get task 'post-exec))
(funcall (get task 'post-exec)
results status))
(setq parallel--tasks (delq task parallel--tasks)))))
(defun parallel--call-with-env (fun env)
"Return a string which can be READ/EVAL by the remote process
to `funcall' FUN with ENV as arguments."
(format "(funcall (read %S) %s)"
(prin1-to-string fun)
(mapconcat (lambda (obj)
;; We need to quote it because the remote
;; process will READ/EVAL it.
(format "'%S" obj)) env " ")))
(defun parallel--filter (connection output)
"Server filter used to retrieve the results send by the remote
process and send the code to be executed by it."
(dolist (data (parallel--read-output output))
(parallel--process-output connection (first data) (rest data))))
(defun parallel--process-output (connection task result)
(put task 'connection connection)
(cond ((and (not (get task 'initialized))
(eq result 'code))
(apply #'parallel-send
task
(get task 'exec-fun)
(get task 'env))
(let ((code nil))
(while (setq code (pop (get task 'queue)))
(apply #'parallel-send task (car code) (cdr code))))
(put task 'initialized t))
(t
(push result (get task 'results))
(if (functionp (get task 'on-event))
(funcall (get task 'on-event) result)))))
(defun parallel-ready-p (task)
"Determine whether TASK is finished and if the results are
available."
(memq (parallel-status task) '(success exit signal)))
(defun parallel-get-result (task)
"Return the last result send by the remote call, that is the
result returned by exec-fun."
(first (parallel-get-results task)))
(defun parallel-get-results (task)
"Return all results send during the call of exec-fun."
(parallel-wait task)
(get task 'results))
(defun parallel-success-p (task)
"Determine whether TASK has ended successfully."
(parallel-wait task)
(eq (parallel-status task) 'success))
(defun parallel-status (task)
"Return TASK status."
(get task 'status))
(defun parallel-wait (task)
"Wait for TASK."
(while (not (parallel-ready-p task))
(sleep-for parallel-sleep))
t) ; for REPL
(defun parallel-stop (task)
"Stop TASK."
(delete-process (get task 'proc)))
(defun parallel-send (task fun &rest env)
"Send FUN to be evaluated by TASK in ENV."
(let ((connection (get task 'connection)))
(if connection
(process-send-string
connection
(parallel--call-with-env fun env))
(push (cons fun env) (get task 'queue)))))
(provide 'parallel)
;;; parallel.el ends here

2292
lisp/ldefs-boot.el
View file

File diff suppressed because it is too large Load diff

13
lisp/net/browse-url.el
View file

@ -668,7 +668,7 @@ regarding its parameter treatment."
;; functions allows them to be stand-alone commands, making it easier
;; to switch between browsers.
(defun browse-url-interactive-arg (prompt &optional default-url)
(defun browse-url-interactive-arg (prompt)
"Read a URL from the minibuffer, prompting with PROMPT.
If `transient-mark-mode' is non-nil and the mark is active,
it defaults to the current region, else to the URL at or before
@ -685,8 +685,7 @@ for use in `interactive'."
"[\t\r\f\n ]+" ""
(buffer-substring-no-properties
(region-beginning) (region-end))))
(browse-url-url-at-point)
default-url))
(browse-url-url-at-point)))
(not (eq (null browse-url-new-window-flag)
(null current-prefix-arg)))))
@ -796,13 +795,6 @@ narrowed."
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Browser-independent commands
(defun url-tidy (url)
"Tidy up URL as much as possible."
(if (equal 0 (string-match ".*://" url))
url
(concat "http://" url) ;;TODO guess more url forms, like mailto
))
;; A generic command to call the current browse-url-browser-function
;;;###autoload
@ -815,7 +807,6 @@ first, if that exists."
(interactive (browse-url-interactive-arg "URL: "))
(unless (called-interactively-p 'interactive)
(setq args (or args (list browse-url-new-window-flag))))
(setq url (url-tidy url))
(when (and url-handler-mode (not (file-name-absolute-p url)))
(setq url (expand-file-name url)))
(let ((process-environment (copy-sequence process-environment))

592
lisp/xwidget.el
View file

@ -1,592 +0,0 @@
;;; xwidget.el --- api functions for xwidgets -*- lexical-binding: t -*-
;; see xwidget.c for more api functions
;;; Commentary:
;;
;;TODO this breaks compilation when we dont have xwidgets
;;(require 'xwidget-internal)
;;TODO model after make-text-button instead!
;;; Code:
(eval-when-compile (require 'cl))
(require 'reporter)
(require 'bookmark)
(defcustom xwidget-webkit-scroll-behaviour 'native
"Scroll behaviour of the webkit instance.
'native or 'image."
:group 'xwidgets)
(defun xwidget-insert (pos type title width height)
"Insert an xwidget at POS.
given ID, TYPE, TITLE WIDTH and
HEIGHT in the current buffer.
Return ID
see `make-xwidget' for types suitable for TYPE."
(goto-char pos)
(let ((id (make-xwidget (point) (point)
type title width height nil)))
(put-text-property (point) (+ 1 (point))
'display (list 'xwidget ':xwidget id))
id))
(defun xwidget-at (pos)
"Return xwidget at POS."
;;TODO this function is a bit tedious because the C layer isnt well protected yet and
;;xwidgetp aparently doesnt work yet
(let* ((disp (get-text-property pos 'display))
(xw (car (cdr (cdr disp)))))
;;(if ( xwidgetp xw) xw nil)
(if (equal 'xwidget (car disp)) xw)))
;; (defun xwidget-socket-handler ()
;; "Create plug for socket. TODO."
;; (interactive)
;; (message "socket handler xwidget %S" last-input-event)
;; (let*
;; ((xwidget-event-type (nth 2 last-input-event))
;; (xwidget-id (nth 1 last-input-event)))
;; (cond ( (eq xwidget-event-type 'xembed-ready)
;; (let*
;; ((xembed-id (nth 3 last-input-event)))
;; (message "xembed ready event: %S xw-id:%s" xembed-id xwidget-id)
;; ;;TODO fetch process data from the xwidget. create it, store process info
;; ;;will start emacs/uzbl in a xembed socket when its ready
;; ;; (cond
;; ;; ((eq 3 xwidget-id)
;; ;; (start-process "xembed" "*xembed*" (format "%ssrc/emacs" default-directory) "-q" "--parent-id" (number-to-string xembed-id) ) )
;; ;; ((eq 5 xwidget-id)
;; ;; (start-process "xembed2" "*xembed2*" "uzbl-core" "-s" (number-to-string xembed-id) "http://www.fsf.org" ) )
;; )))))
(defun xwidget-display (xwidget)
"Force XWIDGET to be displayed to create a xwidget_view.
Return the window displaying XWIDGET."
(let* ((buffer (xwidget-buffer xwidget))
(window (display-buffer buffer))
(frame (window-frame window)))
(set-frame-visible frame t)
(redisplay t)
window))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; webkit support
(require 'browse-url)
(require 'image-mode);;for some image-mode alike functionality
(require 'cl-macs);;for flet
;;;###autoload
(defun xwidget-webkit-browse-url (url &optional new-session)
"Ask xwidget-webkit to browse URL.
NEW-SESSION specifies whether to create a new xwidget-webkit session. URL
defaults to the string looking like a url around the cursor position."
(interactive (progn
(require 'browse-url)
(browse-url-interactive-arg "xwidget-webkit URL: "
;;( xwidget-webkit-current-url)
)))
(when (stringp url)
(setq url (url-tidy url))
(if new-session
(xwidget-webkit-new-session url)
(xwidget-webkit-goto-url url))))
;;shims for adapting image mode code to the webkit browser window
(defun xwidget-image-display-size (spec &optional pixels frame)
"Image code adaptor. SPEC PIXELS FRAME like the corresponding `image-mode' fn."
(let ((xwi (xwidget-info (xwidget-at 1))))
(cons (aref xwi 2)
(aref xwi 3))))
(defadvice image-display-size (around image-display-size-for-xwidget
(spec &optional pixels frame)
activate)
"Advice for re-using image mode for xwidget."
(if (eq (car spec) 'xwidget)
(setq ad-return-value (xwidget-image-display-size spec pixels frame))
ad-do-it))
;;todo.
;; - check that the webkit support is compiled in
(defvar xwidget-webkit-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "g" 'xwidget-webkit-browse-url)
(define-key map "a" 'xwidget-webkit-adjust-size-dispatch)
(define-key map "b" 'xwidget-webkit-back )
(define-key map "r" 'xwidget-webkit-reload )
(define-key map "t" (lambda () (interactive) (message "o")) )
(define-key map "\C-m" 'xwidget-webkit-insert-string)
(define-key map "w" 'xwidget-webkit-current-url)
;;similar to image mode bindings
(define-key map (kbd "SPC") 'xwidget-webkit-scroll-up)
(define-key map (kbd "DEL") 'xwidget-webkit-scroll-down)
(define-key map [remap scroll-up] 'xwidget-webkit-scroll-up)
(define-key map [remap scroll-up-command] 'xwidget-webkit-scroll-up)
(define-key map [remap scroll-down] 'xwidget-webkit-scroll-down)
(define-key map [remap scroll-down-command] 'xwidget-webkit-scroll-down)
(define-key map [remap forward-char] 'xwidget-webkit-scroll-forward)
(define-key map [remap backward-char] 'xwidget-webkit-scroll-backward)
(define-key map [remap right-char] 'xwidget-webkit-scroll-forward)
(define-key map [remap left-char] 'xwidget-webkit-scroll-backward)
;; (define-key map [remap previous-line] 'image-previous-line)
;; (define-key map [remap next-line] 'image-next-line)
;; (define-key map [remap move-beginning-of-line] 'image-bol)
;; (define-key map [remap move-end-of-line] 'image-eol)
;; (define-key map [remap beginning-of-buffer] 'image-bob)
;; (define-key map [remap end-of-buffer] 'image-eob)
map)
"Keymap for `xwidget-webkit-mode'.")
(defun xwidget-webkit-scroll-up ()
"Scroll webkit up,either native or like image mode."
(interactive)
(if (eq xwidget-webkit-scroll-behaviour 'native)
(xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t 50)
(image-scroll-up)))
(defun xwidget-webkit-scroll-down ()
"Scroll webkit down,either native or like image mode."
(interactive)
(if (eq xwidget-webkit-scroll-behaviour 'native)
(xwidget-set-adjustment (xwidget-webkit-last-session) 'vertical t -50)
(image-scroll-down)))
(defun xwidget-webkit-scroll-forward ()
"Scroll webkit forward,either native or like image mode."
(interactive)
(if (eq xwidget-webkit-scroll-behaviour 'native)
(xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t 50)
(xwidget-webkit-scroll-forward)))
(defun xwidget-webkit-scroll-backward ()
"Scroll webkit backward,either native or like image mode."
(interactive)
(if (eq xwidget-webkit-scroll-behaviour 'native)
(xwidget-set-adjustment (xwidget-webkit-last-session) 'horizontal t -50)
(xwidget-webkit-scroll-backward)))
;;the xwidget event needs to go into a higher level handler
;;since the xwidget can generate an event even if its offscreen
;;TODO this needs to use callbacks and consider different xw ev types
(define-key (current-global-map) [xwidget-event] 'xwidget-event-handler)
(defun xwidget-log ( &rest msg)
"Log MSG to a buffer."
(let ( (buf (get-buffer-create "*xwidget-log*")))
(save-excursion
(buffer-disable-undo buf)
(set-buffer buf)
(insert (apply 'format msg))
(insert "\n"))))
(defun xwidget-event-handler ()
"Receive xwidget event."
(interactive)
(xwidget-log "stuff happened to xwidget %S" last-input-event)
(let*
((xwidget-event-type (nth 1 last-input-event))
(xwidget (nth 2 last-input-event))
;(xwidget-callback (xwidget-get xwidget 'callback));;TODO stopped working for some reason
)
;(funcall xwidget-callback xwidget xwidget-event-type)
(message "xw callback %s" xwidget)
(funcall 'xwidget-webkit-callback xwidget xwidget-event-type)))
(defun xwidget-webkit-callback (xwidget xwidget-event-type)
"Callback for xwidgets.
XWIDGET instance, XWIDGET-EVENT-TYPE depends on the originating xwidget."
(save-excursion
(cond ((buffer-live-p (xwidget-buffer xwidget))
(set-buffer (xwidget-buffer xwidget))
(let* ((strarg (nth 3 last-input-event)))
(cond ((eq xwidget-event-type 'document-load-finished)
(xwidget-log "webkit finished loading: '%s'" (xwidget-webkit-get-title xwidget))
;;TODO - check the native/internal scroll
;;(xwidget-adjust-size-to-content xwidget)
(xwidget-webkit-adjust-size-dispatch) ;;TODO send xwidget here
(rename-buffer (format "*xwidget webkit: %s *" (xwidget-webkit-get-title xwidget)))
(pop-to-buffer (current-buffer)))
((eq xwidget-event-type 'navigation-policy-decision-requested)
(if (string-match ".*#\\(.*\\)" strarg)
(xwidget-webkit-show-id-or-named-element xwidget (match-string 1 strarg))))
(t (xwidget-log "unhandled event:%s" xwidget-event-type)))))
(t (xwidget-log "error: callback called for xwidget with dead buffer")))))
(defvar bookmark-make-record-function)
(define-derived-mode xwidget-webkit-mode
special-mode "xwidget-webkit" "xwidget webkit view mode"
(setq buffer-read-only t)
(setq-local bookmark-make-record-function
#'xwidget-webkit-bookmark-make-record)
;; Keep track of [vh]scroll when switching buffers
(image-mode-setup-winprops))
(defun xwidget-webkit-bookmark-make-record ()
(nconc (bookmark-make-record-default t t)
`((page . ,(xwidget-webkit-current-url))
(handler . (lambda (bmk) (browse-url (bookmark-prop-get bmk 'page)))))))
(defvar xwidget-webkit-last-session-buffer nil)
(defun xwidget-webkit-last-session ()
"Last active webkit, or nil."
(if (buffer-live-p xwidget-webkit-last-session-buffer)
(with-current-buffer xwidget-webkit-last-session-buffer
(xwidget-at 1))
nil))
(defun xwidget-webkit-current-session ()
"Either the webkit in the current buffer, or the last one used, which might be nil."
(if (xwidget-at 1)
(xwidget-at 1)
(xwidget-webkit-last-session)))
(defun xwidget-adjust-size-to-content (xw)
"Resize XW to content."
;;xwidgets doesnt support widgets that have their own opinions about size well yet
;;this reads the desired size and resizes the emacs allocated area accordingly
(let ((size (xwidget-size-request xw)))
(xwidget-resize xw (car size) (cadr size))))
(defvar xwidget-webkit-activeelement-js"
function findactiveelement(doc){
//alert(doc.activeElement.value);
if(doc.activeElement.value != undefined){
return doc.activeElement;
}else{
// recurse over the child documents:
var frames = doc.getElementsByTagName('frame');
for (var i = 0; i < frames.length; i++)
{
var d = frames[i].contentDocument;
var rv = findactiveelement(d);
if(rv != undefined){
return rv;
}
}
}
return undefined;
};
"
"javascript that finds the active element."
;;yes its ugly. because:
;; - there is aparently no way to find the active frame other than recursion
;; - the js "for each" construct missbehaved on the "frames" collection
;; - a window with no frameset still has frames.length == 1, but frames[0].document.activeElement != document.activeElement
;;TODO the activeelement type needs to be examined, for iframe, etc. sucks.
)
(defun xwidget-webkit-insert-string (xw str)
"Insert string in the active field in the webkit.
Argument XW webkit.
Argument STR string."
;;read out the string in the field first and provide for edit
(interactive
(let* ((xww (xwidget-webkit-current-session))
(field-value
(progn
(xwidget-webkit-execute-script xww xwidget-webkit-activeelement-js)
(xwidget-webkit-execute-script-rv xww "findactiveelement(document).value;" )))
(field-type (xwidget-webkit-execute-script-rv xww "findactiveelement(document).type;" )))
(list xww
(cond ((equal "text" field-type)
(read-string "text:" field-value))
((equal "password" field-type)
(read-passwd "password:" nil field-value))
((equal "textarea" field-type)
(xwidget-webkit-begin-edit-textarea xww field-value))))))
(xwidget-webkit-execute-script xw (format "findactiveelement(document).value='%s'" str)))
(defvar xwidget-xwbl)
(defun xwidget-webkit-begin-edit-textarea (xw text)
"Start editing of a webkit text area.
XW is the xwidget identifier, TEXT is retrieved from the webkit."
(switch-to-buffer
(generate-new-buffer "textarea"))
(set (make-local-variable 'xwidget-xwbl) xw)
(insert text))
(defun xwidget-webkit-end-edit-textarea ()
"End editing of a webkit text area."
(interactive)
(goto-char (point-min))
(while (search-forward "\n" nil t)
(replace-match "\\n" nil t))
(xwidget-webkit-execute-script xwidget-xwbl (format "findactiveelement(document).value='%s'"
(buffer-substring (point-min) (point-max))))
;;TODO convert linefeed to \n
)
(defun xwidget-webkit-show-named-element (xw element-name)
"Make named-element show. for instance an anchor."
(interactive (list (xwidget-webkit-current-session) (read-string "element name:")))
;;TODO
;; since an xwidget is an Emacs object, it is not trivial to do some things that are taken for granted in a normal browser.
;; scrolling an anchor/named-element into view is one such thing.
;; this function implements a proof-of-concept for this.
;; problems remaining:
;; - the selected window is scrolled but this is not always correct
;; - this needs to be interfaced into browse-url somehow. the tricky part is that we need to do this in two steps:
;; A: load the base url, wait for load signal to arrive B: navigate to the anchor when the base url is finished rendering
;;this part figures out the Y coordinate of the element
(let ((y (string-to-number
(xwidget-webkit-execute-script-rv xw
(format "document.getElementsByName('%s')[0].getBoundingClientRect().top" element-name)
0))))
;;now we need to tell emacs to scroll the element into view.
(xwidget-log "scroll: %d" y)
(set-window-vscroll (selected-window) y t)))
(defun xwidget-webkit-show-id-element (xw element-id)
"make id-element show. for instance an anchor."
(interactive (list (xwidget-webkit-current-session)
(read-string "element id:")))
(let ((y (string-to-number
(xwidget-webkit-execute-script-rv xw
(format "document.getElementById('%s').getBoundingClientRect().top" element-id)
0))))
;;now we need to tell emacs to scroll the element into view.
(xwidget-log "scroll: %d" y)
(set-window-vscroll (selected-window) y t)))
(defun xwidget-webkit-show-id-or-named-element (xw element-id)
"make id-element show. for instance an anchor."
(interactive (list (xwidget-webkit-current-session)
(read-string "element id:")))
(let* ((y1 (string-to-number
(xwidget-webkit-execute-script-rv xw
(format "document.getElementsByName('%s')[0].getBoundingClientRect().top" element-id)
"0")))
(y2 (string-to-number
(xwidget-webkit-execute-script-rv xw
(format "document.getElementById('%s').getBoundingClientRect().top" element-id)
"0")))
(y3 (max y1 y2)))
;;now we need to tell emacs to scroll the element into view.
(xwidget-log "scroll: %d" y3)
(set-window-vscroll (selected-window) y3 t)))
(defun xwidget-webkit-adjust-size-to-content ()
"Adjust webkit to content size."
(interactive)
(xwidget-adjust-size-to-content (xwidget-webkit-current-session)))
(defun xwidget-webkit-adjust-size-dispatch ()
"Adjust size according to mode."
(interactive)
(if (eq xwidget-webkit-scroll-behaviour 'native)
(xwidget-webkit-adjust-size-to-window)
(xwidget-webkit-adjust-size-to-content))
;;the recenter is intended to correct a visual glitch
;;it errors out if the buffer isnt visible, but then we dont get the glitch,
;;so silence errors
(ignore-errors
(recenter-top-bottom))
)
(defun xwidget-webkit-adjust-size-to-window ()
"Adjust webkit to window."
(interactive)
(xwidget-resize ( xwidget-webkit-current-session) (window-pixel-width) (window-pixel-height)))
(defun xwidget-webkit-adjust-size (w h)
"Manualy set webkit size.
Argument W width.
Argument H height."
;;TODO shouldnt be tied to the webkit xwidget
(interactive "nWidth:\nnHeight:\n")
(xwidget-resize ( xwidget-webkit-current-session) w h))
(defun xwidget-webkit-fit-width ()
"Adjust width of webkit to window width."
(interactive)
(xwidget-webkit-adjust-size (- (caddr (window-inside-pixel-edges))
(car (window-inside-pixel-edges)))
1000))
(defun xwidget-webkit-new-session (url)
"Create a new webkit session buffer with URL."
(let*
((bufname (generate-new-buffer-name "*xwidget-webkit*"))
xw)
(setq xwidget-webkit-last-session-buffer (switch-to-buffer (get-buffer-create bufname)))
(insert " 'a' adjusts the xwidget size.")
(setq xw (xwidget-insert 1 'webkit-osr bufname 1000 1000))
(xwidget-put xw 'callback 'xwidget-webkit-callback)
(xwidget-webkit-mode)
(xwidget-webkit-goto-uri (xwidget-webkit-last-session) url )))
(defun xwidget-webkit-goto-url (url)
"Goto URL."
(if (xwidget-webkit-current-session)
(progn
(xwidget-webkit-goto-uri (xwidget-webkit-current-session) url))
(xwidget-webkit-new-session url)))
(defun xwidget-webkit-back ()
"Back in history."
(interactive)
(xwidget-webkit-execute-script (xwidget-webkit-current-session) "history.go(-1);"))
(defun xwidget-webkit-reload ()
"Reload current url."
(interactive)
(xwidget-webkit-execute-script (xwidget-webkit-current-session) "history.go(0);"))
(defun xwidget-webkit-current-url ()
"Get the webkit url. place it on kill ring."
(interactive)
(let* ((rv (xwidget-webkit-execute-script-rv (xwidget-webkit-current-session)
"document.URL"))
(url (kill-new (or rv ""))))
(message "url: %s" url )
url))
(defun xwidget-webkit-execute-script-rv (xw script &optional default)
"Same as 'xwidget-webkit-execute-script' but but with return value.
XW is the webkit instance. SCRIPT is the script to execut.
DEFAULT is the defaultreturn value."
;;notice the fugly "title" hack. it is needed because the webkit api
;;doesnt support returning values. this is a wrapper for the title
;;hack so its easy to remove should webkit someday support JS return
;;values or we find some other way to access the DOM
;;reset webkit title. fugly.
(let* ((emptytag "titlecantbewhitespaceohthehorror")
title)
(xwidget-webkit-execute-script xw (format "document.title=\"%s\";" (or default emptytag)))
(xwidget-webkit-execute-script xw (format "document.title=%s;" script))
(setq title (xwidget-webkit-get-title xw))
(if (equal emptytag title)
(setq title ""))
(unless title
(setq title default))
title))
;; use declare here?
;; (declare-function xwidget-resize-internal "xwidget.c" )
;; check-declare-function?
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun xwidget-webkit-get-selection ()
"Get the webkit selection."
(xwidget-webkit-execute-script-rv (xwidget-webkit-current-session)
"window.getSelection().toString();"))
(defun xwidget-webkit-copy-selection-as-kill ()
"Get the webkit selection and put it on the kill ring."
(interactive)
(kill-new (xwidget-webkit-get-selection)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; xwidget plist management(similar to the process plist functions)
(defun xwidget-get (xwidget propname)
"Return the value of XWIDGET' PROPNAME property.
This is the last value stored with `(xwidget-put XWIDGET PROPNAME VALUE)'."
(plist-get (xwidget-plist xwidget) propname))
(defun xwidget-put (xwidget propname value)
"Change XWIDGET' PROPNAME property to VALUE.
It can be retrieved with `(xwidget-get XWIDGET PROPNAME)'."
(set-xwidget-plist xwidget
(plist-put (xwidget-plist xwidget) propname value)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun xwidget-delete-zombies ()
"Helper for xwidget-cleanup."
(dolist (xwidget-view xwidget-view-list)
(when (or (not (window-live-p (xwidget-view-window xwidget-view)))
(not (memq (xwidget-view-model xwidget-view)
xwidget-list)))
(delete-xwidget-view xwidget-view))))
(defun xwidget-cleanup ()
"Delete zombie xwidgets."
;;its still pretty easy to trigger bugs with xwidgets.
;;this function tries to implement a workaround
(interactive)
;; kill xviews who should have been deleted but stull linger
(xwidget-delete-zombies)
;; redraw display otherwise ghost of zombies will remain to haunt the screen
(redraw-display))
;;this is a workaround because I cant find the right place to put it in C
;;seems to work well in practice though
;;(add-hook 'window-configuration-change-hook 'xwidget-cleanup)
(add-hook 'window-configuration-change-hook 'xwidget-delete-zombies)
(defun xwidget-kill-buffer-query-function ()
"Ask beforek illing a buffer that has xwidgets."
(let ((xwidgets (get-buffer-xwidgets (current-buffer))))
(or (not xwidgets)
(not (memq t (mapcar 'xwidget-query-on-exit-flag xwidgets)))
(yes-or-no-p
(format "Buffer %S has xwidgets; kill it? "
(buffer-name (current-buffer)))))))
(add-hook 'kill-buffer-query-functions 'xwidget-kill-buffer-query-function)
;;killflash is sadly not reliable yet.
(defvar xwidget-webkit-kill-flash-oneshot t)
(defun xwidget-webkit-kill-flash ()
"Disable the flash plugin in webkit.
This is needed because Flash is non-free and doesnt work reliably
on 64 bit systems and offscreen rendering. Sadly not reliable
yet, so deinstall Flash instead for now."
;;you can only call this once or webkit crashes and takes emacs with it. odd.
(unless xwidget-webkit-kill-flash-oneshot
(xwidget-disable-plugin-for-mime "application/x-shockwave-flash")
(setq xwidget-webkit-kill-flash-oneshot t)))
(xwidget-webkit-kill-flash)
(defun report-xwidget-bug ()
"Report a bug in GNU Emacs about the XWidget branch.
Prompts for bug subject. Leaves you in a mail buffer."
(interactive)
(let ((reporter-prompt-for-summary-p t))
(reporter-submit-bug-report "submit@debbugs.gnu.org" nil nil nil nil
(format "Package: emacs-xwidgets
Please describee xactly whata ctions triggered the bug, and the
precise symptoms of the bug. If you can, give a recipe starting
from `emacs -Q'.
If Emacs crashed, and you have the Emacs process in the gdb
deubbger, please include the output from the following gdb
commands:
`bt full' and `xbacktrace'.
For information about debugging Emacs, please read the file
%s" (expand-file-name "DEBUG" data-directory)))))
(provide 'xwidget)
;;; xwidget.el ends here

21
src/ChangeLog
View file

@ -1,24 +1,3 @@
2015-02-01 Martin Rudalics <rudalics@gmx.at>
* xdisp.c (Fwindow_text_pixel_size): Add optional argument BUFFER.
2015-02-01 Joakim Verona <joakim@verona.se>
Support for the new Xwidget feature.
* window.c, Makefile.in, buffer.c, dispextern.h, dispnew.c, emacs.c:
* emacsgtkfixed.c, emacsgtkfixed.h, keyboard.c, lisp.h, print.c:
* termhooks.h, window.c, xdisp.c, xterm.c
New files for xwidgets:
* xwidget.c, xwidget.h:
Support for testing xwidgets
* xwidget-test-manual.el:
2015-02-01 Grégoire Jadi <daimrod@gmail.com>
Support for testing xwidgets
* parallell-remote.el, parallell-xwidget.el, parallell.el:
* xwidget-tests.el:
various improvements to xwidgets:
* xwidgets.c:
2015-01-31 Eli Zaretskii <eliz@gnu.org>
* coding.c (raw_text_coding_system_p): New function.

10
src/Makefile.in
View file

@ -218,12 +218,6 @@ CFLAGS_SOUND= @CFLAGS_SOUND@
RSVG_LIBS= @RSVG_LIBS@
RSVG_CFLAGS= @RSVG_CFLAGS@
WEBKIT_LIBS= @WEBKIT_LIBS@
WEBKIT_CFLAGS= @WEBKIT_CFLAGS@
GIR_LIBS= @GIR_LIBS@
GIR_CFLAGS= @GIR_CFLAGS@
IMAGEMAGICK_LIBS= @IMAGEMAGICK_LIBS@
IMAGEMAGICK_CFLAGS= @IMAGEMAGICK_CFLAGS@
@ -349,7 +343,6 @@ ALL_CFLAGS=-Demacs $(MYCPPFLAGS) -I. -I$(srcdir) \
$(GNUSTEP_CFLAGS) $(CFLAGS_SOUND) $(RSVG_CFLAGS) $(IMAGEMAGICK_CFLAGS) \
$(PNG_CFLAGS) $(LIBXML2_CFLAGS) $(DBUS_CFLAGS) \
$(XRANDR_CFLAGS) $(XINERAMA_CFLAGS) $(XFIXES_CFLAGS) \
$(WEBKIT_CFLAGS) $(GIR_CFLAGS) \
$(SETTINGS_CFLAGS) $(FREETYPE_CFLAGS) $(FONTCONFIG_CFLAGS) \
$(LIBOTF_CFLAGS) $(M17N_FLT_CFLAGS) $(DEPFLAGS) \
$(LIBGNUTLS_CFLAGS) $(GFILENOTIFY_CFLAGS) \
@ -379,13 +372,11 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
process.o gnutls.o callproc.o \
region-cache.o sound.o atimer.o \
doprnt.o intervals.o textprop.o composite.o xml.o $(NOTIFY_OBJ) \
xwidget.o \
profiler.o decompress.o \
$(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
$(W32_OBJ) $(WINDOW_SYSTEM_OBJ) $(XGSELOBJ)
obj = $(base_obj) $(NS_OBJC_OBJ)
xwidget.o: xwidget.c xwidget.h
## Object files used on some machine or other.
## These go in the DOC file on all machines in case they are needed.
## Some of them have no DOC entries, but it does no harm to have them
@ -430,7 +421,6 @@ ALLOBJS = $(FIRSTFILE_OBJ) $(VMLIMIT_OBJ) $(obj) $(otherobj)
LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
$(LIBX_OTHER) $(LIBSOUND) \
$(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_ACL) $(LIB_CLOCK_GETTIME) \
$(WEBKIT_LIBS) $(GIR_LIBS) \
$(LIB_EACCESS) $(LIB_FDATASYNC) $(LIB_TIMER_TIME) $(DBUS_LIBS) \
$(LIB_EXECINFO) $(XRANDR_LIBS) $(XINERAMA_LIBS) $(XFIXES_LIBS) \
$(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \

8
src/buffer.c
View file

@ -42,9 +42,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "keymap.h"
#include "frame.h"
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif /* HAVE_XWIDGETS */
#ifdef WINDOWSNT
#include "w32heap.h" /* for mmap_* */
#endif
@ -1758,11 +1755,6 @@ cleaning up all windows currently displaying the buffer to be killed. */)
kill_buffer_processes (buffer);
UNGCPRO;
#ifdef HAVE_XWIDGETS
GCPRO1 (buffer);
kill_buffer_xwidgets (buffer);
UNGCPRO;
#endif /* HAVE_XWIDGETS */
/* Killing buffer processes may run sentinels which may have killed
our buffer. */
if (!BUFFER_LIVE_P (b))

27
src/dispextern.h
View file

@ -348,10 +348,6 @@ enum glyph_type
/* Glyph is a space of fractional width and/or height. */
STRETCH_GLYPH
#ifdef HAVE_XWIDGETS
/* Glyph is an external widget drawn by the GUI toolkit. */
,XWIDGET_GLYPH
#endif
};
@ -503,9 +499,6 @@ struct glyph
/* Image ID for image glyphs (type == IMAGE_GLYPH). */
int img_id;
#ifdef HAVE_XWIDGETS
struct xwidget* xwidget;
#endif
/* Sub-structure for type == STRETCH_GLYPH. */
struct
{
@ -1360,9 +1353,6 @@ struct glyph_string
/* Image, if any. */
struct image *img;
#ifdef HAVE_XWIDGETS
struct xwidget* xwidget;
#endif
/* Slice */
struct glyph_slice slice;
@ -2107,10 +2097,6 @@ enum display_element_type
/* Continuation glyphs. See the comment for IT_TRUNCATION. */
IT_CONTINUATION
#ifdef HAVE_XWIDGETS
,IT_XWIDGET
#endif
};
@ -2174,9 +2160,6 @@ enum it_method {
GET_FROM_C_STRING,
GET_FROM_IMAGE,
GET_FROM_STRETCH,
#ifdef HAVE_XWIDGETS
GET_FROM_XWIDGET,
#endif
NUM_IT_METHODS
};
@ -2398,12 +2381,6 @@ struct it
struct {
Lisp_Object object;
} stretch;
#ifdef HAVE_XWIDGETS
/* method == GET_FROM_XWIDGET */
struct {
Lisp_Object object;
} xwidget;
#endif
} u;
/* Current text and display positions. */
@ -2528,10 +2505,6 @@ struct it
/* If what == IT_IMAGE, the id of the image to display. */
ptrdiff_t image_id;
#ifdef HAVE_XWIDGETS
/* If what == IT_XWIDGET*/
struct xwidget* xwidget;
#endif
/* Values from `slice' property. */
struct it_slice slice;

12
src/dispnew.c
View file

@ -48,10 +48,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#include <errno.h>
#include <fpending.h>
@ -3546,9 +3542,6 @@ update_window (struct window *w, bool force_p)
add_window_display_history (w, w->current_matrix->method, paused_p);
#endif
#ifdef HAVE_XWIDGETS
xwidget_end_redisplay(w, w->current_matrix);
#endif
clear_glyph_matrix (desired_matrix);
return paused_p;
@ -4132,11 +4125,6 @@ scrolling_window (struct window *w, bool header_line_p)
break;
}
#ifdef HAVE_XWIDGETS
//currently this is needed to detect xwidget movement reliably. or probably not.
return 0;
#endif
/* Give up if some rows in the desired matrix are not enabled. */
if (! MATRIX_ROW_ENABLED_P (desired_matrix, i))
return -1;

6
src/emacs.c
View file

@ -65,9 +65,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "buffer.h"
#include "window.h"
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#include "systty.h"
#include "atimer.h"
#include "blockinput.h"
@ -1437,9 +1434,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
syms_of_xfns ();
syms_of_xmenu ();
syms_of_fontset ();
#ifdef HAVE_XWIDGETS
syms_of_xwidget();
#endif
syms_of_xsettings ();
#ifdef HAVE_X_SM
syms_of_xsmfns ();

119
src/emacsgtkfixed.c
View file

@ -23,9 +23,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "lisp.h"
#include "frame.h"
#include "xterm.h"
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#include "emacsgtkfixed.h"
/* Silence a bogus diagnostic; see GNOME bug 683906. */
@ -34,26 +31,26 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
# pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#endif
//#define EMACS_TYPE_FIXED emacs_fixed_get_type ()
/* #define EMACS_FIXED(obj) \ */
/* G_TYPE_CHECK_INSTANCE_CAST (obj, EMACS_TYPE_FIXED, EmacsFixed) */
#define EMACS_TYPE_FIXED emacs_fixed_get_type ()
#define EMACS_FIXED(obj) \
G_TYPE_CHECK_INSTANCE_CAST (obj, EMACS_TYPE_FIXED, EmacsFixed)
typedef struct _EmacsFixed EmacsFixed;
typedef struct _EmacsFixedPrivate EmacsFixedPrivate;
typedef struct _EmacsFixedClass EmacsFixedClass;
/* struct _EmacsFixed */
/* { */
/* GtkFixed container; */
struct _EmacsFixed
{
GtkFixed container;
/* /\*< private >*\/ */
/* EmacsFixedPrivate *priv; */
/* }; */
/*< private >*/
EmacsFixedPrivate *priv;
};
/* struct _EmacsFixedClass */
/* { */
/* GtkFixedClass parent_class; */
/* }; */
struct _EmacsFixedClass
{
GtkFixedClass parent_class;
};
struct _EmacsFixedPrivate
{
@ -67,109 +64,21 @@ static void emacs_fixed_get_preferred_width (GtkWidget *widget,
static void emacs_fixed_get_preferred_height (GtkWidget *widget,
gint *minimum,
gint *natural);
static GType emacs_fixed_get_type (void);
G_DEFINE_TYPE (EmacsFixed, emacs_fixed, GTK_TYPE_FIXED)
#ifdef HAVE_XWIDGETS
struct GtkFixedPrivateL
{
GList *children;
};
static void emacs_fixed_gtk_widget_size_allocate (GtkWidget *widget,
GtkAllocation *allocation){
//for xwidgets
//TODO 1st call base class method
EmacsFixedClass *klass;
GtkWidgetClass *parent_class;
struct GtkFixedPrivateL* priv;
GtkFixedChild *child;
GtkAllocation child_allocation;
GtkRequisition child_requisition;
GList *children;
struct xwidget_view* xv;
klass = EMACS_FIXED_GET_CLASS (widget);
parent_class = g_type_class_peek_parent (klass);
parent_class->size_allocate (widget, allocation);
priv = G_TYPE_INSTANCE_GET_PRIVATE (widget,
GTK_TYPE_FIXED,
struct GtkFixedPrivateL);
gtk_widget_set_allocation (widget, allocation);
if (gtk_widget_get_has_window (widget))
{
if (gtk_widget_get_realized (widget))
gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x,
allocation->y,
allocation->width,
allocation->height);
}
for (children = priv->children;
children;
children = children->next)
{
child = children->data;
if (!gtk_widget_get_visible (child->widget))
continue;
gtk_widget_get_preferred_size (child->widget, &child_requisition, NULL);
child_allocation.x = child->x;
child_allocation.y = child->y;
if (!gtk_widget_get_has_window (widget))
{
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
}
child_allocation.width = child_requisition.width;
child_allocation.height = child_requisition.height;
xv = (struct xwidget_view*) g_object_get_data (G_OBJECT (child->widget), XG_XWIDGET_VIEW);
if(xv){
child_allocation.width = xv->clip_right;
child_allocation.height = xv->clip_bottom - xv->clip_top;
}
gtk_widget_size_allocate (child->widget, &child_allocation);
}
}
#endif /* HAVE_XWIDGETS */
static void
emacs_fixed_class_init (EmacsFixedClass *klass)
{
GtkWidgetClass *widget_class;
GtkFixedClass *fixed_class;
widget_class = (GtkWidgetClass*) klass;
fixed_class = (GtkFixedClass*) klass;
widget_class->get_preferred_width = emacs_fixed_get_preferred_width;
widget_class->get_preferred_height = emacs_fixed_get_preferred_height;
#ifdef HAVE_XWIDGETS
widget_class->size_allocate = emacs_fixed_gtk_widget_size_allocate;
#endif
g_type_class_add_private (klass, sizeof (EmacsFixedPrivate));
}
static GType
emacs_fixed_child_type (GtkFixed *container)
{
return GTK_TYPE_WIDGET;
}
static void
emacs_fixed_init (EmacsFixed *fixed)
{

28
src/emacsgtkfixed.h
View file

@ -25,35 +25,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
G_BEGIN_DECLS
struct frame;
#define EMACS_TYPE_FIXED (emacs_fixed_get_type ())
#define EMACS_FIXED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EMACS_TYPE_FIXED, EmacsFixed))
#define EMACS_FIXED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EMACS_TYPE_FIXED, EmacsFixedClass))
#define EMACS_IS_FIXED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EMACS_TYPE_FIXED))
#define EMACS_IS_FIXED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EMACS_TYPE_FIXED))
#define EMACS_FIXED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EMACS_TYPE_FIXED, EmacsFixedClass))
//typedef struct _EmacsFixed EmacsFixed;
typedef struct _EmacsFixedPrivate EmacsFixedPrivate;
typedef struct _EmacsFixedClass EmacsFixedClass;
struct _EmacsFixed
{
GtkFixed container;
/*< private >*/
EmacsFixedPrivate *priv;
};
struct _EmacsFixedClass
{
GtkFixedClass parent_class;
};
extern GtkWidget *emacs_fixed_new (struct frame *f);
extern GType emacs_fixed_get_type (void);
G_END_DECLS

25
src/keyboard.c
View file

@ -4123,20 +4123,6 @@ kbd_buffer_get_event (KBOARD **kbp,
obj = make_lispy_event (event);
kbd_fetch_ptr = event + 1;
}
#endif
#ifdef HAVE_XWIDGETS
else if (event->kind == XWIDGET_EVENT)
{
obj = make_lispy_event (event);
kbd_fetch_ptr = event + 1;
}
#endif
#ifdef HAVE_INOTIFY
else if (event->kind == FILE_NOTIFY_EVENT)
{
obj = make_lispy_event (event);
kbd_fetch_ptr = event + 1;
}
#endif
else if (event->kind == CONFIG_CHANGED_EVENT)
{
@ -6084,14 +6070,6 @@ make_lispy_event (struct input_event *event)
}
#endif /* HAVE_DBUS */
#ifdef HAVE_XWIDGETS
case XWIDGET_EVENT:
{
return Fcons (Qxwidget_event,event->arg);
}
#endif /* HAVE_XWIDGETS */
#if defined HAVE_GFILENOTIFY || defined HAVE_INOTIFY
case FILE_NOTIFY_EVENT:
{
@ -11109,9 +11087,6 @@ syms_of_keyboard (void)
DEFSYM (Qdbus_event, "dbus-event");
#endif
#ifdef HAVE_XWIDGETS
DEFSYM (Qxwidget_event,"xwidget-event");
#endif /* HAVE_XWIDGETS */
#ifdef USE_FILE_NOTIFY
DEFSYM (Qfile_notify, "file-notify");
#endif /* USE_FILE_NOTIFY */

5
src/lisp.h
View file

@ -781,11 +781,6 @@ enum pvec_type
PVEC_WINDOW_CONFIGURATION,
PVEC_SUBR,
PVEC_OTHER,
#ifdef HAVE_XWIDGETS
PVEC_XWIDGET,
PVEC_XWIDGET_VIEW,
#endif
/* These should be last, check internal_equal to see why. */
PVEC_COMPILED,
PVEC_CHAR_TABLE,

16
src/print.c
View file

@ -37,10 +37,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "termhooks.h" /* For struct terminal. */
#include "font.h"
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#include <float.h>
#include <ftoastr.h>
@ -1776,18 +1772,6 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun);
PRINTCHAR ('>');
}
#ifdef HAVE_XWIDGETS
else if (XWIDGETP (obj))
{
strout ("#<xwidget ", -1, -1, printcharfun);
PRINTCHAR ('>');
}
else if (XWIDGET_VIEW_P (obj))
{
strout ("#<xwidget-view ", -1, -1, printcharfun);
PRINTCHAR ('>');
}
#endif
else if (WINDOWP (obj))
{
int len;

4
src/termhooks.h
View file

@ -236,10 +236,6 @@ enum event_kind
, NS_NONKEY_EVENT
#endif
#ifdef HAVE_XWIDGETS
/* events generated by xwidgets*/
, XWIDGET_EVENT
#endif
#ifdef USE_FILE_NOTIFY
/* File or directory was changed. */
, FILE_NOTIFY_EVENT

6
src/window.c
View file

@ -44,9 +44,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#ifdef MSDOS
#include "msdos.h"
#endif
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
static int displayed_window_lines (struct window *);
static int count_windows (struct window *);
@ -4562,9 +4559,6 @@ Signal an error when WINDOW is the only window on its frame. */)
/* Block input. */
block_input ();
#ifdef HAVE_XWIDGETS
xwidget_view_delete_all_in_window(w);
#endif
window_resize_apply (p, horflag);
/* If this window is referred to by the dpyinfo's mouse
highlight, invalidate that slot to be safe (Bug#9904). */

303
src/xdisp.c
View file

@ -318,9 +318,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#ifndef FRAME_X_OUTPUT
#define FRAME_X_OUTPUT(f) ((f)->output_data.x)
#endif
@ -845,9 +842,6 @@ static int next_element_from_c_string (struct it *);
static int next_element_from_buffer (struct it *);
static int next_element_from_composition (struct it *);
static int next_element_from_image (struct it *);
#ifdef HAVE_XWIDGETS
static int next_element_from_xwidget(struct it *);
#endif
static int next_element_from_stretch (struct it *);
static void load_overlay_strings (struct it *, ptrdiff_t);
static int init_from_display_pos (struct it *, struct window *,
@ -4684,9 +4678,6 @@ handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
if (CONSP (spec)
/* Simple specifications. */
&& !EQ (XCAR (spec), Qimage)
#ifdef HAVE_XWIDGETS
&& !EQ (XCAR (spec), Qxwidget)
#endif
&& !EQ (XCAR (spec), Qspace)
&& !EQ (XCAR (spec), Qwhen)
&& !EQ (XCAR (spec), Qslice)
@ -5133,12 +5124,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
|| ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
&& valid_image_p (value))
#endif /* not HAVE_WINDOW_SYSTEM */
|| (CONSP (value) && EQ (XCAR (value), Qspace))
#ifdef HAVE_XWIDGETS
|| ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
&& valid_xwidget_spec_p(value))
#endif
);
|| (CONSP (value) && EQ (XCAR (value), Qspace)));
if (valid_p && !display_replaced_p)
{
@ -5213,18 +5199,6 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
*position = it->position = start_pos;
retval = 1 + (it->area == TEXT_AREA);
}
#ifdef HAVE_XWIDGETS
else if (valid_xwidget_spec_p(value))
{
it->what = IT_XWIDGET;
it->method = GET_FROM_XWIDGET;
it->position = start_pos;
it->object = NILP (object) ? it->w->contents : object;
*position = start_pos;
it->xwidget = lookup_xwidget(value);
}
#endif
#ifdef HAVE_WINDOW_SYSTEM
else
{
@ -5961,11 +5935,6 @@ push_it (struct it *it, struct text_pos *position)
case GET_FROM_STRETCH:
p->u.stretch.object = it->object;
break;
#ifdef HAVE_XWIDGETS
case GET_FROM_XWIDGET:
p->u.xwidget.object = it->object;
break;
#endif
}
p->position = position ? *position : it->position;
p->current = it->current;
@ -6059,11 +6028,6 @@ pop_it (struct it *it)
it->object = p->u.image.object;
it->slice = p->u.image.slice;
break;
#ifdef HAVE_XWIDGETS
case GET_FROM_XWIDGET:
it->object = p->u.xwidget.object;
break;
#endif
case GET_FROM_STRETCH:
it->object = p->u.stretch.object;
break;
@ -6726,9 +6690,6 @@ static int (* get_next_element[NUM_IT_METHODS]) (struct it *it) =
next_element_from_c_string,
next_element_from_image,
next_element_from_stretch
#ifdef HAVE_XWIDGETS
,next_element_from_xwidget
#endif
};
#define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
@ -7574,10 +7535,6 @@ set_iterator_to_next (struct it *it, int reseat_p)
case GET_FROM_IMAGE:
case GET_FROM_STRETCH:
#ifdef HAVE_XWIDGETS
case GET_FROM_XWIDGET:
#endif
/* The position etc with which we have to proceed are on
the stack. The position may be at the end of a string,
if the `display' property takes up the whole string. */
@ -8040,16 +7997,6 @@ next_element_from_image (struct it *it)
return 1;
}
#ifdef HAVE_XWIDGETS
/* im not sure about this FIXME JAVE*/
static int
next_element_from_xwidget (struct it *it)
{
it->what = IT_XWIDGET;
return 1;
}
#endif
/* Fill iterator IT with next display element from a stretch glyph
property. IT->object is the value of the text property. Value is
@ -9703,7 +9650,7 @@ in_display_vector_p (struct it *it)
&& it->dpvec + it->current.dpvec_index != it->dpend);
}
DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 7, 0,
DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 6, 0,
doc: /* Return the size of the text of WINDOW's buffer in pixels.
WINDOW must be a live window and defaults to the selected one. The
return value is a cons of the maximum pixel-width of any text line and
@ -9736,42 +9683,28 @@ Optional argument MODE-AND-HEADER-LINE nil or omitted means do not
include the height of the mode- or header-line of WINDOW in the return
value. If it is either the symbol `mode-line' or `header-line', include
only the height of that line, if present, in the return value. If t,
include the height of both, if present, in the return value.
Optional argument BUFFER nil means to return the size of the text of
WINDOW's buffer. BUFFER t means to return the size of the text of the
current buffer as if it were displayed in WINDOW. Else BUFFER has to
specify a live buffer and this function returns the size of the text of
BUFFER as if it were displayed in WINDOW. */)
(Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit,
Lisp_Object y_limit, Lisp_Object mode_and_header_line, Lisp_Object buffer)
include the height of both, if present, in the return value. */)
(Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit, Lisp_Object y_limit,
Lisp_Object mode_and_header_line)
{
struct window *w = decode_live_window (window);
Lisp_Object buf;
struct buffer *b;
struct it it;
struct buffer *old_b = NULL;
struct buffer *old_buffer = NULL;
ptrdiff_t start, end, pos;
struct text_pos startp;
void *itdata = NULL;
int c, max_y = -1, x = 0, y = 0;
if (EQ (buffer, Qt))
b = current_buffer;
else
buf = w->contents;
CHECK_BUFFER (buf);
b = XBUFFER (buf);
if (b != current_buffer)
{
if (NILP (buffer))
buffer = w->contents;
CHECK_BUFFER (buffer);
if (!BUFFER_LIVE_P (XBUFFER (buffer)))
error ("Not a live buffer");
b = XBUFFER (buffer);
if (b != current_buffer)
{
old_b = current_buffer;
set_buffer_internal (b);
}
old_buffer = current_buffer;
set_buffer_internal (b);
}
if (NILP (from))
@ -9847,8 +9780,8 @@ BUFFER as if it were displayed in WINDOW. */)
bidi_unshelve_cache (itdata, 0);
if (old_b)
set_buffer_internal (old_b);
if (old_buffer)
set_buffer_internal (old_buffer);
return Fcons (make_number (x), make_number (y));
}
@ -17070,13 +17003,6 @@ try_window_reusing_current_matrix (struct window *w)
return 0;
#endif
#ifdef HAVE_XWIDGETS_xxx
//currently this is needed to detect xwidget movement reliably. or probably not.
printf("try_window_reusing_current_matrix\n");
return 0;
#endif
if (/* This function doesn't handle terminal frames. */
!FRAME_WINDOW_P (f)
/* Don't try to reuse the display if windows have been split
@ -18671,28 +18597,6 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
glyph->left_box_line_p,
glyph->right_box_line_p);
}
#ifdef HAVE_XWIDGETS
else if (glyph->type == XWIDGET_GLYPH)
{
fprintf (stderr,
" %5d %4c %6d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
glyph - row->glyphs[TEXT_AREA],
'X',
glyph->charpos,
(BUFFERP (glyph->object)
? 'B'
: (STRINGP (glyph->object)
? 'S'
: '-')),
glyph->pixel_width,
glyph->u.xwidget,
'.',
glyph->face_id,
glyph->left_box_line_p,
glyph->right_box_line_p);
}
#endif
}
@ -24110,13 +24014,6 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
return OK_PIXELS (width_p ? img->width : img->height);
}
#ifdef HAVE_XWIDGETS
if (FRAME_WINDOW_P (it->f) && valid_xwidget_spec_p (prop))
{
//TODO dont return dummy size
return OK_PIXELS (width_p ? 100 : 100);
}
#endif
#endif
if (EQ (car, Qplus) || EQ (car, Qminus))
{
@ -24621,18 +24518,6 @@ fill_image_glyph_string (struct glyph_string *s)
}
#ifdef HAVE_XWIDGETS
static void
fill_xwidget_glyph_string (struct glyph_string *s)
{
eassert (s->first_glyph->type == XWIDGET_GLYPH);
s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
s->font = s->face->font;
s->width = s->first_glyph->pixel_width;
s->ybase += s->first_glyph->voffset;
s->xwidget = s->first_glyph->u.xwidget;
}
#endif
/* Fill glyph string S from a sequence of stretch glyphs.
START is the index of the first glyph to consider,
@ -24968,20 +24853,6 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
} \
while (0)
#ifdef HAVE_XWIDGETS
#define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
s = (struct glyph_string *) alloca (sizeof *s); \
INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL); \
fill_xwidget_glyph_string (s); \
append_glyph_string (&HEAD, &TAIL, s); \
++START; \
s->x = (X); \
} \
while (0)
#endif
/* Add a glyph string for a sequence of character glyphs to the list
of strings between HEAD and TAIL. START is the index of the first
@ -25103,7 +24974,7 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
to allocate glyph strings (because draw_glyphs can be called
asynchronously). */
#define BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X) \
#define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
do \
{ \
HEAD = TAIL = NULL; \
@ -25134,15 +25005,8 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
case IMAGE_GLYPH: \
BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL, \
HL, X, LAST_X); \
break;
#define BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X) \
case XWIDGET_GLYPH: \
BUILD_XWIDGET_GLYPH_STRING (START, END, HEAD, TAIL, \
HL, X, LAST_X); \
break;
#define BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X) \
break; \
\
case GLYPHLESS_GLYPH: \
BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL, \
HL, X, LAST_X); \
@ -25161,18 +25025,6 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p)
} while (0)
#ifdef HAVE_XWIDGETS
#define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X) \
BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X) \
BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
#else
#define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X) \
BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X) \
BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
#endif
/* Draw glyphs between START and END in AREA of ROW on window W,
starting at x-position X. X is relative to AREA in W. HL is a
face-override with the following meaning:
@ -25811,113 +25663,6 @@ produce_image_glyph (struct it *it)
}
}
#ifdef HAVE_XWIDGETS
static void
produce_xwidget_glyph (struct it *it)
{
struct xwidget* xw;
struct face *face;
int glyph_ascent, crop;
eassert (it->what == IT_XWIDGET);
face = FACE_FROM_ID (it->f, it->face_id);
eassert (face);
/* Make sure X resources of the face is loaded. */
prepare_face_for_display (it->f, face);
xw = it->xwidget;
it->ascent = it->phys_ascent = glyph_ascent = xw->height/2;
it->descent = xw->height/2;
it->phys_descent = it->descent;
it->pixel_width = xw->width;
/* It's quite possible for images to have an ascent greater than
their height, so don't get confused in that case. */
if (it->descent < 0)
it->descent = 0;
it->nglyphs = 1;
if (face->box != FACE_NO_BOX)
{
if (face->box_line_width > 0)
{
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
if (it->start_of_box_run_p)
it->pixel_width += eabs (face->box_line_width);
it->pixel_width += eabs (face->box_line_width);
}
take_vertical_position_into_account (it);
/* Automatically crop wide image glyphs at right edge so we can
draw the cursor on same display row. */
if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
&& (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
{
it->pixel_width -= crop;
}
if (it->glyph_row)
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (it->glyph_row->reversed_p)
{
struct glyph *g;
/* Make room for the new glyph. */
for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
g[1] = *g;
glyph = it->glyph_row->glyphs[it->area];
}
if (glyph < it->glyph_row->glyphs[area + 1])
{
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
glyph->pixel_width = it->pixel_width;
glyph->ascent = glyph_ascent;
glyph->descent = it->descent;
glyph->voffset = it->voffset;
glyph->type = XWIDGET_GLYPH;
glyph->avoid_cursor_p = it->avoid_cursor_p;
glyph->multibyte_p = it->multibyte_p;
if (it->glyph_row->reversed_p && area == TEXT_AREA)
{
/* In R2L rows, the left and the right box edges need to be
drawn in reverse direction. */
glyph->right_box_line_p = it->start_of_box_run_p;
glyph->left_box_line_p = it->end_of_box_run_p;
}
else
{
glyph->left_box_line_p = it->start_of_box_run_p;
glyph->right_box_line_p = it->end_of_box_run_p;
}
glyph->overlaps_vertically_p = 0;
glyph->padding_p = 0;
glyph->glyph_not_available_p = 0;
glyph->face_id = it->face_id;
glyph->u.xwidget = it->xwidget;
//assert_valid_xwidget_id(glyph->u.xwidget_id,"produce_xwidget_glyph");
glyph->font_type = FONT_TYPE_UNKNOWN;
if (it->bidi_p)
{
glyph->resolved_level = it->bidi_it.resolved_level;
eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
glyph->bidi_type = it->bidi_it.type;
}
++it->glyph_row->used[area];
}
else
IT_EXPAND_MATRIX_WIDTH (it, area);
}
}
#endif
/* Append a stretch glyph to IT->glyph_row. OBJECT is the source
of the glyph, WIDTH and HEIGHT are the width and height of the
@ -27258,10 +27003,6 @@ x_produce_glyphs (struct it *it)
produce_image_glyph (it);
else if (it->what == IT_STRETCH)
produce_stretch_glyph (it);
#ifdef HAVE_XWIDGETS
else if (it->what == IT_XWIDGET)
produce_xwidget_glyph (it);
#endif
done:
/* Accumulate dimensions. Note: can't assume that it->descent > 0
@ -27631,12 +27372,6 @@ get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
/* Use normal cursor if not blinked off. */
if (!w->cursor_off_p)
{
#ifdef HAVE_XWIDGETS
if (glyph != NULL && glyph->type == XWIDGET_GLYPH){
return NO_CURSOR;
}
#endif
if (glyph != NULL && glyph->type == IMAGE_GLYPH)
{
if (cursor_type == FILLED_BOX_CURSOR)

15
src/xterm.c
View file

@ -63,9 +63,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "coding.h"
#include "frame.h"
#include "dispextern.h"
#ifdef HAVE_XWIDGETS
#include "xwidget.h"
#endif
#include "fontset.h"
#include "termhooks.h"
#include "termopts.h"
@ -2679,13 +2676,6 @@ x_draw_glyph_string (struct glyph_string *s)
x_draw_image_glyph_string (s);
break;
#ifdef HAVE_XWIDGETS
case XWIDGET_GLYPH:
//erase xwidget background
//x_draw_glyph_string_background (s, 0);
x_draw_xwidget_glyph_string (s);
break;
#endif
case STRETCH_GLYPH:
x_draw_stretch_glyph_string (s);
break;
@ -8026,11 +8016,6 @@ x_draw_bar_cursor (struct window *w, struct glyph_row *row, int width, enum text
if (cursor_glyph == NULL)
return;
#ifdef HAVE_XWIDGETS
if (cursor_glyph->type == XWIDGET_GLYPH){
return; //experimental avoidance of cursor on xwidget
}
#endif
/* If on an image, draw like a normal cursor. That's usually better
visible than drawing a bar, esp. if the image is large so that
the bar might not be in the window. */

1853
src/xwidget.c
View file

File diff suppressed because it is too large Load diff

115
src/xwidget.h
View file

@ -1,115 +0,0 @@
#ifndef XWIDGET_H_INCLUDED
#define XWIDGET_H_INCLUDED
void x_draw_xwidget_glyph_string (struct glyph_string *s);
void syms_of_xwidget ();
//extern Lisp_Object Qxwidget;
int valid_xwidget_spec_p (Lisp_Object object) ;
#include <gtk/gtk.h>
/*
each xwidget instance/model is described by this struct.
lisp pseudovector.
*/
struct xwidget{
struct vectorlike_header header;
Lisp_Object plist;//auxilliary data
Lisp_Object type;//the widget type
Lisp_Object buffer; //buffer where xwidget lives
Lisp_Object title;//a title that is used for button labels for instance
//here ends the lisp part.
//"height" is the marker field
int height;
int width;
//for offscreen widgets, unused if not osr
GtkWidget* widget_osr;
GtkWidget* widgetwindow_osr;
//this is used if the widget (webkit) is to be wrapped in a scrolled window,
GtkWidget* widgetscrolledwindow_osr;
/* Non-nil means kill silently if Emacs is exited. */
unsigned int kill_without_query : 1;
};
//struct for each xwidget view
struct xwidget_view {
struct vectorlike_header header;
Lisp_Object model;
Lisp_Object w;
//here ends the lisp part.
//"redisplayed" is the marker field
int redisplayed; //if touched by redisplay
int hidden;//if the "live" instance isnt drawn
GtkWidget* widget;
GtkWidget* widgetwindow;
GtkWidget* emacswindow;
int x; int y;
int clip_right; int clip_bottom; int clip_top; int clip_left;
long handler_id;
};
/* Test for xwidget pseudovector*/
#define XWIDGETP(x) PSEUDOVECTORP (x, PVEC_XWIDGET)
#define XXWIDGET(a) (eassert (XWIDGETP(a)), \
(struct xwidget *) XUNTAG(a, Lisp_Vectorlike))
#define CHECK_XWIDGET(x) \
CHECK_TYPE (XWIDGETP (x), Qxwidgetp, x)
/* Test for xwidget_view pseudovector */
#define XWIDGET_VIEW_P(x) PSEUDOVECTORP (x, PVEC_XWIDGET_VIEW)
#define XXWIDGET_VIEW(a) (eassert (XWIDGET_VIEW_P(a)), \
(struct xwidget_view *) XUNTAG(a, Lisp_Vectorlike))
#define CHECK_XWIDGET_VIEW(x) \
CHECK_TYPE (XWIDGET_VIEW_P (x), Qxwidget_view_p, x)
struct xwidget_type
{
/* A symbol uniquely identifying the xwidget type, */
Lisp_Object *type;
/* Check that SPEC is a valid image specification for the given
image type. Value is non-zero if SPEC is valid. */
int (* valid_p) (Lisp_Object spec);
/* Next in list of all supported image types. */
struct xwidget_type *next;
};
static struct xwidget_type *lookup_xwidget_type (Lisp_Object symbol);
struct xwidget* xwidget_from_id(int id);
//extern int xwidget_owns_kbd;
void xwidget_start_redisplay();
void xwidget_end_redisplay (struct window *w, struct glyph_matrix *matrix);
void xwidget_touch (struct xwidget_view *xw);
//void assert_valid_xwidget_id(int id,char *str);
struct xwidget* lookup_xwidget (Lisp_Object spec);
#define XG_XWIDGET "emacs_xwidget"
#define XG_XWIDGET_VIEW "emacs_xwidget_view"
void xwidget_view_delete_all_in_window( struct window *w );
void kill_buffer_xwidgets (Lisp_Object buffer);
#endif /* XWIDGET_H_INCLUDED */

8
test/ChangeLog
View file

@ -1,11 +1,3 @@
2015-02-01 Joakim Verona <joakim@verona.se>
Support for testing xwidgets
* xwidget-test-manual.el:
2015-02-01 Grégoire Jadi <daimrod@gmail.com>
Support for testing xwidgets
* automated/xwidget-tests.el:
2015-01-31 Stefan Monnier <monnier@iro.umontreal.ca>
* automated/eieio-tests.el (eieio-test-23-inheritance-check): Simplify.

121
test/automated/xwidget-tests.el
View file

@ -1,121 +0,0 @@
;; -*- lexical-binding: t; -*-
(require 'cl)
(require 'xwidget)
(require 'xwidget-test)
(require 'parallel)
(defvar xwidget-parallel-config (list :emacs-path (expand-file-name
"~/packages/xwidget-build/src/emacs")))
(defmacro xwidget-deftest (name types &rest body)
(declare (indent defun))
(if (null types)
`(ert-deftest ,(intern (format "%s" name)) ()
(let ((parallel-config xwidget-parallel-config))
,@body))
`(progn
,@(loop for type in types
collect
`(ert-deftest ,(intern (format "%s-%s" name type)) ()
(let ((parallel-config xwidget-parallel-config)
(type ',type)
(title ,(symbol-name type)))
,@body))))))
(xwidget-deftest xwidget-make-xwidget (Button ToggleButton slider socket cairo)
(let* ((beg 1)
(end 1)
(width 100)
(height 100)
(data nil)
(proc (parallel-start
(lambda (beg end type title width height data)
(require 'xwidget)
(require 'cl)
(with-temp-buffer
(insert ?\0)
(let* ((buffer (current-buffer))
(xwidget (make-xwidget beg end type title width height data buffer)))
(set-xwidget-query-on-exit-flag xwidget nil)
(parallel-remote-send (coerce (xwidget-info xwidget) 'list))
(parallel-remote-send (buffer-name buffer))
(buffer-name (xwidget-buffer xwidget)))))
:env (list beg end type title width height data)))
(results (parallel-get-results proc)))
(should (parallel-success-p proc))
(when (parallel-success-p proc)
(destructuring-bind (xwidget-buffer temp-buffer xwidget-info)
results
(should (equal (list type title width height)
xwidget-info))
(should (equal temp-buffer xwidget-buffer))))))
(xwidget-deftest xwidget-query-on-exit-flag ()
(should (equal '(nil t)
(parallel-get-results
(parallel-start (lambda ()
(require 'xwidget)
(let ((xwidget (make-xwidget 1 1 'Button "Button" 100 100 nil)))
(parallel-remote-send (xwidget-query-on-exit-flag xwidget))
(set-xwidget-query-on-exit-flag xwidget nil)
(xwidget-query-on-exit-flag xwidget))))))))
(xwidget-deftest xwidget-query-on-exit-flag (Button ToggleButton slider socket cairo)
(should (parallel-get-result
(parallel-start (lambda (type title)
(require 'xwidget)
(with-temp-buffer
(let ((xwidget (make-xwidget 1 1 type title 10 10 nil)))
(set-xwidget-query-on-exit-flag xwidget nil)
(xwidgetp xwidget))))
:env (list type title)))))
(xwidget-deftest xwidget-CHECK_XWIDGET ()
(should (equal (parallel-get-result
(parallel-start (lambda ()
(require 'xwidget)
(xwidget-info nil))))
'(wrong-type-argument xwidgetp nil)))
(should (equal (parallel-get-result
(parallel-start (lambda ()
(require 'xwidget)
(xwidget-view-info nil))))
'(wrong-type-argument xwidget-view-p nil))))
(xwidget-deftest xwidget-view-p (Button ToggleButton slider socket cairo)
(should (parallel-get-result
(parallel-start (lambda (type title)
(require 'xwidget)
(with-temp-buffer
(insert ?\0)
(let* ((xwidget (xwidget-insert 1 type title 100 100))
(window (xwidget-display xwidget)))
(set-xwidget-query-on-exit-flag xwidget nil)
(xwidget-view-p
(xwidget-view-lookup xwidget window)))))
:env (list type title)
:graphical t
:emacs-args '("-T" "emacs-debug")))))
(defun xwidget-interactive-tests ()
"Interactively test Button ToggleButton and slider.
Start Emacs instances and try to insert the xwidget."
(interactive)
(flet ((test-xwidget (type)
(parallel-get-result
(parallel-start (lambda ()
(require 'xwidget)
(with-temp-buffer
(insert ?\0)
(set-xwidget-query-on-exit-flag
(xwidget-insert 1 type (format "%s" type) 100 100) nil)
(display-buffer (current-buffer))
(cons type (or (y-or-n-p (format "Do you see a %s?" type)) 'failed))))
:graphical t
:debug t
:config xwidget-parallel-config))))
(message "%S" (mapcar #'test-xwidget '(Button ToggleButton slider)))))
(provide 'xwidget-tests)

204
test/xwidget-test-manual.el
View file

@ -1,204 +0,0 @@
;;test like:
;; cd /path/to/xwidgets-emacs-dir
;; make all&& src/emacs -q --eval "(progn (load \"`pwd`/lisp/xwidget-test.el\") (xwidget-demo-basic))"
;; you should see:
;; - a gtk button
;; - a gtk toggle button
;; - a gtk slider button
;; - an xembed window(using gtk_socket) showing another emacs instance
;; - an xembed window(using gtk_socket) showing an uzbl web browser if its installed
;;the widgets will move when you type in the buffer. good!
;;there will be redrawing issues when widgets change rows, etc. bad!
;;its currently difficult to give kbd focus to the xembedded emacs,
;;but try evaling the following:
;; (xwidget-set-keyboard-grab 3 1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; demo/test functions
(require 'xwidget)
(defmacro xwidget-demo (name &rest body)
`(defun ,(intern (concat "xwidget-demo-" name)) ()
(interactive)
(switch-to-buffer ,(format "*xwidget-demo-%s*" name))
(text-mode);;otherwise no local keymap
(insert "Some random text for xwidgets to be inserted in for demo purposes.\n")
,@body))
(xwidget-demo "a-button"
(xwidget-insert (point-min) 'Button "button" 60 50)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-button-bidi"
(xwidget-insert (+ 5 (point-min)) 'Button "button" 60 50)
(set (make-local-variable 'bidi-paragraph-direction) 'right-to-left)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-toggle-button"
(xwidget-insert (point-min) 'ToggleButton "toggle" 60 50)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-big-button"
(xwidget-insert (point-min) 'Button "button" 400 500)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-socket"
(xwidget-insert (point-min) 'socket "socket" 500 500)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-socket-osr-broken"
(xwidget-insert (point-min) 'socket-osr "socket-osr" 500 500)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-slider"
(xwidget-insert (point-min) 'slider "slider" 500 100)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-canvas"
(xwidget-insert (point-min) 'cairo "canvas" 1000 1000)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-webkit-broken"
(xwidget-insert (point-min) 'webkit "webkit" 1000 1000)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-webkit-osr"
(xwidget-insert (point-min) 'webkit-osr "webkit-osr" 1000 1000)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic)
(xwidget-webkit-goto-uri (xwidget-at 1) "http://www.fsf.org"))
(xwidget-demo "a-xwgir"
(xwidget-insert (point-min) 'xwgir "xwgir" 1000 1000)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-xwgir-color-button"
(xwgir-require-namespace "Gtk" "3.0")
(put 'ColorButton :xwgir-class '("Gtk" "ColorSelection"))
(xwidget-insert (point-min) 'ColorButton "xwgir-color-button" 1000 1000)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-xwgir-button"
(xwgir-require-namespace "Gtk" "3.0")
(put 'xwgirButton :xwgir-class '("Gtk" "Button"))
(xwidget-insert (point-min) 'xwgirButton "xwgir label didnt work..." 700 700)
(xwgir-xwidget-call-method (xwidget-at 1) "set_label" '( "xwgir label worked!"))
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-xwgir-check-button"
(xwgir-require-namespace "Gtk" "3.0")
(put 'xwgirCheckButton :xwgir-class '("Gtk" "CheckButton"))
(xwidget-insert (point-min) 'xwgirCheckButton "xwgir label didnt work..." 700 700)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-xwgir-hscale"
(xwgir-require-namespace "Gtk" "3.0")
(put 'xwgirHScale :xwgir-class '("Gtk" "HScale"))
(xwidget-insert (point-min) 'xwgirHScale "xwgir label didnt work..." 700 700)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
(xwidget-demo "a-xwgir-webkit"
(xwgir-require-namespace "WebKit" "3.0")
(put 'xwgirWebkit :xwgir-class '("WebKit" "WebView"))
(xwidget-insert (point-min) 'xwgirWebkit "xwgir webkit..." 700 700)
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
;; tentative testcase:
;; (xwgir-require-namespace "WebKit" "3.0")
;; (put 'webkit-osr :xwgir-class '("WebKit" "WebView"))
;; (xwgir-call-method (xwidget-at 1) "set_zoom_level" '(3.0))
;; (xwgir-require-namespace "Gtk" "3.0")
;; (put 'color-selection :xwgir-class '("Gtk" "ColorSelection"))
(xwidget-demo "basic"
(xwidget-insert (point-min) 'button "button" 40 50 )
(xwidget-insert 15 'toggle "toggle" 60 30 )
(xwidget-insert 30 'socket "emacs" 400 200 )
(xwidget-insert 20 'slider "slider" 100 50 )
(xwidget-insert 40 'socket "uzbl-core" 400 400 )
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic)
)
;it doesnt seem gtk_socket_steal works very well. its deprecated.
; xwininfo -int
; then (xwidget-embed-steal 3 <winid>)
(defun xwidget-demo-grab ()
(interactive)
(insert "0 <<< grabbed appp will appear here\n")
(xwidget-insert 1 1 3 "1" 1000 )
(define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-grab)
)
;ive basically found these xembeddable things:
;openvrml
;emacs
;mplayer
;surf
;uzbl
;try the openvrml:
;/usr/libexec/openvrml-xembed 0 ~/Desktop/HelloWorld.wrl
(defun xwidget-handler-demo-basic ()
(interactive)
(message "stuff happened to xwidget %S" last-input-event)
(let*
((xwidget-event-type (nth 1 last-input-event))
(xwidget (nth 2 last-input-event)))
(cond ( (eq xwidget-event-type 'xembed-ready)
(let*
((xembed-id (nth 3 last-input-event)))
(message "xembed ready event: %S xw-id:%s" xembed-id xwidget)
;;will start emacs/uzbl in a xembed socket when its ready
(cond
(t;;(eq 3 xwidget)
(start-process "xembed" "*xembed*" "/var/lib/jenkins/jobs/emacs-xwidgets-automerge/workspace/src/emacs" "-q" "--parent-id" (number-to-string xembed-id) ) )
;; ((eq 5 xwidget-id)
;; (start-process "xembed2" "*xembed2*" "uzbl-core" "-s" (number-to-string xembed-id) "http://www.fsf.org" )
)
)
))))
(defun xwidget-handler-demo-grab ()
(interactive)
(message "stuff happened to xwidget %S" last-input-event)
(let*
((xwidget-event-type (nth 2 last-input-event)))
(cond ( (eq xwidget-event-type 'xembed-ready)
(let*
((xembed-id (nth 3 last-input-event)))
(message "xembed ready %S" xembed-id)
)
))))
(defun xwidget-dummy-hook ()
(message "xwidget dummy hook called"))
; (xwidget-resize-hack 1 200 200)
;(xwidget-demo-basic)
(provide 'xwidget-test-manual)