~ubuntu-branches/ubuntu/vivid/rabbit/vivid

« back to all changes in this revision

Viewing changes to misc/xyzzy/rabbit-mode.l

  • Committer: Bazaar Package Importer
  • Author(s): Youhei SASAKI
  • Date: 2009-07-22 22:15:37 UTC
  • Revision ID: james.westby@ubuntu.com-20090722221537-iy7foj73p2kyuumi
Tags: upstream-0.6.1
Import upstream version 0.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
; -*- Mode: Lisp; Package: editor -*-
 
2
 
 
3
#|
 
4
= rabbit-mode - rabbit �̃t�����g�G���h
 
5
 
 
6
* Author: MIYAMUKO Katsuyuki ((<URL:mailto:miyamuko (at) mtb.biglobe.ne.jp>))
 
7
* URL: ((<URL:http://miyamuko.s56.xrea.com/xyzzy/rabbit-mode.html>))
 
8
* Version: 0.3
 
9
 
 
10
 
 
11
== ����
 
12
 
 
13
Ruby �ŏ����ꂽ�v���[���c�[����
 
14
((<"rabbit"|URL:http://www.cozmixng.org/~rwiki/?cmd=view;name=Rabbit%3A%3AREADME.ja>))
 
15
�������֗��Ɏg����悤�ɂ���t�����g�G���h�ł��B
 
16
 
 
17
rd �t�@�C����ҏW���Ȃ��� xyzzy ���� rabbit ���N���ł��܂��B
 
18
 
 
19
== �ł��邱��
 
20
 
 
21
* rabbit ���t���X�N���[�����[�h�ŋN���ł���B
 
22
* rabbit ���N���ł���B
 
23
* �^�C�g���y�[�W�̃e���v���[�g��}���ł���B
 
24
 
 
25
* �t�@�C�������Ȃ��Ă����s�ł���
 
26
* �X���C�h�P�ʂł̕ҏW
 
27
  * �X���C�h�ꗗ��\������ jump (list-function)
 
28
  * �X���C�h���Ƃ���\�����‚ƒX���C�h�P�ʂł̈ړ� (C-M-n, C-M-p)
 
29
  * ��\���X���C�h���g�O��
 
30
* ����͈͂̃v���r���[
 
31
  * �͈�
 
32
    * ���݂̃X���C�h�̂�
 
33
    * ���[�W�������̃X���C�h�̂�
 
34
    * �Z���N�V�������̃X���C�h�̂�
 
35
  * �������^�C�g���y�[�W�͊܂܂��B
 
36
    * �X���C�h���w��ŋN���Ƃ��ł��Ȃ�����?
 
37
 
 
38
== ���Ȃ� (�ł��Ȃ�) ����
 
39
 
 
40
* �e�[�}�쐬�p���[�h
 
41
 
 
42
=== ���ꂩ���邩������Ȃ�����
 
43
 
 
44
* �T�u�^�C�g���Ƃ��� interactive �ɓ���
 
45
* save-as-image
 
46
* �e�[�}���̕⊮
 
47
* tdiary theme ���� rabbit theme �ɕϊ��ł���Ƃ����������B
 
48
  * �w�i�摜�Ƃ��͎w��ł��Ȃ�(?)
 
49
    * �ł���炵���B
 
50
      * �E�E�E���Ă���� lisp ����Ȃ��� ruby �Ŏ������� rabbit �{�̂Ɏ�荞��ł�������ق����悳���B
 
51
 
 
52
* rd �����x��
 
53
  * rd �x���� ruby-doc-minor-mode �ɔC���悤�Ǝv�������ǂ�낤���ȁB
 
54
  * rd �ɓ������� rd-mode �����������ɂ����Ƃ‚���B
 
55
  * �ӏ������x��
 
56
* ���� rd ������ rabbit �� (rabbitalize ?)
 
57
  * �ӏ������̃g�b�v���x�����X���C�h�̃^�C�g���ɂ���
 
58
    * ���̕ϊ��� rabbit ���s���ɂ��B
 
59
      * �ӏ�������ϊ�����{�v���r���[,���s}
 
60
        * �ӏ������łЂ����珑�������ꍇ�ɕ֗��B(���Ƃ��΂��� todo ���X�g)
 
61
  * ���o�����x��2 (==) ���X���C�h�̃^�C�g����
 
62
* �v���r���[�T�C�Y�ݒ�
 
63
* �e���v���[�g���w�肵�ĐV�����X���C�h�̍쐬 (C-m)
 
64
* �e���v���[�g�̏[��
 
65
  * ���ʂ̃X���C�h
 
66
  * mimeTex
 
67
  * image
 
68
    * keep_scale�Arelative_width �Ȃǂ̕⊮
 
69
  * �ŏI�X���C�h
 
70
  * �e���v���[�g�̃e�L�X�g�t�@�C����
 
71
    * �e�L�X�g�t�@�C���ō���Ăǂ����ɒu���ƃ��j���[�ɏo�Ă���B
 
72
* Sigma: �� sum: �̎��̎Q�ƁiRabbit�Ǝ��g���j�̕⊮
 
73
* �u�������N���b�N���� xxx ��lj��v�̏�ŃN���b�N����ƂȂɂ��N����B
 
74
* �ړI�ʃX���C�h�V���[
 
75
  * �K�v�ȃX���C�h�i�� or �ԍ�) ���`���� (�ǂ������? ����ȃR�����g?) ���������X���C�h�V���[
 
76
* xyzzy �� http �T�[�o�ɂ��� RWiki/Hiki �̂悤�Ƀy�[�W�\�[�X�̒�
 
77
  * �ȉ��̂悤�ȃP�[�X�Ŗ��ɗ��������B
 
78
    * rwiki ���ȒP�ɗ��Ă��Ȃ�
 
79
    * ���\�}�V���� rabbit �������Ă���
 
80
    * �X���C�h�쐬�}�V���Ɣ��\�}�V�����Ⴄ (�쐬: Win, ���\: Linux �Ƃ�)
 
81
    �E�E�E�K�v�Ȃ����B
 
82
  * RWiki �݊��ɂ���ꍇ soap.l �����Ȃ��Ƃ��߂���
 
83
* rabbit-mode �̂Ƃ��̂݃��j���[�\��
 
84
  * rd-mode ���}�C�i�[���[�h�ɂ��� rabbit-mode �����W���[���[�h
 
85
  * rd-mode �����W���[���[�h�ɂ��� rabbit-mode �̓��[�h�p��
 
86
* xyzzy ���� rabbit �̑���
 
87
  * rabbit �� FindWindow ���� SendMessage ����(?)
 
88
  * �Ǐ]���[�h
 
89
    * �X���C�h�P�ʂňړ������ꍇ�͎����I�� SendKey ����
 
90
    * �y�[�W���� 2 ������ꍇ�͖��� (?)
 
91
 
 
92
* =begin, =end �̍폜
 
93
* zphoto �Ȃǂ̊O���c�[���Ƃ̘A�g
 
94
 
 
95
* rabrick
 
96
* rabbit-theme-browser
 
97
 
 
98
== �C���X�g�[��
 
99
 
 
100
((<NetInstaller|URL:http://www7a.biglobe.ne.jp/~hat/xyzzy/ni.html>)) �ŃC���X�g�[�������ꍇ��
 
101
3 �ȍ~�� OK �ł��B
 
102
 
 
103
(1) �A�[�J�C�u���_�E�����[�h���܂��B
 
104
 
 
105
    ((<URL:http://miyamuko.s56.xrea.com/xyzzy/archives/rabbit-mode.zip>))
 
106
 
 
107
(2) �A�[�J�C�u��W�J���āA$XYZZY/site-lisp �z���Ƀt�@�C�����R�s�[���܂��B
 
108
 
 
109
(3) ~/.xyzzy �܂��� $XYZZY/site-lisp/siteinit.l �Ɉȉ��̃R�[�h��lj����܂��B
 
110
 
 
111
        ;; rabbit-mode
 
112
        (require "rabbit-mode")
 
113
        (pushnew '("\\.rd$" . rabbit-mode) *auto-mode-alist* :test 'equal)
 
114
 
 
115
(4) �ݒ�𔽉f������ɂ� xyzzy ���ċN�����Ă��������B
 
116
 
 
117
    ��siteinit.l �ɋL�q�����ꍇ�ɂ͍ă_���v���K�v�ł��B
 
118
 
 
119
(5) ruby.exe �Ƀp�X��ʂ��Ă��Ȃ��ꍇ�� ((<*rabbit-command*>)) ��ݒ肵�܂��B
 
120
 
 
121
(6) rd �t�@�C�����J�����j���[���� rabbit ���N�����Ă��������B
 
122
 
 
123
 
 
124
== ���t�@�����X
 
125
 
 
126
=== �L�[���蓖��
 
127
 
 
128
: ((%F5%))
 
129
 
 
130
    �X���C�h�V���[���J�n���܂��B
 
131
 
 
132
: ((%C-c n%))
 
133
 
 
134
    �J�[�\�����̃X���C�h���i���[�C���O���܂��B
 
135
 
 
136
: ((%C-c h%))
 
137
 
 
138
    �J�[�\�����̃X���C�h�̕\���E��\�����g�O�����܂��B
 
139
 
 
140
: ((%C-c c%))
 
141
 
 
142
    �J�[�\�����̃X���C�h���R�s�[���đ}�����܂��B
 
143
 
 
144
: ((%C-c C-c%))
 
145
 
 
146
    �X���C�h�ꗗ����I�������X���C�h���R�s�[���đ}�����܂��B
 
147
 
 
148
: ((%C-M-n%))
 
149
 
 
150
    ���̃X���C�h�Ɉړ����܂��B
 
151
 
 
152
: ((%C-M-p%))
 
153
 
 
154
    �O�̃X���C�h�Ɉړ����܂��B
 
155
 
 
156
: ((%C-M-k%))
 
157
 
 
158
    ���݂̃X���C�h�� kill ���܂��B
 
159
 
 
160
: ((%C-M-Up%))
 
161
 
 
162
    ���݂̃X���C�h���ЂƂ�Ɉړ����܂��B
 
163
 
 
164
: ((%C-M-Down%))
 
165
 
 
166
    ���݂̃X���C�h���ЂƂ‰��Ɉړ����܂��B
 
167
 
 
168
: ((%M-NUL%))
 
169
 
 
170
    ���݂̃X���C�h���}�[�N���܂��B
 
171
 
 
172
=== �ϐ�
 
173
 
 
174
--- *rabbit-command*
 
175
    rabbit �����s����R�}���h���w�肵�܂��B�f�t�H���g�� (({ruby -S rabbit})) �ł��B
 
176
 
 
177
    ruby.exe �Ƀp�X��ʂ��Ă��Ȃ��ꍇ��I�v�V�������w�肵�����ꍇ��
 
178
    �����Őݒ肵�܂��B
 
179
 
 
180
    ��:
 
181
        (setf *rabbit-command* "C:/ruby184/bin/ruby.exe -S rabbit")
 
182
 
 
183
    �p�X���ɋ󔒕����������Ă���Ƃ��܂������Ȃ��Ǝv���܂��B
 
184
 
 
185
--- *rabbit-author*
 
186
--- *rabbit-institution*
 
187
    rabbit-insert-title-template �Ń^�C�g���y�[�W��}������Ƃ���
 
188
    ��� (author) �� ���� (institution) ���w�肵�܂��B
 
189
 
 
190
 
 
191
== �֘A���邩������Ȃ��y�[�W
 
192
 
 
193
: rabbit
 
194
    ((<URL:http://www.cozmixng.org/~rwiki/?cmd=view;name=Rabbit%3A%3AREADME.ja>))
 
195
 
 
196
: Ruby-GNOME2 Project Website
 
197
    ((<URL:http://ruby-gnome2.sourceforge.jp/ja/index.html>))
 
198
 
 
199
: RAA - rabbit
 
200
    ((<URL:http://raa.ruby-lang.org/project/rabbit/>))
 
201
 
 
202
: RAA - ruby-gnome2
 
203
    ((<URL:http://raa.ruby-lang.org/project/ruby-gnome2/>))
 
204
 
 
205
 
 
206
== ���C�Z���X
 
207
 
 
208
rabbit-mode �͏C�� BSD ���C�Z���X�Ɋ�Â��ė��p�”\�ł��B
 
209
 
 
210
  Copyright (C) 2004-2006 MIYAMUKO Katsuyuki. All rights reserved.
 
211
 
 
212
  Redistribution and use in source and binary forms, with or without
 
213
  modification, are permitted provided that the following conditions are
 
214
  met:
 
215
 
 
216
  1 Redistributions of source code must retain the above copyright notice,
 
217
    this list of conditions and the following disclaimer as the first lines
 
218
    of this file unmodified.
 
219
 
 
220
  2 Redistributions in binary form must reproduce the above copyright
 
221
    notice, this list of conditions and the following disclaimer in the
 
222
    documentation and/or other materials provided with the distribution.
 
223
 
 
224
  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 
225
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
226
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
227
  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 
228
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
229
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
230
  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
231
  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
232
  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
233
  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
234
  SUCH DAMAGE.
 
235
|#
 
236
 
 
237
(provide "rabbit-mode")
 
238
(in-package "editor")
 
239
 
 
240
(export '(rabbit-slide-show
 
241
          rabbit-preview
 
242
          rabbit-preview-current-slide
 
243
          rabbit-preview-region
 
244
          rabbit-preview-selection
 
245
          rabbit-preview-begin-end
 
246
          rabbit-save-as-image
 
247
          rabbit-insert-title-template
 
248
          rabbit-toggle-hide-slide
 
249
          rabbit-hide-slide-p
 
250
          rabbit-narrow-to-slide
 
251
          rabbit-move-up-slide
 
252
          rabbit-move-down-slide
 
253
          rabbit-copy-slide
 
254
          rabbit-copy-current-slide
 
255
          rabbit-kill-slide
 
256
          rabbit-forward-slide
 
257
          rabbit-backward-slide
 
258
          rabbit-mode
 
259
 
 
260
          *rabbit-command*
 
261
          *rabbit-author*
 
262
          *rabbit-institution*
 
263
          *rabbit-menu*
 
264
          *rabbit-mode-syntax-table*
 
265
          *rabbit-mode-map*
 
266
          *rabbit-mode-hook*))
 
267
 
 
268
(defvar *rabbit-command* "ruby -S rabbit")
 
269
 
 
270
;; �R�����g�A�E�g���ꂽ��\���X���C�h���l��
 
271
(defvar *rabbit-slide-header-regexp* "^#*=[ \t]*\\(.*\\)")
 
272
 
 
273
(defvar *rabbit-author* "���")
 
274
(defvar *rabbit-institution* "����")
 
275
(defvar *rabbit-title-template* (format nil
 
276
"= �������N���b�N���ă^�C�g�������
 
277
 
 
278
: author
 
279
    ~A
 
280
: institution
 
281
    ~A
 
282
" *rabbit-author* *rabbit-institution*))
 
283
 
 
284
(defvar *rabbit-menu* nil)
 
285
(defvar *rabbit-menu-name* "&Rabbit")
 
286
(defvar *rabbit-menu-position* 'ed::help)
 
287
 
 
288
(defvar *rabbit-mode-hook* nil)
 
289
(defvar *rabbit-comment-column* 0)
 
290
 
 
291
(defvar *rabbit-mode-syntax-table* nil)
 
292
(unless *rabbit-mode-syntax-table*
 
293
  (setf *rabbit-mode-syntax-table* (make-syntax-table))
 
294
  (do ((x #x21 (1+ x)))((>= x #x7f))
 
295
    (let ((c (code-char x)))
 
296
      (unless (alphanumericp c)
 
297
        (set-syntax-punctuation *rabbit-mode-syntax-table* c))))
 
298
  (set-syntax-start-comment *rabbit-mode-syntax-table* #\#)
 
299
  (set-syntax-end-comment *rabbit-mode-syntax-table* #\LFD)
 
300
  )
 
301
 
 
302
(defvar *rabbit-mode-map* nil)
 
303
(unless *rabbit-mode-map*
 
304
  (setf *rabbit-mode-map* (make-sparse-keymap))
 
305
  (define-key *rabbit-mode-map* '#\F5 'rabbit-slide-show)
 
306
  (define-key *rabbit-mode-map* '(#\C-c #\n) 'rabbit-narrow-to-slide)
 
307
  (define-key *rabbit-mode-map* '(#\C-c #\h) 'rabbit-toggle-hide-slide)
 
308
  (define-key *rabbit-mode-map* '(#\C-c #\c) 'rabbit-copy-slide)
 
309
  (define-key *rabbit-mode-map* '(#\C-c #\C-c) 'rabbit-copy-current-slide)
 
310
  (define-key *rabbit-mode-map* #\C-M-n 'rabbit-forward-slide)
 
311
  (define-key *rabbit-mode-map* #\C-M-p 'rabbit-backward-slide)
 
312
  (define-key *rabbit-mode-map* #\C-M-k 'rabbit-kill-slide)
 
313
  (define-key *rabbit-mode-map* #\C-M-Up 'rabbit-move-up-slide)
 
314
  (define-key *rabbit-mode-map* #\C-M-Down 'rabbit-move-down-slide)
 
315
  (define-key *rabbit-mode-map* #\M-NUL 'rabbit-mark-slide)
 
316
  )
 
317
 
 
318
;;
 
319
;; RD �F�Â�
 
320
;;
 
321
 
 
322
(defvar *rabbit-regexp-keyword-list* nil)
 
323
(setf *rabbit-regexp-keyword-list*
 
324
  (compile-regexp-keyword-list
 
325
   `(
 
326
     ("^\\(=\\(?:begin\\|end\\)\\)" t ((1 . (:color 7 4))))
 
327
     ("^=\\{1,4\\} +\\([^ \t\r\f\n].*\\)$" t ((1 . (:keyword 0))))
 
328
     ("^\\+\\{1,2\\} +\\([^ \t\r\f\n].*\\)$" t ((1 . (:keyword 0))))
 
329
     ("^ *\\(:\\|---\\) *\\([^ \t\r\f\n].*\\)$" t ((2 . (:color 0 0 :underline))))
 
330
     ("^ *\\(\\*\\)" t ((1 . (:keyword 0))))
 
331
     ("^ *\\(([0-9]+)\\)" t ((1 . (:keyword 0))))
 
332
     ("(([-*{|%:<'].*?[-*}|%:>']))" t ((0 . (:keyword 1))))
 
333
     )))
 
334
 
 
335
;;
 
336
;; menu
 
337
;;
 
338
 
 
339
(defun rabbit-executable-p ()
 
340
  (interactive)
 
341
  (if (rabbit-buffer-filename)
 
342
      (< 0 (file-length (rabbit-buffer-filename)))
 
343
    (< 0 (buffer-size))))
 
344
 
 
345
(unless *rabbit-menu*
 
346
  (setf *rabbit-menu* (copy-menu-items
 
347
                       (define-popup-menu
 
348
                         (:item nil "�X���C�h�V���[(&W)" 'rabbit-slide-show
 
349
                          #'(lambda () (unless (rabbit-executable-p) :disable)))
 
350
                         (:item nil "�v���r���[(&V)" 'rabbit-preview
 
351
                          #'(lambda () (unless (rabbit-executable-p) :disable)))
 
352
                         (:popup nil "�v���r���["
 
353
                          (:item nil "���݂̃X���C�h���v���r���[(&C)" 'rabbit-preview-current-slide
 
354
                           #'(lambda () (unless (rabbit-executable-p) :disable)))
 
355
                          (:item nil "���[�W�������v���r���[(&R)" 'rabbit-preview-region
 
356
                           #'(lambda () (unless (rabbit-executable-p) :disable)))
 
357
                          (:item nil "�I��̈���v���r���[(&S)" 'rabbit-preview-selection
 
358
                           #'(lambda () (unless (rabbit-executable-p) :disable)))
 
359
                          (:item nil "=begin����=end���v���r���[(&E)" 'rabbit-preview-begin-end
 
360
                           #'(lambda () (unless (rabbit-executable-p) :disable))))
 
361
                         :sep
 
362
                         (:item nil "�摜�ŕۑ�����(&S)" 'rabbit-save-as-image
 
363
                          #'(lambda () :disable))
 
364
                         :sep
 
365
                         (:item nil "���̃X���C�h(&N)" 'rabbit-forward-slide)
 
366
                         (:item nil "�O�̃X���C�h(&P)" 'rabbit-backward-slide)
 
367
                         (:item nil "�X���C�h�ꗗ(&D)" 'list-function)
 
368
                         :sep
 
369
                         (:item nil "�X���C�h�𕡐�..." 'rabbit-copy-slide)
 
370
                         (:item nil "���݂̃X���C�h�𕡐�" 'rabbit-copy-current-slide)
 
371
                         (:item nil "�X���C�h���폜" 'rabbit-kill-slide)
 
372
                         (:item nil "�X���C�h���}�[�N" 'rabbit-mark-slide)
 
373
                         :sep
 
374
                         (:item nil "��\���X���C�h�ɐݒ�(&H)" 'rabbit-toggle-hide-slide
 
375
                          #'(lambda () (when (rabbit-hide-slide-p) :check)))
 
376
                         :sep
 
377
                         (:popup nil "�e���v���[�g(&I)"
 
378
                          (:item nil "�^�C�g���y�[�W(&T)" 'rabbit-insert-title-template))
 
379
                         )
 
380
                       (create-menu 'rabbit))))
 
381
 
 
382
(defun insert-rabbit-menu (&key (menu (current-menu))
 
383
                             (position *rabbit-menu-position*)
 
384
                             (menu-name *rabbit-menu-name*))
 
385
  (when (menup menu)
 
386
    (setq menu (copy-menu-items menu (create-menu 'rabbit)))
 
387
    (delete-rabbit-menu menu)
 
388
    (cond
 
389
     ((and (numberp position) (integerp position))
 
390
      (insert-popup-menu menu position *rabbit-menu* menu-name))
 
391
     ((and (symbolp position) (get-menu-position menu position))
 
392
      (insert-popup-menu menu (get-menu-position menu position)
 
393
                         *rabbit-menu* menu-name))
 
394
     (t
 
395
      (add-popup-menu menu *rabbit-menu* menu-name)))
 
396
    (use-local-menu menu)))
 
397
 
 
398
(defun delete-rabbit-menu (&optional (menu (current-menu)))
 
399
  (let (ret)
 
400
    (if (menup menu)
 
401
        (while (delete-menu menu 'ed::rabbit)
 
402
          (setq ret t)))
 
403
    ret))
 
404
 
 
405
(defun insert-rabbit-menu-all-buffers ()
 
406
  (save-excursion
 
407
    (dolist (buffer (buffer-list))
 
408
      (set-buffer buffer)
 
409
      (when (eq buffer-mode 'rabbit-mode)
 
410
        (insert-rabbit-menu)))))
 
411
 
 
412
(unless *app-menu*
 
413
  (add-hook '*post-startup-hook* 'insert-rabbit-menu-all-buffers))
 
414
 
 
415
;;
 
416
;; rabbit �̎��s
 
417
;;
 
418
 
 
419
(defun rabbit-slide-show (&optional theme)
 
420
  (interactive)
 
421
  (rabbit-execute-rabbit (rabbit-buffer-filename) (buffer-fileio-encoding) theme
 
422
                         "--full-screen"))
 
423
 
 
424
(defun rabbit-preview (&optional theme)
 
425
  (interactive)
 
426
  (rabbit-execute-rabbit (rabbit-buffer-filename) (buffer-fileio-encoding) theme))
 
427
 
 
428
(defun rabbit-preview-current-slide (&optional theme)
 
429
  (interactive)
 
430
  (rabbit-funcall-with-current-point 'rabbit-preview-region))
 
431
 
 
432
(defun rabbit-preview-selection (&optional theme)
 
433
  (interactive)
 
434
  (selection-start-end (beg end)
 
435
    (rabbit-preview-region beg end)))
 
436
 
 
437
;; =begin
 
438
;; �������v���r���[
 
439
;; =end
 
440
;; �����Ƃ��͖���
 
441
;; =begin
 
442
;; �������ꏏ��
 
443
;; =end
 
444
(defun rabbit-preview-begin-end (&optional theme)
 
445
  (interactive)
 
446
  (let (slides)
 
447
    (save-excursion
 
448
      (goto-char (point-min))
 
449
      (while (scan-buffer "^=begin\n" :regexp t :tail t)
 
450
        (push (buffer-substring (point) (progn
 
451
                                          (or (scan-buffer "^=end\n" :regexp t) (end-of-buffer))
 
452
                                          (point)))
 
453
              slides)))
 
454
    (unless slides
 
455
      (plain-error "�X���C�h���Ȃ��ł��B"))
 
456
    (rabbit-execute-rabbit-argf (format nil "~{~A~%~}" (reverse slides))
 
457
                                (buffer-fileio-encoding) theme)))
 
458
 
 
459
(defun rabbit-preview-region (beg end &optional theme)
 
460
  (interactive "r")
 
461
  (if (< end beg) (rotatef beg end))
 
462
  (save-excursion
 
463
    (save-restriction
 
464
      (narrow-to-region beg end)
 
465
      (goto-char beg)
 
466
      (rabbit-forward-slide nil)
 
467
      (setf beg (point))))
 
468
  (unless (< beg end)
 
469
    (plain-error "�X���C�h���Ȃ��ł��B"))
 
470
  (let ((slide) (title ""))
 
471
    (unless (= beg (rabbit-title-slide-point))
 
472
      (setf title (rabbit-title-slide)))
 
473
    (setf slide (concat title (buffer-substring beg end)))
 
474
    (rabbit-execute-rabbit-argf slide (buffer-fileio-encoding) theme)))
 
475
 
 
476
(defun rabbit-save-as-image (&optional (type "png"))
 
477
  (interactive)
 
478
  (plain-error "�܂��������Ă��܂���B"))
 
479
 
 
480
;;
 
481
;; rabbit �̎��s (private)
 
482
;;
 
483
 
 
484
(defun rabbit-execute-rabbit (file encoding theme &rest opts)
 
485
  (if file
 
486
      (rabbit-execute-rabbit-file file encoding theme opts)
 
487
    (rabbit-execute-rabbit-argf (buffer-substring (point-min) (point-max))
 
488
                                encoding theme opts)))
 
489
 
 
490
(defun rabbit-execute-rabbit-file (file encoding theme &optional opts)
 
491
  (when (zerop (file-length file))
 
492
    (plain-error (concat "�t�@�C������Ȃ̂� rabbit �����s�ł��܂���: " file)))
 
493
  (rabbit-make-process (format nil "~A ~{~A ~} ~A"
 
494
                               *rabbit-command*
 
495
                               (rabbit-option "file" encoding theme opts)
 
496
                               file)
 
497
                       (rabbit-init-output-buffer)
 
498
                       encoding))
 
499
 
 
500
(defun rabbit-execute-rabbit-argf (str encoding theme &optional opts)
 
501
  (when (zerop (length str))
 
502
    (plain-error "�����񂪋�Ȃ̂� rabbit �����s�ł��܂���"))
 
503
  (let ((proc (rabbit-make-process (format nil "~A ~{~A ~}"
 
504
                                           *rabbit-command*
 
505
                                           (rabbit-option "argf" encoding theme opts))
 
506
                                   (rabbit-init-output-buffer)
 
507
                                   encoding)))
 
508
    (process-send-string proc str)
 
509
    (rabbit-process-send-eof proc)
 
510
    proc))
 
511
 
 
512
(defun rabbit-process-send-eof (proc)
 
513
  (process-send-string proc (format nil "~c" #\C-z)))
 
514
 
 
515
(defun rabbit-option (type encoding theme &optional opts)
 
516
  (let ((result opts))
 
517
    (when type
 
518
      (push (concat "--type " type) result))
 
519
    (when theme
 
520
      (push (concat "--theme " theme) result))
 
521
    (when (rabbit-encoding encoding)
 
522
      (push (concat "--encoding " (rabbit-encoding encoding)) result))
 
523
    result))
 
524
 
 
525
;;
 
526
;; output
 
527
;;
 
528
 
 
529
(defun rabbit-buffer-filename ()
 
530
  (get-buffer-file-name (selected-buffer)))
 
531
 
 
532
(defun rabbit-encoding (encoding)
 
533
  (let ((enc (char-encoding-name encoding)))
 
534
    (if (string-matchp "^utf" enc)
 
535
        nil
 
536
      enc)))
 
537
 
 
538
(defmacro rabbit-with-marker-point (marker &rest body)
 
539
  `(progn
 
540
     (goto-marker ,marker)
 
541
     ,@body
 
542
     (set-marker ,marker (point))))
 
543
(setf (get 'rabbit-with-marker-point 'lisp-indent-hook) 1)
 
544
 
 
545
(defmacro rabbit-with-buffer-selected (buffer &rest body)
 
546
  `(save-excursion
 
547
     (set-buffer ,buffer)
 
548
     ,@body))
 
549
(setf (get 'rabbit-with-buffer-selected 'lisp-indent-hook) 1)
 
550
 
 
551
(defvar *rabbit-buffer-name* "*rabbit:output*")
 
552
(defvar *rabbit-buffer* nil)
 
553
(defun rabbit-make-process (command-line output encoding)
 
554
  (message command-line)
 
555
  (let ((proc (make-process command-line :output output :outcode encoding)))
 
556
    (set-process-filter proc 'rabbit-process-filter)
 
557
    (set-process-sentinel proc 'rabbit-process-sentinel)
 
558
    (rabbit-activate-buffer output)
 
559
    proc))
 
560
 
 
561
(defun rabbit-init-output-buffer ()
 
562
  (save-excursion
 
563
    (when (or (not *rabbit-buffer*)
 
564
              (deleted-buffer-p *rabbit-buffer*))
 
565
      (let ((buf (get-buffer-create *rabbit-buffer-name*)))
 
566
        (set-buffer buf)
 
567
        (make-local-variable 'need-not-save)
 
568
        (setf need-not-save t)
 
569
        (setf *rabbit-buffer* buf)))
 
570
    (erase-buffer *rabbit-buffer*)
 
571
    *rabbit-buffer*))
 
572
 
 
573
(defvar *rabbit-output-buffer-height* 1/10)
 
574
(defun rabbit-activate-buffer (buf)
 
575
  (unless (zerop (buffer-size buf))
 
576
    (pop-to-buffer buf (if (< *rabbit-output-buffer-height* 1)
 
577
                           (ceiling (* (screen-height) *rabbit-output-buffer-height*))
 
578
                         *rabbit-output-buffer-height*))))
 
579
 
 
580
(defun rabbit-process-filter (proc str)
 
581
  (rabbit-with-buffer-selected *rabbit-buffer*
 
582
   (rabbit-with-marker-point (process-marker proc)
 
583
                             (insert str)))
 
584
  (rabbit-activate-buffer *rabbit-buffer*))
 
585
 
 
586
(defun rabbit-process-sentinel (proc)
 
587
  (when (and *rabbit-buffer*
 
588
             (zerop (buffer-size *rabbit-buffer*)))
 
589
    (delete-buffer *rabbit-buffer*)
 
590
    (setf *rabbit-buffer* nil)))
 
591
 
 
592
;;
 
593
;; template
 
594
;;
 
595
 
 
596
(defun rabbit-insert-title-template ()
 
597
  (interactive)
 
598
  (save-excursion (insert *rabbit-title-template*))
 
599
  (forward-char 2))
 
600
 
 
601
;;
 
602
;; �X���C�h�P�ʂł̕ҏW�Ƃ�
 
603
;;
 
604
 
 
605
(defun rabbit-mark-slide ()
 
606
  (interactive)
 
607
  (multiple-value-bind (beg end)
 
608
      (rabbit-current-slide-point)
 
609
    (goto-char end)
 
610
    (set-mark)
 
611
    (goto-char beg)))
 
612
 
 
613
(defun rabbit-toggle-hide-slide ()
 
614
  "rabbit-mode: ��\���X���C�h���g�O������B�P���ɃR�����g�A�E�g���邾��"
 
615
  (interactive)
 
616
  (multiple-value-bind (beg end)
 
617
      (rabbit-current-slide-point)
 
618
    (save-excursion
 
619
      (save-restriction
 
620
        (narrow-to-region beg (1- end)) ; end �͎��̃X���C�h�̍s��
 
621
        (goto-char beg)
 
622
        (if (rabbit-hide-slide-p)
 
623
            (replace-buffer "^#" "" :regexp t)
 
624
          (replace-buffer "^" "#" :regexp t))))))
 
625
 
 
626
(defun rabbit-hide-slide-p ()
 
627
  "rabbit-mode: ��\���X���C�h�Ȃ� non-nil�B"
 
628
  (save-excursion
 
629
    (goto-char (rabbit-current-slide-point))
 
630
    (char= #\# (following-char))))
 
631
 
 
632
(defun rabbit-move-up-slide ()
 
633
  "rabbit-mode: �X���C�h����Ɉړ�����B"
 
634
  (interactive)
 
635
  (let ((slide (rabbit-current-slide)))
 
636
    (rabbit-kill-slide)
 
637
    (rabbit-backward-slide)
 
638
    (rabbit-insert-slide slide)))
 
639
 
 
640
(defun rabbit-move-down-slide ()
 
641
  "rabbit-mode: �X���C�h�����Ɉړ�����B"
 
642
  (interactive)
 
643
  (let ((slide (rabbit-current-slide)))
 
644
    (rabbit-kill-slide)
 
645
    (rabbit-forward-slide)
 
646
    (rabbit-insert-slide slide)))
 
647
 
 
648
(defun rabbit-copy-current-slide ()
 
649
  "rabbit-mode: ���݂̃X���C�h���R�s�[����B"
 
650
  (interactive)
 
651
  (let ((slide (rabbit-current-slide)))
 
652
    (rabbit-forward-slide)
 
653
    (rabbit-insert-slide slide)))
 
654
 
 
655
(defun rabbit-copy-slide ()
 
656
  "rabbit-mode: �X���C�h�ꗗ����X���C�h���R�s�[����B"
 
657
  (interactive)
 
658
  (let ((slide (save-excursion
 
659
                 (and (list-function) (rabbit-current-slide)))))
 
660
    (when slide
 
661
      (rabbit-forward-slide)
 
662
      (rabbit-insert-slide slide))))
 
663
 
 
664
(defun rabbit-insert-slide (slide)
 
665
  (unless (bolp) (insert #\LFD))
 
666
  (save-excursion (insert slide)))
 
667
 
 
668
(defun rabbit-forward-slide (&optional (no-dup t))
 
669
  (interactive)
 
670
  ; forward-paragraph ���ƃ^�C�g���s�̍s���ȊO�ɂ���ꍇ�A�ЂƂ‘O�̃X���C�h�܂Ŗ߂��Ă��܂��B
 
671
  ; ���̏ꍇ�s���ɍs���Ăق����B
 
672
  (or (scan-buffer *rabbit-slide-header-regexp* :regexp t :no-dup no-dup)
 
673
      (end-of-buffer)))
 
674
 
 
675
(defun rabbit-backward-slide (&optional (no-dup t))
 
676
  (interactive)
 
677
  (or (scan-buffer *rabbit-slide-header-regexp* :regexp t :no-dup no-dup :reverse t)
 
678
      (beginning-of-buffer)))
 
679
 
 
680
(defun rabbit-current-slide ()
 
681
  (rabbit-funcall-with-current-point 'buffer-substring))
 
682
 
 
683
(defun rabbit-narrow-to-slide ()
 
684
  (interactive)
 
685
  (rabbit-funcall-with-current-point 'narrow-to-region))
 
686
 
 
687
(defun rabbit-delete-slide ()
 
688
  (interactive)
 
689
  (rabbit-funcall-with-current-point 'delete-region))
 
690
 
 
691
(defun rabbit-kill-slide ()
 
692
  (interactive)
 
693
  (kill-new (rabbit-current-slide))
 
694
  (rabbit-delete-slide))
 
695
 
 
696
(defun rabbit-title-slide ()
 
697
  (multiple-value-bind (beg end)
 
698
      (rabbit-title-slide-point)
 
699
    (buffer-substring beg end)))
 
700
 
 
701
(defun rabbit-title-slide-point ()
 
702
  (save-excursion
 
703
    (goto-char (point-min))
 
704
    (values (progn (rabbit-forward-slide nil) (point))
 
705
            (progn (rabbit-forward-slide) (point)))))
 
706
 
 
707
(defun rabbit-funcall-with-current-point (fn)
 
708
  (multiple-value-bind (beg end)
 
709
      (rabbit-current-slide-point)
 
710
    (funcall fn beg end)))
 
711
 
 
712
(defun rabbit-current-slide-point ()
 
713
  (values (save-excursion (rabbit-backward-slide nil) (point))
 
714
          (save-excursion (rabbit-forward-slide) (point))))
 
715
 
 
716
;;
 
717
;; list-function �ŕ\������X���C�h�̈ꗗ
 
718
;;
 
719
 
 
720
(defun rabbit-build-summary-of-function ()
 
721
  (let ((result nil))
 
722
    (save-excursion
 
723
      (goto-char (point-min))
 
724
      (while (scan-buffer *rabbit-slide-header-regexp* :regexp t :tail t)
 
725
        (push (list (current-line-number) (match-string 1)) result)))
 
726
    (unless result
 
727
      (plain-error "�Ȃ�����"))
 
728
    (nreverse result)))
 
729
 
 
730
;;
 
731
;; �⊮
 
732
;;
 
733
 
 
734
(defvar *rabbit-mode-abbrev-table* nil)
 
735
(unless *rabbit-mode-abbrev-table*
 
736
  (define-abbrev-table '*rabbit-mode-abbrev-table*))
 
737
 
 
738
;;
 
739
;; mode �̎��s
 
740
;;
 
741
(defun rabbit-mode ()
 
742
  "rabbit-mode"
 
743
  (interactive)
 
744
  (kill-all-local-variables)
 
745
  (setf mode-name "Rabbit")
 
746
  (setf buffer-mode 'rabbit-mode)
 
747
  (use-syntax-table *rabbit-mode-syntax-table*)
 
748
  (use-keymap *rabbit-mode-map*)
 
749
 
 
750
  ; ����W�J
 
751
  (setf *local-abbrev-table* *rabbit-mode-abbrev-table*)
 
752
 
 
753
  (make-local-variable 'paragraph-start)
 
754
  (setf paragraph-start *rabbit-slide-header-regexp*)
 
755
  (make-local-variable 'paragraph-separate)
 
756
  (setf paragraph-separate paragraph-start)
 
757
 
 
758
  ; list-funcations
 
759
  (make-local-variable 'build-summary-function)
 
760
  (setf build-summary-function 'rabbit-build-summary-of-function)
 
761
 
 
762
  (setf comment-start "# " comment-end "") ; indent-for-comment�ő}�������z
 
763
  (setf comment-start-skip "#+[ \t]*")
 
764
  (when *rabbit-comment-column*
 
765
    (setf comment-column *rabbit-comment-column*))
 
766
 
 
767
  ; keyword
 
768
  (make-local-variable 'regexp-keyword-list)
 
769
  (setf regexp-keyword-list *rabbit-regexp-keyword-list*)
 
770
 
 
771
  ; ���[�J�����j���[�̐ݒ�
 
772
  (insert-rabbit-menu)
 
773
 
 
774
  ; �t�b�N�̎��s
 
775
  (run-hooks '*rabbit-mode-hook*))