Develop and Download Open Source Software

Browse CVS Repository

Annotation of /shiki/shiki/shiki.c

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph


Revision 1.3 - (hide annotations) (download) (as text)
Thu Nov 2 16:28:52 2006 UTC (17 years, 5 months ago) by aloha
Branch: MAIN
Changes since 1.2: +64 -11 lines
File MIME type: text/x-csrc
Ctrl + n, p, f, b (next line, prev line, forward, backward)

1 aloha 1.1 /* vim: set encoding=utf8:
2     *
3     * shiki.c
4     *
5     * Copyright(C)2006 WAKATSUKI toshihiro
6     *
7     * Permission is hereby granted, free of charge, to any person obtaining a
8     * copy of this software and associated documentation files (the "Software"),
9     * to deal in the Software without restriction, including without limitation
10     * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11     * and/or sell copies of the Software, and to permit persons to whom the
12     * Software is furnished to do so, subject to the following conditions:
13     *
14     * The above copyright notice and this permission notice shall be included in
15     * all copies or substantial portions of the Software.
16     *
17     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23     * SOFTWARE.
24     *
25 aloha 1.3 * $Id: shiki.c,v 1.2 2006/11/02 15:47:16 aloha Exp $
26 aloha 1.1 */
27    
28     #include<gauche.h>
29     #include<gtk/gtk.h>
30     #include<gdk/gdkkeysyms.h>
31    
32     #define INDENT_WIDTH 2
33    
34     static GtkWidget *editor_window;
35    
36     /* ��������������������������������������������������������������� */
37     static gchar* get_all_buffer_contents(GtkTextBuffer *buffer) {
38     GtkTextIter start, end;
39     gtk_text_buffer_get_start_iter(buffer, &start);
40     gtk_text_buffer_get_end_iter(buffer, &end);
41     return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
42     }
43    
44     /* buffer ������������������������ filename ��������� */
45     static gboolean save_text_buffer(const gchar *filename, GtkTextBuffer *buffer) {
46     gchar *contents, *text;
47     gsize br, bw;
48     GError *err = NULL;
49    
50     if(!filename) return FALSE;
51     contents = get_all_buffer_contents(buffer);
52     text = g_locale_from_utf8(contents, -1, &br, &bw, &err);
53     /* ��������������������������������� */
54     g_file_set_contents(filename, text, -1, NULL);
55     gtk_text_buffer_set_modified(buffer, FALSE);
56     g_free(contents); g_free(text);
57     return TRUE;
58     }
59    
60     /* ������������������������������������������������������msg ������������������������������������ */
61     static gchar *get_filename_from_dialog(const gchar *msg) {
62    
63     GtkWidget *dialog = gtk_file_selection_new(msg);
64     int resp = gtk_dialog_run(GTK_DIALOG(dialog));
65     gchar *filename = NULL;
66    
67     /* gtk_file_selection_get_filename ������������������������������������������������������������������������������������������������������������������������������ */
68     if(resp == GTK_RESPONSE_OK)
69     filename = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(dialog)));
70    
71     gtk_widget_destroy(dialog);
72     return filename;
73     }
74 aloha 1.3 /* ������������������������������������������������������������������������������ */
75     static GtkTextView* get_text_view_from_current_tabpage(GtkNotebook* notebook) {
76     gint pagenum = gtk_notebook_get_current_page(notebook);
77     GtkScrolledWindow *scrolledwindow = GTK_SCROLLED_WINDOW(gtk_notebook_get_nth_page(notebook, pagenum));
78     /* GtkBin ������������������������������������������������������������ */
79     return GTK_TEXT_VIEW(gtk_bin_get_child(GTK_BIN(scrolledwindow)));
80     }
81    
82 aloha 1.1
83     /* ������������������������������������������������������������������������������ */
84     static GtkTextBuffer* get_text_buffer_from_current_tabpage(GtkNotebook* notebook) {
85 aloha 1.3 return gtk_text_view_get_buffer(get_text_view_from_current_tabpage(notebook));
86 aloha 1.1 }
87    
88     /* ��������������������������������������������������������������������������������� */
89    
90     /* ��������������������������������������������������������������������� */
91     static void save_file_from_notebook(GtkNotebook *notebook) {
92     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
93     gchar *filename;
94     gint current_page;
95    
96     /* ������������������������������������ */
97     if(!gtk_text_buffer_get_modified(buffer)) return;
98    
99     /* ��������������������������������������������������������������������������������� */
100     current_page = gtk_notebook_get_current_page(notebook);
101     filename = g_strdup(gtk_notebook_get_tab_label_text(notebook, gtk_notebook_get_nth_page(notebook, current_page)));
102    
103     /* ������������������������������������������������������������������������������������������������������ */
104     if(!filename || g_ascii_strcasecmp("*scratch*", filename) == 0) {
105     g_free(filename);
106     if(!save_text_buffer(filename = get_filename_from_dialog("Save File As ..."), buffer))
107     return;
108     } else
109     save_text_buffer(filename, buffer);
110    
111     gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook),
112     gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), current_page),
113     filename);
114     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
115     g_free(filename);
116     }
117    
118     /* ��������������������������������������������������� */
119     static void save_file_handler(GtkWidget *widget, GtkWidget *notebook) {
120     save_file_from_notebook(GTK_NOTEBOOK(notebook));
121     }
122    
123     /* ��������������������������������������������������������������������������� */
124     static void save_file_as_from_notebook(GtkNotebook *notebook) {
125     gint current_page;
126     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
127     gchar *filename = get_filename_from_dialog("Save File As ...");
128    
129     if(!save_text_buffer(filename, buffer)) return;
130    
131     current_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
132     gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook),
133     gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), current_page),
134     filename);
135    
136     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
137    
138     g_free(filename);
139     }
140    
141     /* ��������������������������������������������������������� */
142     static void save_file_as_handler(GtkWidget *widget, GtkWidget *notebook) {
143     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
144     }
145    
146     /* YES ������������NO ������������������������������������ callback */
147     void really_quit_dialog_yes(GtkWidget *widget, gboolean *flag){*flag = FALSE;}
148     void really_quit_dialog_no(GtkWidget *widget, gint *flag){*flag = TRUE;}
149    
150     /* ��������������������������������������������� ? */
151     gboolean not_yet_save_changes_really_quit(GtkTextBuffer *buffer) {
152     GtkWidget *yes_button, *no_button;
153     static GtkWidget *dialog_window = NULL;
154    
155     /* ��������������������������������������� */
156     if(!gtk_text_buffer_get_modified(buffer)) return FALSE;
157    
158     if(dialog_window == NULL) {
159     gboolean flag = TRUE;
160     dialog_window = gtk_dialog_new ();
161    
162     /* ��������������������������������������������� ? ��������������������������� */
163     g_signal_connect(G_OBJECT(dialog_window), "delete_event", G_CALLBACK(gtk_false), NULL);
164     g_signal_connect(G_OBJECT(dialog_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
165    
166     gtk_window_set_title(GTK_WINDOW (dialog_window), "Really Quit ?");
167     /* YES ������������ */
168     yes_button = gtk_button_new_with_label("YES");
169     g_signal_connect(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(really_quit_dialog_yes), &flag);
170     g_signal_connect_swapped(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
171     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), yes_button, TRUE, TRUE, 0);
172    
173     /* NO ������������ */
174     no_button = gtk_button_new_with_label("NO");
175     g_signal_connect(GTK_OBJECT(no_button), "clicked", G_CALLBACK(really_quit_dialog_no), &flag);
176     g_signal_connect_swapped(GTK_OBJECT(no_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
177     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), no_button, TRUE, TRUE, 0);
178    
179     gtk_window_set_modal(GTK_WINDOW(dialog_window), TRUE);
180     gtk_window_set_transient_for(GTK_WINDOW(dialog_window), GTK_WINDOW (editor_window));
181    
182     gtk_widget_show_all(dialog_window);
183     gtk_main ();
184     dialog_window = NULL;
185    
186     /* "delete_event" ��������������� FALSE ���������"destory" ������������������window ������������������ */
187     return flag;
188     }
189     return TRUE;
190     }
191    
192     /* ������������������������������������������������������������������������������������������ */
193     gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, GtkWidget *buffer){
194     return not_yet_save_changes_really_quit(GTK_TEXT_BUFFER(buffer));
195     }
196    
197     /* ������������������������������ */
198     static GtkWidget *new_scrolled_text_buffer() {
199    
200     GtkWidget *scrolledwindow, *view;
201     GtkTextBuffer *buffer;
202    
203     /* ������������������������������������ */
204     scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
205     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
206    
207     /* ������������������������������������������������ */
208     view = gtk_text_view_new();
209     buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
210     gtk_container_add(GTK_CONTAINER(scrolledwindow), view);
211     g_signal_connect(G_OBJECT(editor_window), "delete_event", G_CALLBACK(delete_event_handler), buffer);
212     gtk_widget_set_size_request(GTK_WIDGET(view), 500, 500);
213    
214     /* ������������������������ */
215 aloha 1.3
216 aloha 1.1 /* ������������������������������������������������ */
217     gtk_text_buffer_create_tag (buffer, "parent_emphasis_background", "background", "green", NULL);
218    
219     return scrolledwindow;
220     }
221    
222     /* ��������������������� */
223     static void open_file_from_notebook(GtkNotebook *notebook) {
224     gchar *contents, *text;
225     gsize br, bw, len;
226     GError *err = NULL;
227    
228     gchar *filename = get_filename_from_dialog("File Selection");
229    
230     if(!filename) return;
231    
232     if(g_file_get_contents(filename, &contents, &len, NULL)) {
233     GtkTextBuffer *buffer;
234     GtkWidget *scrolledwindow;
235     GtkTextIter p;
236 aloha 1.3
237 aloha 1.1 /* ������������������������������ */
238     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
239 aloha 1.3 scrolledwindow = new_scrolled_text_buffer(),
240     gtk_label_new(filename));
241 aloha 1.1 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtk_bin_get_child(GTK_BIN(scrolledwindow))));
242    
243     if(!(text = g_locale_to_utf8(contents, -1, &br, &bw, &err)))
244     gtk_text_buffer_set_text(buffer, contents, len);
245     else
246     gtk_text_buffer_set_text(buffer, text, len);
247    
248     /* ������������������������ */
249     gtk_text_buffer_set_modified(buffer, FALSE);
250     /* ������������������������������ */
251     gtk_text_buffer_get_start_iter(buffer, &p);
252     gtk_text_buffer_place_cursor(buffer, &p);
253     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
254     gtk_widget_show_all(GTK_WIDGET(notebook));
255     g_free(contents); g_free(text); g_free(filename);
256     } else
257     g_printerr("Get file contents error !\n");
258     }
259    
260     /* ��������������������������������������������� */
261     static void open_file_handler(GtkWidget *widget, GtkWidget *notebook) {
262     open_file_from_notebook(GTK_NOTEBOOK(notebook));
263     }
264    
265     /* gauche ��������������������������������� */
266     static gchar *eval_cstring_by_gauche(gchar *s) {
267     gchar *msg;
268    
269     ScmObj result, error;
270     /* ������������������������������ */
271     ScmObj os = Scm_MakeOutputStringPort(TRUE);
272    
273     /* Scheme ��������������������������������������� */
274     /* http://alohakun.blog7.fc2.com/blog-entry-517.html */
275     Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*input*")), SCM_MAKE_STR(s));
276     Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), SCM_FALSE);
277    
278     result = Scm_EvalCString("(guard (e (else (set! *error* e) #f)) (eval (read-from-string *input*) (current-module)))", SCM_OBJ(Scm_UserModule()));
279    
280     error = Scm_GlobalVariableRef(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), 0);
281    
282     /* ��������������������������������������������������������� */
283     if (!SCM_FALSEP(error))
284     Scm_Write(error, os, SCM_WRITE_DISPLAY);
285     else
286     Scm_Write(result, os, SCM_WRITE_DISPLAY);
287    
288     msg = Scm_GetString(SCM_STRING(Scm_GetOutputString(SCM_PORT(os))));
289     /* ������������������ */
290     Scm_ClosePort(SCM_PORT(os));
291    
292     return msg;
293     }
294    
295     /* ������������������������������������������������������������������������ S ������������ */
296     static void buffer_exec_handler(GtkWidget *widget, GtkWidget *notebook) {
297     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
298    
299     GtkTextIter start, end, p;
300     gchar *code;
301     gtk_text_buffer_get_end_iter(buffer, &p);
302     gtk_text_buffer_insert(buffer, &p, "\n\n", -1);
303    
304     /* ������������������������������������������������������������ */
305     if(gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) {
306     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
307     gtk_text_buffer_insert(buffer, &p, eval_cstring_by_gauche(code), -1);
308     g_free(code);
309     }
310    
311     }
312    
313     // GtkTextCharPredicate
314     static gboolean is_kakko_or_kokka(gunichar ch, gpointer p) {
315     return ch == '(' || ch == ')';
316     }
317     static gboolean is_kokka(gunichar ch, gpointer p) {return ch == ')';}
318    
319    
320     /* ')' ��������������� '(' ������������������ (S ���) ��������������� */
321     static gboolean search_sexp_string(GtkTextIter *start) {
322     gint nest_level = 0;
323     /* ��������������������������������� S ������������������ */
324     while(1) {
325     if(!gtk_text_iter_backward_find_char(start, is_kakko_or_kokka, NULL, NULL))
326     return FALSE;
327    
328     if(gtk_text_iter_get_char(start) == ')')
329     nest_level++;
330     else {
331     if(!nest_level)
332     break;
333     else
334     nest_level--;
335     }
336     }
337     return TRUE;
338     }
339    
340     /* ������������������������������������������������ */
341     static gint get_parent_nest_level_at_cursor(GtkTextBuffer *buffer) {
342     gint nest_level = 0;
343     GtkTextIter start, end;
344     gtk_text_buffer_get_start_iter(buffer, &start);
345     if(gtk_text_iter_get_char(&start) == '(') nest_level++;
346    
347     /* ��������������������� (= end) ��������� */
348     gtk_text_buffer_get_iter_at_mark(buffer,&end, gtk_text_buffer_get_insert(buffer));
349    
350     while(1) {
351     /* end ������ '(' ��� ')' ��������������������������������������������� */
352     if(!gtk_text_iter_forward_find_char(&start, is_kakko_or_kokka, NULL, &end))
353     return nest_level;
354    
355     if(gtk_text_iter_get_char(&start) == '(')
356     nest_level++;
357     else
358     nest_level--;
359     }
360     }
361    
362     /* ������������������������������������������������������������ */
363     static void switch_page(GtkNotebook *notebook, GtkNotebookPage *page, guint pagenum, gpointer p) {
364     /* ������������������������������������������������������ */
365     gtk_window_set_title (GTK_WINDOW(editor_window), gtk_notebook_get_tab_label_text(notebook, GTK_WIDGET(gtk_notebook_get_nth_page(notebook, pagenum))));
366     }
367    
368     /* ��������������������������������� on/off */
369     static void tabsborder_on_off(GtkButton *button, GtkNotebook *notebook) {
370     gint tval = FALSE;
371     gint bval = FALSE;
372     if(notebook->show_tabs == FALSE)
373     tval = TRUE;
374     if(notebook->show_border == FALSE)
375     bval = TRUE;
376    
377     gtk_notebook_set_show_tabs(notebook, tval);
378     gtk_notebook_set_show_border(notebook, bval);
379     }
380    
381     /* ������������������������������������������ */
382     static void remove_tabpage(GtkNotebook *notebook) {
383     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
384     if(!not_yet_save_changes_really_quit(buffer)) {
385     gint page = gtk_notebook_get_current_page(notebook);
386     gtk_notebook_remove_page(notebook, page);
387     /* ��������������������������������������� */
388     gtk_widget_queue_draw(GTK_WIDGET(notebook));
389     }
390     }
391    
392     static void remove_tabpage_handler(GtkButton *button, GtkWidget *notebook) {
393     remove_tabpage(GTK_NOTEBOOK(notebook));
394     }
395    
396     /* ������������������������������������������������ */
397     static void append_tabpage(GtkButton *button, GtkNotebook *notebook) {
398     gtk_notebook_append_page(notebook, new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
399     gtk_widget_show_all(GTK_WIDGET(notebook));
400     }
401    
402     /* ������������������������ */
403     static void rotate_tab_position(GtkButton *button, GtkNotebook *notebook ) {
404     gtk_notebook_set_tab_pos(notebook, (notebook->tab_pos + 1) % 4);
405     }
406    
407     /* ������������������������������������������ */
408    
409 aloha 1.3 /* ��������������������� ^npfb */
410     static void forward_buffer_from_current_tabpage(GtkNotebook *notebook) {
411     GtkTextBuffer *b = get_text_buffer_from_current_tabpage(notebook);
412     GtkTextIter p;
413     gtk_text_buffer_get_iter_at_mark(b,&p, gtk_text_buffer_get_insert(b));
414     gtk_text_iter_forward_char(&p);
415     gtk_text_buffer_place_cursor(b, &p);
416     }
417     static void backward_buffer_from_current_tabpage(GtkNotebook *notebook) {
418     GtkTextBuffer *b = get_text_buffer_from_current_tabpage(notebook);
419     GtkTextIter p;
420     gtk_text_buffer_get_iter_at_mark(b,&p, gtk_text_buffer_get_insert(b));
421     gtk_text_iter_backward_char(&p);
422     gtk_text_buffer_place_cursor(b, &p);
423     }
424     static void line_forward_buffer_from_current_tabpage(GtkNotebook *notebook) {
425     GtkTextView *v = get_text_view_from_current_tabpage(notebook);
426     GtkTextBuffer *b = gtk_text_view_get_buffer(v);
427     GtkTextIter p;
428     gtk_text_buffer_get_iter_at_mark(b,&p, gtk_text_buffer_get_insert(b));
429     gtk_text_view_forward_display_line(v, &p);
430     gtk_text_buffer_place_cursor(b, &p);
431     }
432     static void line_backward_buffer_from_current_tabpage(GtkNotebook *notebook) {
433     GtkTextView *v = get_text_view_from_current_tabpage(notebook);
434     GtkTextBuffer *b = gtk_text_view_get_buffer(v);
435     GtkTextIter p;
436     gtk_text_buffer_get_iter_at_mark(b,&p, gtk_text_buffer_get_insert(b));
437     gtk_text_view_backward_display_line(v, &p);
438     gtk_text_buffer_place_cursor(b, &p);
439     }
440    
441 aloha 1.1 /* ��������������������� */
442     static gboolean signal_key_press_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
443     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
444    
445     GtkTextIter start, end;
446    
447     /* ������������������������������������ */
448     gtk_text_buffer_get_start_iter(buffer, &start);
449     gtk_text_buffer_get_end_iter(buffer, &end);
450     gtk_text_buffer_remove_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
451    
452 aloha 1.3 /* Ctrl + f : forward */
453     if(event->keyval == GDK_f && event->state & GDK_CONTROL_MASK) {
454     forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
455     }
456     /* Ctrl + b : backward */
457     if(event->keyval == GDK_b && event->state & GDK_CONTROL_MASK) {
458     backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
459     }
460     /* Ctrl + n : next line */
461     if(event->keyval == GDK_n && event->state & GDK_CONTROL_MASK) {
462     line_forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
463     }
464     /* Ctrl + p : previous line */
465     if(event->keyval == GDK_p && event->state & GDK_CONTROL_MASK) {
466     line_backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
467     }
468    
469 aloha 1.1 /* Ctrl + j : ��������������������� S ������������ */
470     if(event->keyval == GDK_j && event->state & GDK_CONTROL_MASK) {
471     gchar *code;
472     GtkTextIter start, end;
473    
474     /* ������������������������������ */
475     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
476    
477     gtk_text_iter_backward_find_char(&end, is_kokka, NULL, NULL);
478     start = end;
479     gtk_text_iter_forward_char(&end);
480    
481     /* ��������������������������������� S ������������������ */
482     if(!search_sexp_string(&start)) return FALSE;
483    
484     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
485     gtk_text_buffer_insert(buffer, &end, "\n\n", -1);
486     gtk_text_buffer_insert(buffer, &end, eval_cstring_by_gauche(code), -1);
487     g_free(code);
488     }
489    
490     /* Ctrl + O : ������������������ */
491     if(event->keyval == GDK_O && event->state & GDK_CONTROL_MASK) {
492     open_file_from_notebook(GTK_NOTEBOOK(notebook));
493     }
494    
495     /* Ctrl + s : ������������������ */
496     if(event->keyval == GDK_s && event->state & GDK_CONTROL_MASK) {
497     save_file_from_notebook(GTK_NOTEBOOK(notebook));
498     }
499    
500     /* Ctrl + w : ������������������������ */
501     if(event->keyval == GDK_w && event->state & GDK_CONTROL_MASK) {
502     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
503     }
504 aloha 1.3
505 aloha 1.1 /* Ctrl + t : ��������������� */
506     if(event->keyval == GDK_t && event->state & GDK_CONTROL_MASK) {
507     gtk_notebook_append_page(GTK_NOTEBOOK(notebook), new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
508     gtk_widget_show_all(GTK_WIDGET(notebook));
509     }
510    
511     /* Ctrl + c : ������������������ */
512     if(event->keyval == GDK_C && event->state & GDK_CONTROL_MASK) {
513     remove_tabpage(GTK_NOTEBOOK(notebook));
514     }
515    
516     /* Ctrl + q : ������ */
517     if(event->keyval == GDK_q && event->state & GDK_CONTROL_MASK) {
518     /* "delete-event" ��������������������������������������� �� ������������������������������������ */
519     GdkEvent ev;
520    
521     ev.any.type = GDK_DELETE;
522     ev.any.window = editor_window->window;
523     ev.any.send_event = FALSE;
524     gdk_event_put (&ev);
525     }
526    
527     return FALSE;
528     }
529    
530     /* ��������������������� */
531     static gboolean signal_key_release_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
532    
533     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
534    
535     if(event->keyval == GDK_parenright && event->state & GDK_SHIFT_MASK) {
536     GtkTextIter start, end;
537    
538     /* ������������������������������ */
539     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
540    
541     start = end;
542     gtk_text_iter_backward_char(&start);
543    
544     /* ��������������������������������� S ������������������ */
545     if(!search_sexp_string(&start)) return FALSE;
546    
547     gtk_text_buffer_apply_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
548     }
549    
550     /* ������������������������������������������������������������������������������������������������ (���������������) ������������������ */
551     if(event->keyval == GDK_Return) {
552     gint indentWidth = get_parent_nest_level_at_cursor(buffer) * INDENT_WIDTH;
553     gchar *indent = g_strnfill(indentWidth, ' ');
554     gtk_text_buffer_insert_at_cursor(buffer, indent, -1);
555     g_free(indent);
556     }
557    
558     return FALSE;
559     }
560    
561     /* ��������������������������������������� */
562     static void editor_window_init() {
563     GtkWidget *vbox, *toolbar, *notebook;
564     GtkToolItem *icon;
565     GtkIconSize iconsize;
566 aloha 1.2 GtkTooltips *toolbar_tips = gtk_tooltips_new();
567 aloha 1.1 /* ��������������������������������������������������������������������������������� */
568     GtkToolItem *oicon, *sicon, *saicon, *eicon;
569    
570     /* ������������ */
571     editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
572     g_signal_connect(G_OBJECT(editor_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
573    
574     /* ������������������������������������ */
575     vbox = gtk_vbox_new(FALSE, 0);
576     /* ��������������������� */
577     toolbar = gtk_toolbar_new();
578     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
579    
580     notebook = gtk_notebook_new();
581     g_signal_connect(G_OBJECT(notebook), "switch-page", GTK_SIGNAL_FUNC(switch_page), NULL);
582    
583     /* ������������������������������������������������ */
584     gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
585     iconsize = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
586    
587     /* ������������������ */
588    
589     /* ������������������ */
590     oicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-open", iconsize), "");
591     /* ������������������������������������������������������������������������������������ */
592     g_signal_connect(G_OBJECT(oicon), "clicked", G_CALLBACK(open_file_handler), G_OBJECT(notebook));
593     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(oicon));
594 aloha 1.2 gtk_tool_item_set_tooltip(oicon, toolbar_tips, "���������������������������",
595     "���������������������������������������������������������������������������������������");
596 aloha 1.1
597     /* ������������������ */
598     sicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save", iconsize), "");
599     /* ������������������������������������������������������������������������������������ */
600     g_signal_connect(G_OBJECT(sicon), "clicked", G_CALLBACK(save_file_handler), G_OBJECT(notebook));
601     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(sicon));
602 aloha 1.2 gtk_tool_item_set_tooltip(sicon, toolbar_tips, "������������������������������",
603     "������������������������������������������������������������������������������������������������������������������������������������");
604 aloha 1.1
605     /* ��������������������������� */
606     saicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save-as", iconsize), "");
607     /* ������������������������������������������������������������������������������������������������������������������ */
608     g_signal_connect(G_OBJECT(saicon), "clicked", G_CALLBACK(save_file_as_handler), G_OBJECT(notebook));
609 aloha 1.2 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(saicon));
610     gtk_tool_item_set_tooltip(saicon, toolbar_tips, "������������������������������������",
611     "");
612 aloha 1.1
613    
614     /* ������������������ */
615     eicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-execute", iconsize), "");
616     /* ��������������������������������� libgauche ������������������ */
617     g_signal_connect(G_OBJECT(eicon), "clicked", G_CALLBACK(buffer_exec_handler), G_OBJECT(notebook));
618     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(eicon));
619 aloha 1.2 gtk_tool_item_set_tooltip(eicon, toolbar_tips, "��������������� S ���������������������",
620     "Scheme (gauche) ������������������ S ������������������������");
621 aloha 1.1
622     /* ������������������������������������������������ */
623     g_signal_connect(G_OBJECT(notebook), "key-press-event", G_CALLBACK (signal_key_press_handler), NULL);
624     g_signal_connect(G_OBJECT(notebook), "key-release-event", G_CALLBACK (signal_key_release_handler), NULL);
625     gtk_container_add(GTK_CONTAINER(editor_window), vbox);
626     gtk_container_add(GTK_CONTAINER(vbox), notebook);
627    
628     /* ������������������������������������ */
629     gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook),
630     new_scrolled_text_buffer(),
631     gtk_label_new("*scratch*"));
632    
633     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-apply", iconsize), "append");
634     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(tabsborder_on_off), G_OBJECT(notebook));
635     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
636 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "��������� on/off",
637     "");
638 aloha 1.1
639     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-preferences", iconsize), "append");
640     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(rotate_tab_position), G_OBJECT( notebook));
641     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
642 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "������������������������",
643     "");
644 aloha 1.1
645     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-add", iconsize), "append");
646     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(append_tabpage), G_OBJECT( notebook));
647     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
648 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������������",
649     "");
650 aloha 1.1
651     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-close", iconsize), "remove");
652     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(remove_tabpage_handler), G_OBJECT( notebook));
653     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
654 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������",
655     "���������������������������������������������������������������");
656 aloha 1.1
657     gtk_widget_show_all(editor_window);
658     }
659    
660     int main(int argc, char *argv[]) {
661     /* ������������������������������������ */
662     gtk_set_locale();
663     gtk_init(&argc, &argv);
664     GC_INIT(); Scm_Init(GAUCHE_SIGNATURE);
665     editor_window_init();
666     gtk_main();
667     Scm_Exit(0);
668     return 0;
669     }

Back to OSDN">Back to OSDN
ViewVC Help
Powered by ViewVC 1.1.26