Develop and Download Open Source Software

Browse CVS Repository

Contents of /shiki/shiki/shiki.c

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


Revision 1.24 - (show annotations) (download) (as text)
Mon Nov 13 17:26:57 2006 UTC (17 years, 4 months ago) by aloha
Branch: MAIN
Changes since 1.23: +27 -33 lines
File MIME type: text/x-csrc
refactoring append_tabpage() (thanks tkng-san)

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: shiki.c,v 1.23 2006/11/13 16:52:56 aloha Exp $
26 */
27
28 #include<gauche.h>
29 #include<gtk/gtk.h>
30 #include<gdk/gdkkeysyms.h>
31
32 static gint editor_indent_width = 2;
33
34 /* ��������������������������������������������� */
35 typedef struct {
36 GtkScrolledWindow *tabpage; /* ������ */
37 gchar *tabpage_label; /* ��������� (���������������) ������ */
38 GtkTextView *text_view; /* ��������������� */
39 GtkTextBuffer *text_buffer; /* ��������������������������������� */
40 gchar *filename; /* ������������������������������ */
41 ScmObj env; /* ��������������������������� Scheme ������ */
42 guint delete_handler_id; /* ��������������������������������������������� ID */
43 } ShikiTabInfo;
44
45 /* ������������������������������������������������������������������������������������������������������������������������������ */
46 struct {
47 GtkWidget *editor_window;
48 GtkWidget *statusbar;
49 GtkWidget *modeline_label;
50 GList *tabInfoList;
51 gint current_tabpage_num;
52 ShikiTabInfo *current_tabpage_info;
53 } shiki_editor;
54
55 #define Shiki_EDITOR_WINDOW shiki_editor.editor_window
56 #define Shiki_EDITOR_STATUSBAR shiki_editor.statusbar
57 #define Shiki_EDITOR_MODELINE_LABEL shiki_editor.modeline_label
58 #define Shiki_EDITOR_TAB_INFO_LIST shiki_editor.tabInfoList
59 #define Shiki_CURRENT_TAB_NUM shiki_editor.current_tabpage_num
60 #define Shiki_CURRENT_TAB_INFO shiki_editor.current_tabpage_info
61 #define Shiki_CURRENT_TAB (shiki_editor.current_tabpage_info)->tabpage
62 #define Shiki_CURRENT_TAB_TITLE (shiki_editor.current_tabpage_info)->tabpage_label
63 #define Shiki_CURRENT_TEXT_VIEW (shiki_editor.current_tabpage_info)->text_view
64 #define Shiki_CURRENT_TEXT_BUFFER (shiki_editor.current_tabpage_info)->text_buffer
65 #define Shiki_CURRENT_FILENAME (shiki_editor.current_tabpage_info)->filename
66 #define Shiki_CURRENT_SCHEME_ENV (shiki_editor.current_tabpage_info)->env
67
68 /* ������������������ */
69 static void clear_current_buffer();
70 static void load_buffer_by_gauche();
71 static void load_scheme_file_by_gauche(GtkNotebook *notebook);
72 static gchar *load_cstring_by_gauche(gchar *s);
73 static void font_selection_ok(GtkWidget *button, GtkWidget *font_dialog);
74 static void select_font();
75 static void about_this_application();
76 static gint get_current_line_number(GtkTextBuffer *buffer);
77 static void update_modeline_label();
78 static void text_buffer_cursor_moved_handler();
79 static gchar* get_all_buffer_contents(GtkTextBuffer *buffer);
80 static gboolean save_text_buffer(const gchar *filename, GtkTextBuffer *buffer);
81 static gchar *get_filename_from_dialog(const gchar *msg);
82 static void save_file_from_notebook(GtkNotebook *notebook);
83 static void save_file_handler(GtkWidget *widget, GtkWidget *notebook);
84 static void save_file_as_from_notebook(GtkNotebook *notebook);
85 static void save_file_as_handler(GtkWidget *widget, GtkWidget *notebook);
86 static void really_quit_dialog_yes(GtkWidget *widget, gboolean *flag);
87 static void really_quit_dialog_no(GtkWidget *widget, gint *flag);
88 static gboolean not_yet_save_changes_really_quit(GtkTextBuffer *buffer);
89 static gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, GtkWidget *buffer);
90 static void open_file(GtkNotebook *notebook, gchar *filename);
91 static void open_file_from_notebook(GtkNotebook *notebook);
92 static void open_file_handler(GtkWidget *widget, GtkWidget *notebook);
93 static gchar *eval_cstring_by_gauche(gchar *s);
94 static void load_region_handler(GtkWidget *widget, GtkWidget *notebook);
95 static gboolean is_kakko_or_kokka(gunichar ch, gpointer);
96 static gboolean is_kokka(gunichar ch, gpointer);
97 static gboolean search_sexp_string(GtkTextIter *start);
98 static gint get_parent_nest_level_at_cursor(GtkTextBuffer *buffer);
99 static void switch_tabpage_handler(GtkNotebook *notebook, GtkNotebookPage *page, guint pagenum) ;
100 static void tabsborder_on_off(GtkButton *button, GtkNotebook *notebook);
101 static void remove_tabpage_handler(GtkButton *button, GtkWidget *notebook);
102 static void append_tabpage_handler(GtkButton *button, GtkNotebook *notebook);
103 static void rotate_tab_position(GtkButton *button, GtkNotebook *notebook);
104 static void forward_current_buffer();
105 static void backward_current_buffer();
106 static void line_forward_current_buffer();
107 static void line_backward_current_buffer();
108 static gboolean signal_key_press_handler(GtkWidget *notebook, GdkEventKey *event, gpointer contextid);
109 static gboolean signal_key_release_handler(GtkWidget *notebook, GdkEventKey *event, gpointer contextid);
110 static void open_online_help(GtkNotebook *notebook);
111 static void online_help_handler(GtkWidget *button, GtkNotebook *notebook);
112 static void shiki_editor_window_init(int argc, char **argv);
113
114
115 /* ������������������������ : ���������������ShikiTabInfo ������������������������������������������������������������������ 2 ������������������������������������������ (������������������) */
116 static void append_tabpage(GtkNotebook *notebook, gchar *filename);
117 static void remove_tabpage(GtkNotebook *notebook);
118
119 /* ��������������������������������������� (������������) ��������� */
120 static void append_tabpage(GtkNotebook *notebook, gchar *filename) {
121 /*-------------------- ������������������������ ----------------------------------*/
122 /* ShikiTabInfo ������������������������������������������������������������������ */
123 ShikiTabInfo *tabinfo = g_malloc(sizeof(ShikiTabInfo));
124 tabinfo->filename = filename;
125 tabinfo->tabpage_label = g_path_get_basename(filename);
126
127 /* ������������������������������ (������������������������) ��������� */
128 tabinfo->tabpage = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
129 gtk_scrolled_window_set_policy (tabinfo->tabpage, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
130
131 /* ��������������������������������������������������������������������������������������� */
132 tabinfo->text_view = GTK_TEXT_VIEW(gtk_text_view_new());
133 tabinfo->text_buffer = gtk_text_view_get_buffer(tabinfo->text_view);
134 gtk_container_add(GTK_CONTAINER(tabinfo->tabpage), GTK_WIDGET(tabinfo->text_view));
135 gtk_widget_set_size_request(GTK_WIDGET(tabinfo->text_view), 500, 500);
136 g_signal_connect(tabinfo->text_buffer, "mark_set", G_CALLBACK(text_buffer_cursor_moved_handler), tabinfo->text_view);
137 /* ������������������������������������������������������������������������������������������������������ */
138 tabinfo->delete_handler_id = g_signal_connect(Shiki_EDITOR_WINDOW, "delete_event", G_CALLBACK(delete_event_handler), tabinfo->text_buffer);
139 /* ������������������������ */
140 /* ������������������������������������������������ */
141 gtk_text_buffer_create_tag (tabinfo->text_buffer, "parent_emphasis_background", "background", "green", NULL);
142
143 /* ������������������������������������������ */
144 gtk_notebook_append_page(notebook, GTK_WIDGET(tabinfo->tabpage), gtk_label_new(tabinfo->tabpage_label));
145 /* ������������������������������������������������������������������ */
146 Shiki_EDITOR_TAB_INFO_LIST = g_list_append(Shiki_EDITOR_TAB_INFO_LIST, tabinfo);
147 gtk_widget_show_all(GTK_WIDGET(notebook));
148 /* ��������������������������������� */
149 gtk_notebook_set_current_page(notebook, g_list_length(Shiki_EDITOR_TAB_INFO_LIST) - 1);
150 }
151
152 /* ������������������������������������������ (������������) ��������� */
153 static void remove_tabpage(GtkNotebook *notebook) {
154 /* ��������� 1 ��������������������������������������������������� */
155 if(g_list_length(Shiki_EDITOR_TAB_INFO_LIST) == 1)
156 return;
157 if(!not_yet_save_changes_really_quit(Shiki_CURRENT_TEXT_BUFFER)) {
158 /* ��������������������������������������������������������������������������������������������� */
159 g_signal_handler_disconnect(Shiki_EDITOR_WINDOW, (Shiki_CURRENT_TAB_INFO)->delete_handler_id);
160 /* ������������������������ */
161 gtk_widget_destroy(GTK_WIDGET(Shiki_CURRENT_TEXT_VIEW));
162 /* ������������������������������������������ */
163 g_free(Shiki_CURRENT_TAB_TITLE);
164 g_free(Shiki_CURRENT_FILENAME);
165 Shiki_EDITOR_TAB_INFO_LIST = g_list_delete_link(Shiki_EDITOR_TAB_INFO_LIST, g_list_nth(Shiki_EDITOR_TAB_INFO_LIST, Shiki_CURRENT_TAB_NUM));
166 g_free(Shiki_CURRENT_TAB_INFO);
167
168 /* ������������������������������������ */
169 Shiki_CURRENT_TAB_INFO = g_list_nth_data(Shiki_EDITOR_TAB_INFO_LIST, Shiki_CURRENT_TAB_NUM);
170 gtk_notebook_remove_page(notebook, Shiki_CURRENT_TAB_NUM);
171 /* ��������������������������������������� */
172 gtk_widget_queue_draw(GTK_WIDGET(notebook));
173 }
174 }
175
176
177 /* ������������������������������ */
178 static void clear_current_buffer() {
179 GtkTextIter start, end;
180 gtk_text_buffer_get_start_iter(Shiki_CURRENT_TEXT_BUFFER, &start);
181 gtk_text_buffer_get_end_iter(Shiki_CURRENT_TEXT_BUFFER, &end);
182 gtk_text_buffer_delete(Shiki_CURRENT_TEXT_BUFFER, &start, &end);
183 }
184
185 /* ������������������������������������ */
186 static void load_buffer_by_gauche() {
187 GtkTextIter p;
188 gtk_text_buffer_get_end_iter(Shiki_CURRENT_TEXT_BUFFER, &p);
189 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, "\n\n", -1);
190 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, load_cstring_by_gauche(get_all_buffer_contents(Shiki_CURRENT_TEXT_BUFFER)), -1);
191 }
192
193 /* ������������������������ */
194 static void load_scheme_file_by_gauche(GtkNotebook *notebook) {
195 gchar *contents, *text;
196 gsize br, bw, len;
197 GError *err = NULL;
198 gchar *filename = get_filename_from_dialog("File Selection");
199 GtkTextIter p;
200
201 if(!filename) return;
202
203 gtk_text_buffer_get_end_iter(Shiki_CURRENT_TEXT_BUFFER, &p);
204 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, "\n\n", -1);
205
206 if(g_file_get_contents(filename, &contents, &len, NULL)) {
207 if(!(text = g_locale_to_utf8(contents, -1, &br, &bw, &err)))
208 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, load_cstring_by_gauche(text), -1);
209 else
210 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, load_cstring_by_gauche(contents), -1);
211 }
212 g_free(text); g_free(contents); g_free(filename);
213 }
214
215 /* gauche ������������������������������������ */
216 static gchar *load_cstring_by_gauche(gchar *s) {
217 gchar *msg;
218
219 ScmObj result, error;
220 /* ��������������������������������� */
221 ScmObj is = Scm_MakeInputStringPort(SCM_STRING(SCM_MAKE_STR(s)), TRUE);
222 /* ������������������������������ */
223 ScmObj os = Scm_MakeOutputStringPort(TRUE);
224
225 Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*input*")), is);
226 Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), SCM_FALSE);
227 /* Scheme ��������������������������������������������������������������������������������� S ��������������������������������������������������������������������������� *error* ������������������ */
228 result = Scm_EvalCString("(guard (e (else (set! *error* e) #f)) (eval (load-from-port *input*) (current-module)))", SCM_OBJ(Scm_UserModule()));
229
230 error = Scm_GlobalVariableRef(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), 0);
231
232 /* ��������������������������������������������������������� */
233 if (!SCM_FALSEP(error))
234 Scm_Write(error, os, SCM_WRITE_DISPLAY);
235 else
236 Scm_Write(result, os, SCM_WRITE_DISPLAY);
237
238 msg = Scm_GetString(SCM_STRING(Scm_GetOutputString(SCM_PORT(os))));
239 /* ������������������ */
240 Scm_ClosePort(SCM_PORT(is));
241 Scm_ClosePort(SCM_PORT(os));
242
243 return msg;
244 }
245
246 static void font_selection_ok(GtkWidget *button, GtkWidget *font_dialog) {
247 gchar *font_name = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG (font_dialog));
248 if(font_name) {
249 GtkRcStyle *style = gtk_rc_style_new ();
250 pango_font_description_free(style->font_desc);
251 style->font_desc = pango_font_description_from_string(font_name);
252 gtk_widget_modify_style (GTK_WIDGET(Shiki_CURRENT_TEXT_VIEW), style);
253 g_free (font_name);
254 }
255 }
256
257 /* ������������������������������������������������������ */
258 static void select_font(){
259 GtkWidget *font_dialog = gtk_font_selection_dialog_new("Font Selection Dialog");
260 g_signal_connect (GTK_FONT_SELECTION_DIALOG (font_dialog)->ok_button, "clicked", G_CALLBACK(font_selection_ok), font_dialog);
261 gtk_dialog_run(GTK_DIALOG(font_dialog));
262 gtk_widget_destroy(font_dialog);
263 }
264
265 /* ������������������������������������������ */
266 static void about_this_application() {
267 GtkAboutDialog *about = GTK_ABOUT_DIALOG(gtk_about_dialog_new());
268 const gchar *authors[] = {
269 "������������ (���������) <alohakun@gmail.com>\n",
270 "Contribute : tkng ������",
271 "(http://d.hatena.ne.jp/tkng/20061113)", NULL
272 };
273 gtk_about_dialog_set_authors(about, authors);
274 gtk_about_dialog_set_copyright(about, "Copyright(C)2006 WAKATSUKI Toshihiro");
275 gtk_about_dialog_set_name(about, "��� (SHIKI)");
276 gtk_about_dialog_set_website_label(about, "���������30������������������������������������������������������������Blog");
277 gtk_about_dialog_set_website(about, "http://alohakun.blog7.fc2.com/blog-category-29.html");
278 gtk_dialog_run(GTK_DIALOG(about));
279 gtk_widget_destroy(GTK_WIDGET(about));
280 }
281
282 /* ��������������������������������������������������������������� */
283 static gint get_current_line_number(GtkTextBuffer *b) {
284 GtkTextIter p;
285 gtk_text_buffer_get_iter_at_mark(b, &p, gtk_text_buffer_get_insert(b));
286 return gtk_text_iter_get_line(&p) + 1;
287 }
288
289 /* ��������������������������������������������������������������� */
290 static void update_modeline_label() {
291 gchar* basename = g_path_get_basename(Shiki_CURRENT_TAB_TITLE);
292 gchar* l = g_strdup_printf("-E:%s %-10s (Gauche Interaction)--L%d--------------------------------------",
293 gtk_text_buffer_get_modified(Shiki_CURRENT_TEXT_BUFFER) ? "**" : "--",
294 basename, get_current_line_number(Shiki_CURRENT_TEXT_BUFFER));
295 gtk_label_set_text(GTK_LABEL(Shiki_EDITOR_MODELINE_LABEL), l);
296 g_free(l); g_free(basename);
297 }
298
299 static void text_buffer_cursor_moved_handler(){
300 update_modeline_label();
301 }
302
303 /* ��������������������������������������������������������������� */
304 static gchar* get_all_buffer_contents(GtkTextBuffer *buffer) {
305 GtkTextIter start, end;
306 gtk_text_buffer_get_start_iter(buffer, &start);
307 gtk_text_buffer_get_end_iter(buffer, &end);
308 return gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
309 }
310
311 /* buffer ������������������������ filename ��������� */
312 static gboolean save_text_buffer(const gchar *filename, GtkTextBuffer *buffer) {
313 gchar *contents, *text;
314 gsize br, bw;
315 GError *err = NULL;
316
317 if(!filename) return FALSE;
318 contents = get_all_buffer_contents(buffer);
319 text = g_locale_from_utf8(contents, -1, &br, &bw, &err);
320 /* ��������������������������������� */
321 g_file_set_contents(filename, text, -1, NULL);
322 gtk_text_buffer_set_modified(buffer, FALSE);
323 update_modeline_label();
324 g_free(contents); g_free(text);
325 return TRUE;
326 }
327
328 /* ������������������������������������������������������msg ������������������������������������ */
329 static gchar *get_filename_from_dialog(const gchar *msg) {
330
331 GtkWidget *dialog = gtk_file_selection_new(msg);
332 int resp = gtk_dialog_run(GTK_DIALOG(dialog));
333 gchar *filename = NULL;
334
335 /* gtk_file_selection_get_filename ������������������������������������������������������������������������������������������������������������������������������ */
336 if(resp == GTK_RESPONSE_OK)
337 filename = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION(dialog)));
338
339 gtk_widget_destroy(dialog);
340 return filename;
341 }
342
343 /* ��������������������������������������������������������������������� */
344 static void save_file_from_notebook(GtkNotebook *notebook) {
345
346 /* ��������������������������������������� */
347 if(g_ascii_strcasecmp("*help*", Shiki_CURRENT_TAB_TITLE) == 0) return;
348
349 /* ������������������������������������ */
350 if(!gtk_text_buffer_get_modified(Shiki_CURRENT_TEXT_BUFFER)) return;
351
352 /* ������������������������������������������������������������������������������������������������������ */
353 if(g_ascii_strcasecmp("*scratch*", Shiki_CURRENT_TAB_TITLE) == 0) {
354 gchar *filename = get_filename_from_dialog("Save File As ...");
355 if(!filename) return;
356 if(!save_text_buffer(filename, Shiki_CURRENT_TEXT_BUFFER)) return;
357 gtk_notebook_set_tab_label_text(notebook, GTK_WIDGET(Shiki_CURRENT_TAB), filename);
358 gtk_window_set_title (GTK_WINDOW(Shiki_EDITOR_WINDOW), filename);
359 g_free(filename);
360 } else
361 save_text_buffer(Shiki_CURRENT_TAB_TITLE, Shiki_CURRENT_TEXT_BUFFER);
362 }
363
364 /* ��������������������������������������������������� */
365 static void save_file_handler(GtkWidget *widget, GtkWidget *notebook) {
366 save_file_from_notebook(GTK_NOTEBOOK(notebook));
367 }
368
369 /* ��������������������������������������������������������������������������� */
370 static void save_file_as_from_notebook(GtkNotebook *notebook) {
371 gchar *filename = get_filename_from_dialog("Save File As ...");
372
373 if(!filename) return;
374 if(!save_text_buffer(filename, Shiki_CURRENT_TEXT_BUFFER)) return;
375
376 gtk_notebook_set_tab_label_text(notebook, GTK_WIDGET(Shiki_CURRENT_TAB), filename);
377 gtk_window_set_title (GTK_WINDOW (Shiki_EDITOR_WINDOW), filename);
378
379 g_free(filename);
380 }
381
382 /* ��������������������������������������������������������� */
383 static void save_file_as_handler(GtkWidget *widget, GtkWidget *notebook) {
384 save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
385 }
386
387 /* YES ������������NO ������������������������������������ callback */
388 static void really_quit_dialog_yes(GtkWidget *widget, gboolean *flag){*flag = FALSE;}
389 static void really_quit_dialog_no(GtkWidget *widget, gint *flag){*flag = TRUE;}
390
391 /* ��������������������������������������������� ? */
392 static gboolean not_yet_save_changes_really_quit(GtkTextBuffer *buffer) {
393 GtkWidget *yes_button, *no_button;
394 static GtkWidget *dialog_window = NULL;
395
396 /* ��������������������������������������� */
397 if(!gtk_text_buffer_get_modified(buffer)) return FALSE;
398
399 if(dialog_window == NULL) {
400 gboolean flag = TRUE;
401 dialog_window = gtk_dialog_new ();
402
403 /* ��������������������������������������������� ? ��������������������������� */
404 g_signal_connect(G_OBJECT(dialog_window), "delete_event", G_CALLBACK(gtk_false), NULL);
405 g_signal_connect(G_OBJECT(dialog_window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
406 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
407 gtk_label_new("������������������������������������������\n��������������������������������������� ?"), TRUE, TRUE, 0);
408 gtk_window_set_title(GTK_WINDOW (dialog_window), "Really Quit ?");
409 /* YES ������������ */
410 yes_button = gtk_button_new_with_mnemonic("������ (_Y)");
411 g_signal_connect(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(really_quit_dialog_yes), &flag);
412 g_signal_connect_swapped(GTK_OBJECT(yes_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
413 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), yes_button, TRUE, TRUE, 0);
414
415 /* NO ������������ */
416 no_button = gtk_button_new_with_mnemonic("��������� (_N)");
417 g_signal_connect(GTK_OBJECT(no_button), "clicked", G_CALLBACK(really_quit_dialog_no), &flag);
418 g_signal_connect_swapped(GTK_OBJECT(no_button), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(dialog_window));
419 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog_window)->action_area), no_button, TRUE, TRUE, 0);
420
421 gtk_window_set_modal(GTK_WINDOW(dialog_window), TRUE);
422 gtk_window_set_transient_for(GTK_WINDOW(dialog_window), GTK_WINDOW (Shiki_EDITOR_WINDOW));
423
424 gtk_widget_show_all(dialog_window);
425 gtk_main ();
426 dialog_window = NULL;
427
428 /* "delete_event" ��������������� FALSE ���������"destory" ������������������window ������������������ */
429 return flag;
430 }
431 return TRUE;
432 }
433
434 /* ������������������������������������������������������������������������������������������ */
435 static gboolean delete_event_handler(GtkWidget *widget, GdkEvent *event, GtkWidget *buffer){
436 return not_yet_save_changes_really_quit(GTK_TEXT_BUFFER(buffer));
437 }
438
439 /* ��������������������� */
440 static void open_file(GtkNotebook *notebook, gchar *filename) {
441 gchar *contents, *text;
442 gsize br, bw, len;
443 GError *err = NULL;
444
445 if(g_file_get_contents(filename, &contents, &len, NULL)) {
446 GtkTextIter p;
447
448 /* ������������������������������ */
449 append_tabpage(notebook, g_strdup(filename));
450
451 if(!(text = g_locale_to_utf8(contents, -1, &br, &bw, &err)))
452 gtk_text_buffer_set_text(Shiki_CURRENT_TEXT_BUFFER, contents, len);
453 else
454 gtk_text_buffer_set_text(Shiki_CURRENT_TEXT_BUFFER, text, len);
455
456 /* ������������������������ */
457 gtk_text_buffer_set_modified(Shiki_CURRENT_TEXT_BUFFER, FALSE);
458 /* ������������������������������ */
459 gtk_text_buffer_get_start_iter(Shiki_CURRENT_TEXT_BUFFER, &p);
460 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
461 update_modeline_label();
462 gtk_window_set_title (GTK_WINDOW (Shiki_EDITOR_WINDOW), filename);
463 gtk_widget_show_all(GTK_WIDGET(notebook));
464 g_free(contents); g_free(text); g_free(filename);
465 } else
466 g_printerr("Get file contents error !\n");
467 }
468
469 /* ��������������������������������������������������� */
470 static void open_file_from_notebook(GtkNotebook *notebook) {
471 gchar *filename = get_filename_from_dialog("File Selection");
472
473 if(!filename) return;
474 open_file(notebook, filename);
475 }
476
477 /* ��������������������������������������������� */
478 static void open_file_handler(GtkWidget *widget, GtkWidget *notebook) {
479 open_file_from_notebook(GTK_NOTEBOOK(notebook));
480 }
481
482 /* gauche ��������������������������������� */
483 static gchar *eval_cstring_by_gauche(gchar *s) {
484 gchar *msg;
485
486 ScmObj result, error;
487 /* ������������������������������ */
488 ScmObj os = Scm_MakeOutputStringPort(TRUE);
489
490 /* Scheme ��������������������������������������� */
491 /* http://alohakun.blog7.fc2.com/blog-entry-517.html */
492 Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*input*")), SCM_MAKE_STR(s));
493 Scm_Define(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), SCM_FALSE);
494
495 result = Scm_EvalCString("(guard (e (else (set! *error* e) #f)) (eval (read-from-string *input*) (current-module)))", SCM_OBJ(Scm_UserModule()));
496
497 error = Scm_GlobalVariableRef(Scm_UserModule(), SCM_SYMBOL(SCM_INTERN("*error*")), 0);
498
499 /* ��������������������������������������������������������� */
500 if (!SCM_FALSEP(error))
501 Scm_Write(error, os, SCM_WRITE_DISPLAY);
502 else
503 Scm_Write(result, os, SCM_WRITE_DISPLAY);
504
505 msg = Scm_GetString(SCM_STRING(Scm_GetOutputString(SCM_PORT(os))));
506 /* ������������������ */
507 Scm_ClosePort(SCM_PORT(os));
508
509 return msg;
510 }
511
512 /* ������������������������������������������������������������������ S ��������������� (������������) */
513 static void load_region_handler(GtkWidget *widget, GtkWidget *notebook) {
514
515 GtkTextIter start, end, p;
516 gchar *code;
517 gtk_text_buffer_get_end_iter(Shiki_CURRENT_TEXT_BUFFER, &p);
518 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, "\n\n", -1);
519
520 /* ������������������������������������������������������������ */
521 if(gtk_text_buffer_get_selection_bounds(Shiki_CURRENT_TEXT_BUFFER, &start, &end)) {
522 code = gtk_text_buffer_get_text(Shiki_CURRENT_TEXT_BUFFER, &start, &end, FALSE);
523 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &p, load_cstring_by_gauche(code), -1);
524 g_free(code);
525 }
526 }
527
528 // GtkTextCharPredicate
529 static gboolean is_kakko_or_kokka(gunichar ch, gpointer p) {
530 return ch == '(' || ch == ')';
531 }
532 static gboolean is_kokka(gunichar ch, gpointer p) {return ch == ')';}
533
534
535 /* ')' ��������������� '(' ������������������ (S ���) ��������������� */
536 static gboolean search_sexp_string(GtkTextIter *start) {
537 gint nest_level = 0;
538 /* ��������������������������������� S ������������������ */
539 while(1) {
540 if(!gtk_text_iter_backward_find_char(start, is_kakko_or_kokka, NULL, NULL))
541 return FALSE;
542
543 if(gtk_text_iter_get_char(start) == ')')
544 nest_level++;
545 else {
546 if(!nest_level)
547 break;
548 else
549 nest_level--;
550 }
551 }
552 return TRUE;
553 }
554
555 /* ������������������������������������������������ */
556 static gint get_parent_nest_level_at_cursor(GtkTextBuffer *buffer) {
557 gint nest_level = 0;
558 GtkTextIter start, end;
559 gtk_text_buffer_get_start_iter(buffer, &start);
560 if(gtk_text_iter_get_char(&start) == '(') nest_level++;
561
562 /* ��������������������� (= end) ��������� */
563 gtk_text_buffer_get_iter_at_mark(buffer,&end, gtk_text_buffer_get_insert(buffer));
564
565 while(1) {
566 /* end ������ '(' ��� ')' ��������������������������������������������� */
567 if(!gtk_text_iter_forward_find_char(&start, is_kakko_or_kokka, NULL, &end))
568 return nest_level;
569
570 if(gtk_text_iter_get_char(&start) == '(')
571 nest_level++;
572 else
573 nest_level--;
574 }
575 }
576
577 /* ������������������������������������������������������������ */
578 static void switch_tabpage_handler(GtkNotebook *notebook, GtkNotebookPage *page, guint pagenum) {
579 /* ��������������������������������������������������������������������� */
580 Shiki_CURRENT_TAB_INFO = (ShikiTabInfo *)g_list_nth_data(Shiki_EDITOR_TAB_INFO_LIST, pagenum);
581 /* ������������������������������������ */
582 Shiki_CURRENT_TAB_NUM = pagenum;
583
584 /* ������������������������������������������������������ */
585 if(!Shiki_CURRENT_TAB_INFO) return;
586 gtk_window_set_title (GTK_WINDOW(Shiki_EDITOR_WINDOW), Shiki_CURRENT_FILENAME);
587
588 update_modeline_label();
589 }
590
591 /* ��������������������������������� on/off */
592 static void tabsborder_on_off(GtkButton *button, GtkNotebook *notebook) {
593 gint tval = FALSE;
594 gint bval = FALSE;
595 if(notebook->show_tabs == FALSE)
596 tval = TRUE;
597 if(notebook->show_border == FALSE)
598 bval = TRUE;
599
600 gtk_notebook_set_show_tabs(notebook, tval);
601 gtk_notebook_set_show_border(notebook, bval);
602 }
603
604 static void remove_tabpage_handler(GtkButton *button, GtkWidget *notebook) {
605 remove_tabpage(GTK_NOTEBOOK(notebook));
606 }
607
608 static void append_tabpage_handler(GtkButton *button, GtkNotebook *notebook) {
609 append_tabpage(notebook, g_strdup("*scratch*"));
610 }
611
612 /* ������������������������ */
613 static void rotate_tab_position(GtkButton *button, GtkNotebook *notebook ) {
614 gtk_notebook_set_tab_pos(notebook, (notebook->tab_pos + 1) % 4);
615 }
616
617 /* ������������������������������������������ */
618
619 /* ��������������������� ^npfb */
620 static void forward_current_buffer() {
621 GtkTextIter p;
622 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER,&p, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
623 gtk_text_iter_forward_char(&p);
624 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
625 }
626 static void backward_current_buffer() {
627 GtkTextIter p;
628 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER,&p, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
629 gtk_text_iter_backward_char(&p);
630 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
631 }
632 static void line_forward_current_buffer() {
633 GtkTextIter p;
634 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER, &p, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
635 gtk_text_view_forward_display_line(Shiki_CURRENT_TEXT_VIEW, &p);
636 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
637 }
638 static void line_backward_current_buffer() {
639 GtkTextIter p;
640 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER,&p, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
641 gtk_text_view_backward_display_line(Shiki_CURRENT_TEXT_VIEW, &p);
642 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
643 }
644
645 /* ��������������������� */
646 static gboolean signal_key_press_handler (GtkWidget *notebook, GdkEventKey *event, gpointer contextid) {
647 GtkTextIter start, end;
648
649 /* ������������������������������������ */
650 gtk_text_buffer_get_start_iter(Shiki_CURRENT_TEXT_BUFFER, &start);
651 gtk_text_buffer_get_end_iter(Shiki_CURRENT_TEXT_BUFFER, &end);
652 gtk_text_buffer_remove_tag_by_name(Shiki_CURRENT_TEXT_BUFFER, "parent_emphasis_background", &start, &end);
653
654 if(event->state & GDK_CONTROL_MASK) {
655 switch(event->keyval) {
656 case GDK_f : /* Ctrl + f : forward */
657 forward_current_buffer();
658 break;
659 case GDK_b : /* Ctrl + b : backward */
660 backward_current_buffer();
661 break;
662 case GDK_n : /* Ctrl + n : next line */
663 line_forward_current_buffer();
664 break;
665 case GDK_p : /* Ctrl + p : previous line */
666 line_backward_current_buffer();
667 break;
668
669 case GDK_j : /* Ctrl + j : ��������������������� S ������������ */
670 {
671 gchar *code;
672 GtkTextIter start, end;
673
674 /* ������������������������������ */
675 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER, &end, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
676
677 gtk_text_iter_backward_find_char(&end, is_kokka, NULL, NULL);
678 start = end;
679 gtk_text_iter_forward_char(&end);
680
681 /* ��������������������������������� S ������������������ */
682 if(!search_sexp_string(&start)) return FALSE;
683
684 code = gtk_text_buffer_get_text(Shiki_CURRENT_TEXT_BUFFER, &start, &end, FALSE);
685 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &end, "\n\n", -1);
686 gtk_text_buffer_insert(Shiki_CURRENT_TEXT_BUFFER, &end, eval_cstring_by_gauche(code), -1);
687 g_free(code);
688 }
689 break;
690
691 case GDK_t : /* Ctrl + t : ��������������� */
692 append_tabpage(GTK_NOTEBOOK(notebook), g_strdup("*scratch*"));
693 break;
694
695 case GDK_k : /* Ctrl + k : ������������������ */
696 remove_tabpage(GTK_NOTEBOOK(notebook));
697 break;
698 }
699 }
700 return FALSE;
701 }
702
703 /* ��������������������� */
704 static gboolean signal_key_release_handler (GtkWidget *notebook, GdkEventKey *event, gpointer contextid) {
705 static gint metakey_pressed = 0;
706 static gint controlx_pressed = 0;
707
708 if(event->keyval == GDK_parenright && event->state & GDK_SHIFT_MASK) {
709 GtkTextIter start, end;
710
711 /* ������������������������������ */
712 gtk_text_buffer_get_iter_at_mark(Shiki_CURRENT_TEXT_BUFFER, &end, gtk_text_buffer_get_insert(Shiki_CURRENT_TEXT_BUFFER));
713
714 start = end;
715 gtk_text_iter_backward_char(&start);
716
717 /* ��������������������������������� S ������������������ */
718 if(!search_sexp_string(&start)) return FALSE;
719
720 gtk_text_buffer_apply_tag_by_name(Shiki_CURRENT_TEXT_BUFFER, "parent_emphasis_background", &start, &end);
721 }
722
723 /* ������������������������������������������������������������������������������������������������ (���������������) ������������������ */
724 if(event->keyval == GDK_Return) {
725 gint indentWidth = get_parent_nest_level_at_cursor(Shiki_CURRENT_TEXT_BUFFER) * editor_indent_width;
726 gchar *indent = g_strnfill(indentWidth, ' ');
727 gtk_text_buffer_insert_at_cursor(Shiki_CURRENT_TEXT_BUFFER, indent, -1);
728 g_free(indent);
729 }
730
731 /* C-x */
732 if(event->keyval == GDK_x && event->state & GDK_CONTROL_MASK) {
733 controlx_pressed++;
734 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "C-x -");
735 } else if(event->state & GDK_CONTROL_MASK) {
736
737 if(controlx_pressed > 0) {
738 switch(event->keyval) {
739 case GDK_c :/* C-x C-c : ������ */
740 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "C-c");
741 {/* "delete-event" ��������������������������������������� �� ������������������������������������ */
742 GdkEvent ev;
743
744 ev.any.type = GDK_DELETE;
745 ev.any.window = Shiki_EDITOR_WINDOW->window;
746 ev.any.send_event = FALSE;
747 gdk_event_put (&ev);
748 }
749 break;
750
751 case GDK_f : /* C-x C-f : ������������������ */
752 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "C-f");
753 open_file_from_notebook(GTK_NOTEBOOK(notebook));
754 break;
755
756 case GDK_s : /* C-x C-s : ������������������ */
757 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "C-s");
758 save_file_from_notebook(GTK_NOTEBOOK(notebook));
759 break;
760
761 case GDK_w : /* C-x C-w : ������������������������ */
762 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "C-w");
763 save_file_as_from_notebook(GTK_NOTEBOOK(notebook));
764 break;
765 }
766 controlx_pressed = 0;
767 }
768
769 switch(event->keyval) {
770 case GDK_g :/* C-g : ��������������� */
771 metakey_pressed = 0;
772 controlx_pressed = 0;
773
774 gtk_statusbar_push(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), GPOINTER_TO_INT(contextid), "Quit");
775 break;
776 }
777
778 }
779 return FALSE;
780 }
781 static void open_online_help(GtkNotebook *notebook) {
782 GtkTextIter p;
783 append_tabpage(notebook, g_strdup("*help*"));
784 gtk_text_buffer_set_text(Shiki_CURRENT_TEXT_BUFFER,
785 "������\n"
786 "$ ./shiki [file1 file2 ....]\n\n"
787 "[���������������������������] ��������������������� (C-x C-f)\n"
788 "[������������������������������������������] ��������������������� (C-x C-s)\n"
789 "[���������������������������������������������] ��������������������������� (C-x C-w)\n"
790 "[���������������������] ��������������� gauche ������������ (region-compile)\n"
791 "[��������������� (���������) ���������������] ��������� on/off\n"
792 "[������ (���������) ���������������] ������������������������\n"
793 "[������ + ������������] ��������������������������� (Ctrl + t) (tab)\n"
794 "[���������������������] ������������������������\n"
795 "[�� ������������] ������������������������ (Ctrl + k) (kill buffer)\n"
796 "[A ������������] ���������������������\n"
797 "[���������������������������] Scheme ������������������������\n"
798 "[���������������������������������] ���������������������������������������\n"
799 "[��������� (?) ������������] ���������������������������������������\n"
800 "[info ������������] ���������������������������������������������������\n\n"
801 "C-f : ��� ��������� (forward)\n"
802 "C-b : ��� ��������� (backward)\n"
803 "C-n : ��� ��������� (next line)\n"
804 "C-p : ��� ��������� (previous line)\n\n"
805 "C-j : ��������������������� S ������������ (eval-last-sexp)\n"
806 "(emacs/xyzzy ��� *scratch* ���������������������)\n\n"
807
808 "C-x C-c : ��������������������������� �� ���������������������������������\n\n"
809
810 "������������������������������������������������������������������Reqlly Quit ?���������������������������������\n", -1);
811 gtk_text_buffer_set_modified(Shiki_CURRENT_TEXT_BUFFER, FALSE);
812 /* ������������������������������ */
813 gtk_text_buffer_get_start_iter(Shiki_CURRENT_TEXT_BUFFER, &p);
814 gtk_text_buffer_place_cursor(Shiki_CURRENT_TEXT_BUFFER, &p);
815 }
816
817 static void online_help_handler(GtkWidget *button, GtkNotebook *notebook) {
818 open_online_help(notebook);
819 }
820
821 /* ��������������������������������������� */
822 static void shiki_editor_window_init(int argc, char **argv) {
823 GtkWidget *vbox, *toolbar, *notebook;
824 GtkToolItem *icon;
825 GtkIconSize iconsize;
826 GtkTooltips *toolbar_tips = gtk_tooltips_new();
827 /* ��������������������������������������������������������������������������������� */
828 GtkToolItem *oicon, *sicon, *saicon, *eicon;
829
830 gint contextid;
831
832 /* ������������ */
833 Shiki_EDITOR_WINDOW = gtk_window_new(GTK_WINDOW_TOPLEVEL);
834 g_signal_connect(G_OBJECT(Shiki_EDITOR_WINDOW), "destroy", G_CALLBACK(gtk_main_quit), NULL);
835
836 /* ������������������������������������ */
837 vbox = gtk_vbox_new(FALSE, 0);
838 /* ��������������������� */
839 toolbar = gtk_toolbar_new();
840 gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
841
842 notebook = gtk_notebook_new();
843 g_signal_connect(G_OBJECT(notebook), "switch-page", GTK_SIGNAL_FUNC(switch_tabpage_handler), NULL);
844
845 /* ������������������������������������������������ */
846 gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
847 iconsize = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
848
849 /* ������������������ */
850
851 /* ������������������ */
852 oicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-open", iconsize), "");
853 /* ������������������������������������������������������������������������������������ */
854 g_signal_connect(G_OBJECT(oicon), "clicked", G_CALLBACK(open_file_handler), G_OBJECT(notebook));
855 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(oicon));
856 gtk_tool_item_set_tooltip(oicon, toolbar_tips, "���������������������������",
857 "���������������������������������������������������������������������������������������");
858
859 /* ������������������ */
860 sicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save", iconsize), "");
861 /* ������������������������������������������������������������������������������������ */
862 g_signal_connect(G_OBJECT(sicon), "clicked", G_CALLBACK(save_file_handler), G_OBJECT(notebook));
863 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(sicon));
864 gtk_tool_item_set_tooltip(sicon, toolbar_tips, "������������������������������",
865 "������������������������������������������������������������������������������������������������������������������������������������");
866
867 /* ��������������������������� */
868 saicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-save-as", iconsize), "");
869 /* ������������������������������������������������������������������������������������������������������������������ */
870 g_signal_connect(G_OBJECT(saicon), "clicked", G_CALLBACK(save_file_as_handler), G_OBJECT(notebook));
871 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(saicon));
872 gtk_tool_item_set_tooltip(saicon, toolbar_tips, "������������������������������������",
873 "");
874
875 /* ������������������ */
876 eicon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-execute", iconsize), "");
877 /* ������������������������������������������ libgauche ������������������ */
878 g_signal_connect(G_OBJECT(eicon), "clicked", G_CALLBACK(load_region_handler), G_OBJECT(notebook));
879 gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET(eicon));
880 gtk_tool_item_set_tooltip(eicon, toolbar_tips, "��������������� S ������������������������ (load-region-lisp)",
881 "Scheme (gauche) ������������������ S ������������������������");
882
883 gtk_container_add(GTK_CONTAINER(Shiki_EDITOR_WINDOW), vbox);
884 gtk_container_add(GTK_CONTAINER(vbox), notebook);
885
886 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-apply", iconsize), "");
887 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(tabsborder_on_off), G_OBJECT(notebook));
888 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
889 gtk_tool_item_set_tooltip(icon, toolbar_tips, "��������� on/off", "");
890
891 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-preferences", iconsize), "");
892 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(rotate_tab_position), G_OBJECT(notebook));
893 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
894 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������", "");
895
896 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-add", iconsize), "");
897 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(append_tabpage_handler), G_OBJECT(notebook));
898 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
899 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������������", "");
900
901 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-delete", iconsize), "");
902 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(clear_current_buffer), G_OBJECT(notebook));
903 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
904 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������������",
905 "���������������������������������������������������������������������");
906
907 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-close", iconsize), "");
908 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(remove_tabpage_handler), G_OBJECT(notebook));
909 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
910 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������������",
911 "���������������������������������������������������������������");
912
913 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-bold", iconsize), "");
914 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(select_font), NULL);
915 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
916 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������������������", "");
917
918 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-connect", iconsize), "");
919 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(load_scheme_file_by_gauche), G_OBJECT(notebook));
920 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
921 gtk_tool_item_set_tooltip(icon, toolbar_tips, "Scheme ������������������������", "");
922
923 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-convert", iconsize), "");
924 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(load_buffer_by_gauche), G_OBJECT(notebook));
925 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
926 gtk_tool_item_set_tooltip(icon, toolbar_tips, "������������������������", "");
927
928 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-dialog-question", iconsize), "");
929 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(online_help_handler), notebook);
930 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
931 gtk_tool_item_set_tooltip(icon, toolbar_tips, "���������", "");
932
933 icon = gtk_tool_button_new(gtk_image_new_from_stock ("gtk-dialog-info", iconsize), "");
934 g_signal_connect(G_OBJECT(icon), "clicked", G_CALLBACK(about_this_application), NULL);
935 gtk_container_add(GTK_CONTAINER (toolbar), GTK_WIDGET(icon));
936 gtk_tool_item_set_tooltip(icon, toolbar_tips, "������������������������������������������", "");
937
938 gtk_box_pack_start(GTK_BOX(vbox), Shiki_EDITOR_MODELINE_LABEL = gtk_label_new("-E:** *scratch* (Gauche Interaction)--L1--All---------------------------------"), TRUE, TRUE, 0);
939
940 /* C-x C-s ��������������������������������������������������������������������������������������� */
941 Shiki_EDITOR_STATUSBAR = gtk_statusbar_new();
942 gtk_box_pack_start(GTK_BOX(vbox), Shiki_EDITOR_STATUSBAR, TRUE, TRUE, 0);
943 contextid = gtk_statusbar_get_context_id(GTK_STATUSBAR(Shiki_EDITOR_STATUSBAR), "");
944
945 /* ������������������������������������������������ */
946 g_signal_connect(G_OBJECT(notebook), "key-press-event", G_CALLBACK (signal_key_press_handler), GINT_TO_POINTER(contextid));
947 g_signal_connect(G_OBJECT(notebook), "key-release-event", G_CALLBACK (signal_key_release_handler), GINT_TO_POINTER(contextid));
948
949 /* ��������������������������������������������� */
950 if(argc >= 2) {
951 int i;
952 for(i = 1; i < argc; i++)
953 open_file(GTK_NOTEBOOK(notebook), g_strdup(argv[i]));
954 } else /* ������������������������������������������������������������������ */
955 open_online_help(GTK_NOTEBOOK(notebook));
956
957 gtk_widget_grab_focus(notebook);
958 gtk_widget_show_all(Shiki_EDITOR_WINDOW);
959 }
960
961 int main(int argc, char *argv[]) {
962 /* ������������������������������������ */
963 gtk_set_locale();
964 gtk_init(&argc, &argv);
965 GC_INIT(); Scm_Init(GAUCHE_SIGNATURE);
966 shiki_editor_window_init(argc, argv);
967 gtk_main();
968 Scm_Exit(0);
969 return 0;
970 }

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