viewport.c File Reference

#include "spice.h"
#include "sced.h"
#include "scedmacs.h"

Include dependency graph for viewport.c:

Go to the source code of this file.

Data Structures
struct	mark

Functions
static int	get_menu_index ()
static void	fix_menu_entry_prefix ()
static void	display_menu_entry ()
static void	display_selected_entry ()
static void	mark_object ()
static void	show_mark ()
static void	gp_mark ()
static int	my_strnicmp ()
void	PToL (struct ka *Window, long *X, long *Y)
void	ClipToGridPoint (long *x, long *y)
void	ShowCommandMenu ()
void	ShowMenu (MENU *Menu)
MENU *	GetCurrentMenu ()
void	AlterMenuEntries (char *Word1, char *Word2)
void	MenuSelect (char *Selection)
void	MenuDeselect (char *Selection)
void	MenuSelectDev (char *Selection)
void	MenuDeselectDev (char *Selection)
void	FixMenuPrefix (MENU *Menu)
static void	fix_menu_entry_prefix (MENU *Menu, int Index)
static int	get_menu_index (MENU *Menu, char *String)
static void	display_menu_entry (MENU *Menu, int Index)
static void	display_selected_entry (MENU *Menu, int Index)
void	ShowPrompt (char *Prompt)
void	ShowPromptAndWait (char *cp)
void	ShowPromptWithColor (char *Prompt, int Color)
void	RedrawPrompt ()
void	AppendToOldPrompt (char c)
void	ErasePrompt ()
void	OutlineText (int Left, int Bottom, int Right, int Top, char Type, char DisplayOrErase, int Pixel)
void	EraseLargeCoarseViewport ()
void	EraseFineViewport ()
void	ShowFineViewport ()
void	ShowCurrentObject (struct o *Pointer, char DisplayOrErase)
static void	mark_object (struct o *Pointer)
void	ShowMarker (char DisplayOrErase, int Color, long X, long Y, int Delta, int Type, int Orient)
static void	show_mark (struct mark *m, int Color)
static void	gp_mark (int c, int Color, int x, int y, int delta, int orient)
static int	my_strnicmp (char *s1, char *s2, int n)

Variables
static char	BackPrompt [200]
static char	BackColor

Function Documentation

void AlterMenuEntries	(	char *	Word1,
		char*	Word2
	)

Definition at line 186 of file viewport.c.

{
    int i;

    i = get_menu_index(BasicMenu,Word1);
    if (i >= 0) {
        BasicMenu[i].mEntry = Word2;
        fix_menu_entry_prefix(BasicMenu,i);
    }
    i = get_menu_index(AmbiguityMenu,Word1);
    if (i >= 0) {
        AmbiguityMenu[i].mEntry = Word2;
        fix_menu_entry_prefix(AmbiguityMenu,i);
    }
}

void AppendToOldPrompt

(

char

c

)

Definition at line 523 of file viewport.c.

{
    char s[4];

    s[0] = ' ';
    s[1] = s[0];
    s[2] = c;
    s[3] = '\0';
    strcat(BackPrompt,s);
}

void ClipToGridPoint	(	long *	x,
		long*	y
	)

Definition at line 89 of file viewport.c.

{

    long k;

    /* snap to grid/2 points */
    k = Parameters.kpGrid/2;

    if (*x > 0)
        *x = ((*x+k/2)/k)*k;
    else
        *x = ((*x-k/2)/k)*k;

    if (*y > 0)
        *y = ((*y+k/2)/k)*k;
    else
        *y = ((*y-k/2)/k)*k;
}

static void display_menu_entry ( )

static

static void display_menu_entry ( MENU *  Menu, int  Index  )

static

Definition at line 355 of file viewport.c.

{
    char MenuSelection[8],*prefix;
    int Left;

    strncpy(MenuSelection,Menu[Index].mEntry,MenuViewport.kaX);
    MenuSelection[MenuViewport.kaX] = '\0';
    prefix = Menu[Index].mPrefix;

    Index += MenuViewport.kaTop;
    Left = MenuViewport.kaLeft;
    if (Index > MenuViewport.kaY) {
        Left += 6;
        Index -= MenuViewport.kaY;
    }
    /*
     * Erase highlight box.
     */
    OutlineText(Left,Index,Left+4,Index,FILL,ERASE,0);
    /*
     * Redisplay menu selection.
     */
    DevSetColor(MenuTextColor);
    FBText(ROW_COLUMN,Index,Left,MenuSelection);

    DevSetColor(MenuTextPrefixColor);
    FBText(ROW_COLUMN,Index,Left,prefix);
}

static void display_selected_entry ( )

static

static void display_selected_entry ( MENU *  Menu, int  Index  )

static

Definition at line 389 of file viewport.c.

{
    char MenuSelection[8], *prefix;
    int Left;

    strncpy(MenuSelection,Menu[Index].mEntry,MenuViewport.kaX);
    MenuSelection[MenuViewport.kaX] = '\0';
    prefix = Menu[Index].mPrefix;

    Index += MenuViewport.kaTop;
    Left = MenuViewport.kaLeft;
    if (Index > MenuViewport.kaY) {
        Left += 6;
        Index -= MenuViewport.kaY;
    }
    /*
     * Erase Menu command
     */
    OutlineText(Left,Index,Left+4,Index,FILL,ERASE,0);

    /*
     * Display highlight box.
     */
    OutlineText(Left,Index,Left+4,Index,FILL,DISPLAY,
        MenuHighlightingColor);

    /*
     * Redisplay menu selection.
     */
    DevSetColor(MenuSelectedColor);
    FBText(ROW_COLUMN,Index,Left,MenuSelection);

    DevSetColor(MenuSelectedPrefixColor);
    FBText(ROW_COLUMN,Index,Left,prefix);
}

void EraseFineViewport

(

)

Definition at line 594 of file viewport.c.

{
    /*
     * Erase fine positioning window in coarse window and patch
     * up the hole.  'c' will disable showing of fine positioning
     * window in Redisplay.
     */
    Parameters.kpRedisplayControl = COARSEVIEWPORTONLY;
    EraseBox(View->kvFineWindow);
    Redisplay(View->kvFineWindow);
    Parameters.kpRedisplayControl = SPLITSCREEN;
}

void EraseLargeCoarseViewport

(

)

Definition at line 583 of file viewport.c.

{
    FBEraseBox(View->kvLargeCoarseViewport->kaLeft-1,
        View->kvLargeCoarseViewport->kaBottom-1,
        View->kvLargeCoarseViewport->kaRight,
        View->kvLargeCoarseViewport->kaTop);
}

void ErasePrompt

(

)

Definition at line 538 of file viewport.c.

{
    OutlineText(1,gi_numtextrows,gi_numtextcols,
        gi_numtextrows,FILL,ERASE,0);
    Parameters.kpLastCursorColumn = 1;
    BackPrompt[0] = '\0';
    DevUpdate();
}

static void fix_menu_entry_prefix ( )

static

static void fix_menu_entry_prefix ( MENU *  Menu, int  Index  )

static

Definition at line 301 of file viewport.c.

{
    int Count;
    char m1[32], m2[32];
    int j,k;

    memset(Menu[Index].mPrefix,0,6);

    Count = 1;
    strcpy(m1,Menu[Index].mEntry);
    for (j = 0; Menu[j].mEntry; j++) {
        if (Index == j) continue;
        strcpy(m2,Menu[j].mEntry);
        if (cieq(m1,m2)) {
            if (*Menu[Index].mEntry != ' ')
                for (k = j; Menu[k].mEntry; k++) {
                    strcpy(Menu[k].mPrefix,Menu[k+1].mPrefix);
                    Menu[k].mEntry = Menu[k+1].mEntry;
                    Menu[k].mActive = Menu[k+1].mActive;
                }
            continue;
        }
        while (!my_strnicmp(m1,m2,Count))
            Count++;
    }
    if (Count > 5) Count = 5;
    while (Count--)
        Menu[Index].mPrefix[Count] = Menu[Index].mEntry[Count];
}

void FixMenuPrefix

(

MENU *

Menu

)

Definition at line 289 of file viewport.c.

{
    int i;

    for (i = 0; Menu[i].mEntry; i++)
        fix_menu_entry_prefix(Menu,i);
}

static int get_menu_index ( )

static

static int get_menu_index ( MENU *  Menu, char *  String  )

static

Definition at line 339 of file viewport.c.

{
    int i = 0;

    while (Menu[i].mEntry != NULL) {
        if (!strcmp(Menu[i].mEntry,String)) return (i);
        i++;
    }
    return (-1);
}

MENU* GetCurrentMenu

(

)

Definition at line 174 of file viewport.c.

{
    if (Parameters.kpMenu == BASICMENU)
        return (BasicMenu);
    if (Parameters.kpMenu == AMBIGUITYMENU)
        return (AmbiguityMenu);
    return (NULL);
}

static void gp_mark ( )

static

static void gp_mark ( int  c, int  Color, int  x, int  y, int  delta, int  orient  )

static

Definition at line 857 of file viewport.c.

{
    int x0, x1, y0, y1, y2;
    struct ka AOI;

    delta /= 2;
    x0 = x - delta;
    x1 = x + delta;
    y0 = y - delta;
    y1 = y;
    y2 = y + delta;

    AOI.kaLeft = x0;
    AOI.kaRight = x1;
    AOI.kaTop = y2;
    AOI.kaBottom = y0;

    switch (orient) {
        case MARK_NONE:
            EraseBox(&AOI);
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            ShowLine(Color,x0,y0,x0,y2);
            break;
        case MARK_UP: /* up */
            AOI.kaTop += delta;
            EraseBox(&AOI);
            ShowLine(Color,x0,y2,(x0+x1)/2,y2+delta);
            ShowLine(Color,(x0+x1)/2,y2+delta,x1,y2);
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            ShowLine(Color,x0,y0,x0,y2);
            break;
        case MARK_RT: /* right */
            AOI.kaRight += delta;
            EraseBox(&AOI);
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1+delta,y1);
            ShowLine(Color,x1+delta,y1,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            ShowLine(Color,x0,y0,x0,y2);
            break;
        case MARK_DN: /* down */
            AOI.kaBottom -= delta;
            EraseBox(&AOI);
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x1,y0,(x0+x1)/2,y0-delta);
            ShowLine(Color,(x0+x1)/2,y0-delta,x0,y0);
            ShowLine(Color,x0,y0,x0,y2);
            break;
        case MARK_LT: /* left */
            AOI.kaLeft -= delta;
            EraseBox(&AOI);
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            ShowLine(Color,x0,y0,x0-delta,y1);
            ShowLine(Color,x0-delta,y1,x0,y2);
            break;
    }

    delta /= 2;
    x0 += delta;
    x1 -= delta;
    y0 += delta;
    y2 -= delta;

    switch (c) {
        case MARK_GP1:
            ShowLine(Color,x1,y2,x1,y0);
            break;
        case MARK_GP2:
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1,y1);
            ShowLine(Color,x1,y1,x0,y1);
            ShowLine(Color,x0,y1,x0,y0);
            ShowLine(Color,x0,y0,x1,y0);
            break;
        case MARK_GP3:
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x0,y1,x1,y1);
            ShowLine(Color,x0,y0,x1,y0);
            break;
        case MARK_GP4:
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x0,y2,x0,y1);
            ShowLine(Color,x0,y1,x1,y1);
            break;
        case MARK_GP5:
            ShowLine(Color,x1,y2,x0,y2);
            ShowLine(Color,x0,y2,x0,y1);
            ShowLine(Color,x0,y1,x1,y1);
            ShowLine(Color,x1,y1,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            break;
        case MARK_GP6:
            ShowLine(Color,x0,y2,x0,y0);
            ShowLine(Color,x0,y1,x1,y1);
            ShowLine(Color,x1,y1,x1,y0);
            ShowLine(Color,x1,y0,x0,y0);
            break;
        case MARK_GP7:
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x1,y2,x1,y0);
            break;
        case MARK_GP8:
            ShowLine(Color,x0,y2,x1,y2);
            ShowLine(Color,x0,y1,x1,y1);
            ShowLine(Color,x0,y0,x1,y0);
            ShowLine(Color,x1,y2,x1,y0);
            ShowLine(Color,x0,y2,x0,y0);
            break;
    }
}

static void mark_object ( )

static

static void mark_object ( struct o *  Pointer )

static

Definition at line 699 of file viewport.c.

{
    struct ka AOI;
    struct p *Path;
    int Layer;
    long Width;


    if (Pointer->oType == CDWIRE) {
        CDWire(Pointer,&Layer,&Width,&Path);
        ShowWire(HighlightingColor,Width,Path);
    }
    else {
        /*
         * Show the object with an X through the bounding box.
         */
        CDBB(Parameters.kpCellDesc,Pointer,&AOI.kaLeft,&AOI.kaBottom,
        &AOI.kaRight,&AOI.kaTop);
        ShowLine(HighlightingColor,AOI.kaLeft,AOI.kaBottom,
            AOI.kaRight,AOI.kaTop);
        ShowLine(HighlightingColor,AOI.kaLeft,AOI.kaTop,
            AOI.kaRight,AOI.kaBottom);
        ShowEmptyBox(HighlightingColor,&AOI);
    }
}

void MenuDeselect

(

char *

Selection

)

Definition at line 229 of file viewport.c.

{
    int Int1;

    Int1 = get_menu_index(BasicMenu,Selection);
    if (Int1 >= 0) {
        BasicMenu[Int1].mActive = False;
        if (Parameters.kpMenu == BASICMENU)
            display_menu_entry(BasicMenu,Int1);
    }
    Int1 = get_menu_index(AmbiguityMenu,Selection);
    if (Int1 >= 0) {
        AmbiguityMenu[Int1].mActive = False;
        if (Parameters.kpMenu == AMBIGUITYMENU)
            display_menu_entry(AmbiguityMenu,Int1);
    }
}

void MenuDeselectDev

(

char *

Selection

)

Definition at line 270 of file viewport.c.

{
    int Int1,Int2;

    Int1 = get_menu_index(DeviceMenu,Selection);
    if (Int1 >= 0) {
        for (Int2 = 0; ; Int2++)
            if (BasicMenu[Int2].mEntry == NULL) break;
        if (Int2 < MenuViewport.kaY)
            Int2 = MenuViewport.kaY;
        DeviceMenu[Int1].mActive = False;
        display_menu_entry(DeviceMenu-Int2,Int1+Int2);
    }
}

void MenuSelect

(

char *

Selection

)

Definition at line 207 of file viewport.c.

{
    int Int1;

    Int1 = get_menu_index(BasicMenu,Selection);
    if (Int1 >= 0) {
        BasicMenu[Int1].mActive = True;
        if (Parameters.kpMenu == BASICMENU)
            display_selected_entry(BasicMenu,Int1);
    }
    Int1 = get_menu_index(AmbiguityMenu,Selection);
    if (Int1 >= 0) {
        AmbiguityMenu[Int1].mActive = True;
        if (Parameters.kpMenu == AMBIGUITYMENU)
            display_selected_entry(AmbiguityMenu,Int1);
    }
}

void MenuSelectDev

(

char *

Selection

)

Definition at line 251 of file viewport.c.

{
    int Int1,Int2;

    Int1 = get_menu_index(DeviceMenu,Selection);
    if (Int1 >= 0) {
        for (Int2 = 0; ; Int2++)
            if (BasicMenu[Int2].mEntry == NULL) break;
        if (Int2 < MenuViewport.kaY)
            Int2 = MenuViewport.kaY;
        DeviceMenu[Int1].mActive = True;
        display_selected_entry(DeviceMenu-Int2,Int1+Int2);
    }
}

static int my_strnicmp ( )

static

static int my_strnicmp ( char *  s1, char *  s2, int  n  )

static

Definition at line 986 of file viewport.c.

{
    char c, d;

    while (n--) {
        c = *s1;
        d = *s2;
        if (c == '\0') return (-1);
        if (d == '\0') return (1);
        if (isupper(c)) c = tolower(c);
        if (isupper(d)) d = tolower(d);
        if (c != d) return (c-d);
        s1++;
        s2++;
    }
    return (0);
}

void OutlineText	(	int	Left,
		int	Bottom,
		int	Right,
		int	Top,
		char	Type,
		char	DisplayOrErase,
		int	Pixel
	)

Definition at line 550 of file viewport.c.

{
    /*
     * Outline the box defined by LeftColumn, BottomRow, RightColumn, and
     * TopRow in the color associated with Pixel.
     */

    Bottom = gi_maxy-Bottom*gi_fntheight;
    if (Bottom < 0) Bottom = 0;
    Top = gi_maxy-(Top-1)*gi_fntheight;
    if (Top > gi_maxy) Top = gi_maxy;
    Left = (Left-1) * gi_fntwidth;
    Right = (Right * gi_fntwidth) + 1;
    if (Type == OUTLINE) {
        ++Bottom;
        --Top;
    }
    FBBox(Pixel,DisplayOrErase,Type,Left,Bottom,Right,Top-1);
}

void PToL	(	struct ka *	Window,
		long *	X,
		long *	Y
	)

Definition at line 59 of file viewport.c.

{
    if (Window == View->kvCoarseWindow) {
        *X = .5+(*X - View->kvCoarseViewport->kaLeft)/
            View->kvCoarseRatio;
        *X += Window->kaLeft;
        *Y = .5+(*Y - View->kvCoarseViewport->kaBottom)/
            View->kvCoarseRatio;
        *Y += Window->kaBottom;
    }
    elif (Window == View->kvFineWindow) {
        *X = .5+(*X - View->kvFineViewport->kaLeft)/
            View->kvFineRatio;
        *X += Window->kaLeft;
        *Y = .5+(*Y - View->kvFineViewport->kaBottom)/
            View->kvFineRatio;
        *Y += Window->kaBottom;
    }
    else {
        *X = *Y = 0;
        return;
    }
}

void RedrawPrompt

(

)

Definition at line 512 of file viewport.c.

{
    if (BackPrompt[0] == '\0') return;
    DevSetColor(BackColor);
    FBText(ROW_COLUMN,gi_numtextrows,1,BackPrompt);
    Parameters.kpLastCursorColumn = 1 + strlen(BackPrompt);
}

static void show_mark ( )

static

static void show_mark ( struct mark *  m, int  Color  )

static

Definition at line 802 of file viewport.c.

{
    long X, Y;
    int Delta;

    X = m->X;
    Y = m->Y;
    Delta = m->Delta;
    
    /* transform for PUSH */
    TPoint(&X,&Y);

    switch (m->Type) {
        case MARK_ARROW:
            switch (m->Orient) {
                default:
                case MARK_UP:
                    ShowLine(Color,X,Y-Delta,X,Y+Delta);
                    ShowLine(Color,X-Delta,Y,X,Y+Delta);
                    ShowLine(Color,X+Delta,Y,X,Y+Delta);
                    break;
                case MARK_RT:
                    ShowLine(Color,X-Delta,Y,X+Delta,Y);
                    ShowLine(Color,X,Y+Delta,X+Delta,Y);
                    ShowLine(Color,X,Y-Delta,X+Delta,Y);
                    break;
                case MARK_DN:
                    ShowLine(Color,X,Y-Delta,X,Y+Delta);
                    ShowLine(Color,X-Delta,Y,X,Y-Delta);
                    ShowLine(Color,X+Delta,Y,X,Y-Delta);
                    break;
                case MARK_LT:
                    ShowLine(Color,X-Delta,Y,X+Delta,Y);
                    ShowLine(Color,X,Y+Delta,X-Delta,Y);
                    ShowLine(Color,X,Y-Delta,X-Delta,Y);
                    break;
            }
            break;
        case MARK_CROSS:
            /* cross (no orientation) */
            ShowLine(Color,X-Delta,Y,X+Delta,Y);
            ShowLine(Color,X,Y-Delta,X,Y+Delta);
            break;
        default:
            /* graphical post-processor marks */
            gp_mark(m->Type,Color,X,Y,Delta,m->Orient);
            break;
    }
}

void ShowCommandMenu

(

)

Definition at line 121 of file viewport.c.

{
    if (Parameters.kpMenu == BASICMENU) {
        ShowMenu(BasicMenu);
        return;
    }
    if (Parameters.kpMenu == AMBIGUITYMENU) {
        ShowMenu(AmbiguityMenu);
        return;
    }
}

void ShowCurrentObject	(	struct o *	Pointer,
		char	DisplayOrErase
	)

Definition at line 642 of file viewport.c.

{
    struct ka AOI;
    static struct ks *ObjQ;
    struct ks *q,*qq;

    if (Pointer == NULL) {
        for (q = ObjQ; q; q = qq) {
            qq = q->ksSucc;
            if (DisplayOrErase == DISPLAY)
                mark_object(q->ksPointer);
            else {
                CDBB(Parameters.kpCellDesc,q->ksPointer,&AOI.kaLeft,
                    &AOI.kaBottom,&AOI.kaRight,&AOI.kaTop);
                EraseBox(&AOI);
                ObjQ = NULL;
                Redisplay(&AOI);
                tfree(q);
            }
        }
        SetCurrentAOI(View->kvCoarseWindow);
        DevUpdate();
        return;
    }

    if (DisplayOrErase == DISPLAY) {
        mark_object(Pointer);
        q = alloc(ks);
        if (q == NULL) MallocFailed();
        q->ksPointer = Pointer;
        q->ksSucc = ObjQ;
        ObjQ = q;
    }
    else {
        for (qq = NULL,q = ObjQ; q; qq = q,q = q->ksSucc)
            if (q->ksPointer == Pointer) {
                if (qq)
                    qq->ksSucc = q->ksSucc;
                else
                    ObjQ = q->ksSucc;
                tfree(q);
                break;
            }
        CDBB(Parameters.kpCellDesc,Pointer,&AOI.kaLeft,&AOI.kaBottom,
            &AOI.kaRight,&AOI.kaTop);
        EraseBox(&AOI);
        Redisplay(&AOI);
    }
    SetCurrentAOI(View->kvCoarseWindow);
    DevUpdate();
}

void ShowFineViewport

(

)

Definition at line 610 of file viewport.c.

{
    if (Parameters.kpRedisplayControl == COARSEVIEWPORTONLY) {
        EraseLargeCoarseViewport();
        Redisplay(View->kvCoarseWindow);
    } 
    else {
        FBEraseBox(View->kvFineViewport->kaLeft-1,
            View->kvFineViewport->kaBottom-1,
            View->kvFineViewport->kaRight,
            View->kvFineViewport->kaTop);
        /* Show fine positioning window in coarse window. */
        ShowEmptyBox(HighlightingColor,View->kvFineWindow);
        /* Redisplay in magnifying glass. */
        Parameters.kpRedisplayControl = FINEVIEWPORTONLY;
        Redisplay(View->kvFineWindow);
        Parameters.kpRedisplayControl = SPLITSCREEN;
    }
    DevUpdate();
}

void ShowMarker	(	char	DisplayOrErase,
		int	Color,
		long	X,
		long	Y,
		int	Delta,
		int	Type,
		int	Orient
	)

Definition at line 729 of file viewport.c.

{
    struct t *TGen;
    struct ka BB;
    long X1,Y1,X2,Y2;
    long DX, DY;

    /* SRW ** save markers for redraw after screen alteration */
    static struct mark *mlist;
    struct mark *mm, *mtmp;

    /* SRW ** display stored marks */
    if (!Delta && DisplayOrErase == DISPLAY) {
        for (mm = mlist; mm; mm = mm->next) {
            show_mark(mm,Color);
        }
        ShowCurrentObject((struct o *)NULL,DISPLAY);
        return;
    }

    /* SRW ** constant size on screen */
    if (Parameters.kpRedisplayControl == COARSEVIEWPORTONLY)
        Delta *= View->kvCoarseWindow->kaHeight/100;
    else
        Delta *= View->kvFineWindow->kaHeight/50;
    Delta /= RESOLUTION;

    if (DisplayOrErase == DISPLAY) {
        DevSetColor(Color);

        /* add marker to list */
        mm = alloc(mark);
        if (!mm) MallocFailed();
        mm->X = X;
        mm->Y = Y;
        mm->Delta = Delta;
        mm->Type = Type;
        mm->Orient = Orient;
        mm->next = mlist;
        mlist = mm;

        show_mark(mm,Color);
    }
    else {
        /* remove from list */
        for (mtmp = NULL,mm = mlist; mm; mtmp = mm,mm = mm->next) {
            if (mm->X == X && mm->Y == Y) {
                Delta = mm->Delta;
                if (mm == mlist) mlist = mm->next;
                else mtmp->next = mm->next;
                tfree(mm);
                break;
            }
        }
        BB.kaLeft = X - Delta;
        BB.kaRight = X + Delta;
        BB.kaBottom = Y - Delta;
        BB.kaTop = Y + Delta;
        EraseBox(&BB);
        Redisplay(&BB);
    }
    SetCurrentAOI(View->kvCoarseWindow);
}

void ShowMenu

(

MENU *

Menu

)

Definition at line 136 of file viewport.c.

{
    int Int1,Int2;

    /*
     * Erase the entire menu viewport. 
     */
    OutlineText((int)MenuViewport.kaLeft,(int)MenuViewport.kaBottom,
    (int)MenuViewport.kaRight,(int)MenuViewport.kaTop,FILL,ERASE,0);
    /*
     * Display Menu Table
     */
    for (Int1 = 0; ; Int1++) {
        if (Menu[Int1].mEntry == NULL) break;
        if (Menu[Int1].mActive)
            display_selected_entry(Menu,Int1);
        else
            display_menu_entry(Menu,Int1);
    }
    if (Menu == BasicMenu) {
        Int2 = Int1;
        if (Int2 < MenuViewport.kaY)
            Int2 = MenuViewport.kaY;
        for (Int1 = 0; ; Int1++) {
            if (DeviceMenu[Int1].mEntry == NULL) break;
            if (DeviceMenu[Int1].mActive)
                display_selected_entry(DeviceMenu-Int2,Int1+Int2);
            else
                display_menu_entry(DeviceMenu-Int2,Int1+Int2);
        }
    }
    DevUpdate();
}

void ShowPrompt

(

char *

Prompt

)

Definition at line 441 of file viewport.c.

{
    ShowPromptWithColor(Prompt,PromptTextColor);
}

void ShowPromptAndWait

(

char *

cp

)

Definition at line 450 of file viewport.c.

{
    putchar('\007');
    fflush(stdout);
    ShowPrompt(cp);
    sleep(2);
}

void ShowPromptWithColor	(	char *	Prompt,
		int	Color
	)

Definition at line 462 of file viewport.c.

{
    /*
     * Implements a basic scroller in a prompt window.
     * Displays MORE when window is full and continues when
     * user hits and key.
     */
    char *cp;
    char *TypeIn;
    char buffer[200];
    int Int1;
    int Row;

    Row = gi_numtextrows;
    ErasePrompt();
    DevSetColor(Color);
    BackColor = Color;
    cp = Prompt;
    Int1 = 0;
    while (*cp != EOS) {
        buffer[Int1] = *cp++;
        if (buffer[Int1] == '\n')
            buffer[Int1] = EOS;
        Int1++;
        if (*cp == EOS) {
            buffer[Int1++] = EOS;
            strcpy(BackPrompt,buffer);
            FBText(ROW_COLUMN,Row,1,buffer);
            DevUpdate();
            Parameters.kpLastCursorColumn = strlen(buffer) + 1;
        }
        elif ((Int1 > gi_numtextcols - 8) Or (Int1 > 190)) {
            sprintf(&buffer[Int1]," MORE");
            strcpy(BackPrompt,buffer);
            FBText(ROW_COLUMN,Row,1,buffer);
            DevUpdate();
            Parameters.kpLastCursorColumn = strlen(buffer);
            (void)FBGetchar(ERASE);
            ErasePrompt();
            DevSetColor(Color);
            Int1 = 0;
        }
    }
}

Variable Documentation

char BackColor

static

Definition at line 437 of file viewport.c.

char BackPrompt[200]

static

Definition at line 436 of file viewport.c.