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.16 - (show annotations) (download) (as text)
Sat Nov 11 08:52:57 2006 UTC (17 years, 5 months ago) by aloha
Branch: MAIN
Changes since 1.15: +107 -87 lines
File MIME type: text/x-csrc
refactoring

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

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