84d9c625bf
- Fix for possible unset uid/gid in toproto
- Fix for default mtree style
- Update libelf
- Importing libexecinfo
- Resynchronize GCC, mpc, gmp, mpfr
- build.sh: Replace params with show-params.
This has been done as the make target has been renamed in the same
way, while a new target named params has been added. This new
target generates a file containing all the parameters, instead of
printing it on the console.
- Update test48 with new etc/services (Fix by Ben Gras <ben@minix3.org)
get getservbyport() out of the inner loop
Change-Id: Ie6ad5226fa2621ff9f0dee8782ea48f9443d2091
1441 lines
34 KiB
C
1441 lines
34 KiB
C
/* $NetBSD: m_vi.c,v 1.2 2013/11/22 15:52:06 christos Exp $ */
|
||
* Copyright (c) 1996
|
||
* Rob Zimmermann. All rights reserved.
|
||
* Copyright (c) 1996
|
||
* Keith Bostic. All rights reserved.
|
||
*
|
||
* See the LICENSE file for redistribution information.
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#ifndef lint
|
||
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 ";
|
||
#endif /* not lint */
|
||
|
||
#include <sys/types.h>
|
||
#include <sys/queue.h>
|
||
|
||
#include <X11/Intrinsic.h>
|
||
#include <X11/StringDefs.h>
|
||
#include <X11/cursorfont.h>
|
||
#include <Xm/PanedW.h>
|
||
#include <Xm/DrawingA.h>
|
||
#include <Xm/Form.h>
|
||
#include <Xm/Frame.h>
|
||
#include <Xm/ScrollBar.h>
|
||
|
||
#include <bitstring.h>
|
||
#include <ctype.h>
|
||
#include <errno.h>
|
||
#include <fcntl.h>
|
||
#include <signal.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
|
||
#undef LOCK_SUCCESS
|
||
#include "../common/common.h"
|
||
#include "../ipc/ip.h"
|
||
#include "m_motif.h"
|
||
#include "vi_mextern.h"
|
||
#include "pathnames.h"
|
||
|
||
extern int vi_ofd;
|
||
|
||
static void f_copy(String *buffer, int *len);
|
||
static void f_paste(int widget, int buffer, int length);
|
||
static void f_clear(Widget widget);
|
||
|
||
|
||
/*
|
||
* Globals and costants
|
||
*/
|
||
|
||
#define BufferSize 1024
|
||
|
||
static XFontStruct *font;
|
||
static GC gc;
|
||
GC __vi_copy_gc;
|
||
static XtAppContext ctx;
|
||
|
||
xvi_screen *__vi_screen = NULL;
|
||
static Cursor std_cursor;
|
||
static Cursor busy_cursor;
|
||
static XtTranslations area_trans;
|
||
static int multi_click_length;
|
||
|
||
void (*__vi_exitp)(); /* Exit function. */
|
||
|
||
|
||
/* hack for drag scrolling...
|
||
* I'm not sure why, but the current protocol gets out of sync when
|
||
* a lot of drag messages get passed around. Likely, we need to wait
|
||
* for core to finish repainting the screen before sending more drag
|
||
* messages.
|
||
* To that end, we set scroll_block when we receive input from the scrollbar,
|
||
* and we clear it when we process the IPO_REFRESH message from core.
|
||
* A specific SCROLL_COMPLETED message would be better, but this seems to work.
|
||
*/
|
||
|
||
static Boolean scroll_block = False;
|
||
|
||
/*
|
||
* PUBLIC: void __vi_set_scroll_block __P((void));
|
||
*/
|
||
void
|
||
__vi_set_scroll_block(void)
|
||
{
|
||
scroll_block = True;
|
||
}
|
||
|
||
/*
|
||
* PUBLIC: void __vi_clear_scroll_block __P((void));
|
||
*/
|
||
void
|
||
__vi_clear_scroll_block(void)
|
||
{
|
||
scroll_block = False;
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void set_gc_colors( xvi_screen *this_screen, int val )
|
||
#else
|
||
static void set_gc_colors( this_screen, val )
|
||
xvi_screen *this_screen;
|
||
int val;
|
||
#endif
|
||
{
|
||
static Pixel fg, bg, hi, shade;
|
||
static int prev = COLOR_INVALID;
|
||
|
||
/* no change? */
|
||
if ( prev == val ) return;
|
||
|
||
/* init? */
|
||
if ( gc == NULL ) {
|
||
|
||
/* what colors are selected for the drawing area? */
|
||
XtVaGetValues( this_screen->area,
|
||
XtNbackground, &bg,
|
||
XtNforeground, &fg,
|
||
XmNhighlightColor, &hi,
|
||
XmNtopShadowColor, &shade,
|
||
0
|
||
);
|
||
|
||
gc = XCreateGC( XtDisplay(this_screen->area),
|
||
DefaultRootWindow(XtDisplay(this_screen->area)),
|
||
0,
|
||
0
|
||
);
|
||
|
||
XSetFont( XtDisplay(this_screen->area), gc, font->fid );
|
||
}
|
||
|
||
/* special colors? */
|
||
if ( val & COLOR_CARET ) {
|
||
XSetForeground( XtDisplay(this_screen->area), gc, fg );
|
||
XSetBackground( XtDisplay(this_screen->area), gc, hi );
|
||
}
|
||
else if ( val & COLOR_SELECT ) {
|
||
XSetForeground( XtDisplay(this_screen->area), gc, fg );
|
||
XSetBackground( XtDisplay(this_screen->area), gc, shade );
|
||
}
|
||
else switch (val) {
|
||
case COLOR_STANDARD:
|
||
XSetForeground( XtDisplay(this_screen->area), gc, fg );
|
||
XSetBackground( XtDisplay(this_screen->area), gc, bg );
|
||
break;
|
||
case COLOR_INVERSE:
|
||
XSetForeground( XtDisplay(this_screen->area), gc, bg );
|
||
XSetBackground( XtDisplay(this_screen->area), gc, fg );
|
||
break;
|
||
default: /* implement color map later */
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* Memory utilities
|
||
*/
|
||
|
||
#ifdef REALLOC
|
||
#undef REALLOC
|
||
#endif
|
||
|
||
#define REALLOC( ptr, size ) \
|
||
((ptr == NULL) ? malloc(size) : realloc(ptr,size))
|
||
|
||
|
||
/* X windows routines.
|
||
* We currently create a single, top-level shell. In that is a
|
||
* single drawing area into which we will draw text. This allows
|
||
* us to put multi-color (and font, but we'll never build that) text
|
||
* into the drawing area. In the future, we'll add scrollbars to the
|
||
* drawing areas
|
||
*/
|
||
|
||
void select_start();
|
||
void select_extend();
|
||
void select_paste();
|
||
void key_press();
|
||
void insert_string();
|
||
void beep __P((Widget w));
|
||
void find();
|
||
void command();
|
||
|
||
static XtActionsRec area_actions[] = {
|
||
{ "select_start", select_start },
|
||
{ "select_extend", select_extend },
|
||
{ "select_paste", select_paste },
|
||
{ "key_press", key_press },
|
||
{ "insert_string", insert_string },
|
||
{ "beep", beep },
|
||
{ "find", find },
|
||
{ "command", command },
|
||
};
|
||
|
||
char areaTrans[] =
|
||
"<Btn1Down>: select_start() \n\
|
||
<Btn1Motion>: select_extend() \n\
|
||
<Btn2Down>: select_paste() \n\
|
||
<Btn3Down>: select_extend() \n\
|
||
<Btn3Motion>: select_extend() \n\
|
||
<Key>End: command(VI_C_BOTTOM) \n\
|
||
<Key>Escape: command(EINSERT) \n\
|
||
<Key>Find: find() \n\
|
||
<Key>Home: command(VI_C_TOP) \n\
|
||
<Key>Next: command(VI_C_PGDOWN) \n\
|
||
<Key>Prior: command(VI_C_PGUP) \n\
|
||
<Key>osfBackSpace: command(VI_C_LEFT) \n\
|
||
<Key>osfBeginLine: command(VI_C_BOL) \n\
|
||
<Key>osfCopy: beep() \n\
|
||
<Key>osfCut: beep() \n\
|
||
<Key>osfDelete: command(VI_C_DEL) \n\
|
||
<Key>osfDown: command(VI_C_DOWN) \n\
|
||
<Key>osfEndLine: command(VI_C_EOL) \n\
|
||
<Key>osfInsert: command(VI_C_INSERT) \n\
|
||
<Key>osfLeft: command(VI_C_LEFT) \n\
|
||
<Key>osfPageDown: command(VI_C_PGDOWN) \n\
|
||
<Key>osfPageUp: command(VI_C_PGUP) \n\
|
||
<Key>osfPaste: insert_string(p) \n\
|
||
<Key>osfRight: command(VI_C_RIGHT) \n\
|
||
<Key>osfUndo: command(VI_UNDO) \n\
|
||
<Key>osfUp: command(VI_C_UP) \n\
|
||
Ctrl<Key>C: command(VI_INTERRUPT) \n\
|
||
<Key>: key_press()";
|
||
|
||
|
||
static XutResource resource[] = {
|
||
{ "font", XutRKfont, &font },
|
||
{ "pointerShape", XutRKcursor, &std_cursor },
|
||
{ "busyShape", XutRKcursor, &busy_cursor },
|
||
};
|
||
|
||
|
||
/*
|
||
* vi_input_func --
|
||
* We've received input on the pipe from vi.
|
||
*
|
||
* PUBLIC: void vi_input_func __P((XtPointer, int *, XtInputId *));
|
||
*/
|
||
void
|
||
vi_input_func(XtPointer client_data, int *source, XtInputId *id)
|
||
{
|
||
/* Parse and dispatch on commands in the queue. */
|
||
(void)ipvi_motif->input(ipvi_motif, *source);
|
||
|
||
#ifdef notdef
|
||
/* Check the pipe for unused events when not busy. */
|
||
XtAppAddWorkProc(ctx, process_pipe_input, NULL);
|
||
#endif
|
||
}
|
||
|
||
|
||
|
||
/* Send the window size. */
|
||
#if defined(__STDC__)
|
||
static void send_resize( xvi_screen *this_screen )
|
||
#else
|
||
static void send_resize( this_screen )
|
||
xvi_screen *this_screen;
|
||
#endif
|
||
{
|
||
IP_BUF ipb;
|
||
|
||
ipb.val1 = this_screen->rows;
|
||
ipb.val2 = this_screen->cols;
|
||
ipb.code = VI_RESIZE;
|
||
|
||
#ifdef TRACE
|
||
vtrace("resize_func ( %d x %d )\n", this_screen->rows, this_screen->cols);
|
||
#endif
|
||
|
||
/* send up the pipe */
|
||
vi_send(vi_ofd, "12", &ipb);
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void resize_backing_store( xvi_screen *this_screen )
|
||
#else
|
||
static void resize_backing_store( this_screen )
|
||
xvi_screen *this_screen;
|
||
#endif
|
||
{
|
||
int total_chars = this_screen->rows * this_screen->cols;
|
||
|
||
this_screen->characters = REALLOC( this_screen->characters,
|
||
total_chars
|
||
);
|
||
memset( this_screen->characters, ' ', total_chars );
|
||
|
||
this_screen->flags = REALLOC( this_screen->flags,
|
||
total_chars
|
||
);
|
||
memset( this_screen->flags, 0, total_chars );
|
||
}
|
||
|
||
|
||
|
||
/* X will call this when we are resized */
|
||
#if defined(__STDC__)
|
||
static void resize_func( Widget wid,
|
||
XtPointer client_data,
|
||
XtPointer call_data
|
||
)
|
||
#else
|
||
static void resize_func( wid, client_data, call_data )
|
||
Widget wid;
|
||
XtPointer client_data;
|
||
XtPointer call_data;
|
||
#endif
|
||
{
|
||
xvi_screen *this_screen = (xvi_screen *) client_data;
|
||
Dimension height, width;
|
||
|
||
XtVaGetValues( wid, XmNheight, &height, XmNwidth, &width, 0 );
|
||
|
||
/* generate correct sizes when we have font metrics implemented */
|
||
this_screen->cols = width / this_screen->ch_width;
|
||
this_screen->rows = height / this_screen->ch_height;
|
||
|
||
resize_backing_store( this_screen );
|
||
send_resize( this_screen );
|
||
}
|
||
|
||
|
||
/*
|
||
* __vi_draw_text --
|
||
* Draw from backing store.
|
||
*
|
||
* PUBLIC: void __vi_draw_text __P((xvi_screen *, int, int, int));
|
||
*/
|
||
void
|
||
__vi_draw_text(xvi_screen *this_screen, int row, int start_col, int len)
|
||
{
|
||
int col, color, xpos;
|
||
char *start, *end;
|
||
|
||
start = CharAt( __vi_screen, row, start_col );
|
||
color = *FlagAt( __vi_screen, row, start_col );
|
||
xpos = XPOS( __vi_screen, start_col );
|
||
|
||
/* one column at a time */
|
||
for ( col=start_col;
|
||
col<this_screen->cols && col<start_col+len;
|
||
col++ ) {
|
||
|
||
/* has the color changed? */
|
||
if ( *FlagAt( __vi_screen, row, col ) == color )
|
||
continue;
|
||
|
||
/* is there anything to write? */
|
||
end = CharAt( __vi_screen, row, col );
|
||
if ( end == start )
|
||
continue;
|
||
|
||
/* yes. write in the previous color */
|
||
set_gc_colors( __vi_screen, color );
|
||
|
||
/* add to display */
|
||
XDrawImageString( XtDisplay(__vi_screen->area),
|
||
XtWindow(__vi_screen->area),
|
||
gc,
|
||
xpos,
|
||
YPOS( __vi_screen, row ),
|
||
start,
|
||
end - start
|
||
);
|
||
|
||
/* this is the new context */
|
||
color = *FlagAt( __vi_screen, row, col );
|
||
xpos = XPOS( __vi_screen, col );
|
||
start = end;
|
||
}
|
||
|
||
/* is there anything to write? */
|
||
end = CharAt( __vi_screen, row, col );
|
||
if ( end != start ) {
|
||
/* yes. write in the previous color */
|
||
set_gc_colors( __vi_screen, color );
|
||
|
||
/* add to display */
|
||
XDrawImageString( XtDisplay(__vi_screen->area),
|
||
XtWindow(__vi_screen->area),
|
||
gc,
|
||
xpos,
|
||
YPOS( __vi_screen, row ),
|
||
start,
|
||
end - start
|
||
);
|
||
}
|
||
}
|
||
|
||
|
||
/* set clipping rectangles accordingly */
|
||
#if defined(__STDC__)
|
||
static void add_to_clip( xvi_screen *cur_screen, int x, int y, int width, int height )
|
||
#else
|
||
static void add_to_clip( cur_screen, x, y, width, height )
|
||
xvi_screen *cur_screen;
|
||
int x;
|
||
int y;
|
||
int width;
|
||
int height;
|
||
#endif
|
||
{
|
||
XRectangle rect;
|
||
rect.x = x;
|
||
rect.y = y;
|
||
rect.height = height;
|
||
rect.width = width;
|
||
if ( cur_screen->clip == NULL )
|
||
cur_screen->clip = XCreateRegion();
|
||
XUnionRectWithRegion( &rect, cur_screen->clip, cur_screen->clip );
|
||
}
|
||
|
||
|
||
/*
|
||
* __vi_expose_func --
|
||
* Redraw the window's contents.
|
||
*
|
||
* NOTE: When vi wants to force a redraw, we are called with NULL widget
|
||
* and call_data.
|
||
*
|
||
* PUBLIC: void __vi_expose_func __P((Widget, XtPointer, XtPointer));
|
||
*/
|
||
void
|
||
__vi_expose_func(Widget wid, XtPointer client_data, XtPointer call_data)
|
||
{
|
||
xvi_screen *this_screen;
|
||
XmDrawingAreaCallbackStruct *cbs;
|
||
XExposeEvent *xev;
|
||
XGraphicsExposeEvent *gev;
|
||
int row;
|
||
|
||
/* convert pointers */
|
||
this_screen = (xvi_screen *) client_data;
|
||
cbs = (XmDrawingAreaCallbackStruct *) call_data;
|
||
|
||
/* first exposure? tell vi we are ready... */
|
||
if ( this_screen->init == False ) {
|
||
|
||
/* what does the user want to see? */
|
||
__vi_set_cursor( __vi_screen, False );
|
||
|
||
/* vi wants a resize as the first event */
|
||
send_resize( __vi_screen );
|
||
|
||
/* fine for now. we'll be back */
|
||
this_screen->init = True;
|
||
return;
|
||
}
|
||
|
||
if ( call_data == NULL ) {
|
||
|
||
/* vi core calls this when it wants a full refresh */
|
||
#ifdef TRACE
|
||
vtrace("expose_func: full refresh\n");
|
||
#endif
|
||
|
||
XClearWindow( XtDisplay(this_screen->area),
|
||
XtWindow(this_screen->area)
|
||
);
|
||
}
|
||
else {
|
||
switch ( cbs->event->type ) {
|
||
|
||
case GraphicsExpose:
|
||
gev = (XGraphicsExposeEvent *) cbs->event;
|
||
|
||
/* set clipping rectangles accordingly */
|
||
add_to_clip( this_screen,
|
||
gev->x, gev->y,
|
||
gev->width, gev->height
|
||
);
|
||
|
||
/* X calls here when XCopyArea exposes new bits */
|
||
#ifdef TRACE
|
||
vtrace("expose_func (X): (x=%d,y=%d,w=%d,h=%d), count=%d\n",
|
||
gev->x, gev->y,
|
||
gev->width, gev->height,
|
||
gev->count);
|
||
#endif
|
||
|
||
/* more coming? do it then */
|
||
if ( gev->count > 0 ) return;
|
||
|
||
/* set clipping region */
|
||
XSetRegion( XtDisplay(wid), gc, this_screen->clip );
|
||
break;
|
||
|
||
case Expose:
|
||
xev = (XExposeEvent *) cbs->event;
|
||
|
||
/* set clipping rectangles accordingly */
|
||
add_to_clip( this_screen,
|
||
xev->x, xev->y,
|
||
xev->width, xev->height
|
||
);
|
||
|
||
/* Motif calls here when DrawingArea is exposed */
|
||
#ifdef TRACE
|
||
vtrace("expose_func (Motif): (x=%d,y=%d,w=%d,h=%d), count=%d\n",
|
||
xev->x, xev->y,
|
||
xev->width, xev->height,
|
||
xev->count);
|
||
#endif
|
||
|
||
/* more coming? do it then */
|
||
if ( xev->count > 0 ) return;
|
||
|
||
/* set clipping region */
|
||
XSetRegion( XtDisplay(wid), gc, this_screen->clip );
|
||
break;
|
||
|
||
default:
|
||
/* don't care? */
|
||
return;
|
||
}
|
||
}
|
||
|
||
/* one row at a time */
|
||
for (row=0; row<this_screen->rows; row++) {
|
||
|
||
/* draw from the backing store */
|
||
__vi_draw_text( this_screen, row, 0, this_screen->cols );
|
||
}
|
||
|
||
/* clear clipping region */
|
||
XSetClipMask( XtDisplay(this_screen->area), gc, None );
|
||
if ( this_screen->clip != NULL ) {
|
||
XDestroyRegion( this_screen->clip );
|
||
this_screen->clip = NULL;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void xexpose ( Widget w,
|
||
XtPointer client_data,
|
||
XEvent *ev,
|
||
Boolean *cont
|
||
)
|
||
#else
|
||
static void xexpose ( w, client_data, ev, cont )
|
||
Widget w;
|
||
XtPointer client_data;
|
||
XEvent *ev;
|
||
Boolean *cont;
|
||
#endif
|
||
{
|
||
XmDrawingAreaCallbackStruct cbs;
|
||
|
||
switch ( ev->type ) {
|
||
case GraphicsExpose:
|
||
cbs.event = ev;
|
||
cbs.window = XtWindow(w);
|
||
cbs.reason = XmCR_EXPOSE;
|
||
__vi_expose_func( w, client_data, (XtPointer) &cbs );
|
||
*cont = False; /* we took care of it */
|
||
break;
|
||
default:
|
||
/* don't care */
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/* unimplemented keystroke or command */
|
||
#if defined(__STDC__)
|
||
static void beep( Widget w )
|
||
#else
|
||
static void beep( w )
|
||
Widget w;
|
||
#endif
|
||
{
|
||
XBell(XtDisplay(w),0);
|
||
}
|
||
|
||
|
||
/* give me a search dialog */
|
||
#if defined(__STDC__)
|
||
static void find( Widget w )
|
||
#else
|
||
static void find( w )
|
||
Widget w;
|
||
#endif
|
||
{
|
||
__vi_show_search_dialog( w, "Find" );
|
||
}
|
||
|
||
/*
|
||
* command --
|
||
* Translate simple keyboard input into vi protocol commands.
|
||
*/
|
||
static void
|
||
command(Widget widget, XKeyEvent *event, String *str, Cardinal *cardinal)
|
||
{
|
||
static struct {
|
||
String name;
|
||
int code;
|
||
int count;
|
||
} table[] = {
|
||
{ "VI_C_BOL", VI_C_BOL, 0 },
|
||
{ "VI_C_BOTTOM", VI_C_BOTTOM, 0 },
|
||
{ "VI_C_DEL", VI_C_DEL, 0 },
|
||
{ "VI_C_DOWN", VI_C_DOWN, 1 },
|
||
{ "VI_C_EOL", VI_C_EOL, 0 },
|
||
{ "VI_C_INSERT", VI_C_INSERT, 0 },
|
||
{ "VI_C_LEFT", VI_C_LEFT, 0 },
|
||
{ "VI_C_PGDOWN", VI_C_PGDOWN, 1 },
|
||
{ "VI_C_PGUP", VI_C_PGUP, 1 },
|
||
{ "VI_C_RIGHT", VI_C_RIGHT, 0 },
|
||
{ "VI_C_TOP", VI_C_TOP, 0 },
|
||
{ "VI_C_UP", VI_C_UP, 1 },
|
||
{ "VI_INTERRUPT", VI_INTERRUPT, 0 },
|
||
};
|
||
IP_BUF ipb;
|
||
int i;
|
||
|
||
/*
|
||
* XXX
|
||
* Do fast lookup based on character #6 -- sleazy, but I don't
|
||
* want to do 10 strcmp's per keystroke.
|
||
*/
|
||
ipb.val1 = 1;
|
||
for (i = 0; i < XtNumber(table); i++)
|
||
if (table[i].name[6] == (*str)[6] &&
|
||
strcmp(table[i].name, *str) == 0) {
|
||
ipb.code = table[i].code;
|
||
vi_send(vi_ofd, table[i].count ? "1" : NULL, &ipb);
|
||
return;
|
||
}
|
||
|
||
/* oops. */
|
||
beep(widget);
|
||
}
|
||
|
||
/* mouse or keyboard input. */
|
||
#if defined(__STDC__)
|
||
static void insert_string( Widget widget,
|
||
XKeyEvent *event,
|
||
String *str,
|
||
Cardinal *cardinal
|
||
)
|
||
#else
|
||
static void insert_string( widget, event, str, cardinal )
|
||
Widget widget;
|
||
XKeyEvent *event;
|
||
String *str;
|
||
Cardinal *cardinal;
|
||
#endif
|
||
{
|
||
IP_BUF ipb;
|
||
|
||
ipb.len1 = strlen( *str );
|
||
if ( ipb.len1 != 0 ) {
|
||
ipb.code = VI_STRING;
|
||
ipb.str1 = *str;
|
||
vi_send(vi_ofd, "a", &ipb);
|
||
}
|
||
|
||
#ifdef TRACE
|
||
vtrace("insert_string {%.*s}\n", strlen( *str ), *str );
|
||
#endif
|
||
}
|
||
|
||
|
||
/* mouse or keyboard input. */
|
||
#if defined(__STDC__)
|
||
static void key_press( Widget widget,
|
||
XKeyEvent *event,
|
||
String str,
|
||
Cardinal *cardinal
|
||
)
|
||
#else
|
||
static void key_press( widget, event, str, cardinal )
|
||
Widget widget;
|
||
XKeyEvent *event;
|
||
String str;
|
||
Cardinal *cardinal;
|
||
#endif
|
||
{
|
||
IP_BUF ipb;
|
||
char bp[BufferSize];
|
||
|
||
ipb.len1 = XLookupString( event, bp, BufferSize, NULL, NULL );
|
||
if ( ipb.len1 != 0 ) {
|
||
ipb.code = VI_STRING;
|
||
ipb.str1 = bp;
|
||
#ifdef TRACE
|
||
vtrace("key_press {%.*s}\n", ipb.len1, bp );
|
||
#endif
|
||
vi_send(vi_ofd, "a", &ipb);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void scrollbar_moved( Widget widget,
|
||
XtPointer ptr,
|
||
XmScrollBarCallbackStruct *cbs
|
||
)
|
||
#else
|
||
static void scrollbar_moved( widget, ptr, cbs )
|
||
Widget widget;
|
||
XtPointer ptr;
|
||
XmScrollBarCallbackStruct *cbs;
|
||
#endif
|
||
{
|
||
/* Future: Need to scroll the correct screen! */
|
||
xvi_screen *cur_screen = (xvi_screen *) ptr;
|
||
IP_BUF ipb;
|
||
|
||
/* if we are still processing messages from core, skip this event
|
||
* (see comments near __vi_set_scroll_block())
|
||
*/
|
||
if ( scroll_block ) {
|
||
return;
|
||
}
|
||
__vi_set_scroll_block();
|
||
|
||
#ifdef TRACE
|
||
switch ( cbs->reason ) {
|
||
case XmCR_VALUE_CHANGED:
|
||
vtrace( "scrollbar VALUE_CHANGED %d\n", cbs->value );
|
||
break;
|
||
case XmCR_DRAG:
|
||
vtrace( "scrollbar DRAG %d\n", cbs->value );
|
||
break;
|
||
default:
|
||
vtrace( "scrollbar <default> %d\n", cbs->value );
|
||
break;
|
||
}
|
||
vtrace("scrollto {%d}\n", cbs->value );
|
||
#endif
|
||
|
||
/* Send the new cursor position. */
|
||
ipb.code = VI_C_SETTOP;
|
||
ipb.val1 = cbs->value;
|
||
(void)vi_send(vi_ofd, "1", &ipb);
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static xvi_screen *create_screen( Widget parent, int rows, int cols )
|
||
#else
|
||
static xvi_screen *create_screen( parent, rows, cols )
|
||
Widget parent;
|
||
int rows, cols;
|
||
#endif
|
||
{
|
||
xvi_screen *new_screen = (xvi_screen *) calloc( 1, sizeof(xvi_screen) );
|
||
Widget frame;
|
||
|
||
/* init... */
|
||
new_screen->color = COLOR_STANDARD;
|
||
new_screen->parent = parent;
|
||
|
||
/* figure out the sizes */
|
||
new_screen->rows = rows;
|
||
new_screen->cols = cols;
|
||
new_screen->ch_width = font->max_bounds.width;
|
||
new_screen->ch_height = font->descent + font->ascent;
|
||
new_screen->ch_descent = font->descent;
|
||
new_screen->clip = NULL;
|
||
|
||
/* allocate and init the backing stores */
|
||
resize_backing_store( new_screen );
|
||
|
||
/* set up a translation table for the X toolkit */
|
||
if ( area_trans == NULL )
|
||
area_trans = XtParseTranslationTable(areaTrans);
|
||
|
||
/* future, new screen gets inserted into the parent sash
|
||
* immediately after the current screen. Default Pane action is
|
||
* to add it to the end
|
||
*/
|
||
|
||
/* use a form to hold the drawing area and the scrollbar */
|
||
new_screen->form = XtVaCreateManagedWidget( "form",
|
||
xmFormWidgetClass,
|
||
parent,
|
||
XmNpaneMinimum, 2*new_screen->ch_height,
|
||
XmNallowResize, True,
|
||
NULL
|
||
);
|
||
|
||
/* create a scrollbar. */
|
||
new_screen->scroll = XtVaCreateManagedWidget( "scroll",
|
||
xmScrollBarWidgetClass,
|
||
new_screen->form,
|
||
XmNtopAttachment, XmATTACH_FORM,
|
||
XmNbottomAttachment, XmATTACH_FORM,
|
||
XmNrightAttachment, XmATTACH_FORM,
|
||
XmNminimum, 1,
|
||
XmNmaximum, 2,
|
||
XmNsliderSize, 1,
|
||
NULL
|
||
);
|
||
XtAddCallback( new_screen->scroll,
|
||
XmNvalueChangedCallback,
|
||
scrollbar_moved,
|
||
new_screen
|
||
);
|
||
XtAddCallback( new_screen->scroll,
|
||
XmNdragCallback,
|
||
scrollbar_moved,
|
||
new_screen
|
||
);
|
||
|
||
/* create a frame because they look nice */
|
||
frame = XtVaCreateManagedWidget( "frame",
|
||
xmFrameWidgetClass,
|
||
new_screen->form,
|
||
XmNshadowType, XmSHADOW_ETCHED_IN,
|
||
XmNtopAttachment, XmATTACH_FORM,
|
||
XmNbottomAttachment, XmATTACH_FORM,
|
||
XmNleftAttachment, XmATTACH_FORM,
|
||
XmNrightAttachment, XmATTACH_WIDGET,
|
||
XmNrightWidget, new_screen->scroll,
|
||
NULL
|
||
);
|
||
|
||
/* create a drawing area into which we will put text */
|
||
new_screen->area = XtVaCreateManagedWidget( "screen",
|
||
xmDrawingAreaWidgetClass,
|
||
frame,
|
||
XmNheight, new_screen->ch_height * new_screen->rows,
|
||
XmNwidth, new_screen->ch_width * new_screen->cols,
|
||
XmNtranslations, area_trans,
|
||
XmNuserData, new_screen,
|
||
XmNnavigationType, XmNONE,
|
||
XmNtraversalOn, False,
|
||
NULL
|
||
);
|
||
|
||
/* this callback is for when the drawing area is resized */
|
||
XtAddCallback( new_screen->area,
|
||
XmNresizeCallback,
|
||
resize_func,
|
||
new_screen
|
||
);
|
||
|
||
/* this callback is for when the drawing area is exposed */
|
||
XtAddCallback( new_screen->area,
|
||
XmNexposeCallback,
|
||
__vi_expose_func,
|
||
new_screen
|
||
);
|
||
|
||
/* this callback is for when we expose obscured bits
|
||
* (e.g. there is a window over part of our drawing area
|
||
*/
|
||
XtAddEventHandler( new_screen->area,
|
||
0, /* no standard events */
|
||
True, /* we *WANT* GraphicsExpose */
|
||
xexpose, /* what to do */
|
||
new_screen
|
||
);
|
||
|
||
return new_screen;
|
||
}
|
||
|
||
|
||
static xvi_screen *split_screen(void)
|
||
{
|
||
Cardinal num;
|
||
WidgetList c;
|
||
int rows = __vi_screen->rows / 2;
|
||
xvi_screen *new_screen;
|
||
|
||
/* Note that (global) cur_screen needs to be correctly set so that
|
||
* insert_here knows which screen to put the new one after
|
||
*/
|
||
new_screen = create_screen( __vi_screen->parent,
|
||
rows,
|
||
__vi_screen->cols
|
||
);
|
||
|
||
/* what are the screens? */
|
||
XtVaGetValues( __vi_screen->parent,
|
||
XmNnumChildren, &num,
|
||
XmNchildren, &c,
|
||
NULL
|
||
);
|
||
|
||
/* unmanage all children in preparation for resizing */
|
||
XtUnmanageChildren( c, num );
|
||
|
||
/* force resize of the affected screens */
|
||
XtVaSetValues( new_screen->form,
|
||
XmNheight, new_screen->ch_height * rows,
|
||
NULL
|
||
);
|
||
XtVaSetValues( __vi_screen->form,
|
||
XmNheight, __vi_screen->ch_height * rows,
|
||
NULL
|
||
);
|
||
|
||
/* re-manage */
|
||
XtManageChildren( c, num );
|
||
|
||
/* done */
|
||
return new_screen;
|
||
}
|
||
|
||
|
||
/* Tell me where to insert the next subpane */
|
||
#if defined(__STDC__)
|
||
static Cardinal insert_here( Widget wid )
|
||
#else
|
||
static Cardinal insert_here( wid )
|
||
Widget wid;
|
||
#endif
|
||
{
|
||
Cardinal i, num;
|
||
WidgetList c;
|
||
|
||
XtVaGetValues( XtParent(wid),
|
||
XmNnumChildren, &num,
|
||
XmNchildren, &c,
|
||
NULL
|
||
);
|
||
|
||
/* The default XmNinsertPosition procedure for PanedWindow
|
||
* causes sashes to be inserted at the end of the list of children
|
||
* and causes non-sash widgets to be inserted after other
|
||
* non-sash children but before any sashes.
|
||
*/
|
||
if ( ! XmIsForm( wid ) )
|
||
return num;
|
||
|
||
/* We will put the widget after the one with the current screen */
|
||
for (i=0; i<num && XmIsForm(c[i]); i++) {
|
||
if ( __vi_screen == NULL || __vi_screen->form == c[i] )
|
||
return i+1; /* after the i-th */
|
||
}
|
||
|
||
/* could not find it? this should never happen */
|
||
return num;
|
||
}
|
||
|
||
|
||
/*
|
||
* vi_create_editor --
|
||
* Create the necessary widgetry.
|
||
*
|
||
* PUBLIC: Widget vi_create_editor __P((String, Widget, void (*)(void)));
|
||
*/
|
||
Widget
|
||
vi_create_editor(String name, Widget parent, void (*exitp) (void))
|
||
{
|
||
Widget pane_w;
|
||
Display *display = XtDisplay( parent );
|
||
|
||
__vi_exitp = exitp;
|
||
|
||
/* first time through? */
|
||
if ( ctx == NULL ) {
|
||
|
||
/* save this for later */
|
||
ctx = XtWidgetToApplicationContext( parent );
|
||
|
||
/* add our own special actions */
|
||
XtAppAddActions( ctx, area_actions, XtNumber(area_actions) );
|
||
|
||
/* how long is double-click? */
|
||
multi_click_length = XtGetMultiClickTime( display );
|
||
|
||
/* check the resource database for interesting resources */
|
||
__XutConvertResources( parent,
|
||
vi_progname,
|
||
resource,
|
||
XtNumber(resource)
|
||
);
|
||
|
||
/* we need a context for moving bits around in the windows */
|
||
__vi_copy_gc = XCreateGC( display,
|
||
DefaultRootWindow(display),
|
||
0,
|
||
0
|
||
);
|
||
|
||
/* routines for inter client communications conventions */
|
||
__vi_InitCopyPaste( f_copy, f_paste, f_clear, fprintf );
|
||
}
|
||
|
||
/* create the paned window */
|
||
pane_w = XtVaCreateManagedWidget( "pane",
|
||
xmPanedWindowWidgetClass,
|
||
parent,
|
||
XmNinsertPosition, insert_here,
|
||
NULL
|
||
);
|
||
|
||
/* allocate our data structure. in the future we will have several
|
||
* screens running around at the same time
|
||
*/
|
||
__vi_screen = create_screen( pane_w, 24, 80 );
|
||
|
||
/* force creation of our color text context */
|
||
set_gc_colors( __vi_screen, COLOR_STANDARD );
|
||
|
||
/* done */
|
||
return pane_w;
|
||
}
|
||
|
||
|
||
/* These routines deal with the selection buffer */
|
||
|
||
static int selection_start, selection_end, selection_anchor;
|
||
static enum select_enum {
|
||
select_char, select_word, select_line
|
||
} select_type = select_char;
|
||
static int last_click;
|
||
|
||
static char *clipboard = NULL;
|
||
static int clipboard_size = 0,
|
||
clipboard_length;
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void copy_to_clipboard( xvi_screen *cur_screen )
|
||
#else
|
||
static void copy_to_clipboard( cur_screen )
|
||
xvi_screen *cur_screen;
|
||
#endif
|
||
{
|
||
/* for now, copy from the backing store. in the future,
|
||
* vi core will tell us exactly what the selection buffer contains
|
||
*/
|
||
clipboard_length = 1 + selection_end - selection_start;
|
||
|
||
if ( clipboard == NULL )
|
||
clipboard = (char *) malloc( clipboard_length );
|
||
else if ( clipboard_size < clipboard_length )
|
||
clipboard = (char *) realloc( clipboard, clipboard_length );
|
||
|
||
memcpy( clipboard,
|
||
cur_screen->characters + selection_start,
|
||
clipboard_length
|
||
);
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void mark_selection( xvi_screen *cur_screen, int start, int end )
|
||
#else
|
||
static void mark_selection( cur_screen, start, end )
|
||
xvi_screen *cur_screen;
|
||
int start;
|
||
int end;
|
||
#endif
|
||
{
|
||
int row, col, i;
|
||
|
||
for ( i=start; i<=end; i++ ) {
|
||
if ( !( cur_screen->flags[i] & COLOR_SELECT ) ) {
|
||
cur_screen->flags[i] |= COLOR_SELECT;
|
||
ToRowCol( cur_screen, i, row, col );
|
||
__vi_draw_text( cur_screen, row, col, 1 );
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void erase_selection( xvi_screen *cur_screen, int start, int end )
|
||
#else
|
||
static void erase_selection( cur_screen, start, end )
|
||
xvi_screen *cur_screen;
|
||
int start;
|
||
int end;
|
||
#endif
|
||
{
|
||
int row, col, i;
|
||
|
||
for ( i=start; i<=end; i++ ) {
|
||
if ( cur_screen->flags[i] & COLOR_SELECT ) {
|
||
cur_screen->flags[i] &= ~COLOR_SELECT;
|
||
ToRowCol( cur_screen, i, row, col );
|
||
__vi_draw_text( cur_screen, row, col, 1 );
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void left_expand_selection( xvi_screen *cur_screen, int *start )
|
||
#else
|
||
static void left_expand_selection( cur_screen, start )
|
||
xvi_screen *cur_screen;
|
||
int *start;
|
||
#endif
|
||
{
|
||
int row, col;
|
||
|
||
switch ( select_type ) {
|
||
case select_word:
|
||
if ( *start == 0 || isspace( (unsigned char)cur_screen->characters[*start] ) )
|
||
return;
|
||
for (;;) {
|
||
if ( isspace( (unsigned char)cur_screen->characters[*start-1] ) )
|
||
return;
|
||
if ( --(*start) == 0 )
|
||
return;
|
||
}
|
||
case select_line:
|
||
ToRowCol( cur_screen, *start, row, col );
|
||
col = 0;
|
||
*start = Linear( cur_screen, row, col );
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void right_expand_selection( xvi_screen *cur_screen, int *end )
|
||
#else
|
||
static void right_expand_selection( cur_screen, end )
|
||
xvi_screen *cur_screen;
|
||
int *end;
|
||
#endif
|
||
{
|
||
int row, col, last = cur_screen->cols * cur_screen->rows - 1;
|
||
|
||
switch ( select_type ) {
|
||
case select_word:
|
||
if ( *end == last || isspace( (unsigned char)cur_screen->characters[*end] ) )
|
||
return;
|
||
for (;;) {
|
||
if ( isspace( (unsigned char)cur_screen->characters[*end+1] ) )
|
||
return;
|
||
if ( ++(*end) == last )
|
||
return;
|
||
}
|
||
case select_line:
|
||
ToRowCol( cur_screen, *end, row, col );
|
||
col = cur_screen->cols -1;
|
||
*end = Linear( cur_screen, row, col );
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void select_start( Widget widget,
|
||
XEvent *event,
|
||
String str,
|
||
Cardinal *cardinal
|
||
)
|
||
#else
|
||
static void select_start( widget, event, str, cardinal )
|
||
Widget widget;
|
||
XEvent *event;
|
||
String str;
|
||
Cardinal *cardinal;
|
||
#endif
|
||
{
|
||
IP_BUF ipb;
|
||
int xpos, ypos;
|
||
XPointerMovedEvent *ev = (XPointerMovedEvent *) event;
|
||
static int last_click;
|
||
|
||
/*
|
||
* NOTE: when multiple panes are implemented, we need to find the correct
|
||
* screen. For now, there is only one.
|
||
*/
|
||
xpos = COLUMN( __vi_screen, ev->x );
|
||
ypos = ROW( __vi_screen, ev->y );
|
||
|
||
/* Remove the old one. */
|
||
erase_selection( __vi_screen, selection_start, selection_end );
|
||
|
||
/* Send the new cursor position. */
|
||
ipb.code = VI_MOUSE_MOVE;
|
||
ipb.val1 = ypos;
|
||
ipb.val2 = xpos;
|
||
(void)vi_send(vi_ofd, "12", &ipb);
|
||
|
||
/* click-click, and we go for words, lines, etc */
|
||
if ( ev->time - last_click < multi_click_length )
|
||
select_type = (enum select_enum) ((((int)select_type)+1)%3);
|
||
else
|
||
select_type = select_char;
|
||
last_click = ev->time;
|
||
|
||
/* put the selection here */
|
||
selection_anchor = Linear( __vi_screen, ypos, xpos );
|
||
selection_start = selection_anchor;
|
||
selection_end = selection_anchor;
|
||
|
||
/* expand to include words, line, etc */
|
||
left_expand_selection( __vi_screen, &selection_start );
|
||
right_expand_selection( __vi_screen, &selection_end );
|
||
|
||
/* draw the new one */
|
||
mark_selection( __vi_screen, selection_start, selection_end );
|
||
|
||
/* and tell the window manager we own the selection */
|
||
if ( select_type != select_char ) {
|
||
__vi_AcquirePrimary( widget );
|
||
copy_to_clipboard( __vi_screen );
|
||
}
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void select_extend( Widget widget,
|
||
XEvent *event,
|
||
String str,
|
||
Cardinal *cardinal
|
||
)
|
||
#else
|
||
static void select_extend( widget, event, str, cardinal )
|
||
Widget widget;
|
||
XEvent *event;
|
||
String str;
|
||
Cardinal *cardinal;
|
||
#endif
|
||
{
|
||
int xpos, ypos, pos;
|
||
XPointerMovedEvent *ev = (XPointerMovedEvent *) event;
|
||
|
||
/* NOTE: when multiple panes are implemented, we need to find
|
||
* the correct screen. For now, there is only one.
|
||
*/
|
||
xpos = COLUMN( __vi_screen, ev->x );
|
||
ypos = ROW( __vi_screen, ev->y );
|
||
|
||
/* deal with words, lines, etc */
|
||
pos = Linear( __vi_screen, ypos, xpos );
|
||
if ( pos < selection_anchor )
|
||
left_expand_selection( __vi_screen, &pos );
|
||
else
|
||
right_expand_selection( __vi_screen, &pos );
|
||
|
||
/* extend from before the start? */
|
||
if ( pos < selection_start ) {
|
||
mark_selection( __vi_screen, pos, selection_start-1 );
|
||
selection_start = pos;
|
||
}
|
||
|
||
/* extend past the end? */
|
||
else if ( pos > selection_end ) {
|
||
mark_selection( __vi_screen, selection_end+1, pos );
|
||
selection_end = pos;
|
||
}
|
||
|
||
/* between the anchor and the start? */
|
||
else if ( pos < selection_anchor ) {
|
||
erase_selection( __vi_screen, selection_start, pos-1 );
|
||
selection_start = pos;
|
||
}
|
||
|
||
/* between the anchor and the end? */
|
||
else {
|
||
erase_selection( __vi_screen, pos+1, selection_end );
|
||
selection_end = pos;
|
||
}
|
||
|
||
/* and tell the window manager we own the selection */
|
||
__vi_AcquirePrimary( widget );
|
||
copy_to_clipboard( __vi_screen );
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void select_paste( Widget widget,
|
||
XEvent *event,
|
||
String str,
|
||
Cardinal *cardinal
|
||
)
|
||
#else
|
||
static void select_paste( widget, event, str, cardinal )
|
||
Widget widget;
|
||
XEvent *event;
|
||
String str;
|
||
Cardinal *cardinal;
|
||
#endif
|
||
{
|
||
__vi_PasteFromClipboard( widget );
|
||
}
|
||
|
||
|
||
/* Interface to copy and paste
|
||
* (a) callbacks from the window manager
|
||
* f_copy - it wants our buffer
|
||
* f_paste - it wants us to paste some text
|
||
* f_clear - we've lost the selection, clear it
|
||
*/
|
||
|
||
#if defined(__STDC__)
|
||
static void f_copy( String *buffer, int *len )
|
||
#else
|
||
static void f_copy( buffer, len )
|
||
String *buffer;
|
||
int *len;
|
||
#endif
|
||
{
|
||
#ifdef TRACE
|
||
vtrace("f_copy() called");
|
||
#endif
|
||
*buffer = clipboard;
|
||
*len = clipboard_length;
|
||
}
|
||
|
||
|
||
|
||
static void f_paste(int widget, int buffer, int length)
|
||
{
|
||
/* NOTE: when multiple panes are implemented, we need to find
|
||
* the correct screen. For now, there is only one.
|
||
*/
|
||
#ifdef TRACE
|
||
vtrace("f_paste() called with '%*.*s'\n", length, length, buffer);
|
||
#endif
|
||
}
|
||
|
||
|
||
#if defined(__STDC__)
|
||
static void f_clear( Widget widget )
|
||
#else
|
||
static void f_clear( widget )
|
||
Widget widget;
|
||
#endif
|
||
{
|
||
xvi_screen *cur_screen;
|
||
|
||
#ifdef TRACE
|
||
vtrace("f_clear() called");
|
||
#endif
|
||
|
||
XtVaGetValues( widget, XmNuserData, &cur_screen, 0 );
|
||
|
||
erase_selection( cur_screen, selection_start, selection_end );
|
||
}
|
||
|
||
|
||
/*
|
||
* These routines deal with the cursor.
|
||
*
|
||
* PUBLIC: void __vi_set_cursor __P((xvi_screen *, int));
|
||
*/
|
||
void
|
||
__vi_set_cursor(xvi_screen *cur_screen, int is_busy)
|
||
{
|
||
XDefineCursor( XtDisplay(cur_screen->area),
|
||
XtWindow(cur_screen->area),
|
||
(is_busy) ? busy_cursor : std_cursor
|
||
);
|
||
}
|
||
|
||
|
||
|
||
/* hooks for the tags widget */
|
||
|
||
static String cur_word = NULL;
|
||
|
||
/*
|
||
* PUBLIC: void __vi_set_word_at_caret __P((xvi_screen *));
|
||
*/
|
||
void
|
||
__vi_set_word_at_caret(xvi_screen *this_screen)
|
||
{
|
||
char *start, *end, save;
|
||
int newx, newy;
|
||
|
||
newx = this_screen->curx;
|
||
newy = this_screen->cury;
|
||
|
||
/* Note that this really ought to be done by core due to wrapping issues */
|
||
for ( end = start = CharAt( this_screen, newy, newx );
|
||
(isalnum( (unsigned char)*end ) || *end == '_') && (newx < this_screen->cols);
|
||
end++, newx++
|
||
);
|
||
save = *end;
|
||
*end = '\0';
|
||
if ( cur_word != NULL ) free( cur_word );
|
||
cur_word = strdup( start );
|
||
*end = save;
|
||
|
||
/* if the tag stack widget is active, set the text field there
|
||
* to agree with the current caret position.
|
||
*/
|
||
__vi_set_tag_text( cur_word );
|
||
}
|
||
|
||
|
||
String __vi_get_word_at_caret(xvi_screen *this_screen)
|
||
{
|
||
return (cur_word) ? cur_word : "";
|
||
}
|
||
|
||
|
||
/*
|
||
* These routines deal with the caret.
|
||
*
|
||
* PUBLIC: void draw_caret __P((xvi_screen *));
|
||
*/
|
||
static void
|
||
draw_caret(xvi_screen *this_screen)
|
||
{
|
||
/* draw the caret by drawing the text in highlight color */
|
||
*FlagAt( this_screen, this_screen->cury, this_screen->curx ) |= COLOR_CARET;
|
||
__vi_draw_text( this_screen, this_screen->cury, this_screen->curx, 1 );
|
||
}
|
||
|
||
/*
|
||
* PUBLIC: void __vi_erase_caret __P((xvi_screen *));
|
||
*/
|
||
void
|
||
__vi_erase_caret(xvi_screen *this_screen)
|
||
{
|
||
/* erase the caret by drawing the text in normal video */
|
||
*FlagAt( this_screen, this_screen->cury, this_screen->curx ) &= ~COLOR_CARET;
|
||
__vi_draw_text( this_screen, this_screen->cury, this_screen->curx, 1 );
|
||
}
|
||
|
||
/*
|
||
* PUBLIC: void __vi_move_caret __P((xvi_screen *, int, int));
|
||
*/
|
||
void
|
||
__vi_move_caret(xvi_screen *this_screen, int newy, int newx)
|
||
{
|
||
/* remove the old caret */
|
||
__vi_erase_caret( this_screen );
|
||
|
||
/* caret is now here */
|
||
this_screen->curx = newx;
|
||
this_screen->cury = newy;
|
||
draw_caret( this_screen );
|
||
}
|