?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tools/llvm: Do not build with symbols
[minix3.git] / external / bsd / nvi / dist / motif_l / m_vi.c
blob3f5d2bf121228a9651d0cf2eb1b9255c493012d6
1 /* $NetBSD: m_vi.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
2 * Copyright (c) 1996
3 * Rob Zimmermann. All rights reserved.
4 * Copyright (c) 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #ifndef lint
13 static const char sccsid[] = "Id: m_vi.c,v 8.41 2003/11/05 17:10:01 skimo Exp (Berkeley) Date: 2003/11/05 17:10:01 ";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/queue.h>
18
19 #include <X11/Intrinsic.h>
20 #include <X11/StringDefs.h>
21 #include <X11/cursorfont.h>
22 #include <Xm/PanedW.h>
23 #include <Xm/DrawingA.h>
24 #include <Xm/Form.h>
25 #include <Xm/Frame.h>
26 #include <Xm/ScrollBar.h>
27
28 #include <bitstring.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <signal.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37
38 #undef LOCK_SUCCESS
39 #include "../common/common.h"
40 #include "../ipc/ip.h"
41 #include "m_motif.h"
42 #include "vi_mextern.h"
43 #include "pathnames.h"
44
45 extern int vi_ofd;
46
47 static void f_copy(String *buffer, int *len);
48 static void f_paste(int widget, int buffer, int length);
49 static void f_clear(Widget widget);
50
51 \f
52 /*
53 * Globals and costants
54 */
55
56 #define BufferSize 1024
57
58 static XFontStruct *font;
59 static GC gc;
60 GC __vi_copy_gc;
61 static XtAppContext ctx;
62
63 xvi_screen *__vi_screen = NULL;
64 static Cursor std_cursor;
65 static Cursor busy_cursor;
66 static XtTranslations area_trans;
67 static int multi_click_length;
68
69 void (*__vi_exitp)(); /* Exit function. */
70
71 \f
72 /* hack for drag scrolling...
73 * I'm not sure why, but the current protocol gets out of sync when
74 * a lot of drag messages get passed around. Likely, we need to wait
75 * for core to finish repainting the screen before sending more drag
76 * messages.
77 * To that end, we set scroll_block when we receive input from the scrollbar,
78 * and we clear it when we process the IPO_REFRESH message from core.
79 * A specific SCROLL_COMPLETED message would be better, but this seems to work.
80 */
81
82 static Boolean scroll_block = False;
83
84 /*
85 * PUBLIC: void __vi_set_scroll_block __P((void));
86 */
87 void
88 __vi_set_scroll_block(void)
89 {
90 scroll_block = True;
91 }
92
93 /*
94 * PUBLIC: void __vi_clear_scroll_block __P((void));
95 */
96 void
97 __vi_clear_scroll_block(void)
98 {
99 scroll_block = False;
100 }
101
102 \f
103 #if defined(__STDC__)
104 static void set_gc_colors( xvi_screen *this_screen, int val )
105 #else
106 static void set_gc_colors( this_screen, val )
107 xvi_screen *this_screen;
108 int val;
109 #endif
110 {
111 static Pixel fg, bg, hi, shade;
112 static int prev = COLOR_INVALID;
113
114 /* no change? */
115 if ( prev == val ) return;
116
117 /* init? */
118 if ( gc == NULL ) {
119
120 /* what colors are selected for the drawing area? */
121 XtVaGetValues( this_screen->area,
122 XtNbackground, &bg,
123 XtNforeground, &fg,
124 XmNhighlightColor, &hi,
125 XmNtopShadowColor, &shade,
126 0
127 );
128
129 gc = XCreateGC( XtDisplay(this_screen->area),
130 DefaultRootWindow(XtDisplay(this_screen->area)),
131 0,
132 0
133 );
134
135 XSetFont( XtDisplay(this_screen->area), gc, font->fid );
136 }
137
138 /* special colors? */
139 if ( val & COLOR_CARET ) {
140 XSetForeground( XtDisplay(this_screen->area), gc, fg );
141 XSetBackground( XtDisplay(this_screen->area), gc, hi );
142 }
143 else if ( val & COLOR_SELECT ) {
144 XSetForeground( XtDisplay(this_screen->area), gc, fg );
145 XSetBackground( XtDisplay(this_screen->area), gc, shade );
146 }
147 else switch (val) {
148 case COLOR_STANDARD:
149 XSetForeground( XtDisplay(this_screen->area), gc, fg );
150 XSetBackground( XtDisplay(this_screen->area), gc, bg );
151 break;
152 case COLOR_INVERSE:
153 XSetForeground( XtDisplay(this_screen->area), gc, bg );
154 XSetBackground( XtDisplay(this_screen->area), gc, fg );
155 break;
156 default: /* implement color map later */
157 break;
158 }
159 }
160
161 \f
162 /*
163 * Memory utilities
164 */
165
166 #ifdef REALLOC
167 #undef REALLOC
168 #endif
169
170 #define REALLOC( ptr, size ) \
171 ((ptr == NULL) ? malloc(size) : realloc(ptr,size))
172
173 \f
174 /* X windows routines.
175 * We currently create a single, top-level shell. In that is a
176 * single drawing area into which we will draw text. This allows
177 * us to put multi-color (and font, but we'll never build that) text
178 * into the drawing area. In the future, we'll add scrollbars to the
179 * drawing areas
180 */
181
182 void select_start();
183 void select_extend();
184 void select_paste();
185 void key_press();
186 void insert_string();
187 void beep __P((Widget w));
188 void find();
189 void command();
190
191 static XtActionsRec area_actions[] = {
192 { "select_start", select_start },
193 { "select_extend", select_extend },
194 { "select_paste", select_paste },
195 { "key_press", key_press },
196 { "insert_string", insert_string },
197 { "beep", beep },
198 { "find", find },
199 { "command", command },
200 };
201
202 char areaTrans[] =
203 "<Btn1Down>: select_start() \n\
204 <Btn1Motion>: select_extend() \n\
205 <Btn2Down>: select_paste() \n\
206 <Btn3Down>: select_extend() \n\
207 <Btn3Motion>: select_extend() \n\
208 <Key>End: command(VI_C_BOTTOM) \n\
209 <Key>Escape: command(EINSERT) \n\
210 <Key>Find: find() \n\
211 <Key>Home: command(VI_C_TOP) \n\
212 <Key>Next: command(VI_C_PGDOWN) \n\
213 <Key>Prior: command(VI_C_PGUP) \n\
214 <Key>osfBackSpace: command(VI_C_LEFT) \n\
215 <Key>osfBeginLine: command(VI_C_BOL) \n\
216 <Key>osfCopy: beep() \n\
217 <Key>osfCut: beep() \n\
218 <Key>osfDelete: command(VI_C_DEL) \n\
219 <Key>osfDown: command(VI_C_DOWN) \n\
220 <Key>osfEndLine: command(VI_C_EOL) \n\
221 <Key>osfInsert: command(VI_C_INSERT) \n\
222 <Key>osfLeft: command(VI_C_LEFT) \n\
223 <Key>osfPageDown: command(VI_C_PGDOWN) \n\
224 <Key>osfPageUp: command(VI_C_PGUP) \n\
225 <Key>osfPaste: insert_string(p) \n\
226 <Key>osfRight: command(VI_C_RIGHT) \n\
227 <Key>osfUndo: command(VI_UNDO) \n\
228 <Key>osfUp: command(VI_C_UP) \n\
229 Ctrl<Key>C: command(VI_INTERRUPT) \n\
230 <Key>: key_press()";
231
232
233 static XutResource resource[] = {
234 { "font", XutRKfont, &font },
235 { "pointerShape", XutRKcursor, &std_cursor },
236 { "busyShape", XutRKcursor, &busy_cursor },
237 };
238
239
240 /*
241 * vi_input_func --
242 * We've received input on the pipe from vi.
243 *
244 * PUBLIC: void vi_input_func __P((XtPointer, int *, XtInputId *));
245 */
246 void
247 vi_input_func(XtPointer client_data, int *source, XtInputId *id)
248 {
249 /* Parse and dispatch on commands in the queue. */
250 (void)ipvi_motif->input(ipvi_motif, *source);
251
252 #ifdef notdef
253 /* Check the pipe for unused events when not busy. */
254 XtAppAddWorkProc(ctx, process_pipe_input, NULL);
255 #endif
256 }
257
258
259 \f
260 /* Send the window size. */
261 #if defined(__STDC__)
262 static void send_resize( xvi_screen *this_screen )
263 #else
264 static void send_resize( this_screen )
265 xvi_screen *this_screen;
266 #endif
267 {
268 IP_BUF ipb;
269
270 ipb.val1 = this_screen->rows;
271 ipb.val2 = this_screen->cols;
272 ipb.code = VI_RESIZE;
273
274 #ifdef TRACE
275 vtrace("resize_func ( %d x %d )\n", this_screen->rows, this_screen->cols);
276 #endif
277
278 /* send up the pipe */
279 vi_send(vi_ofd, "12", &ipb);
280 }
281
282 \f
283 #if defined(__STDC__)
284 static void resize_backing_store( xvi_screen *this_screen )
285 #else
286 static void resize_backing_store( this_screen )
287 xvi_screen *this_screen;
288 #endif
289 {
290 int total_chars = this_screen->rows * this_screen->cols;
291
292 this_screen->characters = REALLOC( this_screen->characters,
293 total_chars
294 );
295 memset( this_screen->characters, ' ', total_chars );
296
297 this_screen->flags = REALLOC( this_screen->flags,
298 total_chars
299 );
300 memset( this_screen->flags, 0, total_chars );
301 }
302
303
304 \f
305 /* X will call this when we are resized */
306 #if defined(__STDC__)
307 static void resize_func( Widget wid,
308 XtPointer client_data,
309 XtPointer call_data
310 )
311 #else
312 static void resize_func( wid, client_data, call_data )
313 Widget wid;
314 XtPointer client_data;
315 XtPointer call_data;
316 #endif
317 {
318 xvi_screen *this_screen = (xvi_screen *) client_data;
319 Dimension height, width;
320
321 XtVaGetValues( wid, XmNheight, &height, XmNwidth, &width, 0 );
322
323 /* generate correct sizes when we have font metrics implemented */
324 this_screen->cols = width / this_screen->ch_width;
325 this_screen->rows = height / this_screen->ch_height;
326
327 resize_backing_store( this_screen );
328 send_resize( this_screen );
329 }
330
331
332 /*
333 * __vi_draw_text --
334 * Draw from backing store.
335 *
336 * PUBLIC: void __vi_draw_text __P((xvi_screen *, int, int, int));
337 */
338 void
339 __vi_draw_text(xvi_screen *this_screen, int row, int start_col, int len)
340 {
341 int col, color, xpos;
342 char *start, *end;
343
344 start = CharAt( __vi_screen, row, start_col );
345 color = *FlagAt( __vi_screen, row, start_col );
346 xpos = XPOS( __vi_screen, start_col );
347
348 /* one column at a time */
349 for ( col=start_col;
350 col<this_screen->cols && col<start_col+len;
351 col++ ) {
352
353 /* has the color changed? */
354 if ( *FlagAt( __vi_screen, row, col ) == color )
355 continue;
356
357 /* is there anything to write? */
358 end = CharAt( __vi_screen, row, col );
359 if ( end == start )
360 continue;
361
362 /* yes. write in the previous color */
363 set_gc_colors( __vi_screen, color );
364
365 /* add to display */
366 XDrawImageString( XtDisplay(__vi_screen->area),
367 XtWindow(__vi_screen->area),
368 gc,
369 xpos,
370 YPOS( __vi_screen, row ),
371 start,
372 end - start
373 );
374
375 /* this is the new context */
376 color = *FlagAt( __vi_screen, row, col );
377 xpos = XPOS( __vi_screen, col );
378 start = end;
379 }
380
381 /* is there anything to write? */
382 end = CharAt( __vi_screen, row, col );
383 if ( end != start ) {
384 /* yes. write in the previous color */
385 set_gc_colors( __vi_screen, color );
386
387 /* add to display */
388 XDrawImageString( XtDisplay(__vi_screen->area),
389 XtWindow(__vi_screen->area),
390 gc,
391 xpos,
392 YPOS( __vi_screen, row ),
393 start,
394 end - start
395 );
396 }
397 }
398
399 \f
400 /* set clipping rectangles accordingly */
401 #if defined(__STDC__)
402 static void add_to_clip( xvi_screen *cur_screen, int x, int y, int width, int height )
403 #else
404 static void add_to_clip( cur_screen, x, y, width, height )
405 xvi_screen *cur_screen;
406 int x;
407 int y;
408 int width;
409 int height;
410 #endif
411 {
412 XRectangle rect;
413 rect.x = x;
414 rect.y = y;
415 rect.height = height;
416 rect.width = width;
417 if ( cur_screen->clip == NULL )
418 cur_screen->clip = XCreateRegion();
419 XUnionRectWithRegion( &rect, cur_screen->clip, cur_screen->clip );
420 }
421
422 \f
423 /*
424 * __vi_expose_func --
425 * Redraw the window's contents.
426 *
427 * NOTE: When vi wants to force a redraw, we are called with NULL widget
428 * and call_data.
429 *
430 * PUBLIC: void __vi_expose_func __P((Widget, XtPointer, XtPointer));
431 */
432 void
433 __vi_expose_func(Widget wid, XtPointer client_data, XtPointer call_data)
434 {
435 xvi_screen *this_screen;
436 XmDrawingAreaCallbackStruct *cbs;
437 XExposeEvent *xev;
438 XGraphicsExposeEvent *gev;
439 int row;
440
441 /* convert pointers */
442 this_screen = (xvi_screen *) client_data;
443 cbs = (XmDrawingAreaCallbackStruct *) call_data;
444
445 /* first exposure? tell vi we are ready... */
446 if ( this_screen->init == False ) {
447
448 /* what does the user want to see? */
449 __vi_set_cursor( __vi_screen, False );
450
451 /* vi wants a resize as the first event */
452 send_resize( __vi_screen );
453
454 /* fine for now. we'll be back */
455 this_screen->init = True;
456 return;
457 }
458
459 if ( call_data == NULL ) {
460
461 /* vi core calls this when it wants a full refresh */
462 #ifdef TRACE
463 vtrace("expose_func: full refresh\n");
464 #endif
465
466 XClearWindow( XtDisplay(this_screen->area),
467 XtWindow(this_screen->area)
468 );
469 }
470 else {
471 switch ( cbs->event->type ) {
472
473 case GraphicsExpose:
474 gev = (XGraphicsExposeEvent *) cbs->event;
475
476 /* set clipping rectangles accordingly */
477 add_to_clip( this_screen,
478 gev->x, gev->y,
479 gev->width, gev->height
480 );
481
482 /* X calls here when XCopyArea exposes new bits */
483 #ifdef TRACE
484 vtrace("expose_func (X): (x=%d,y=%d,w=%d,h=%d), count=%d\n",
485 gev->x, gev->y,
486 gev->width, gev->height,
487 gev->count);
488 #endif
489
490 /* more coming? do it then */
491 if ( gev->count > 0 ) return;
492
493 /* set clipping region */
494 XSetRegion( XtDisplay(wid), gc, this_screen->clip );
495 break;
496
497 case Expose:
498 xev = (XExposeEvent *) cbs->event;
499
500 /* set clipping rectangles accordingly */
501 add_to_clip( this_screen,
502 xev->x, xev->y,
503 xev->width, xev->height
504 );
505
506 /* Motif calls here when DrawingArea is exposed */
507 #ifdef TRACE
508 vtrace("expose_func (Motif): (x=%d,y=%d,w=%d,h=%d), count=%d\n",
509 xev->x, xev->y,
510 xev->width, xev->height,
511 xev->count);
512 #endif
513
514 /* more coming? do it then */
515 if ( xev->count > 0 ) return;
516
517 /* set clipping region */
518 XSetRegion( XtDisplay(wid), gc, this_screen->clip );
519 break;
520
521 default:
522 /* don't care? */
523 return;
524 }
525 }
526
527 /* one row at a time */
528 for (row=0; row<this_screen->rows; row++) {
529
530 /* draw from the backing store */
531 __vi_draw_text( this_screen, row, 0, this_screen->cols );
532 }
533
534 /* clear clipping region */
535 XSetClipMask( XtDisplay(this_screen->area), gc, None );
536 if ( this_screen->clip != NULL ) {
537 XDestroyRegion( this_screen->clip );
538 this_screen->clip = NULL;
539 }
540
541 }
542
543 \f
544 #if defined(__STDC__)
545 static void xexpose ( Widget w,
546 XtPointer client_data,
547 XEvent *ev,
548 Boolean *cont
549 )
550 #else
551 static void xexpose ( w, client_data, ev, cont )
552 Widget w;
553 XtPointer client_data;
554 XEvent *ev;
555 Boolean *cont;
556 #endif
557 {
558 XmDrawingAreaCallbackStruct cbs;
559
560 switch ( ev->type ) {
561 case GraphicsExpose:
562 cbs.event = ev;
563 cbs.window = XtWindow(w);
564 cbs.reason = XmCR_EXPOSE;
565 __vi_expose_func( w, client_data, (XtPointer) &cbs );
566 *cont = False; /* we took care of it */
567 break;
568 default:
569 /* don't care */
570 break;
571 }
572 }
573
574
575 /* unimplemented keystroke or command */
576 #if defined(__STDC__)
577 static void beep( Widget w )
578 #else
579 static void beep( w )
580 Widget w;
581 #endif
582 {
583 XBell(XtDisplay(w),0);
584 }
585
586
587 /* give me a search dialog */
588 #if defined(__STDC__)
589 static void find( Widget w )
590 #else
591 static void find( w )
592 Widget w;
593 #endif
594 {
595 __vi_show_search_dialog( w, "Find" );
596 }
597
598 /*
599 * command --
600 * Translate simple keyboard input into vi protocol commands.
601 */
602 static void
603 command(Widget widget, XKeyEvent *event, String *str, Cardinal *cardinal)
604 {
605 static struct {
606 String name;
607 int code;
608 int count;
609 } table[] = {
610 { "VI_C_BOL", VI_C_BOL, 0 },
611 { "VI_C_BOTTOM", VI_C_BOTTOM, 0 },
612 { "VI_C_DEL", VI_C_DEL, 0 },
613 { "VI_C_DOWN", VI_C_DOWN, 1 },
614 { "VI_C_EOL", VI_C_EOL, 0 },
615 { "VI_C_INSERT", VI_C_INSERT, 0 },
616 { "VI_C_LEFT", VI_C_LEFT, 0 },
617 { "VI_C_PGDOWN", VI_C_PGDOWN, 1 },
618 { "VI_C_PGUP", VI_C_PGUP, 1 },
619 { "VI_C_RIGHT", VI_C_RIGHT, 0 },
620 { "VI_C_TOP", VI_C_TOP, 0 },
621 { "VI_C_UP", VI_C_UP, 1 },
622 { "VI_INTERRUPT", VI_INTERRUPT, 0 },
623 };
624 IP_BUF ipb;
625 int i;
626
627 /*
628 * XXX
629 * Do fast lookup based on character #6 -- sleazy, but I don't
630 * want to do 10 strcmp's per keystroke.
631 */
632 ipb.val1 = 1;
633 for (i = 0; i < XtNumber(table); i++)
634 if (table[i].name[6] == (*str)[6] &&
635 strcmp(table[i].name, *str) == 0) {
636 ipb.code = table[i].code;
637 vi_send(vi_ofd, table[i].count ? "1" : NULL, &ipb);
638 return;
639 }
640
641 /* oops. */
642 beep(widget);
643 }
644
645 /* mouse or keyboard input. */
646 #if defined(__STDC__)
647 static void insert_string( Widget widget,
648 XKeyEvent *event,
649 String *str,
650 Cardinal *cardinal
651 )
652 #else
653 static void insert_string( widget, event, str, cardinal )
654 Widget widget;
655 XKeyEvent *event;
656 String *str;
657 Cardinal *cardinal;
658 #endif
659 {
660 IP_BUF ipb;
661
662 ipb.len1 = strlen( *str );
663 if ( ipb.len1 != 0 ) {
664 ipb.code = VI_STRING;
665 ipb.str1 = *str;
666 vi_send(vi_ofd, "a", &ipb);
667 }
668
669 #ifdef TRACE
670 vtrace("insert_string {%.*s}\n", strlen( *str ), *str );
671 #endif
672 }
673
674
675 /* mouse or keyboard input. */
676 #if defined(__STDC__)
677 static void key_press( Widget widget,
678 XKeyEvent *event,
679 String str,
680 Cardinal *cardinal
681 )
682 #else
683 static void key_press( widget, event, str, cardinal )
684 Widget widget;
685 XKeyEvent *event;
686 String str;
687 Cardinal *cardinal;
688 #endif
689 {
690 IP_BUF ipb;
691 char bp[BufferSize];
692
693 ipb.len1 = XLookupString( event, bp, BufferSize, NULL, NULL );
694 if ( ipb.len1 != 0 ) {
695 ipb.code = VI_STRING;
696 ipb.str1 = bp;
697 #ifdef TRACE
698 vtrace("key_press {%.*s}\n", ipb.len1, bp );
699 #endif
700 vi_send(vi_ofd, "a", &ipb);
701 }
702
703 }
704
705
706 #if defined(__STDC__)
707 static void scrollbar_moved( Widget widget,
708 XtPointer ptr,
709 XmScrollBarCallbackStruct *cbs
710 )
711 #else
712 static void scrollbar_moved( widget, ptr, cbs )
713 Widget widget;
714 XtPointer ptr;
715 XmScrollBarCallbackStruct *cbs;
716 #endif
717 {
718 /* Future: Need to scroll the correct screen! */
719 xvi_screen *cur_screen = (xvi_screen *) ptr;
720 IP_BUF ipb;
721
722 /* if we are still processing messages from core, skip this event
723 * (see comments near __vi_set_scroll_block())
724 */
725 if ( scroll_block ) {
726 return;
727 }
728 __vi_set_scroll_block();
729
730 #ifdef TRACE
731 switch ( cbs->reason ) {
732 case XmCR_VALUE_CHANGED:
733 vtrace( "scrollbar VALUE_CHANGED %d\n", cbs->value );
734 break;
735 case XmCR_DRAG:
736 vtrace( "scrollbar DRAG %d\n", cbs->value );
737 break;
738 default:
739 vtrace( "scrollbar <default> %d\n", cbs->value );
740 break;
741 }
742 vtrace("scrollto {%d}\n", cbs->value );
743 #endif
744
745 /* Send the new cursor position. */
746 ipb.code = VI_C_SETTOP;
747 ipb.val1 = cbs->value;
748 (void)vi_send(vi_ofd, "1", &ipb);
749 }
750
751
752 #if defined(__STDC__)
753 static xvi_screen *create_screen( Widget parent, int rows, int cols )
754 #else
755 static xvi_screen *create_screen( parent, rows, cols )
756 Widget parent;
757 int rows, cols;
758 #endif
759 {
760 xvi_screen *new_screen = (xvi_screen *) calloc( 1, sizeof(xvi_screen) );
761 Widget frame;
762
763 /* init... */
764 new_screen->color = COLOR_STANDARD;
765 new_screen->parent = parent;
766
767 /* figure out the sizes */
768 new_screen->rows = rows;
769 new_screen->cols = cols;
770 new_screen->ch_width = font->max_bounds.width;
771 new_screen->ch_height = font->descent + font->ascent;
772 new_screen->ch_descent = font->descent;
773 new_screen->clip = NULL;
774
775 /* allocate and init the backing stores */
776 resize_backing_store( new_screen );
777
778 /* set up a translation table for the X toolkit */
779 if ( area_trans == NULL )
780 area_trans = XtParseTranslationTable(areaTrans);
781
782 /* future, new screen gets inserted into the parent sash
783 * immediately after the current screen. Default Pane action is
784 * to add it to the end
785 */
786
787 /* use a form to hold the drawing area and the scrollbar */
788 new_screen->form = XtVaCreateManagedWidget( "form",
789 xmFormWidgetClass,
790 parent,
791 XmNpaneMinimum, 2*new_screen->ch_height,
792 XmNallowResize, True,
793 NULL
794 );
795
796 /* create a scrollbar. */
797 new_screen->scroll = XtVaCreateManagedWidget( "scroll",
798 xmScrollBarWidgetClass,
799 new_screen->form,
800 XmNtopAttachment, XmATTACH_FORM,
801 XmNbottomAttachment, XmATTACH_FORM,
802 XmNrightAttachment, XmATTACH_FORM,
803 XmNminimum, 1,
804 XmNmaximum, 2,
805 XmNsliderSize, 1,
806 NULL
807 );
808 XtAddCallback( new_screen->scroll,
809 XmNvalueChangedCallback,
810 scrollbar_moved,
811 new_screen
812 );
813 XtAddCallback( new_screen->scroll,
814 XmNdragCallback,
815 scrollbar_moved,
816 new_screen
817 );
818
819 /* create a frame because they look nice */
820 frame = XtVaCreateManagedWidget( "frame",
821 xmFrameWidgetClass,
822 new_screen->form,
823 XmNshadowType, XmSHADOW_ETCHED_IN,
824 XmNtopAttachment, XmATTACH_FORM,
825 XmNbottomAttachment, XmATTACH_FORM,
826 XmNleftAttachment, XmATTACH_FORM,
827 XmNrightAttachment, XmATTACH_WIDGET,
828 XmNrightWidget, new_screen->scroll,
829 NULL
830 );
831
832 /* create a drawing area into which we will put text */
833 new_screen->area = XtVaCreateManagedWidget( "screen",
834 xmDrawingAreaWidgetClass,
835 frame,
836 XmNheight, new_screen->ch_height * new_screen->rows,
837 XmNwidth, new_screen->ch_width * new_screen->cols,
838 XmNtranslations, area_trans,
839 XmNuserData, new_screen,
840 XmNnavigationType, XmNONE,
841 XmNtraversalOn, False,
842 NULL
843 );
844
845 /* this callback is for when the drawing area is resized */
846 XtAddCallback( new_screen->area,
847 XmNresizeCallback,
848 resize_func,
849 new_screen
850 );
851
852 /* this callback is for when the drawing area is exposed */
853 XtAddCallback( new_screen->area,
854 XmNexposeCallback,
855 __vi_expose_func,
856 new_screen
857 );
858
859 /* this callback is for when we expose obscured bits
860 * (e.g. there is a window over part of our drawing area
861 */
862 XtAddEventHandler( new_screen->area,
863 0, /* no standard events */
864 True, /* we *WANT* GraphicsExpose */
865 xexpose, /* what to do */
866 new_screen
867 );
868
869 return new_screen;
870 }
871
872
873 static xvi_screen *split_screen(void)
874 {
875 Cardinal num;
876 WidgetList c;
877 int rows = __vi_screen->rows / 2;
878 xvi_screen *new_screen;
879
880 /* Note that (global) cur_screen needs to be correctly set so that
881 * insert_here knows which screen to put the new one after
882 */
883 new_screen = create_screen( __vi_screen->parent,
884 rows,
885 __vi_screen->cols
886 );
887
888 /* what are the screens? */
889 XtVaGetValues( __vi_screen->parent,
890 XmNnumChildren, &num,
891 XmNchildren, &c,
892 NULL
893 );
894
895 /* unmanage all children in preparation for resizing */
896 XtUnmanageChildren( c, num );
897
898 /* force resize of the affected screens */
899 XtVaSetValues( new_screen->form,
900 XmNheight, new_screen->ch_height * rows,
901 NULL
902 );
903 XtVaSetValues( __vi_screen->form,
904 XmNheight, __vi_screen->ch_height * rows,
905 NULL
906 );
907
908 /* re-manage */
909 XtManageChildren( c, num );
910
911 /* done */
912 return new_screen;
913 }
914
915 \f
916 /* Tell me where to insert the next subpane */
917 #if defined(__STDC__)
918 static Cardinal insert_here( Widget wid )
919 #else
920 static Cardinal insert_here( wid )
921 Widget wid;
922 #endif
923 {
924 Cardinal i, num;
925 WidgetList c;
926
927 XtVaGetValues( XtParent(wid),
928 XmNnumChildren, &num,
929 XmNchildren, &c,
930 NULL
931 );
932
933 /* The default XmNinsertPosition procedure for PanedWindow
934 * causes sashes to be inserted at the end of the list of children
935 * and causes non-sash widgets to be inserted after other
936 * non-sash children but before any sashes.
937 */
938 if ( ! XmIsForm( wid ) )
939 return num;
940
941 /* We will put the widget after the one with the current screen */
942 for (i=0; i<num && XmIsForm(c[i]); i++) {
943 if ( __vi_screen == NULL || __vi_screen->form == c[i] )
944 return i+1; /* after the i-th */
945 }
946
947 /* could not find it? this should never happen */
948 return num;
949 }
950
951
952 /*
953 * vi_create_editor --
954 * Create the necessary widgetry.
955 *
956 * PUBLIC: Widget vi_create_editor __P((String, Widget, void (*)(void)));
957 */
958 Widget
959 vi_create_editor(String name, Widget parent, void (*exitp) (void))
960 {
961 Widget pane_w;
962 Display *display = XtDisplay( parent );
963
964 __vi_exitp = exitp;
965
966 /* first time through? */
967 if ( ctx == NULL ) {
968
969 /* save this for later */
970 ctx = XtWidgetToApplicationContext( parent );
971
972 /* add our own special actions */
973 XtAppAddActions( ctx, area_actions, XtNumber(area_actions) );
974
975 /* how long is double-click? */
976 multi_click_length = XtGetMultiClickTime( display );
977
978 /* check the resource database for interesting resources */
979 __XutConvertResources( parent,
980 vi_progname,
981 resource,
982 XtNumber(resource)
983 );
984
985 /* we need a context for moving bits around in the windows */
986 __vi_copy_gc = XCreateGC( display,
987 DefaultRootWindow(display),
988 0,
989 0
990 );
991
992 /* routines for inter client communications conventions */
993 __vi_InitCopyPaste( f_copy, f_paste, f_clear, fprintf );
994 }
995
996 /* create the paned window */
997 pane_w = XtVaCreateManagedWidget( "pane",
998 xmPanedWindowWidgetClass,
999 parent,
1000 XmNinsertPosition, insert_here,
1001 NULL
1002 );
1003
1004 /* allocate our data structure. in the future we will have several
1005 * screens running around at the same time
1006 */
1007 __vi_screen = create_screen( pane_w, 24, 80 );
1008
1009 /* force creation of our color text context */
1010 set_gc_colors( __vi_screen, COLOR_STANDARD );
1011
1012 /* done */
1013 return pane_w;
1014 }
1015
1016 \f
1017 /* These routines deal with the selection buffer */
1018
1019 static int selection_start, selection_end, selection_anchor;
1020 static enum select_enum {
1021 select_char, select_word, select_line
1022 } select_type = select_char;
1023 static int last_click;
1024
1025 static char *clipboard = NULL;
1026 static int clipboard_size = 0,
1027 clipboard_length;
1028
1029
1030 #if defined(__STDC__)
1031 static void copy_to_clipboard( xvi_screen *cur_screen )
1032 #else
1033 static void copy_to_clipboard( cur_screen )
1034 xvi_screen *cur_screen;
1035 #endif
1036 {
1037 /* for now, copy from the backing store. in the future,
1038 * vi core will tell us exactly what the selection buffer contains
1039 */
1040 clipboard_length = 1 + selection_end - selection_start;
1041
1042 if ( clipboard == NULL )
1043 clipboard = (char *) malloc( clipboard_length );
1044 else if ( clipboard_size < clipboard_length )
1045 clipboard = (char *) realloc( clipboard, clipboard_length );
1046
1047 memcpy( clipboard,
1048 cur_screen->characters + selection_start,
1049 clipboard_length
1050 );
1051 }
1052
1053
1054 #if defined(__STDC__)
1055 static void mark_selection( xvi_screen *cur_screen, int start, int end )
1056 #else
1057 static void mark_selection( cur_screen, start, end )
1058 xvi_screen *cur_screen;
1059 int start;
1060 int end;
1061 #endif
1062 {
1063 int row, col, i;
1064
1065 for ( i=start; i<=end; i++ ) {
1066 if ( !( cur_screen->flags[i] & COLOR_SELECT ) ) {
1067 cur_screen->flags[i] |= COLOR_SELECT;
1068 ToRowCol( cur_screen, i, row, col );
1069 __vi_draw_text( cur_screen, row, col, 1 );
1070 }
1071 }
1072 }
1073
1074
1075 #if defined(__STDC__)
1076 static void erase_selection( xvi_screen *cur_screen, int start, int end )
1077 #else
1078 static void erase_selection( cur_screen, start, end )
1079 xvi_screen *cur_screen;
1080 int start;
1081 int end;
1082 #endif
1083 {
1084 int row, col, i;
1085
1086 for ( i=start; i<=end; i++ ) {
1087 if ( cur_screen->flags[i] & COLOR_SELECT ) {
1088 cur_screen->flags[i] &= ~COLOR_SELECT;
1089 ToRowCol( cur_screen, i, row, col );
1090 __vi_draw_text( cur_screen, row, col, 1 );
1091 }
1092 }
1093 }
1094
1095
1096 #if defined(__STDC__)
1097 static void left_expand_selection( xvi_screen *cur_screen, int *start )
1098 #else
1099 static void left_expand_selection( cur_screen, start )
1100 xvi_screen *cur_screen;
1101 int *start;
1102 #endif
1103 {
1104 int row, col;
1105
1106 switch ( select_type ) {
1107 case select_word:
1108 if ( *start == 0 || isspace( (unsigned char)cur_screen->characters[*start] ) )
1109 return;
1110 for (;;) {
1111 if ( isspace( (unsigned char)cur_screen->characters[*start-1] ) )
1112 return;
1113 if ( --(*start) == 0 )
1114 return;
1115 }
1116 case select_line:
1117 ToRowCol( cur_screen, *start, row, col );
1118 col = 0;
1119 *start = Linear( cur_screen, row, col );
1120 break;
1121 }
1122 }
1123
1124
1125 #if defined(__STDC__)
1126 static void right_expand_selection( xvi_screen *cur_screen, int *end )
1127 #else
1128 static void right_expand_selection( cur_screen, end )
1129 xvi_screen *cur_screen;
1130 int *end;
1131 #endif
1132 {
1133 int row, col, last = cur_screen->cols * cur_screen->rows - 1;
1134
1135 switch ( select_type ) {
1136 case select_word:
1137 if ( *end == last || isspace( (unsigned char)cur_screen->characters[*end] ) )
1138 return;
1139 for (;;) {
1140 if ( isspace( (unsigned char)cur_screen->characters[*end+1] ) )
1141 return;
1142 if ( ++(*end) == last )
1143 return;
1144 }
1145 case select_line:
1146 ToRowCol( cur_screen, *end, row, col );
1147 col = cur_screen->cols -1;
1148 *end = Linear( cur_screen, row, col );
1149 break;
1150 }
1151 }
1152
1153
1154 #if defined(__STDC__)
1155 static void select_start( Widget widget,
1156 XEvent *event,
1157 String str,
1158 Cardinal *cardinal
1159 )
1160 #else
1161 static void select_start( widget, event, str, cardinal )
1162 Widget widget;
1163 XEvent *event;
1164 String str;
1165 Cardinal *cardinal;
1166 #endif
1167 {
1168 IP_BUF ipb;
1169 int xpos, ypos;
1170 XPointerMovedEvent *ev = (XPointerMovedEvent *) event;
1171 static int last_click;
1172
1173 /*
1174 * NOTE: when multiple panes are implemented, we need to find the correct
1175 * screen. For now, there is only one.
1176 */
1177 xpos = COLUMN( __vi_screen, ev->x );
1178 ypos = ROW( __vi_screen, ev->y );
1179
1180 /* Remove the old one. */
1181 erase_selection( __vi_screen, selection_start, selection_end );
1182
1183 /* Send the new cursor position. */
1184 ipb.code = VI_MOUSE_MOVE;
1185 ipb.val1 = ypos;
1186 ipb.val2 = xpos;
1187 (void)vi_send(vi_ofd, "12", &ipb);
1188
1189 /* click-click, and we go for words, lines, etc */
1190 if ( ev->time - last_click < multi_click_length )
1191 select_type = (enum select_enum) ((((int)select_type)+1)%3);
1192 else
1193 select_type = select_char;
1194 last_click = ev->time;
1195
1196 /* put the selection here */
1197 selection_anchor = Linear( __vi_screen, ypos, xpos );
1198 selection_start = selection_anchor;
1199 selection_end = selection_anchor;
1200
1201 /* expand to include words, line, etc */
1202 left_expand_selection( __vi_screen, &selection_start );
1203 right_expand_selection( __vi_screen, &selection_end );
1204
1205 /* draw the new one */
1206 mark_selection( __vi_screen, selection_start, selection_end );
1207
1208 /* and tell the window manager we own the selection */
1209 if ( select_type != select_char ) {
1210 __vi_AcquirePrimary( widget );
1211 copy_to_clipboard( __vi_screen );
1212 }
1213 }
1214
1215
1216 #if defined(__STDC__)
1217 static void select_extend( Widget widget,
1218 XEvent *event,
1219 String str,
1220 Cardinal *cardinal
1221 )
1222 #else
1223 static void select_extend( widget, event, str, cardinal )
1224 Widget widget;
1225 XEvent *event;
1226 String str;
1227 Cardinal *cardinal;
1228 #endif
1229 {
1230 int xpos, ypos, pos;
1231 XPointerMovedEvent *ev = (XPointerMovedEvent *) event;
1232
1233 /* NOTE: when multiple panes are implemented, we need to find
1234 * the correct screen. For now, there is only one.
1235 */
1236 xpos = COLUMN( __vi_screen, ev->x );
1237 ypos = ROW( __vi_screen, ev->y );
1238
1239 /* deal with words, lines, etc */
1240 pos = Linear( __vi_screen, ypos, xpos );
1241 if ( pos < selection_anchor )
1242 left_expand_selection( __vi_screen, &pos );
1243 else
1244 right_expand_selection( __vi_screen, &pos );
1245
1246 /* extend from before the start? */
1247 if ( pos < selection_start ) {
1248 mark_selection( __vi_screen, pos, selection_start-1 );
1249 selection_start = pos;
1250 }
1251
1252 /* extend past the end? */
1253 else if ( pos > selection_end ) {
1254 mark_selection( __vi_screen, selection_end+1, pos );
1255 selection_end = pos;
1256 }
1257
1258 /* between the anchor and the start? */
1259 else if ( pos < selection_anchor ) {
1260 erase_selection( __vi_screen, selection_start, pos-1 );
1261 selection_start = pos;
1262 }
1263
1264 /* between the anchor and the end? */
1265 else {
1266 erase_selection( __vi_screen, pos+1, selection_end );
1267 selection_end = pos;
1268 }
1269
1270 /* and tell the window manager we own the selection */
1271 __vi_AcquirePrimary( widget );
1272 copy_to_clipboard( __vi_screen );
1273 }
1274
1275
1276 #if defined(__STDC__)
1277 static void select_paste( Widget widget,
1278 XEvent *event,
1279 String str,
1280 Cardinal *cardinal
1281 )
1282 #else
1283 static void select_paste( widget, event, str, cardinal )
1284 Widget widget;
1285 XEvent *event;
1286 String str;
1287 Cardinal *cardinal;
1288 #endif
1289 {
1290 __vi_PasteFromClipboard( widget );
1291 }
1292
1293 \f
1294 /* Interface to copy and paste
1295 * (a) callbacks from the window manager
1296 * f_copy - it wants our buffer
1297 * f_paste - it wants us to paste some text
1298 * f_clear - we've lost the selection, clear it
1299 */
1300
1301 #if defined(__STDC__)
1302 static void f_copy( String *buffer, int *len )
1303 #else
1304 static void f_copy( buffer, len )
1305 String *buffer;
1306 int *len;
1307 #endif
1308 {
1309 #ifdef TRACE
1310 vtrace("f_copy() called");
1311 #endif
1312 *buffer = clipboard;
1313 *len = clipboard_length;
1314 }
1315
1316
1317
1318 static void f_paste(int widget, int buffer, int length)
1319 {
1320 /* NOTE: when multiple panes are implemented, we need to find
1321 * the correct screen. For now, there is only one.
1322 */
1323 #ifdef TRACE
1324 vtrace("f_paste() called with '%*.*s'\n", length, length, buffer);
1325 #endif
1326 }
1327
1328
1329 #if defined(__STDC__)
1330 static void f_clear( Widget widget )
1331 #else
1332 static void f_clear( widget )
1333 Widget widget;
1334 #endif
1335 {
1336 xvi_screen *cur_screen;
1337
1338 #ifdef TRACE
1339 vtrace("f_clear() called");
1340 #endif
1341
1342 XtVaGetValues( widget, XmNuserData, &cur_screen, 0 );
1343
1344 erase_selection( cur_screen, selection_start, selection_end );
1345 }
1346
1347 \f
1348 /*
1349 * These routines deal with the cursor.
1350 *
1351 * PUBLIC: void __vi_set_cursor __P((xvi_screen *, int));
1352 */
1353 void
1354 __vi_set_cursor(xvi_screen *cur_screen, int is_busy)
1355 {
1356 XDefineCursor( XtDisplay(cur_screen->area),
1357 XtWindow(cur_screen->area),
1358 (is_busy) ? busy_cursor : std_cursor
1359 );
1360 }
1361
1362
1363 \f
1364 /* hooks for the tags widget */
1365
1366 static String cur_word = NULL;
1367
1368 /*
1369 * PUBLIC: void __vi_set_word_at_caret __P((xvi_screen *));
1370 */
1371 void
1372 __vi_set_word_at_caret(xvi_screen *this_screen)
1373 {
1374 char *start, *end, save;
1375 int newx, newy;
1376
1377 newx = this_screen->curx;
1378 newy = this_screen->cury;
1379
1380 /* Note that this really ought to be done by core due to wrapping issues */
1381 for ( end = start = CharAt( this_screen, newy, newx );
1382 (isalnum( (unsigned char)*end ) || *end == '_') && (newx < this_screen->cols);
1383 end++, newx++
1384 );
1385 save = *end;
1386 *end = '\0';
1387 if ( cur_word != NULL ) free( cur_word );
1388 cur_word = strdup( start );
1389 *end = save;
1390
1391 /* if the tag stack widget is active, set the text field there
1392 * to agree with the current caret position.
1393 */
1394 __vi_set_tag_text( cur_word );
1395 }
1396
1397
1398 String __vi_get_word_at_caret(xvi_screen *this_screen)
1399 {
1400 return (cur_word) ? cur_word : "";
1401 }
1402
1403 \f
1404 /*
1405 * These routines deal with the caret.
1406 *
1407 * PUBLIC: void draw_caret __P((xvi_screen *));
1408 */
1409 static void
1410 draw_caret(xvi_screen *this_screen)
1411 {
1412 /* draw the caret by drawing the text in highlight color */
1413 *FlagAt( this_screen, this_screen->cury, this_screen->curx ) |= COLOR_CARET;
1414 __vi_draw_text( this_screen, this_screen->cury, this_screen->curx, 1 );
1415 }
1416
1417 /*
1418 * PUBLIC: void __vi_erase_caret __P((xvi_screen *));
1419 */
1420 void
1421 __vi_erase_caret(xvi_screen *this_screen)
1422 {
1423 /* erase the caret by drawing the text in normal video */
1424 *FlagAt( this_screen, this_screen->cury, this_screen->curx ) &= ~COLOR_CARET;
1425 __vi_draw_text( this_screen, this_screen->cury, this_screen->curx, 1 );
1426 }
1427
1428 /*
1429 * PUBLIC: void __vi_move_caret __P((xvi_screen *, int, int));
1430 */
1431 void
1432 __vi_move_caret(xvi_screen *this_screen, int newy, int newx)
1433 {
1434 /* remove the old caret */
1435 __vi_erase_caret( this_screen );
1436
1437 /* caret is now here */
1438 this_screen->curx = newx;
1439 this_screen->cury = newy;
1440 draw_caret( this_screen );
1441 }
MINIX 3 (repo.or.cz mirror)