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.1.1.1 - (hide annotations) (download) (as text) (vendor branch)
Thu Nov 2 12:07:44 2006 UTC (17 years, 5 months ago) by aloha
Branch: aloha
CVS Tags: start
Changes since 1.1: +0 -0 lines
File MIME type: text/x-csrc

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     * $Id$
26     */
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    
75     /* ������������������������������������������������������������������������������ */
76     static GtkTextBuffer* get_text_buffer_from_current_tabpage(GtkNotebook* notebook) {
77     gint pagenum = gtk_notebook_get_current_page(notebook);
78     GtkScrolledWindow *scrolledwindow = GTK_SCROLLED_WINDOW(gtk_notebook_get_nth_page(notebook, pagenum));
79     /* GtkBin ������������������������������������������������������������ */
80     GtkTextView *view = GTK_TEXT_VIEW(gtk_bin_get_child(GTK_BIN(scrolledwindow)));
81     return gtk_text_view_get_buffer(view);
82     }
83    
84     /* ��������������������������������������������������������������������������������� */
85    
86     /* ��������������������������������������������������������������������� */
87     static void save_file_from_notebook(GtkNotebook *notebook) {
88     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
89     gchar *filename;
90     gint current_page;
91    
92     /* ������������������������������������ */
93     if(!gtk_text_buffer_get_modified(buffer)) return;
94    
95     /* ��������������������������������������������������������������������������������� */
96     current_page = gtk_notebook_get_current_page(notebook);
97     filename = g_strdup(gtk_notebook_get_tab_label_text(notebook, gtk_notebook_get_nth_page(notebook, current_page)));
98    
99     /* ������������������������������������������������������������������������������������������������������ */
100     if(!filename || g_ascii_strcasecmp("*scratch*", filename) == 0) {
101     g_free(filename);
102     if(!save_text_buffer(filename = get_filename_from_dialog("Save File As ..."), buffer))
103     return;
104     } else
105     save_text_buffer(filename, buffer);
106    
107     gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook),
108     gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), current_page),
109     filename);
110     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
111     g_free(filename);
112     }
113    
114     /* ��������������������������������������������������� */
115     static void save_file_handler(GtkWidget *widget, GtkWidget *notebook) {
116     save_file_from_notebook(GTK_NOTEBOOK(notebook));
117     }
118    
119     /* ��������������������������������������������������������������������������� */
120     static void save_file_as_from_notebook(GtkNotebook *notebook) {
121     gint current_page;
122     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
123     gchar *filename = get_filename_from_dialog("Save File As ...");
124    
125     if(!save_text_buffer(filename, buffer)) return;
126    
127     current_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
128     gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(notebook),
129     gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), current_page),
130     filename);
131    
132     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
133    
134     g_free(filename);
135     }
136    
137     /* ��������������������������������������������������������� */
138     static void save_file_as_handler(GtkWidget *widget, GtkWidget *notebook) {
139     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
140     }
141    
142     /* YES ������������NO ������������������������������������ callback */
143     void really_quit_dialog_yes(GtkWidget *widget, gboolean *flag){*flag = FALSE;}
144     void really_quit_dialog_no(GtkWidget *widget, gint *flag){*flag = TRUE;}
145    
146     /* ��������������������������������������������� ? */
147     gboolean not_yet_save_changes_really_quit(GtkTextBuffer *buffer) {
148     GtkWidget *yes_button, *no_button;
149     static GtkWidget *dialog_window = NULL;
150    
151     /* ��������������������������������������� */
152     if(!gtk_text_buffer_get_modified(buffer)) return FALSE;
153    
154     if(dialog_window == NULL) {
155     gboolean flag = TRUE;
156     dialog_window = gtk_dialog_new ();
157    
158     /* ��������������������������������������������� ? ��������������������������� */
159     g_signal_connect(G_OBJECT(dialog_window), "delete_event", G_CALLBACK(gtk_false), NULL);
160     g_signal_connect(G_OBJECT(dialog_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
161    
162     gtk_window_set_title(GTK_WINDOW (dialog_window), "Really Quit ?");
163     /* YES ������������ */
164     yes_button = gtk_button_new_with_label("YES");
165     g_signal_connect(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(really_quit_dialog_yes), &flag);
166     g_signal_connect_swapped(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
167     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), yes_button, TRUE, TRUE, 0);
168    
169     /* NO ������������ */
170     no_button = gtk_button_new_with_label("NO");
171     g_signal_connect(GTK_OBJECT(no_button), "clicked", G_CALLBACK(really_quit_dialog_no), &flag);
172     g_signal_connect_swapped(GTK_OBJECT(no_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
173     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), no_button, TRUE, TRUE, 0);
174    
175     gtk_window_set_modal(GTK_WINDOW(dialog_window), TRUE);
176     gtk_window_set_transient_for(GTK_WINDOW(dialog_window), GTK_WINDOW (editor_window));
177    
178     gtk_widget_show_all(dialog_window);
179     gtk_main ();
180     dialog_window = NULL;
181    
182     /* "delete_event" ��������������� FALSE ���������"destory" ������������������window ������������������ */
183     return flag;
184     }
185     return TRUE;
186     }
187    
188     /* ������������������������������������������������������������������������������������������ */
189     gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, GtkWidget *buffer){
190     return not_yet_save_changes_really_quit(GTK_TEXT_BUFFER(buffer));
191     }
192    
193     /* ������������������������������ */
194     static GtkWidget *new_scrolled_text_buffer() {
195    
196     GtkWidget *scrolledwindow, *view;
197     GtkTextBuffer *buffer;
198    
199     /* ������������������������������������ */
200     scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
201     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
202    
203     /* ������������������������������������������������ */
204     view = gtk_text_view_new();
205     buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
206     gtk_container_add(GTK_CONTAINER(scrolledwindow), view);
207     g_signal_connect(G_OBJECT(editor_window), "delete_event", G_CALLBACK(delete_event_handler), buffer);
208     gtk_widget_set_size_request(GTK_WIDGET(view), 500, 500);
209    
210     /* ������������������������ */
211    
212     /* ������������������������������������������������ */
213     gtk_text_buffer_create_tag (buffer, "parent_emphasis_background", "background", "green", NULL);
214    
215     return scrolledwindow;
216     }
217    
218     /* ��������������������� */
219     static void open_file_from_notebook(GtkNotebook *notebook) {
220     gchar *contents, *text;
221     gsize br, bw, len;
222     GError *err = NULL;
223    
224     gchar *filename = get_filename_from_dialog("File Selection");
225    
226     if(!filename) return;
227    
228     if(g_file_get_contents(filename, &contents, &len, NULL)) {
229     GtkTextBuffer *buffer;
230     GtkWidget *scrolledwindow;
231     GtkTextIter p;
232    
233     /* ������������������������������ */
234     gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
235     scrolledwindow = new_scrolled_text_buffer(),
236     gtk_label_new(filename));
237     buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtk_bin_get_child(GTK_BIN(scrolledwindow))));
238    
239     if(!(text = g_locale_to_utf8(contents, -1, &br, &bw, &err)))
240     gtk_text_buffer_set_text(buffer, contents, len);
241     else
242     gtk_text_buffer_set_text(buffer, text, len);
243    
244     /* ������������������������ */
245     gtk_text_buffer_set_modified(buffer, FALSE);
246     /* ������������������������������ */
247     gtk_text_buffer_get_start_iter(buffer, &p);
248     gtk_text_buffer_place_cursor(buffer, &p);
249     gtk_window_set_title (GTK_WINDOW (editor_window), filename);
250     gtk_widget_show_all(GTK_WIDGET(notebook));
251     g_free(contents); g_free(text); g_free(filename);
252     } else
253     g_printerr("Get file contents error !\n");
254     }
255    
256     /* ��������������������������������������������� */
257     static void open_file_handler(GtkWidget *widget, GtkWidget *notebook) {
258     open_file_from_notebook(GTK_NOTEBOOK(notebook));
259     }
260    
261     /* gauche ��������������������������������� */
262     static gchar *eval_cstring_by_gauche(gchar *s) {
263     gchar *msg;
264    
265     ScmObj result, error;
266     /* ������������������������������ */
267     ScmObj os = Scm_MakeOutputStringPort(TRUE);
268    
269     /* Scheme ��������������������������������������� */
270     /* http://alohakun.blog7.fc2.com/blog-entry-517.html */
271     Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*input*")), SCM_MAKE_STR(s));
272     Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), SCM_FALSE);
273    
274     result = Scm_EvalCString("(guard (e (else (set! *error* e) #f)) (eval (read-from-string *input*) (current-module)))", SCM_OBJ(Scm_UserModule()));
275    
276     error = Scm_GlobalVariableRef(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), 0);
277    
278     /* ��������������������������������������������������������� */
279     if (!SCM_FALSEP(error))
280     Scm_Write(error, os, SCM_WRITE_DISPLAY);
281     else
282     Scm_Write(result, os, SCM_WRITE_DISPLAY);
283    
284     msg = Scm_GetString(SCM_STRING(Scm_GetOutputString(SCM_PORT(os))));
285     /* ������������������ */
286     Scm_ClosePort(SCM_PORT(os));
287    
288     return msg;
289     }
290    
291     /* ������������������������������������������������������������������������ S ������������ */
292     static void buffer_exec_handler(GtkWidget *widget, GtkWidget *notebook) {
293     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
294    
295     GtkTextIter start, end, p;
296     gchar *code;
297     gtk_text_buffer_get_end_iter(buffer, &p);
298     gtk_text_buffer_insert(buffer, &p, "\n\n", -1);
299    
300     /* ������������������������������������������������������������ */
301     if(gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) {
302     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
303     gtk_text_buffer_insert(buffer, &p, eval_cstring_by_gauche(code), -1);
304     g_free(code);
305     }
306    
307     }
308    
309     // GtkTextCharPredicate
310     static gboolean is_kakko_or_kokka(gunichar ch, gpointer p) {
311     return ch == '(' || ch == ')';
312     }
313     static gboolean is_kokka(gunichar ch, gpointer p) {return ch == ')';}
314    
315    
316     /* ')' ��������������� '(' ������������������ (S ���) ��������������� */
317     static gboolean search_sexp_string(GtkTextIter *start) {
318     gint nest_level = 0;
319     /* ��������������������������������� S ������������������ */
320     while(1) {
321     if(!gtk_text_iter_backward_find_char(start, is_kakko_or_kokka, NULL, NULL))
322     return FALSE;
323    
324     if(gtk_text_iter_get_char(start) == ')')
325     nest_level++;
326     else {
327     if(!nest_level)
328     break;
329     else
330     nest_level--;
331     }
332     }
333     return TRUE;
334     }
335    
336     /* ������������������������������������������������ */
337     static gint get_parent_nest_level_at_cursor(GtkTextBuffer *buffer) {
338     gint nest_level = 0;
339     GtkTextIter start, end;
340     gtk_text_buffer_get_start_iter(buffer, &start);
341     if(gtk_text_iter_get_char(&start) == '(') nest_level++;
342    
343     /* ��������������������� (= end) ��������� */
344     gtk_text_buffer_get_iter_at_mark(buffer,&end, gtk_text_buffer_get_insert(buffer));
345    
346     while(1) {
347     /* end ������ '(' ��� ')' ��������������������������������������������� */
348     if(!gtk_text_iter_forward_find_char(&start, is_kakko_or_kokka, NULL, &end))
349     return nest_level;
350    
351     if(gtk_text_iter_get_char(&start) == '(')
352     nest_level++;
353     else
354     nest_level--;
355     }
356     }
357    
358     /* ������������������������������������������������������������ */
359     static void switch_page(GtkNotebook *notebook, GtkNotebookPage *page, guint pagenum, gpointer p) {
360     /* ������������������������������������������������������ */
361     gtk_window_set_title (GTK_WINDOW(editor_window), gtk_notebook_get_tab_label_text(notebook, GTK_WIDGET(gtk_notebook_get_nth_page(notebook, pagenum))));
362     }
363    
364     /* ��������������������������������� on/off */
365     static void tabsborder_on_off(GtkButton *button, GtkNotebook *notebook) {
366     gint tval = FALSE;
367     gint bval = FALSE;
368     if(notebook->show_tabs == FALSE)
369     tval = TRUE;
370     if(notebook->show_border == FALSE)
371     bval = TRUE;
372    
373     gtk_notebook_set_show_tabs(notebook, tval);
374     gtk_notebook_set_show_border(notebook, bval);
375     }
376    
377     /* ������������������������������������������ */
378     static void remove_tabpage(GtkNotebook *notebook) {
379     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(notebook);
380     if(!not_yet_save_changes_really_quit(buffer)) {
381     gint page = gtk_notebook_get_current_page(notebook);
382     gtk_notebook_remove_page(notebook, page);
383     /* ��������������������������������������� */
384     gtk_widget_queue_draw(GTK_WIDGET(notebook));
385     }
386     }
387    
388     static void remove_tabpage_handler(GtkButton *button, GtkWidget *notebook) {
389     remove_tabpage(GTK_NOTEBOOK(notebook));
390     }
391    
392     /* ������������������������������������������������ */
393     static void append_tabpage(GtkButton *button, GtkNotebook *notebook) {
394     gtk_notebook_append_page(notebook, new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
395     gtk_widget_show_all(GTK_WIDGET(notebook));
396     }
397    
398     /* ������������������������ */
399     static void rotate_tab_position(GtkButton *button, GtkNotebook *notebook ) {
400     gtk_notebook_set_tab_pos(notebook, (notebook->tab_pos + 1) % 4);
401     }
402    
403     /* ������������������������������������������ */
404    
405     /* ��������������������� */
406     static gboolean signal_key_press_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
407     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
408    
409     GtkTextIter start, end;
410    
411     /* ������������������������������������ */
412     gtk_text_buffer_get_start_iter(buffer, &start);
413     gtk_text_buffer_get_end_iter(buffer, &end);
414     gtk_text_buffer_remove_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
415    
416     /* Ctrl + j : ��������������������� S ������������ */
417     if(event->keyval == GDK_j && event->state & GDK_CONTROL_MASK) {
418     gchar *code;
419     GtkTextIter start, end;
420    
421     /* ������������������������������ */
422     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
423    
424     gtk_text_iter_backward_find_char(&end, is_kokka, NULL, NULL);
425     start = end;
426     gtk_text_iter_forward_char(&end);
427    
428     /* ��������������������������������� S ������������������ */
429     if(!search_sexp_string(&start)) return FALSE;
430    
431     code = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
432     gtk_text_buffer_insert(buffer, &end, "\n\n", -1);
433     gtk_text_buffer_insert(buffer, &end, eval_cstring_by_gauche(code), -1);
434     g_free(code);
435     }
436    
437     /* Ctrl + O : ������������������ */
438     if(event->keyval == GDK_O && event->state & GDK_CONTROL_MASK) {
439     open_file_from_notebook(GTK_NOTEBOOK(notebook));
440     }
441    
442     /* Ctrl + s : ������������������ */
443     if(event->keyval == GDK_s && event->state & GDK_CONTROL_MASK) {
444     save_file_from_notebook(GTK_NOTEBOOK(notebook));
445     }
446    
447     /* Ctrl + w : ������������������������ */
448     if(event->keyval == GDK_w && event->state & GDK_CONTROL_MASK) {
449     save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
450     }
451    
452     /* Ctrl + t : ��������������� */
453     if(event->keyval == GDK_t && event->state & GDK_CONTROL_MASK) {
454     gtk_notebook_append_page(GTK_NOTEBOOK(notebook), new_scrolled_text_buffer(), gtk_label_new("*scratch*"));
455     gtk_widget_show_all(GTK_WIDGET(notebook));
456     }
457    
458     /* Ctrl + c : ������������������ */
459     if(event->keyval == GDK_C && event->state & GDK_CONTROL_MASK) {
460     remove_tabpage(GTK_NOTEBOOK(notebook));
461     }
462    
463     /* Ctrl + q : ������ */
464     if(event->keyval == GDK_q && event->state & GDK_CONTROL_MASK) {
465     /* "delete-event" ��������������������������������������� �� ������������������������������������ */
466     GdkEvent ev;
467    
468     ev.any.type = GDK_DELETE;
469     ev.any.window = editor_window->window;
470     ev.any.send_event = FALSE;
471     gdk_event_put (&ev);
472     }
473    
474     return FALSE;
475     }
476    
477     /* ��������������������� */
478     static gboolean signal_key_release_handler (GtkWidget *notebook, GdkEventKey *event, gpointer p) {
479    
480     GtkTextBuffer *buffer = get_text_buffer_from_current_tabpage(GTK_NOTEBOOK(notebook));
481    
482     if(event->keyval == GDK_parenright && event->state & GDK_SHIFT_MASK) {
483     GtkTextIter start, end;
484    
485     /* ������������������������������ */
486     gtk_text_buffer_get_iter_at_mark(buffer, &end, gtk_text_buffer_get_insert(buffer));
487    
488     start = end;
489     gtk_text_iter_backward_char(&start);
490    
491     /* ��������������������������������� S ������������������ */
492     if(!search_sexp_string(&start)) return FALSE;
493    
494     gtk_text_buffer_apply_tag_by_name(buffer, "parent_emphasis_background", &start, &end);
495     }
496    
497     /* ������������������������������������������������������������������������������������������������ (���������������) ������������������ */
498     if(event->keyval == GDK_Return) {
499     gint indentWidth = get_parent_nest_level_at_cursor(buffer) * INDENT_WIDTH;
500     gchar *indent = g_strnfill(indentWidth, ' ');
501     gtk_text_buffer_insert_at_cursor(buffer, indent, -1);
502     g_free(indent);
503     }
504    
505     return FALSE;
506     }
507    
508     /* ��������������������������������������� */
509     static void editor_window_init() {
510     GtkWidget *vbox, *toolbar, *notebook;
511     GtkToolItem *icon;
512     GtkIconSize iconsize;
513     /* ��������������������������������������������������������������������������������� */
514     GtkToolItem *oicon, *sicon, *saicon, *eicon;
515    
516     /* ������������ */
517     editor_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
518     g_signal_connect(G_OBJECT(editor_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
519    
520     /* ������������������������������������ */
521     vbox = gtk_vbox_new(FALSE, 0);
522     /* ��������������������� */
523     toolbar = gtk_toolbar_new();
524     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
525    
526     notebook = gtk_notebook_new();
527     g_signal_connect(G_OBJECT(notebook), "switch-page", GTK_SIGNAL_FUNC(switch_page), NULL);
528    
529     /* ������������������������������������������������ */
530     gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
531     iconsize = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
532    
533     /* ������������������ */
534    
535     /* ������������������ */
536     oicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-open", iconsize), "");
537     /* ������������������������������������������������������������������������������������ */
538     g_signal_connect(G_OBJECT(oicon), "clicked", G_CALLBACK(open_file_handler), G_OBJECT(notebook));
539     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(oicon));
540    
541     /* ������������������ */
542     sicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save", iconsize), "");
543     /* ������������������������������������������������������������������������������������ */
544     g_signal_connect(G_OBJECT(sicon), "clicked", G_CALLBACK(save_file_handler), G_OBJECT(notebook));
545     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(sicon));
546    
547     /* ��������������������������� */
548     saicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save-as", iconsize), "");
549     /* ������������������������������������������������������������������������������������������������������������������ */
550     g_signal_connect(G_OBJECT(saicon), "clicked", G_CALLBACK(save_file_as_handler), G_OBJECT(notebook));
551    
552     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(saicon));
553    
554     /* ������������������ */
555     eicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-execute", iconsize), "");
556     /* ��������������������������������� libgauche ������������������ */
557     g_signal_connect(G_OBJECT(eicon), "clicked", G_CALLBACK(buffer_exec_handler), G_OBJECT(notebook));
558     gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(eicon));
559    
560     /* ������������������������������������������������ */
561     g_signal_connect(G_OBJECT(notebook), "key-press-event", G_CALLBACK (signal_key_press_handler), NULL);
562     g_signal_connect(G_OBJECT(notebook), "key-release-event", G_CALLBACK (signal_key_release_handler), NULL);
563     gtk_container_add(GTK_CONTAINER(editor_window), vbox);
564     gtk_container_add(GTK_CONTAINER(vbox), notebook);
565    
566     /* ������������������������������������ */
567     gtk_notebook_prepend_page(GTK_NOTEBOOK(notebook),
568     new_scrolled_text_buffer(),
569     gtk_label_new("*scratch*"));
570    
571     /* ��������� on/off */
572     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-apply", iconsize), "append");
573     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(tabsborder_on_off), G_OBJECT(notebook));
574     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
575    
576     /* ��������������� */
577     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-preferences", iconsize), "append");
578     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(rotate_tab_position), G_OBJECT( notebook));
579     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
580    
581     /* ��������������� */
582     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-add", iconsize), "append");
583     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(append_tabpage), G_OBJECT( notebook));
584     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
585    
586     /* ��������������������������������������������� */
587     icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-close", iconsize), "remove");
588     g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(remove_tabpage_handler), G_OBJECT( notebook));
589     gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
590    
591     gtk_widget_show_all(editor_window);
592     }
593    
594     int main(int argc, char *argv[]) {
595     /* ������������������������������������ */
596     gtk_set_locale();
597     gtk_init(&argc, &argv);
598     GC_INIT(); Scm_Init(GAUCHE_SIGNATURE);
599     editor_window_init();
600     gtk_main();
601     Scm_Exit(0);
602     return 0;
603     }

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