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.5 - (hide annotations) (download) (as text)
Fri Nov 3 08:02:51 2006 UTC (17 years, 5 months ago) by aloha
Branch: MAIN
Changes since 1.4: +87 -76 lines
File MIME type: text/x-csrc
emacs like keybind support (C-x C-s, C-w, C-q ...) But default emacs keybindings is unable to work currently (Because, I guess,  key press event such as C-x or C-a or C-s dispossessed by Window Manager or Gtk default input handler or something).

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.5 * $Id: shiki.c,v 1.4 2006/11/03 06:47:02 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 aloha 1.5 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
166     gtk_label_new("������������������������������������������\n��������������������������������������� ?"), TRUE, TRUE, 0);
167 aloha 1.1 gtk_window_set_title(GTK_WINDOW (dialog_window), "Really Quit ?");
168     /* YES ������������ */
169 aloha 1.5 yes_button = gtk_button_new_with_label("������ (Y)");
170 aloha 1.1 g_signal_connect(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(really_quit_dialog_yes), &flag);
171     g_signal_connect_swapped(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
172     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), yes_button, TRUE, TRUE, 0);
173    
174     /* NO ������������ */
175 aloha 1.5 no_button = gtk_button_new_with_label("��������� (N)");
176 aloha 1.1 g_signal_connect(GTK_OBJECT(no_button), "clicked", G_CALLBACK(really_quit_dialog_no), &flag);
177     g_signal_connect_swapped(GTK_OBJECT(no_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
178     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), no_button, TRUE, TRUE, 0);
179    
180     gtk_window_set_modal(GTK_WINDOW(dialog_window), TRUE);
181     gtk_window_set_transient_for(GTK_WINDOW(dialog_window), GTK_WINDOW (editor_window));
182    
183     gtk_widget_show_all(dialog_window);
184     gtk_main ();
185     dialog_window = NULL;
186    
187     /* "delete_event" ��������������� FALSE ���������"destory" ������������������window ������������������ */
188     return flag;
189     }
190     return TRUE;
191     }
192    
193     /* ������������������������������������������������������������������������������������������ */
194     gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, GtkWidget *buffer){
195     return not_yet_save_changes_really_quit(GTK_TEXT_BUFFER(buffer));
196     }
197    
198     /* ������������������������������ */
199     static GtkWidget *new_scrolled_text_buffer() {
200    
201     GtkWidget *scrolledwindow, *view;
202     GtkTextBuffer *buffer;
203    
204     /* ������������������������������������ */
205     scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
206     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
207    
208     /* ������������������������������������������������ */
209     view = gtk_text_view_new();
210     buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
211     gtk_container_add(GTK_CONTAINER(scrolledwindow), view);
212     g_signal_connect(G_OBJECT(editor_window), "delete_event", G_CALLBACK(delete_event_handler), buffer);
213     gtk_widget_set_size_request(GTK_WIDGET(view), 500, 500);
214    
215     /* ������������������������ */
216     /* ������������������������������������������������ */
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 aloha 1.5 //static gint metakey_pressed = 0;
445     static gint controlx_pressed = 0;
446 aloha 1.1 GtkTextIter start, end;
447    
448     /* ������������������������������������ */
449     gtk_text_buffer_get_start_iter(buffer, &start);
450     gtk_text_buffer_get_end_iter(buffer, &end);
451     gtk_text_buffer_remove_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
452    
453 aloha 1.5 /* C-x */
454     if(event->keyval == GDK_x && event->state & GDK_CONTROL_MASK) {
455     controlx_pressed++;
456     g_print("C-x ");
457     } else if(event->state & GDK_CONTROL_MASK) {
458     if(controlx_pressed > 0) {
459     g_print("C-%s\n", event->string);
460     switch(event->keyval) {
461     case GDK_c :/* C-x C-c : ������ */
462     {/* "delete-event" ��������������������������������������� �� ������������������������������������ */
463     GdkEvent ev;
464    
465     ev.any.type = GDK_DELETE;
466     ev.any.window = editor_window->window;
467     ev.any.send_event = FALSE;
468     gdk_event_put (&ev);
469     }
470     break;
471    
472     case GDK_f : /* C-x C-f : ������������������ */
473     open_file_from_notebook(GTK_NOTEBOOK(notebook));
474     g_print("C-f\n");
475     break;
476    
477     case GDK_s : /* C-x C-s : ������������������ */
478     save_file_from_notebook(GTK_NOTEBOOK(notebook));
479     break;
480    
481     case GDK_w : /* C-x C-w : ������������������������ */
482     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
483     break;
484     }
485     controlx_pressed = 0;
486     } else {
487     switch(event->keyval) {
488     case GDK_f : /* Ctrl + f : forward */
489     forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
490     break;
491     case GDK_b : /* Ctrl + b : backward */
492     backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
493     break;
494     case GDK_n : /* Ctrl + n : next line */
495     line_forward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
496     break;
497     case GDK_p : /* Ctrl + p : previous line */
498     line_backward_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
499     break;
500    
501     case GDK_j : /* Ctrl + j : ��������������������� S ������������ */
502     {
503     gchar *code;
504     GtkTextIter start, end;
505    
506     /* ������������������������������ */
507     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
508    
509     gtk_text_iter_backward_find_char(&end, is_kokka, NULL, NULL);
510     start = end;
511     gtk_text_iter_forward_char(&end);
512    
513     /* ��������������������������������� S ������������������ */
514     if(!search_sexp_string(&start)) return FALSE;
515    
516     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
517     gtk_text_buffer_insert(buffer, &end, "\n\n", -1);
518     gtk_text_buffer_insert(buffer, &end, eval_cstring_by_gauche(code), -1);
519     g_free(code);
520     }
521     break;
522    
523     case GDK_t : /* Ctrl + t : ��������������� */
524     gtk_notebook_append_page(GTK_NOTEBOOK(notebook), new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
525     gtk_widget_show_all(GTK_WIDGET(notebook));
526     break;
527    
528     case GDK_k : /* Ctrl + k : ������������������ */
529     remove_tabpage(GTK_NOTEBOOK(notebook));
530     break;
531     }
532 aloha 1.4 }
533 aloha 1.1 }
534     return FALSE;
535     }
536    
537     /* ��������������������� */
538     static gboolean signal_key_release_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
539    
540     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
541    
542     if(event->keyval == GDK_parenright && event->state & GDK_SHIFT_MASK) {
543     GtkTextIter start, end;
544    
545     /* ������������������������������ */
546     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
547    
548     start = end;
549     gtk_text_iter_backward_char(&start);
550    
551     /* ��������������������������������� S ������������������ */
552     if(!search_sexp_string(&start)) return FALSE;
553    
554     gtk_text_buffer_apply_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
555     }
556    
557     /* ������������������������������������������������������������������������������������������������ (���������������) ������������������ */
558     if(event->keyval == GDK_Return) {
559     gint indentWidth = get_parent_nest_level_at_cursor(buffer) * INDENT_WIDTH;
560     gchar *indent = g_strnfill(indentWidth, ' ');
561     gtk_text_buffer_insert_at_cursor(buffer, indent, -1);
562     g_free(indent);
563     }
564    
565     return FALSE;
566     }
567    
568     /* ��������������������������������������� */
569     static void editor_window_init() {
570     GtkWidget *vbox, *toolbar, *notebook;
571     GtkToolItem *icon;
572     GtkIconSize iconsize;
573 aloha 1.2 GtkTooltips *toolbar_tips = gtk_tooltips_new();
574 aloha 1.1 /* ��������������������������������������������������������������������������������� */
575     GtkToolItem *oicon, *sicon, *saicon, *eicon;
576    
577     /* ������������ */
578     editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
579     g_signal_connect(G_OBJECT(editor_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
580    
581     /* ������������������������������������ */
582     vbox = gtk_vbox_new(FALSE, 0);
583     /* ��������������������� */
584     toolbar = gtk_toolbar_new();
585     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
586    
587     notebook = gtk_notebook_new();
588     g_signal_connect(G_OBJECT(notebook), "switch-page", GTK_SIGNAL_FUNC(switch_page), NULL);
589    
590     /* ������������������������������������������������ */
591     gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
592     iconsize = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
593    
594     /* ������������������ */
595    
596     /* ������������������ */
597     oicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-open", iconsize), "");
598     /* ������������������������������������������������������������������������������������ */
599     g_signal_connect(G_OBJECT(oicon), "clicked", G_CALLBACK(open_file_handler), G_OBJECT(notebook));
600     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(oicon));
601 aloha 1.2 gtk_tool_item_set_tooltip(oicon, toolbar_tips, "���������������������������",
602     "���������������������������������������������������������������������������������������");
603 aloha 1.1
604     /* ������������������ */
605     sicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save", iconsize), "");
606     /* ������������������������������������������������������������������������������������ */
607     g_signal_connect(G_OBJECT(sicon), "clicked", G_CALLBACK(save_file_handler), G_OBJECT(notebook));
608     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(sicon));
609 aloha 1.2 gtk_tool_item_set_tooltip(sicon, toolbar_tips, "������������������������������",
610     "������������������������������������������������������������������������������������������������������������������������������������");
611 aloha 1.1
612     /* ��������������������������� */
613     saicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save-as", iconsize), "");
614     /* ������������������������������������������������������������������������������������������������������������������ */
615     g_signal_connect(G_OBJECT(saicon), "clicked", G_CALLBACK(save_file_as_handler), G_OBJECT(notebook));
616 aloha 1.2 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(saicon));
617     gtk_tool_item_set_tooltip(saicon, toolbar_tips, "������������������������������������",
618     "");
619 aloha 1.1
620    
621     /* ������������������ */
622     eicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-execute", iconsize), "");
623     /* ��������������������������������� libgauche ������������������ */
624     g_signal_connect(G_OBJECT(eicon), "clicked", G_CALLBACK(buffer_exec_handler), G_OBJECT(notebook));
625     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(eicon));
626 aloha 1.2 gtk_tool_item_set_tooltip(eicon, toolbar_tips, "��������������� S ���������������������",
627     "Scheme (gauche) ������������������ S ������������������������");
628 aloha 1.1
629     /* ������������������������������������������������ */
630     g_signal_connect(G_OBJECT(notebook), "key-press-event", G_CALLBACK (signal_key_press_handler), NULL);
631     g_signal_connect(G_OBJECT(notebook), "key-release-event", G_CALLBACK (signal_key_release_handler), NULL);
632     gtk_container_add(GTK_CONTAINER(editor_window), vbox);
633     gtk_container_add(GTK_CONTAINER(vbox), notebook);
634    
635     /* ������������������������������������ */
636     gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook),
637     new_scrolled_text_buffer(),
638     gtk_label_new("*scratch*"));
639    
640     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-apply", iconsize), "append");
641     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(tabsborder_on_off), G_OBJECT(notebook));
642     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
643 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "��������� on/off",
644     "");
645 aloha 1.1
646     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-preferences", iconsize), "append");
647     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(rotate_tab_position), G_OBJECT( notebook));
648     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
649 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "������������������������",
650     "");
651 aloha 1.1
652     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-add", iconsize), "append");
653     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(append_tabpage), G_OBJECT( notebook));
654     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
655 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������������",
656     "");
657 aloha 1.1
658     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-close", iconsize), "remove");
659     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(remove_tabpage_handler), G_OBJECT( notebook));
660     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
661 aloha 1.2 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������",
662     "���������������������������������������������������������������");
663 aloha 1.1
664 aloha 1.5 gtk_widget_grab_focus(notebook);
665 aloha 1.1 gtk_widget_show_all(editor_window);
666     }
667    
668     int main(int argc, char *argv[]) {
669     /* ������������������������������������ */
670     gtk_set_locale();
671     gtk_init(&argc, &argv);
672     GC_INIT(); Scm_Init(GAUCHE_SIGNATURE);
673     editor_window_init();
674     gtk_main();
675     Scm_Exit(0);
676     return 0;
677     }

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