?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update
[midnight-commander.git] / gtkedit / gtkedit.c
bloba81a091793c38f6ab6b50963a3e26f5bf597def0
1 /* gtkedit.c -
2 front end for gtk/gnome version
3
4 Copyright (C) 1996, 1997 the Free Software Foundation
5
6 Authors: 1996, 1997 Paul Sheer
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21
22 #define _GTK_EDIT_C
23
24 #include <config.h>
25 #include <gnome.h>
26 #include <ctype.h>
27 #include <string.h>
28 #include <pwd.h>
29 #include "gdk/gdkkeysyms.h"
30 #include "gtk/gtkmain.h"
31 #include "gtk/gtkselection.h"
32 #include "gtk/gtksignal.h"
33 #include "edit.h"
34 #include "mousemark.h"
35
36 #define EDIT_BORDER_ROOM 1
37 #define MIN_EDIT_WIDTH_LINES 20
38 #define MIN_EDIT_HEIGHT_LINES 10
39
40 #define GDK_FONT_XFONT(font) (((GdkFontPrivate*) font)->xfont)
41
42 int edit_key_emulation = 0;
43 int column_highlighting = 0;
44
45 static GtkWidgetClass *parent_class = NULL;
46
47 WEdit *edit_init (WEdit * edit, int lines, int columns, const char *filename, const char *text, const char *dir, unsigned long text_size);
48 void edit_destroy_callback (CWidget * w);
49 int edit_translate_key (unsigned int x_keycode, long x_key, int x_state, int *cmd, int *ch);
50 void gtk_edit_alloc_colors (GtkEdit *edit, GdkColormap *colormap);
51 static void gtk_edit_set_position (GtkEditable *editable, gint position);
52 void edit_mouse_mark (WEdit * edit, XEvent * event, int double_click);
53 void edit_move_to_prev_col (WEdit * edit, long p);
54 int edit_load_file_from_filename (WEdit *edit, char *exp);
55 static void gtk_edit_set_selection (GtkEditable * editable, gint start, gint end);
56
57 guchar gtk_edit_font_width_per_char[256];
58 int gtk_edit_option_text_line_spacing;
59 int gtk_edit_option_font_ascent;
60 int gtk_edit_option_font_descent;
61 int gtk_edit_option_font_mean_width;
62 int gtk_edit_fixed_font;
63
64 #if defined NEVER_DEFINED_ONLY_A_HACK
65 const char *dummy_txt_0 = _("&Dismiss");
66 const char *dummy_txt_1 = _(" Enter file name: ");
67 #endif
68
69 static void clear_focus_area (GtkEdit *edit, gint area_x, gint area_y, gint area_width, gint area_height)
70 {
71 return;
72 }
73
74 void gtk_edit_freeze (GtkEdit *edit)
75 {
76 return;
77 }
78
79 void gtk_edit_insert (GtkEdit *edit,
80 GdkFont *font,
81 GdkColor *fore,
82 GdkColor *back,
83 const char *chars,
84 gint length)
85 {
86 while (length-- > 0)
87 edit_insert (GTK_EDIT (edit)->editor, *chars++);
88 }
89
90 void gtk_edit_set_editable (GtkEdit *text,
91 gint editable)
92 {
93 return;
94 }
95
96 void gtk_edit_thaw (GtkEdit *text)
97 {
98 return;
99 }
100
101
102 void gtk_edit_configure_font_dimensions (GtkEdit * edit)
103 {
104 XFontStruct *f;
105 XCharStruct s;
106 char *p;
107 char q[256];
108 unsigned char t;
109 int i, direction;
110 f = GDK_FONT_XFONT (edit->editable.widget.style->font);
111 p = _ ("The Quick Brown Fox Jumps Over The Lazy Dog");
112 for (i = ' '; i <= '~'; i++)
113 q[i - ' '] = i;
114 if (XTextWidth (f, "M", 1) == XTextWidth (f, "M", 1))
115 gtk_edit_fixed_font = 1;
116 else
117 gtk_edit_fixed_font = 0;
118 XTextExtents (f, q, '~' - ' ', &direction, &gtk_edit_option_font_ascent, &gtk_edit_option_font_descent, &s);
119 gtk_edit_option_font_mean_width = XTextWidth (f, p, strlen (p)) / strlen (p);
120 for (i = 0; i < 256; i++) {
121 t = (unsigned char) i;
122 if (i > f->max_char_or_byte2 || i < f->min_char_or_byte2) {
123 gtk_edit_font_width_per_char[i] = 0;
124 } else {
125 gtk_edit_font_width_per_char[i] = XTextWidth (f, (char *) &t, 1);
126 }
127 }
128 }
129
130 void gtk_edit_set_adjustments (GtkEdit * edit,
131 GtkAdjustment * hadj,
132 GtkAdjustment * vadj)
133 {
134 g_return_if_fail (edit != NULL);
135 g_return_if_fail (GTK_IS_EDIT (edit));
136
137 if (edit->hadj && (edit->hadj != hadj)) {
138 gtk_signal_disconnect_by_data (GTK_OBJECT (edit->hadj), edit);
139 gtk_object_unref (GTK_OBJECT (edit->hadj));
140 }
141 if (edit->vadj && (edit->vadj != vadj)) {
142 gtk_signal_disconnect_by_data (GTK_OBJECT (edit->vadj), edit);
143 gtk_object_unref (GTK_OBJECT (edit->vadj));
144 }
145 if (!hadj)
146 hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
147
148 if (!vadj)
149 vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
150
151 if (edit->hadj != hadj) {
152 edit->hadj = hadj;
153 gtk_object_ref (GTK_OBJECT (edit->hadj));
154 gtk_object_sink (GTK_OBJECT (edit->hadj));
155
156 #if 0
157 gtk_signal_connect (GTK_OBJECT (edit->hadj), "changed",
158 (GtkSignalFunc) gtk_edit_adjustment,
159 edit);
160 gtk_signal_connect (GTK_OBJECT (edit->hadj), "value_changed",
161 (GtkSignalFunc) gtk_edit_adjustment,
162 edit);
163 gtk_signal_connect (GTK_OBJECT (edit->hadj), "disconnect",
164 (GtkSignalFunc) gtk_edit_disconnect,
165 edit);
166 #endif
167 }
168 if (edit->vadj != vadj) {
169 edit->vadj = vadj;
170 gtk_object_ref (GTK_OBJECT (edit->vadj));
171 gtk_object_sink (GTK_OBJECT (edit->vadj));
172
173 #if 0
174 gtk_signal_connect (GTK_OBJECT (edit->vadj), "changed",
175 (GtkSignalFunc) gtk_edit_adjustment,
176 edit);
177 gtk_signal_connect (GTK_OBJECT (edit->vadj), "value_changed",
178 (GtkSignalFunc) gtk_edit_adjustment,
179 edit);
180 gtk_signal_connect (GTK_OBJECT (edit->vadj), "disconnect",
181 (GtkSignalFunc) gtk_edit_disconnect,
182 edit);
183 #endif
184 }
185 }
186
187 GtkWidget *gtk_edit_new (GtkAdjustment * hadj,
188 GtkAdjustment * vadj)
189 {
190 GtkEdit *edit;
191 edit = gtk_type_new (gtk_edit_get_type ());
192 gtk_edit_set_adjustments (edit, hadj, vadj);
193 gtk_edit_configure_font_dimensions (edit);
194 return GTK_WIDGET (edit);
195 }
196
197 static void gtk_edit_realize (GtkWidget * widget)
198 {
199 GtkEdit *edit;
200 GtkEditable *editable;
201 GdkWindowAttr attributes;
202 GdkColormap *colormap;
203 gint attributes_mask;
204
205 g_return_if_fail (widget != NULL);
206 g_return_if_fail (GTK_IS_EDIT (widget));
207
208 edit = GTK_EDIT (widget);
209 editable = GTK_EDITABLE (widget);
210 GTK_WIDGET_SET_FLAGS (edit, GTK_REALIZED);
211
212 attributes.window_type = GDK_WINDOW_CHILD;
213 attributes.x = widget->allocation.x;
214 attributes.y = widget->allocation.y;
215 attributes.width = widget->allocation.width;
216 attributes.height = widget->allocation.height;
217 attributes.wclass = GDK_INPUT_OUTPUT;
218 attributes.visual = gtk_widget_get_visual (widget);
219 colormap = attributes.colormap = gtk_widget_get_colormap (widget);
220 attributes.event_mask = gtk_widget_get_events (widget);
221 attributes.event_mask |= (GDK_EXPOSURE_MASK |
222 GDK_BUTTON_PRESS_MASK |
223 GDK_BUTTON_RELEASE_MASK |
224 GDK_BUTTON_MOTION_MASK |
225 GDK_ENTER_NOTIFY_MASK |
226 GDK_LEAVE_NOTIFY_MASK |
227 GDK_KEY_RELEASE_MASK |
228 GDK_KEY_PRESS_MASK);
229 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
230
231 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
232 gdk_window_set_user_data (widget->window, edit);
233
234 attributes.x = (widget->style->klass->xthickness + EDIT_BORDER_ROOM);
235 attributes.y = (widget->style->klass->ythickness + EDIT_BORDER_ROOM);
236 attributes.width = widget->allocation.width - attributes.x * 2;
237 attributes.height = widget->allocation.height - attributes.y * 2;
238
239 edit->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
240 gdk_window_set_user_data (edit->text_area, edit);
241
242 widget->style = gtk_style_attach (widget->style, widget->window);
243
244 gtk_edit_alloc_colors (edit, colormap);
245
246 /* Can't call gtk_style_set_background here because it's handled specially */
247 gdk_window_set_background (widget->window, &edit->color[1]);
248 gdk_window_set_background (edit->text_area, &edit->color[1]);
249
250 edit->gc = gdk_gc_new (edit->text_area);
251 gdk_gc_set_exposures (edit->gc, TRUE);
252 gdk_gc_set_foreground (edit->gc, &edit->color[26]);
253 gdk_gc_set_background (edit->gc, &edit->color[1]);
254
255
256 gdk_window_show (edit->text_area);
257
258 if (editable->selection_start_pos != editable->selection_end_pos)
259 gtk_editable_claim_selection (editable, TRUE, GDK_CURRENT_TIME);
260
261 #if 0
262 if ((widget->allocation.width > 1) || (widget->allocation.height > 1))
263 recompute_geometry (edit);
264 #endif
265 }
266
267 static void gtk_edit_unrealize (GtkWidget * widget)
268 {
269 GtkEdit *edit;
270
271 g_return_if_fail (widget != NULL);
272 g_return_if_fail (GTK_IS_EDIT (widget));
273
274 edit = GTK_EDIT (widget);
275
276 gdk_window_set_user_data (edit->text_area, NULL);
277 gdk_window_destroy (edit->text_area);
278 edit->text_area = NULL;
279
280 gdk_gc_destroy (edit->gc);
281 edit->gc = NULL;
282
283 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
284 (*GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
285 }
286
287 static void gtk_edit_destroy (GtkObject * object)
288 {
289 GtkEdit *edit;
290
291 g_return_if_fail (object != NULL);
292 g_return_if_fail (GTK_IS_EDIT (object));
293
294 edit = (GtkEdit *) object;
295 if (edit->hadj) {
296 gtk_object_unref (GTK_OBJECT (edit->hadj));
297 edit->hadj = NULL;
298 }
299 if (edit->vadj) {
300 gtk_object_unref (GTK_OBJECT (edit->vadj));
301 edit->vadj = NULL;
302 }
303 if (edit->timer) {
304 gtk_timeout_remove (edit->timer);
305 edit->timer = 0;
306 }
307 edit_clean (edit->editor);
308 if (edit->editor) {
309 free (edit->editor);
310 edit->editor = NULL;
311 }
312 GTK_OBJECT_CLASS (parent_class)->destroy (object);
313 }
314
315 static void gtk_edit_style_set (GtkWidget * widget,
316 GtkStyle * previous_style)
317 {
318 GtkEdit *edit;
319
320 g_return_if_fail (widget != NULL);
321 g_return_if_fail (GTK_IS_EDIT (widget));
322
323 edit = GTK_EDIT (widget);
324 if (GTK_WIDGET_REALIZED (widget)) {
325 gdk_window_set_background (widget->window, &edit->color[1]);
326 gdk_window_set_background (edit->text_area, &edit->color[1]);
327
328 #if 0
329 if ((widget->allocation.width > 1) || (widget->allocation.height > 1))
330 recompute_geometry (edit);
331 #endif
332 }
333 if (GTK_WIDGET_DRAWABLE (widget))
334 gdk_window_clear (widget->window);
335 }
336
337 static void gtk_edit_draw_focus (GtkWidget * widget)
338 {
339 GtkEdit *edit;
340 gint width, height;
341 gint x, y;
342
343 g_return_if_fail (widget != NULL);
344 g_return_if_fail (GTK_IS_EDIT (widget));
345
346 edit = GTK_EDIT (widget);
347
348 if (GTK_WIDGET_DRAWABLE (widget)) {
349 gint ythick = widget->style->klass->ythickness;
350 gint xthick = widget->style->klass->xthickness;
351 gint xextra = EDIT_BORDER_ROOM;
352 gint yextra = EDIT_BORDER_ROOM;
353
354 /* TDEBUG (("in gtk_edit_draw_focus\n")); */
355
356 x = 0;
357 y = 0;
358 width = widget->allocation.width;
359 height = widget->allocation.height;
360
361 if (GTK_WIDGET_HAS_FOCUS (widget)) {
362 x += 1;
363 y += 1;
364 width -= 2;
365 height -= 2;
366 xextra -= 1;
367 yextra -= 1;
368
369 gdk_draw_rectangle (widget->window,
370 widget->style->fg_gc[GTK_STATE_NORMAL],
371 FALSE, 0, 0,
372 widget->allocation.width - 1,
373 widget->allocation.height - 1);
374 }
375 gtk_draw_shadow (widget->style, widget->window,
376 GTK_STATE_NORMAL, GTK_SHADOW_IN,
377 x, y, width, height);
378
379 x += xthick;
380 y += ythick;
381 width -= 2 * xthick;
382 height -= 2 * ythick;
383
384 if (widget->style->bg_pixmap[GTK_STATE_NORMAL]) {
385 /* top rect */
386 clear_focus_area (edit, x, y, width, yextra);
387 /* left rect */
388 clear_focus_area (edit, x, y + yextra,
389 xextra, y + height - 2 * yextra);
390 /* right rect */
391 clear_focus_area (edit, x + width - xextra, y + yextra,
392 xextra, height - 2 * ythick);
393 /* bottom rect */
394 clear_focus_area (edit, x, x + height - yextra, width, yextra);
395 } else if (!GTK_WIDGET_HAS_FOCUS (widget)) {
396 gdk_draw_rectangle (widget->window,
397 widget->style->base_gc[GTK_STATE_NORMAL], FALSE,
398 x, y,
399 width - 1,
400 height - 1);
401 }
402 }
403 #if 0
404 else {
405 TDEBUG (("in gtk_edit_draw_focus (undrawable !!!)\n"));
406 }
407 #endif
408 }
409
410 static void gtk_edit_size_request (GtkWidget * widget,
411 GtkRequisition * requisition)
412 {
413 gint xthickness;
414 gint ythickness;
415 gint char_height;
416 gint char_width;
417
418 g_return_if_fail (widget != NULL);
419 g_return_if_fail (GTK_IS_EDIT (widget));
420 g_return_if_fail (requisition != NULL);
421
422 xthickness = widget->style->klass->xthickness + EDIT_BORDER_ROOM;
423 ythickness = widget->style->klass->ythickness + EDIT_BORDER_ROOM;
424
425 char_height = MIN_EDIT_HEIGHT_LINES * (widget->style->font->ascent +
426 widget->style->font->descent);
427
428 char_width = MIN_EDIT_WIDTH_LINES * (gdk_text_width (widget->style->font,
429 "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
430 26)
431 / 26);
432
433 requisition->width = char_width + xthickness * 2;
434 requisition->height = char_height + ythickness * 2;
435 }
436
437 static void gtk_edit_size_allocate (GtkWidget * widget,
438 GtkAllocation * allocation)
439 {
440 GtkEdit *edit;
441 GtkEditable *editable;
442
443 g_return_if_fail (widget != NULL);
444 g_return_if_fail (GTK_IS_EDIT (widget));
445 g_return_if_fail (allocation != NULL);
446
447 edit = GTK_EDIT (widget);
448 editable = GTK_EDITABLE (widget);
449
450 widget->allocation = *allocation;
451 if (GTK_WIDGET_REALIZED (widget)) {
452 gdk_window_move_resize (widget->window,
453 allocation->x, allocation->y,
454 allocation->width, allocation->height);
455
456 gdk_window_move_resize (edit->text_area,
457 widget->style->klass->xthickness + EDIT_BORDER_ROOM,
458 widget->style->klass->ythickness + EDIT_BORDER_ROOM,
459 widget->allocation.width - (widget->style->klass->xthickness +
460 EDIT_BORDER_ROOM) * 2,
461 widget->allocation.height - (widget->style->klass->ythickness +
462 EDIT_BORDER_ROOM) * 2);
463
464 #if 0
465 recompute_geometry (edit);
466 #endif
467 }
468 }
469
470 static void gtk_edit_draw (GtkWidget * widget,
471 GdkRectangle * area)
472 {
473 GtkEdit *edit;
474 g_return_if_fail (widget != NULL);
475 g_return_if_fail (GTK_IS_EDIT (widget));
476 g_return_if_fail (area != NULL);
477
478 if (GTK_WIDGET_DRAWABLE (widget)) {
479 /* convert the gtk expose to a coolwidget expose */
480 XExposeEvent xexpose;
481 xexpose.x = area->x;
482 xexpose.y = area->y;
483 xexpose.width = area->width;
484 xexpose.height = area->height;
485 edit = GTK_EDIT (widget);
486 edit_render_expose (edit->editor, &xexpose);
487 edit_status (edit->editor);
488 }
489 }
490
491 void gtk_edit_set_colors (GtkEdit *win)
492 {
493 edit_set_foreground_colors (
494 color_palette (option_editor_fg_normal),
495 color_palette (option_editor_fg_bold),
496 color_palette (option_editor_fg_italic)
497 );
498 edit_set_background_colors (
499 color_palette (option_editor_bg_normal),
500 color_palette (option_editor_bg_abnormal),
501 color_palette (option_editor_bg_marked),
502 color_palette (option_editor_bg_marked_abnormal),
503 color_palette (option_editor_bg_highlighted)
504 );
505 edit_set_cursor_color (
506 color_palette (option_editor_fg_cursor)
507 );
508 }
509
510 static gint
511 gtk_edit_expose (GtkWidget * widget,
512 GdkEventExpose * event)
513 {
514 GtkEdit *edit;
515 g_return_val_if_fail (widget != NULL, FALSE);
516 g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
517 g_return_val_if_fail (event != NULL, FALSE);
518
519 if (GTK_WIDGET_DRAWABLE (widget)) {
520 /* convert the gtk expose to a coolwidget expose */
521 XExposeEvent xexpose;
522 xexpose.x = event->area.x;
523 xexpose.y = event->area.y;
524 xexpose.width = event->area.width;
525 xexpose.height = event->area.height;
526 edit = GTK_EDIT (widget);
527 gtk_edit_set_colors (edit);
528 edit_render_expose (edit->editor, &xexpose);
529 edit_status (edit->editor);
530 }
531 return FALSE;
532 }
533
534 void edit_update_screen (WEdit * e)
535 {
536 if (!e)
537 return;
538 if (!e->force)
539 return;
540
541 edit_scroll_screen_over_cursor (e);
542 edit_update_curs_row (e);
543 edit_update_curs_col (e);
544 #if 0
545 update_scroll_bars (e);
546 #endif
547 edit_status (e);
548
549 if (e->force & REDRAW_COMPLETELY)
550 e->force |= REDRAW_PAGE;
551
552 /* pop all events for this window for internal handling */
553 if (e->force & (REDRAW_CHAR_ONLY | REDRAW_COMPLETELY)) {
554 edit_render_keypress (e);
555 #if 0
556 } else if (CCheckWindowEvent (e->widget->winid, ButtonPressMask | ButtonReleaseMask | ButtonMotionMask, 0)
557 || CKeyPending ()) {
558 e->force |= REDRAW_PAGE;
559 return;
560 #endif
561 } else {
562 edit_render_keypress (e);
563 }
564 }
565
566
567 void gtk_edit_mouse_redraw (WEdit * edit, long click)
568 {
569 edit->force |= REDRAW_PAGE | REDRAW_LINE;
570 edit_update_curs_row (edit);
571 edit_update_curs_col (edit);
572 edit->prev_col = edit_get_col (edit);
573 edit_update_screen (edit);
574 edit->search_start = click;
575 }
576
577 /* returns the position in the edit buffer of a window click */
578 static long edit_get_click_pos (WEdit * edit, int x, int y)
579 {
580 long click;
581 /* (1) goto to left margin */
582 click = edit_bol (edit, edit->curs1);
583
584 /* (1) move up or down */
585 if (y > (edit->curs_row + 1))
586 click = edit_move_forward (edit, click, y - (edit->curs_row + 1), 0);
587 if (y < (edit->curs_row + 1))
588 click = edit_move_backward (edit, click, (edit->curs_row + 1) - y);
589
590 /* (3) move right to x pos */
591 click = edit_move_forward3 (edit, click, x - edit->start_col - 1, 0);
592 return click;
593 }
594
595 static void edit_translate_xy (int xs, int ys, int *x, int *y)
596 {
597 *x = xs - EDIT_TEXT_HORIZONTAL_OFFSET;
598 *y = (ys - EDIT_TEXT_VERTICAL_OFFSET - option_text_line_spacing / 2 - 1) / FONT_PIX_PER_LINE + 1;
599 }
600
601 static gint gtk_edit_button_press_release (GtkWidget * widget,
602 GdkEventButton * event)
603 {
604 GtkEditable *editable;
605 GtkEdit *edit;
606 WEdit *e;
607 static GdkAtom ctext_atom = GDK_NONE;
608 int x_text = 0, y_text = 0;
609 long mouse_pos;
610 static long button_down_pos;
611 static long dragging = 0;
612
613 g_return_val_if_fail (widget != NULL, FALSE);
614 g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
615 g_return_val_if_fail (event != NULL, FALSE);
616
617 if (ctext_atom == GDK_NONE)
618 ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE);
619
620 edit = GTK_EDIT (widget);
621 e = edit->editor;
622 editable = GTK_EDITABLE (widget);
623
624 if (!GTK_WIDGET_HAS_FOCUS (widget))
625 if (!(event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)))
626 gtk_widget_grab_focus (widget);
627
628 edit_translate_xy (event->x, event->y, &x_text, &y_text);
629 mouse_pos = edit_get_click_pos (e, x_text, y_text);
630
631 switch (event->type) {
632 case GDK_BUTTON_RELEASE:
633 if (!dragging)
634 return FALSE;
635 case GDK_MOTION_NOTIFY:
636 if (mouse_pos == button_down_pos)
637 return FALSE;
638 dragging = 1;
639 edit_cursor_move (e, mouse_pos - e->curs1);
640 gtk_edit_set_selection (GTK_EDITABLE (widget), mouse_pos, button_down_pos);
641 gtk_edit_mouse_redraw (e, mouse_pos);
642 break;
643 case GDK_BUTTON_PRESS:
644 dragging = 0;
645 if (event->button == 2) {
646 edit_cursor_move (e, mouse_pos - e->curs1);
647 editable->current_pos = mouse_pos;
648 gtk_selection_convert (GTK_WIDGET (edit), GDK_SELECTION_PRIMARY,
649 ctext_atom, event->time);
650 gtk_edit_mouse_redraw (e, mouse_pos);
651 editable->selection_start_pos = e->mark1;
652 editable->selection_end_pos = e->mark2;
653 return FALSE;
654 }
655 button_down_pos = mouse_pos;
656 #if 0
657 if (editable->has_selection)
658 if (mouse_pos >= editable->selection_start_pos
659 && mouse_pos < editable->selection_end_pos)
660 gtk_edit_set_selection (GTK_EDITABLE (widget), mouse_pos, mouse_pos);
661 #endif
662 edit_cursor_move (e, mouse_pos - e->curs1);
663 gtk_edit_mouse_redraw (e, mouse_pos);
664 break;
665 case GDK_2BUTTON_PRESS:
666 dragging = 0;
667 edit_cursor_move (e, mouse_pos - e->curs1);
668 edit_right_word_move (e);
669 mouse_pos = e->curs1;
670 edit_left_word_move (e);
671 button_down_pos = e->curs1;
672 gtk_edit_set_selection (GTK_EDITABLE (widget), mouse_pos, button_down_pos);
673 gtk_edit_mouse_redraw (e, mouse_pos);
674 break;
675 case GDK_3BUTTON_PRESS:
676 dragging = 0;
677 mouse_pos = edit_bol (e, mouse_pos);
678 edit_cursor_move (e, mouse_pos - e->curs1);
679 button_down_pos = edit_eol (e, mouse_pos) + 1;
680 gtk_edit_set_selection (GTK_EDITABLE (widget), mouse_pos, button_down_pos);
681 gtk_edit_mouse_redraw (e, mouse_pos);
682 break;
683 default:
684 dragging = 0;
685 break;
686 }
687 editable->current_pos = e->curs1;
688 return FALSE;
689 }
690
691 static gint
692 gtk_edit_button_motion (GtkWidget * widget,
693 GdkEventMotion * event)
694 {
695 return gtk_edit_button_press_release (widget, (GdkEventButton *) event);
696 }
697
698 static guint toggle_bit (guint x, guint mask)
699 {
700 unsigned long m = -1;
701 if ((x & mask))
702 return x & (m - mask);
703 else
704 return x | mask;
705 }
706
707 int mod_type_key (guint x)
708 {
709 switch ((guint) x) {
710 case GDK_Shift_L:
711 case GDK_Shift_R:
712 case GDK_Control_L:
713 case GDK_Control_R:
714 case GDK_Caps_Lock:
715 case GDK_Shift_Lock:
716 case GDK_Meta_L:
717 case GDK_Meta_R:
718 case GDK_Alt_L:
719 case GDK_Alt_R:
720 case GDK_Super_L:
721 case GDK_Super_R:
722 case GDK_Hyper_L:
723 case GDK_Hyper_R:
724 return 1;
725 }
726 return 0;
727 }
728
729 /* get a 15 bit "almost unique" key sym that includes keyboard modifier
730 info in the top 3 bits */
731 short key_sym_mod (gint key, gint state)
732 {
733 if (key && !mod_type_key (key)) {
734 key = toggle_bit (key, 0x1000 * ((state & GDK_SHIFT_MASK) != 0));
735 key = toggle_bit (key, 0x2000 * ((state & GDK_CONTROL_MASK) != 0));
736 key = toggle_bit (key, 0x4000 * ((state & GDK_MOD1_MASK) != 0));
737 key &= 0x7FFF;
738 } else
739 key = 0;
740 return key;
741 }
742
743 static gint gtk_edit_key_press (GtkWidget * widget, GdkEventKey * event)
744 {
745 GtkEditable *editable;
746 GtkEdit *edit;
747 WEdit *e;
748 gint command = 0, insert = -1, r = 0;
749 guint key, state;
750 g_return_val_if_fail (widget != NULL, FALSE);
751 g_return_val_if_fail (GTK_IS_EDIT (widget), FALSE);
752 g_return_val_if_fail (event != NULL, FALSE);
753 edit = GTK_EDIT (widget);
754 editable = GTK_EDITABLE (widget);
755 e = edit->editor;
756 if (!edit_translate_key (0, event->keyval, event->state, &command, &insert)) {
757 return FALSE;
758 }
759 key = event->keyval;
760 state = event->state;
761 if (!command && insert < 0) { /* no translation took place, so lets see if we have a macro */
762 if ((key == GDK_r || key == GDK_R) && (state & ControlMask)) {
763 command = e->macro_i < 0 ? CK_Begin_Record_Macro : CK_End_Record_Macro;
764 } else {
765 command = key_sym_mod (key, state);
766 if (command > 0)
767 command = CK_Macro (command);
768 }
769 }
770 r = edit_execute_key_command (e, command, insert);
771 if (r)
772 edit_update_screen (e);
773 editable->selection_start_pos = e->mark1;
774 editable->selection_end_pos = ((e->mark2 < 0) ? e->curs1 : e->mark2);
775 editable->has_selection = editable->selection_start_pos != editable->selection_end_pos;
776 editable->current_pos = e->curs1;
777 return r;
778 }
779
780 /**********************************************************************/
781 /* Widget Crap */
782 /**********************************************************************/
783
784 char *home_dir = 0;
785
786 static void get_home_dir (void)
787 {
788 if (home_dir) /* already been set */
789 return;
790 home_dir = getenv ("HOME");
791 if (home_dir)
792 if (*home_dir) {
793 home_dir = strdup (home_dir);
794 return;
795 }
796 home_dir = (getpwuid (geteuid ()))->pw_dir;
797 if (home_dir)
798 if (*home_dir) {
799 home_dir = strdup (home_dir);
800 return;
801 }
802 fprintf (stderr, _("gtkedit.c: HOME environment variable not set and no passwd entry - aborting\n"));
803 abort ();
804 }
805
806 static gchar *gtk_edit_get_chars (GtkEditable * editable,
807 gint start_pos,
808 gint end_pos)
809 {
810 GtkEdit *edit;
811 gchar *retval;
812 int i;
813 g_return_val_if_fail (editable != NULL, NULL);
814 g_return_val_if_fail (GTK_IS_EDIT (editable), NULL);
815 edit = GTK_EDIT (editable);
816 if (end_pos < 0)
817 end_pos = edit->editor->last_byte;
818 if ((start_pos < 0) ||
819 (end_pos > edit->editor->last_byte) ||
820 (end_pos < start_pos))
821 return 0;
822 retval = malloc (end_pos - start_pos + 1);
823 retval[end_pos - start_pos] = '\0';
824 for (i = 0; start_pos < end_pos; start_pos++, i++)
825 retval[i] = (gchar) edit_get_byte (edit->editor, start_pos);
826 return retval;
827 }
828
829 static void gtk_edit_set_selection (GtkEditable * editable,
830 gint start,
831 gint end)
832 {
833 GtkEdit *edit = GTK_EDIT (editable);
834 WEdit *e;
835 e = edit->editor;
836 if (end < 0)
837 end = edit->editor->last_byte;
838 editable->selection_start_pos = e->mark1 = MIN (start, end);
839 editable->selection_end_pos = e->mark2 = MAX (start, end);
840 editable->has_selection = (e->mark2 != e->mark1);
841 gtk_edit_mouse_redraw (e, e->curs1);
842 gtk_editable_claim_selection (editable, TRUE, GDK_CURRENT_TIME);
843 }
844
845 static void gtk_edit_insert_text (GtkEditable * editable,
846 const gchar * new_text,
847 gint new_text_length,
848 gint * position)
849 {
850 GtkEdit *edit = GTK_EDIT (editable);
851 edit_cursor_move (edit->editor, *position - edit->editor->curs1);
852 while (new_text_length--)
853 edit_insert_ahead (edit->editor, new_text[new_text_length]);
854 *position = edit->editor->curs1;
855 }
856
857 static void gtk_edit_class_init (GtkEditClass * class)
858 {
859 GtkObjectClass *object_class;
860 GtkWidgetClass *widget_class;
861 GtkEditableClass *editable_class;
862
863 object_class = (GtkObjectClass *) class;
864 widget_class = (GtkWidgetClass *) class;
865 editable_class = (GtkEditableClass *) class;
866
867 parent_class = gtk_type_class (gtk_editable_get_type ());
868
869 object_class->destroy = gtk_edit_destroy;
870
871 widget_class->realize = gtk_edit_realize;
872 widget_class->unrealize = gtk_edit_unrealize;
873 widget_class->style_set = gtk_edit_style_set;
874 widget_class->draw_focus = gtk_edit_draw_focus;
875 widget_class->size_request = gtk_edit_size_request;
876 widget_class->size_allocate = gtk_edit_size_allocate;
877 widget_class->draw = gtk_edit_draw;
878 widget_class->expose_event = gtk_edit_expose;
879 widget_class->button_press_event = gtk_edit_button_press_release;
880 widget_class->button_release_event = gtk_edit_button_press_release;
881 widget_class->motion_notify_event = gtk_edit_button_motion;
882
883 widget_class->key_press_event = gtk_edit_key_press;
884 #if 0
885 widget_class->focus_in_event = gtk_edit_focus_in;
886 widget_class->focus_out_event = gtk_edit_focus_out;
887 #endif
888 widget_class->focus_in_event = 0;
889 widget_class->focus_out_event = 0;
890
891 editable_class->insert_text = gtk_edit_insert_text;
892 #if 0
893 editable_class->delete_text = gtk_edit_delete_text;
894 editable_class->update_text = gtk_edit_update_text;
895 #else
896 editable_class->delete_text = 0;
897 editable_class->update_text = 0;
898 #endif
899
900 editable_class->get_chars = gtk_edit_get_chars;
901 editable_class->set_selection = gtk_edit_set_selection;
902 editable_class->set_position = gtk_edit_set_position;
903
904
905 #if 0
906 editable_class->set_position = 0;
907 #endif
908
909 get_home_dir ();
910 }
911
912 static void gtk_edit_init (GtkEdit * edit)
913 {
914 static made_directory = 0;
915
916 GTK_WIDGET_SET_FLAGS (edit, GTK_CAN_FOCUS);
917
918 edit->editor = edit_init (0, 80, 25, 0, "", "/", 0);
919 edit->editor->macro_i = -1;
920 edit->editor->widget = edit;
921 edit->timer = 0;
922 edit->menubar = 0;
923 edit->status = 0;
924 edit->options = 0;
925
926 gtk_edit_configure_font_dimensions (edit);
927
928 if (!made_directory) {
929 mkdir (catstrs (home_dir, EDIT_DIR, 0), 0700);
930 made_directory = 1;
931 }
932 GTK_EDITABLE (edit)->editable = TRUE;
933 }
934
935 guint
936 gtk_edit_get_type (void)
937 {
938 static guint edit_type = 0;
939
940 if (!edit_type) {
941 GtkTypeInfo edit_info =
942 {
943 "GtkEdit",
944 sizeof (GtkEdit),
945 sizeof (GtkEditClass),
946 (GtkClassInitFunc) gtk_edit_class_init,
947 (GtkObjectInitFunc) gtk_edit_init,
948 (GtkArgSetFunc) NULL,
949 (GtkArgGetFunc) NULL,
950 };
951
952 edit_type = gtk_type_unique (gtk_editable_get_type (), &edit_info);
953 }
954 return edit_type;
955 }
956
957 #include <libgnomeui/gtkcauldron.h>
958 #include <libgnomeui/gnome-stock.h>
959
960 char *gtk_edit_dialog_get_save_file (guchar * dir, guchar * def, guchar * title)
961 {
962 char *s;
963 s = gtk_dialog_cauldron (
964 title, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
965 " ( ( (Filename:)d | %Fgxf )f )xf / ( %Bxfgrq || %Bxfgq )f ",
966 &def, "filename", title,
967 GNOME_STOCK_BUTTON_OK,
968 GNOME_STOCK_BUTTON_CANCEL
969 );
970 if (s == GTK_CAULDRON_ESCAPE || !s || s == GNOME_STOCK_BUTTON_CANCEL)
971 return 0;
972 return def;
973 }
974
975 char *gtk_edit_dialog_get_load_file (guchar * dir, guchar * def, guchar * title)
976 {
977 char *s;
978 s = gtk_dialog_cauldron (
979 title, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
980 " ( ( (Filename:)d | %Fgxf )f )xf / ( %Bxfgrq || %Bxfgq )f ",
981 &def, "filename", title,
982 GNOME_STOCK_BUTTON_OK,
983 GNOME_STOCK_BUTTON_CANCEL
984 );
985 if (s == GTK_CAULDRON_ESCAPE || !s || s == GNOME_STOCK_BUTTON_CANCEL)
986 return 0;
987 return def;
988 }
989
990 void gtk_edit_dialog_message (guchar * heading, char *fmt,...)
991 {
992 gchar s[8192];
993 va_list ap;
994 va_start (ap, fmt);
995 vsprintf (s, fmt, ap);
996 va_end (ap);
997 gtk_dialog_cauldron (
998 heading, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
999 " [ ( %Ld )xf ]xf / ( %Bxfgq )f ",
1000 s,
1001 GNOME_STOCK_BUTTON_CANCEL
1002 );
1003 return;
1004 }
1005
1006 int gtk_edit_dialog_query (guchar * heading, guchar * first,...)
1007 {
1008 char *buttons[16];
1009 char s[1024], *r;
1010 int n;
1011 va_list ap;
1012 va_start (ap, first);
1013 n = 0;
1014 while ((buttons[n++] = va_arg (ap, char *)) && n < 15);
1015 va_end (ap);
1016 buttons[n] = 0;
1017 strcpy (s, " [ ( %Lxf )xf ]xf / ( ");
1018 n = 0;
1019 while (buttons[n]) {
1020 strcat (s, " %Bqxf ");
1021 if (!buttons[n])
1022 break;
1023 strcat (s, " ||");
1024 n++;
1025 }
1026 strcat (s, " )f");
1027 r = gtk_dialog_cauldron (heading, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_IGNOREENTER | GTK_CAULDRON_GRAB, s, first,
1028 buttons[0], buttons[1], buttons[2], buttons[3],
1029 buttons[4], buttons[5], buttons[6], buttons[7],
1030 buttons[8], buttons[9], buttons[10], buttons[11],
1031 buttons[12], buttons[13], buttons[14], buttons[15]
1032 );
1033 n = 0;
1034 if (r == GTK_CAULDRON_ESCAPE || !r || r == GNOME_STOCK_BUTTON_CANCEL)
1035 return -1;
1036 while (buttons[n]) {
1037 if (!strcmp (buttons[n], r))
1038 return n;
1039 n++;
1040 }
1041 return -1;
1042 }
1043
1044 void gtk_edit_dialog_error (guchar * heading, char *fmt, ...)
1045 {
1046 gchar s[8192];
1047 va_list ap;
1048 va_start (ap, fmt);
1049 vsprintf (s, fmt, ap);
1050 va_end (ap);
1051 gtk_dialog_cauldron (
1052 heading, GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB,
1053 " [ ( %Ld )xf ]xf / ( %Bxfgq )f",
1054 s,
1055 GNOME_STOCK_BUTTON_CANCEL
1056 );
1057 return;
1058 }
1059
1060
1061
1062 struct color_matrix_struct {
1063 unsigned int R, G, B;
1064 } color_matrix[27] =
1065 {
1066 {0, 0, 0},
1067 {0, 0, 128},
1068 {0, 0, 255},
1069 {0, 139, 0},
1070 {0, 139, 139},
1071 {0, 154, 205},
1072 {0, 255, 0},
1073 {0, 250, 154},
1074 {0, 255, 255},
1075 {139, 37, 0},
1076 {139, 0, 139},
1077 {125, 38, 205},
1078 {139, 117, 0},
1079 {127, 127, 127},
1080 {123, 104, 238},
1081 {127, 255, 0},
1082 {135, 206, 235},
1083 {127, 255, 212},
1084 {238, 0, 0},
1085 {238, 18, 137},
1086 {238, 0, 238},
1087 {205, 102, 0},
1088 {248, 183, 183},
1089 {224, 102, 255},
1090 {238, 238, 0},
1091 {238, 230, 133},
1092 {248, 248, 255}
1093 };
1094
1095 void gtk_edit_alloc_colors (GtkEdit *edit, GdkColormap *colormap)
1096 {
1097 int i;
1098 for (i = 0; i < 27; i++) {
1099 edit->color[i].red = (gushort) color_matrix[i].R << 8;
1100 edit->color[i].green = (gushort) color_matrix[i].G << 8;
1101 edit->color[i].blue = (gushort) color_matrix[i].B << 8;
1102 if (!gdk_color_alloc (colormap, &edit->color[i]))
1103 g_warning ("cannot allocate color");
1104 }
1105 edit->color_last_pixel = 27;
1106 }
1107
1108 int allocate_color (WEdit *edit, gchar *color)
1109 {
1110 GtkEdit *win;
1111 win = (GtkEdit *) edit->widget;
1112 if (!color)
1113 return NO_COLOR;
1114 if (*color >= '0' && *color <= '9') {
1115 return atoi (color);
1116 } else {
1117 int i;
1118 GdkColor c;
1119 if (!color)
1120 return NO_COLOR;
1121 if (!gdk_color_parse (color, &c))
1122 return NO_COLOR;
1123 if (!gdk_color_alloc (gtk_widget_get_colormap(GTK_WIDGET (edit->widget)), &c))
1124 return NO_COLOR;
1125 for (i = 0; i < (GTK_EDIT (edit->widget))->color_last_pixel; i++)
1126 if (color_palette (i) == c.pixel)
1127 return i;
1128 GTK_EDIT (edit->widget)->color[(GTK_EDIT (edit->widget))->color_last_pixel].pixel = c.pixel;
1129 return (GTK_EDIT (edit->widget))->color_last_pixel++;
1130 }
1131 }
1132
1133 static void gtk_edit_set_position (GtkEditable * editable, gint position)
1134 {
1135 WEdit *edit;
1136 edit = GTK_EDIT(editable)->editor;
1137 edit_cursor_move (edit, position - edit->curs1);
1138 edit_move_to_prev_col (edit, 0);
1139 edit->force |= REDRAW_PAGE;
1140 edit->search_start = 0;
1141 edit_update_curs_row (edit);
1142 }
1143
1144
1145 /* returns 1 on error */
1146 gint gtk_edit_load_file_from_filename (GtkWidget * edit, const gchar * filename)
1147 {
1148 return edit_load_file_from_filename (GTK_EDIT (edit)->editor, (char *) filename);
1149 }
1150
1151 void gtk_edit_set_top_line (GtkWidget * e, int line)
1152 {
1153 WEdit *edit;
1154 edit = GTK_EDIT (e)->editor;
1155 edit_move_display (edit, line - edit->num_widget_lines / 2 - 1);
1156 edit->force |= REDRAW_COMPLETELY;
1157 }
1158
1159 void gtk_edit_set_cursor_line (GtkWidget * e, int line)
1160 {
1161 WEdit *edit;
1162 edit = GTK_EDIT (e)->editor;
1163 edit_move_to_line (edit, line - 1);
1164 edit->force |= REDRAW_COMPLETELY;
1165 }
1166
1167 void about_cb (GtkWidget * widget, void *data)
1168 {
1169 gtk_dialog_cauldron ("About", GTK_CAULDRON_TOPLEVEL | GTK_CAULDRON_GRAB, " [ (Mcedit - an editor for the midnight commander\n\
1170 ported from Cooledit - a user friendly text editor for the X Window System.)xf ]xf / ( %Bgqxf )f ", GNOME_STOCK_BUTTON_OK);
1171 return;
1172 }
1173
1174 void gtk_edit_command (GtkEdit * edit, gint command)
1175 {
1176 int r;
1177 gtk_widget_grab_focus (GTK_WIDGET (edit));
1178 r = edit_execute_key_command (edit->editor, command, -1);
1179 if (r)
1180 edit_update_screen (edit->editor);
1181 }
1182
1183 void gtk_edit_quit (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Exit); }
1184
1185 void gtk_edit_load_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Load); }
1186 void gtk_edit_new_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_New); }
1187 void gtk_edit_save_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Save); }
1188 void gtk_edit_save_as_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Save_As); }
1189 void gtk_edit_insert_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Insert_File); }
1190 void gtk_edit_copy_to_file (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Save_Block); }
1191
1192 void gtk_edit_clip_cut (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_XCut); }
1193 void gtk_edit_clip_copy (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_XStore); }
1194 void gtk_edit_clip_paste (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_XPaste); }
1195
1196 void gtk_edit_toggle_mark (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Mark); }
1197 void gtk_edit_search (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Find); }
1198 void gtk_edit_search_again (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Find_Again); }
1199 void gtk_edit_replace (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Replace); }
1200 void gtk_edit_copy (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Copy); }
1201 void gtk_edit_move (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Move); }
1202 void gtk_edit_delete (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Remove); }
1203 void gtk_edit_undo (GtkEdit * widget, void *data) { GtkEdit *edit = (GtkEdit *) data ; gtk_edit_command (edit, CK_Undo); }
1204
1205 #if 0
1206 struct _GnomeUIInfo {
1207 GnomeUIInfoType type;
1208 gchar *label;
1209 gchar *hint; /* For toolbar items, the tooltip. For menu items, the status bar message */
1210
1211 /* For an item, toggleitem, or radioitem, procedure to call when activated.
1212 For a subtree, point to the GnomeUIInfo array for that subtree.
1213 For a radioitem lead entry, point to the GnomeUIInfo array for
1214 the radio item group. For the radioitem array, procedure to
1215 call when activated. For a help item, specifies the help node to load
1216 (or NULL for main prog's name)
1217 For builder data, point to the GnomeUIBuilderData structure for the following items */
1218 gpointer moreinfo;
1219 gpointer user_data;
1220 gpointer unused_data;
1221 GnomeUIPixmapType pixmap_type;
1222 /* Either
1223 * a pointer to the char for the pixmap (GNOME_APP_PIXMAP_DATA),
1224 * a char* for the filename (GNOME_APP_PIXMAP_FILENAME),
1225 * or a char* for the stock pixmap name (GNOME_APP_PIXMAP_STOCK).
1226 */
1227 gpointer pixmap_info;
1228 guint accelerator_key; /* Accelerator key... Set to 0 to ignore */
1229 GdkModifierType ac_mods; /* An OR of the masks for the accelerator */
1230 GtkWidget *widget; /* Filled in by gnome_app_create* */
1231 };
1232
1233 #endif
1234
1235 typedef struct _TbItems TbItems;
1236 struct _TbItems {
1237 char *key, *text, *tooltip, *icon;
1238 void (*cb) (GtkEdit *, void *);
1239 GtkWidget *widget; /* will be filled in */
1240 };
1241
1242 #define TB_PROP 7
1243
1244 static TbItems tb_items[] =
1245 {
1246 {"F1", "Help", "Interactive help browser", GNOME_STOCK_MENU_BLANK, 0, NULL},
1247 {"F2", "Save", "Save to current file name", GNOME_STOCK_MENU_SAVE, gtk_edit_save_file, NULL},
1248 {"F3", "Mark", "Toggle In/Off invisible marker to highlight text", GNOME_STOCK_MENU_BLANK, gtk_edit_toggle_mark, NULL},
1249 {"F4", "Replc", "Find and replace strings/regular expressions", GNOME_STOCK_MENU_SRCHRPL, gtk_edit_replace, NULL},
1250 {"F5", "Copy", "Copy highlighted block to cursor postition", GNOME_STOCK_MENU_COPY, gtk_edit_copy, NULL},
1251
1252 {"F6", "Move", "Copy highlighted block to cursor postition", GNOME_STOCK_MENU_BLANK, gtk_edit_move, NULL},
1253 {"F7", "Find", "Find strings/regular expressions", GNOME_STOCK_MENU_SEARCH, gtk_edit_search, NULL},
1254 {"F8", "Dlete", "Delete highlighted text", GNOME_STOCK_MENU_BLANK, gtk_edit_delete, NULL},
1255 {"F9", "Menu", "Pull down menu", GNOME_STOCK_MENU_BLANK, /* gtk_edit_menu*/ 0, NULL},
1256 {"F10", "Quit", "Exit editor", GNOME_STOCK_MENU_QUIT, gtk_edit_quit, NULL},
1257 {0, 0, 0, 0, 0, 0}
1258 };
1259
1260 static GtkWidget *create_toolbar (GtkWidget * window, GtkEdit * edit)
1261 {
1262 GtkWidget *toolbar;
1263 TbItems *t;
1264 toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
1265 for (t = &tb_items[0]; t->text; t++) {
1266 t->widget = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
1267 t->text,
1268 t->tooltip,
1269 0,
1270 gnome_stock_pixmap_widget (window, t->icon),
1271 t->cb,
1272 t->cb ? edit : 0);
1273 }
1274 return toolbar;
1275 }
1276
1277 /* returns 1 on error */
1278 int edit (const char *file, int line)
1279 {
1280 GtkWidget *app;
1281 GtkWidget *edit, *statusbar;
1282
1283 edit = gtk_edit_new (NULL, NULL);
1284 app = gnome_app_new ("mcedit", (char *) (file ? file : "Mcedit"));
1285
1286 {
1287 GnomeUIInfo file_menu[] =
1288 {
1289 GNOMEUIINFO_MENU_OPEN_ITEM( gtk_edit_load_file, edit),
1290 GNOMEUIINFO_MENU_NEW_ITEM( "_New", N_ ("Clear the edit buffer"), gtk_edit_new_file, edit),
1291 GNOMEUIINFO_SEPARATOR,
1292 GNOMEUIINFO_MENU_SAVE_ITEM( gtk_edit_save_file, edit),
1293 GNOMEUIINFO_MENU_SAVE_AS_ITEM( gtk_edit_save_as_file, edit),
1294 GNOMEUIINFO_SEPARATOR,
1295 GNOMEUIINFO_ITEM_DATA( N_ ("Insert File"), N_ ("Insert text from a file"),
1296 gtk_edit_insert_file, edit, NULL),
1297 GNOMEUIINFO_ITEM_DATA( N_ ("Copy to file"), N_ ("copy a block to a file"),
1298 gtk_edit_copy_to_file, edit, NULL),
1299 GNOMEUIINFO_SEPARATOR,
1300 GNOMEUIINFO_MENU_EXIT_ITEM(gtk_edit_quit,edit),
1301 GNOMEUIINFO_END
1302
1303 };
1304
1305 GnomeUIInfo edit_menu[] =
1306 {
1307 GNOMEUIINFO_MENU_COPY_ITEM(gtk_edit_clip_copy, edit),
1308 GNOMEUIINFO_MENU_CUT_ITEM( gtk_edit_clip_cut, edit),
1309 GNOMEUIINFO_MENU_PASTE_ITEM( gtk_edit_clip_paste, edit),
1310 GNOMEUIINFO_SEPARATOR,
1311 GNOMEUIINFO_MENU_UNDO_ITEM(gtk_edit_undo, edit),
1312 GNOMEUIINFO_END
1313 };
1314
1315 GnomeUIInfo search_menu[] =
1316 {
1317 GNOMEUIINFO_MENU_FIND_ITEM(gtk_edit_search, edit),
1318 GNOMEUIINFO_MENU_FIND_AGAIN_ITEM(gtk_edit_search_again, edit),
1319 GNOMEUIINFO_MENU_REPLACE_ITEM(gtk_edit_replace, edit),
1320 GNOMEUIINFO_END
1321 };
1322
1323 GnomeUIInfo help_menu[] =
1324 {
1325 GNOMEUIINFO_MENU_ABOUT_ITEM(about_cb, NULL),
1326 #if 0
1327 GNOMEUIINFO_SEPARATOR,
1328 GNOMEUIINFO_HELP ("hello"),
1329 #endif
1330 GNOMEUIINFO_END
1331 };
1332
1333 GnomeUIInfo main_menu[] =
1334 {
1335 GNOMEUIINFO_MENU_FILE_TREE(file_menu),
1336 GNOMEUIINFO_MENU_EDIT_TREE(edit_menu),
1337 GNOMEUIINFO_SUBTREE (N_ ("Search/Replace"), search_menu),
1338 GNOMEUIINFO_MENU_HELP_TREE(help_menu),
1339 GNOMEUIINFO_END
1340 };
1341
1342 gtk_widget_realize (app);
1343 statusbar = gtk_entry_new ();
1344 gtk_entry_set_editable (GTK_ENTRY (statusbar), 0);
1345 gtk_widget_set_usize (app, 400, 400);
1346 gnome_app_create_menus (GNOME_APP (app), main_menu);
1347 gnome_app_set_contents (GNOME_APP (app), edit);
1348 gnome_app_set_statusbar (GNOME_APP (app), GTK_WIDGET (statusbar));
1349 GTK_EDIT (edit)->menubar = GNOME_APP (app)->menubar;
1350 GTK_EDIT (edit)->status = statusbar;
1351 gnome_app_set_toolbar(GNOME_APP (app), GTK_TOOLBAR(create_toolbar(app, GTK_EDIT (edit))));
1352 GTK_EDIT(edit)->destroy_me = gtk_widget_destroy;
1353 GTK_EDIT(edit)->destroy_me_user_data = app;
1354
1355 gtk_widget_show (edit);
1356 gtk_widget_realize (edit);
1357 if (file)
1358 if (*file)
1359 if (gtk_edit_load_file_from_filename (edit, file)) {
1360 gtk_widget_destroy (app);
1361 return 1;
1362 }
1363 gtk_edit_set_cursor_line (edit, line);
1364 gtk_widget_show_all (app);
1365 gtk_widget_grab_focus (edit);
1366 }
1367 return 0;
1368 }
Midnight Commander