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.4 - (hide annotations) (download) (as text)
Fri Nov 3 06:47:02 2006 UTC (17 years, 5 months ago) by aloha
Branch: MAIN
Changes since 1.3: +65 -68 lines
File MIME type: text/x-csrc
refactoring signal_key_press_handler

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.4 * $Id: shiki.c,v 1.3 2006/11/02 16:28:52 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.4 /* ��������������������������������������������� */
453     if(event->state & GDK_CONTROL_MASK) {
454     switch(event->keyval) {
455     case GDK_f : /* Ctrl + f : forward */
456     forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
457     break;
458     case GDK_b : /* Ctrl + b : backward */
459     backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
460     break;
461     case GDK_n : /* Ctrl + n : next line */
462     line_forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
463     break;
464     case GDK_p : /* Ctrl + p : previous line */
465     line_backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
466     break;
467 aloha 1.3
468 aloha 1.4 case GDK_j : /* Ctrl + j : ��������������������� S ������������ */
469     {
470     gchar *code;
471     GtkTextIter start, end;
472    
473     /* ������������������������������ */
474     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
475    
476     gtk_text_iter_backward_find_char(&end, is_kokka, NULL, NULL);
477     start = end;
478     gtk_text_iter_forward_char(&end);
479    
480     /* ��������������������������������� S ������������������ */
481     if(!search_sexp_string(&start)) return FALSE;
482    
483     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
484     gtk_text_buffer_insert(buffer, &end, "\n\n", -1);
485     gtk_text_buffer_insert(buffer, &end, eval_cstring_by_gauche(code), -1);
486     g_free(code);
487     }
488     break;
489 aloha 1.1
490 aloha 1.4 case GDK_O : /* Ctrl + O : ������������������ */
491     open_file_from_notebook(GTK_NOTEBOOK(notebook));
492     break;
493 aloha 1.1
494 aloha 1.4 case GDK_s : /* Ctrl + s : ������������������ */
495     save_file_from_notebook(GTK_NOTEBOOK(notebook));
496     break;
497 aloha 1.1
498 aloha 1.4 case GDK_w : /* Ctrl + w : ������������������������ */
499     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
500     break;
501 aloha 1.1
502 aloha 1.4 case GDK_t : /* Ctrl + t : ��������������� */
503     gtk_notebook_append_page(GTK_NOTEBOOK(notebook), new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
504     gtk_widget_show_all(GTK_WIDGET(notebook));
505     break;
506 aloha 1.1
507 aloha 1.4 case GDK_C : /* Ctrl + c : ������������������ */
508     remove_tabpage(GTK_NOTEBOOK(notebook));
509     break;
510 aloha 1.1
511 aloha 1.4 case GDK_q :/* Ctrl + q : ������ */
512     {
513     /* "delete-event" ��������������������������������������� �� ������������������������������������ */
514     GdkEvent ev;
515    
516     ev.any.type = GDK_DELETE;
517     ev.any.window = editor_window->window;
518     ev.any.send_event = FALSE;
519     gdk_event_put (&ev);
520     }
521     break;
522     }
523 aloha 1.1 }
524     return FALSE;
525     }
526    
527     /* ��������������������� */
528     static gboolean signal_key_release_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
529    
530     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
531    
532     if(event->keyval == GDK_parenright && event->state & GDK_SHIFT_MASK) {
533     GtkTextIter start, end;
534    
535     /* ������������������������������ */
536     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
537    
538     start = end;
539     gtk_text_iter_backward_char(&start);
540    
541     /* ��������������������������������� S ������������������ */
542     if(!search_sexp_string(&start)) return FALSE;
543    
544     gtk_text_buffer_apply_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
545     }
546    
547     /* ������������������������������������������������������������������������������������������������ (���������������) ������������������ */
548     if(event->keyval == GDK_Return) {
549     gint indentWidth = get_parent_nest_level_at_cursor(buffer) * INDENT_WIDTH;
550     gchar *indent = g_strnfill(indentWidth, ' ');
551     gtk_text_buffer_insert_at_cursor(buffer, indent, -1);
552     g_free(indent);
553     }
554    
555     return FALSE;
556     }
557    
558     /* ��������������������������������������� */
559     static void editor_window_init() {
560     GtkWidget *vbox, *toolbar, *notebook;
561     GtkToolItem *icon;
562     GtkIconSize iconsize;
563 aloha 1.2 GtkTooltips *toolbar_tips = gtk_tooltips_new();
564 aloha 1.1 /* ��������������������������������������������������������������������������������� */
565     GtkToolItem *oicon, *sicon, *saicon, *eicon;
566    
567     /* ������������ */
568     editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
569     g_signal_connect(G_OBJECT(editor_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
570    
571     /* ������������������������������������ */
572     vbox = gtk_vbox_new(FALSE, 0);
573     /* ��������������������� */
574     toolbar = gtk_toolbar_new();
575     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
576    
577     notebook = gtk_notebook_new();
578     g_signal_connect(G_OBJECT(notebook), "switch-page", GTK_SIGNAL_FUNC(switch_page), NULL);
579    
580     /* ������������������������������������������������ */
581     gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
582     iconsize = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
583    
584     /* ������������������ */
585    
586     /* ������������������ */
587     oicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-open", iconsize), "");
588     /* ������������������������������������������������������������������������������������ */
589     g_signal_connect(G_OBJECT(oicon), "clicked", G_CALLBACK(open_file_handler), G_OBJECT(notebook));
590     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(oicon));
591 aloha 1.2 gtk_tool_item_set_tooltip(oicon, toolbar_tips, "���������������������������",
592     "���������������������������������������������������������������������������������������");
593 aloha 1.1
594     /* ������������������ */
595     sicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save", iconsize), "");
596     /* ������������������������������������������������������������������������������������ */
597     g_signal_connect(G_OBJECT(sicon), "clicked", G_CALLBACK(save_file_handler), G_OBJECT(notebook));
598     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(sicon));
599 aloha 1.2 gtk_tool_item_set_tooltip(sicon, toolbar_tips, "������������������������������",
600     "������������������������������������������������������������������������������������������������������������������������������������");
601 aloha 1.1
602     /* ��������������������������� */
603     saicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save-as", iconsize), "");
604     /* ������������������������������������������������������������������������������������������������������������������ */
605     g_signal_connect(G_OBJECT(saicon), "clicked", G_CALLBACK(save_file_as_handler), G_OBJECT(notebook));
606 aloha 1.2 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(saicon));
607     gtk_tool_item_set_tooltip(saicon, toolbar_tips, "������������������������������������",
608     "");
609 aloha 1.1
610    
611     /* ������������������ */
612     eicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-execute", iconsize), "");
613     /* ��������������������������������� libgauche ������������������ */
614     g_signal_connect(G_OBJECT(eicon), "clicked", G_CALLBACK(buffer_exec_handler), G_OBJECT(notebook));
615     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(eicon));
616 aloha 1.2 gtk_tool_item_set_tooltip(eicon, toolbar_tips, "��������������� S ���������������������",
617     "Scheme (gauche) ������������������ S ������������������������");
618 aloha 1.1
619     /* ������������������������������������������������ */
620     g_signal_connect(G_OBJECT(notebook), "key-press-event", G_CALLBACK (signal_key_press_handler), NULL);
621     g_signal_connect(G_OBJECT(notebook), "key-release-event", G_CALLBACK (signal_key_release_handler), NULL);
622     gtk_container_add(GTK_CONTAINER(editor_window), vbox);
623     gtk_container_add(GTK_CONTAINER(vbox), notebook);
624    
625     /* ������������������������������������ */
626     gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook),
627     new_scrolled_text_buffer(),
628     gtk_label_new("*scratch*"));
629    
630     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-apply", iconsize), "append");
631     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(tabsborder_on_off), G_OBJECT(notebook));
632     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
633 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "��������� on/off",
634     "");
635 aloha 1.1
636     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-preferences", iconsize), "append");
637     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(rotate_tab_position), G_OBJECT( notebook));
638     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
639 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "������������������������",
640     "");
641 aloha 1.1
642     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-add", iconsize), "append");
643     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(append_tabpage), G_OBJECT( notebook));
644     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
645 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������������",
646     "");
647 aloha 1.1
648     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-close", iconsize), "remove");
649     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(remove_tabpage_handler), G_OBJECT( notebook));
650     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
651 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������",
652     "���������������������������������������������������������������");
653 aloha 1.1
654     gtk_widget_show_all(editor_window);
655     }
656    
657     int main(int argc, char *argv[]) {
658     /* ������������������������������������ */
659     gtk_set_locale();
660     gtk_init(&argc, &argv);
661     GC_INIT(); Scm_Init(GAUCHE_SIGNATURE);
662     editor_window_init();
663     gtk_main();
664     Scm_Exit(0);
665     return 0;
666     }

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