luke
/
magic
mirror of https://github.com/RTimothyEdwards/magic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
magic/plow/PlowTest.c

824 lines
22 KiB
C
Raw Blame History

/*
* PlowTest.c --
*
* Plowing.
* Debugging and testing.
*
* *********************************************************************
* * Copyright (C) 1985, 1990 Regents of the University of California. *
* * Permission to use, copy, modify, and distribute this *
* * software and its documentation for any purpose and without *
* * fee is hereby granted, provided that the above copyright *
* * notice appear in all copies. The University of California *
* * makes no representations about the suitability of this *
* * software for any purpose. It is provided "as is" without *
* * express or implied warranty. Export of this software outside *
* * of the United States of America may require an export license. *
* *********************************************************************
*/
#ifndef lint
static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/plow/PlowTest.c,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $";
#endif /* not lint */
#include <stdio.h>
#include <stdlib.h>
#include "utils/magic.h"
#include "utils/styles.h"
#include "utils/utils.h"
#include "utils/geometry.h"
#include "tiles/tile.h"
#include "utils/hash.h"
#include "utils/undo.h"
#include "database/database.h"
#include "windows/windows.h"
#include "graphics/graphics.h"
#include "dbwind/dbwind.h"
#include "utils/main.h"
#include "commands/commands.h"
#include "drc/drc.h"
#include "debug/debug.h"
#include "plow/plowInt.h"
#include "textio/textio.h"
#include "textio/txcommands.h"
/* Forward declarations */
extern void plowShowShadow();
extern int plowShowOutline();
extern void plowTestJog();
extern void plowDebugMore();
/* Imports from PlowMain.c */
extern CellDef *plowYankDef;
extern CellUse *plowDummyUse;
/* Debugging flags */
ClientData plowDebugID;
int plowDebAdd;
int plowDebMove;
int plowDebNext;
int plowDebTime;
int plowDebWidth;
int plowDebJogs;
int plowDebYankAll;
/* Other debugging info */
bool plowWhenTop, plowWhenBot;
Point plowWhenTopPoint, plowWhenBotPoint;
/* Imports */
extern CellDef *plowSpareDef;
/*
* ----------------------------------------------------------------------------
*
* PlowTest --
*
* Real command interface for debugging plowing.
*
* Results:
* None.
*
* Side effects:
* See individual commands.
*
* ----------------------------------------------------------------------------
*/
typedef enum
{
PC_HELP, PC_ERROR,
PC_PLOW,
PC_JOG,
PC_RANDOM,
PC_TECHSHOW,
PC_OUTLINE, PC_LSHADOW, PC_SHADOW, PC_WIDTH, PC_LWIDTH,
PC_SPLIT, PC_MERGEUP, PC_MERGEDOWN, PC_MOVE, PC_TRAIL, PC_PRINT,
PC_WHENTOP, PC_WHENBOT,
PC_SETD, PC_CLRD, PC_SHOWD
} pCmd;
struct
{
char *p_name;
pCmd p_cmd;
char *p_help;
} plowCmds[] = {
{"clrdebug", PC_CLRD, "flags"},
{"help", PC_HELP, ""},
{"jogreduce", PC_JOG, ""},
{"lwidth", PC_LWIDTH, "layers"},
{"lshadow", PC_LSHADOW, "layers"},
{"mergedown", PC_MERGEDOWN, ""},
{"mergeup", PC_MERGEUP, ""},
{"move", PC_MOVE, ""},
{"outline", PC_OUTLINE, "direction layers"},
{"plow", PC_PLOW, "direction [layers]"},
{"print", PC_PRINT, ""},
{"random", PC_RANDOM, ""},
{"setdebug", PC_SETD, "flags"},
{"shadow", PC_SHADOW, "layers"},
{"showdebug", PC_SHOWD, ""},
{"split", PC_SPLIT, ""},
{"techshow", PC_TECHSHOW, "[file]"},
{"trail", PC_TRAIL, "[value]"},
{"whenbot", PC_WHENBOT, "[xbot ybot]"},
{"whentop", PC_WHENTOP, "[xtop ytop]"},
{"width", PC_WIDTH, "layers"},
{0},
};
void
PlowTest(w, cmd)
MagWindow *w;
TxCommand *cmd;
{
pCmd plowCmd, plowGetCommand();
Rect editArea, dummyRect, rootBox, area2;
CellDef *def, *rootBoxDef, *saveDef;
TileTypeBitMask okTypes;
int dir, n, trail;
Point editPoint;
Plane *plane;
Edge edge;
Tile *tp;
FILE *f;
if (!ToolGetEditBox(&editArea) || !ToolGetBox(&rootBoxDef, &rootBox))
return;
(void) CmdGetEditPoint(&editPoint, &dummyRect);
if ((plowCmd = plowGetCommand(cmd)) == PC_ERROR)
return;
def = EditCellUse->cu_def;
plane = def->cd_planes[PL_TECHDEPBASE];
switch (plowCmd)
{
case PC_HELP:
TxPrintf("Usage: *plow cmd [args]\n");
TxPrintf("Valid plowing command are:\n");
for (n = 0; plowCmds[n].p_name; n++)
TxPrintf("%-15s %s\n", plowCmds[n].p_name, plowCmds[n].p_help);
break;
case PC_RANDOM:
PlowRandomTest(def);
break;
case PC_JOG:
plowTestJog(def, &editArea);
break;
case PC_SETD:
DebugSet(plowDebugID, cmd->tx_argc - 2, &cmd->tx_argv[2], TRUE);
break;
case PC_CLRD:
DebugSet(plowDebugID, cmd->tx_argc - 2, &cmd->tx_argv[2], FALSE);
break;
case PC_SHOWD:
DebugShow(plowDebugID);
break;
case PC_OUTLINE:
if (cmd->tx_argc < 4)
{
TxError("Usage: *plow outline direction layers\n");
return;
}
dir = GeoNameToPos(cmd->tx_argv[2], TRUE, TRUE);
if (dir != GEO_NORTH && dir != GEO_SOUTH)
{
TxError("Only legal starting directions are north or south\n");
return;
}
if (!CmdParseLayers(cmd->tx_argv[3], &okTypes))
return;
(void) plowSrOutline(PL_TECHDEPBASE, &editArea.r_ll, okTypes, dir,
GMASK_NORTH|GMASK_SOUTH|GMASK_EAST|GMASK_WEST,
plowShowOutline, (ClientData) &editArea);
break;
case PC_PLOW:
if (cmd->tx_argc < 3)
{
TxError("Usage: *plow plow direction [layers]\n");
return;
}
dir = GeoNameToPos(cmd->tx_argv[2], TRUE, TRUE);
okTypes = DBAllTypeBits;
if (cmd->tx_argc > 3 && !CmdParseLayers(cmd->tx_argv[3], &okTypes))
return;
if (!Plow(def, &editArea, okTypes, dir))
{
TxPrintf("Reduced plow size since we ran into the barrier.\n");
GeoTransRect(&EditToRootTransform, &editArea, &rootBox);
ToolMoveBox(TOOL_BL, &rootBox.r_ll, FALSE, rootBoxDef);
ToolMoveCorner(TOOL_TR, &rootBox.r_ur, FALSE, rootBoxDef);
}
break;
case PC_LSHADOW:
if (cmd->tx_argc < 3)
{
TxError("Usage: *plow lshadow layers\n");
return;
}
if (!CmdParseLayers(cmd->tx_argv[2], &okTypes))
return;
saveDef = plowYankDef;
plowYankDef = def;
(void) plowSrShadowBack(PL_TECHDEPBASE, &editArea,
okTypes, plowShowShadow, (ClientData) def);
plowYankDef = saveDef;
break;
case PC_SHADOW:
if (cmd->tx_argc < 3)
{
TxError("Usage: *plow shadow layers\n");
return;
}
if (!CmdParseLayers(cmd->tx_argv[2], &okTypes))
return;
saveDef = plowYankDef;
plowYankDef = def;
(void) plowSrShadow(PL_TECHDEPBASE, &editArea,
okTypes, plowShowShadow, (ClientData) def);
plowYankDef = saveDef;
break;
case PC_TECHSHOW:
f = stdout;
if (cmd->tx_argc >= 3)
{
f = fopen(cmd->tx_argv[2], "w");
if (f == NULL)
{
perror(cmd->tx_argv[2]);
break;
}
}
plowTechShow(f);
if (f != stdout)
(void) fclose(f);
break;
case PC_WIDTH:
if (cmd->tx_argc < 3)
{
TxError("Usage: *plow width layers\n");
return;
}
if (!CmdParseLayers(cmd->tx_argv[2], &okTypes))
return;
edge.e_rect = editArea;
edge.e_pNum = PL_TECHDEPBASE;
TxPrintf("Box: X: %d .. %d Y: %d .. %d\n",
editArea.r_xbot, editArea.r_xtop,
editArea.r_ybot, editArea.r_ytop);
saveDef = plowYankDef;
plowYankDef = def;
(void) plowFindWidth(&edge, okTypes, &def->cd_bbox, &editArea);
plowYankDef = saveDef;
GeoTransRect(&EditToRootTransform, &editArea, &rootBox);
ToolMoveBox(TOOL_BL, &rootBox.r_ll, FALSE, rootBoxDef);
ToolMoveCorner(TOOL_TR, &rootBox.r_ur, FALSE, rootBoxDef);
break;
case PC_LWIDTH:
if (cmd->tx_argc < 3)
{
TxError("Usage: *plow lwidth layers\n");
return;
}
if (!CmdParseLayers(cmd->tx_argv[2], &okTypes))
return;
edge.e_rect = editArea;
edge.e_pNum = PL_TECHDEPBASE;
TxPrintf("Box: X: %d .. %d Y: %d .. %d\n",
editArea.r_xbot, editArea.r_xtop,
editArea.r_ybot, editArea.r_ytop);
saveDef = plowYankDef;
plowYankDef = def;
(void) plowFindWidthBack(&edge, okTypes, &def->cd_bbox, &editArea);
plowYankDef = saveDef;
GeoTransRect(&EditToRootTransform, &editArea, &rootBox);
ToolMoveBox(TOOL_BL, &rootBox.r_ll, FALSE, rootBoxDef);
ToolMoveCorner(TOOL_TR, &rootBox.r_ur, FALSE, rootBoxDef);
break;
case PC_TRAIL:
if (cmd->tx_argc > 3)
{
TxError("Usage: *plow trail [value]\n");
return;
}
tp = TiSrPointNoHint(plane, &editArea.r_ll);
if (cmd->tx_argc == 3) trail = atoi(cmd->tx_argv[2]);
else trail = editArea.r_xtop;
TxPrintf("Trailing coordinate of tile %p updated from %d to %d\n",
(void *)tp, TRAILING(tp), trail);
plowSetTrailing(tp, trail);
break;
case PC_MOVE:
edge.e_pNum = PL_TECHDEPBASE;
edge.e_rect = editArea;
TxPrintf("Moving edge from %d to %d\n",
editArea.r_xbot, editArea.r_xtop);
plowMoveEdge(&edge);
editArea.r_xbot--;
DBWAreaChanged(def, &editArea, DBW_ALLWINDOWS, &DBAllButSpaceBits);
break;
case PC_SPLIT:
tp = TiSrPointNoHint(plane, &editArea.r_ll);
if (editArea.r_ybot == BOTTOM(tp) || editArea.r_ybot == TOP(tp))
{
TxError("Can't split at top or bottom of tile\n");
return;
}
TiToRect(tp, &area2);
TxPrintf("Splitting tile %p at y=%d yielding %p\n",
(void *)tp, editArea.r_ybot, (void *)plowSplitY(tp, editArea.r_ybot));
DBWAreaChanged(def, &area2, DBW_ALLWINDOWS, &DBAllButSpaceBits);
break;
case PC_MERGEDOWN:
tp = TiSrPointNoHint(plane, &editArea.r_ll);
TxPrintf("Merging tile %p below\n", tp);
TiToRect(tp, &editArea);
TiToRect(RT(tp), &area2);
(void) GeoInclude(&area2, &editArea);
plowMergeBottom(tp, plane);
DBWAreaChanged(def, &editArea, DBW_ALLWINDOWS, &DBAllButSpaceBits);
break;
case PC_MERGEUP:
tp = TiSrPointNoHint(plane, &editArea.r_ll);
TxPrintf("Merging tile %p above\n", tp);
TiToRect(tp, &editArea);
TiToRect(RT(tp), &area2);
(void) GeoInclude(&area2, &editArea);
plowMergeTop(tp, plane);
DBWAreaChanged(def, &editArea, DBW_ALLWINDOWS, &DBAllButSpaceBits);
break;
case PC_PRINT:
tp = TiSrPointNoHint(plane, &editArea.r_ll);
TxPrintf("Tile %p LEFT=%d RIGHT=%d BOTTOM=%d TOP=%d\n",
tp, LEFT(tp), RIGHT(tp), BOTTOM(tp), TOP(tp));
TxPrintf(" TRAILING=%d LEADING=%d TYPE=%s\n",
TRAILING(tp), LEADING(tp), DBTypeLongName(TiGetTypeExact(tp)));
break;
case PC_WHENTOP:
if (cmd->tx_argc == 2)
{
plowWhenTop = FALSE;
break;
}
if (cmd->tx_argc != 4)
{
TxError("Usage: *plow whentop xtop ytop\n");
break;
}
plowWhenTopPoint.p_x = atoi(cmd->tx_argv[2]);
plowWhenTopPoint.p_y = atoi(cmd->tx_argv[3]);
plowWhenTop = TRUE;
break;
case PC_WHENBOT:
if (cmd->tx_argc == 2)
{
plowWhenBot = FALSE;
break;
}
if (cmd->tx_argc != 4)
{
TxError("Usage: *plow whenbot xbot ybot\n");
break;
}
plowWhenBotPoint.p_x = atoi(cmd->tx_argv[2]);
plowWhenBotPoint.p_y = atoi(cmd->tx_argv[3]);
plowWhenBot = TRUE;
break;
}
}
/*
* ----------------------------------------------------------------------------
*
* plowGetCommand --
*
* Pull off the subcommand from the TxCommand passed to PlowTest()
* above. Verify that it is a valid command.
*
* Results:
* Returns PC_ERROR on error; otherwise, returns the command
* code (pCmd) corresponding to the command in cmd->tx_argv[1].
*
* Side effects:
* None.
*
* ----------------------------------------------------------------------------
*/
pCmd
plowGetCommand(cmd)
TxCommand *cmd;
{
int plowIndex;
if (cmd->tx_argc <= 1)
{
TxError("Usage: *plow cmd [args]\n");
return (PC_ERROR);
}
plowIndex = LookupStruct(cmd->tx_argv[1],
(LookupTable *) plowCmds, sizeof plowCmds[0]);
if (plowIndex < 0)
{
TxError("Bad plowing command '%s'.\n", cmd->tx_argv[1]);
TxError("Try '*plow help' for a list of commands.\n");
return (PC_ERROR);
}
return (plowCmds[plowIndex].p_cmd);
}
/*
* ----------------------------------------------------------------------------
*
* plowDebugInit --
*
* Initialize debugging flags.
*
* Results:
* None.
*
* Side effects:
* Registers various debugging flags with the debugging module.
*
* ----------------------------------------------------------------------------
*/
void
plowDebugInit()
{
int n;
static struct
{
char *di_name;
int *di_id;
} debug[] = {
{"addedge", &plowDebAdd},
{"jogs", &plowDebJogs},
{"moveedge", &plowDebMove},
{"nextedge", &plowDebNext},
{"time", &plowDebTime},
{"width", &plowDebWidth},
{"yankall", &plowDebYankAll},
{0}
};
/* Register ourselves with the debugging module */
plowDebugID = DebugAddClient("plow", sizeof debug/sizeof debug[0]);
for (n = 0; debug[n].di_name; n++)
*(debug[n].di_id) = DebugAddFlag(plowDebugID, debug[n].di_name);
}
/*
* ----------------------------------------------------------------------------
*
* plowShowShadow --
*
* Debug shadow search. Called for each edge found, we display
* feedback over the area of the edge.
*
* Results:
* None.
*
* Side effects:
* Leaves feedback.
*
* ----------------------------------------------------------------------------
*/
void
plowShowShadow(edge, def)
Edge *edge;
CellDef *def;
{
char mesg[512];
int scaleFactor = 10;
Rect edgeArea;
(void) sprintf(mesg, "Edge between %s and %s",
DBTypeLongName(edge->e_ltype), DBTypeLongName(edge->e_rtype));
edgeArea.r_xbot = edge->e_x * scaleFactor - 1;
edgeArea.r_xtop = edge->e_x * scaleFactor + 1;
edgeArea.r_ybot = edge->e_ybot * scaleFactor;
edgeArea.r_ytop = edge->e_ytop * scaleFactor;
DBWFeedbackAdd(&edgeArea, mesg, def, scaleFactor, STYLE_SOLIDHIGHLIGHTS);
}
/*
* ----------------------------------------------------------------------------
*
* plowTestJog --
*
* Test jog elimination.
* Yank the area enclosed by the box, plus a TechHalo-lambda halo around it,
* into plowYankDef, and then call plowCleanupJogs() to reduce jogs in this
* yank buffer.
*
* Results:
* None.
*
* Side effects:
* Modifies plowYankDef.
* Redisplays.
*
* ----------------------------------------------------------------------------
*/
void
plowTestJog(def, area)
CellDef *def;
Rect *area;
{
extern CellUse *plowYankUse;
extern Rect plowYankedArea;
extern CellDef *plowYankDef;
Rect changedArea;
SearchContext scx;
PaintUndoInfo ui;
/* Make sure the yank buffers exist */
plowYankCreate();
/* Yank into yank buffer */
UndoDisable();
DBCellClearDef(plowYankDef);
plowDummyUse->cu_def = def;
scx.scx_use = plowDummyUse;
scx.scx_trans = GeoIdentityTransform;
scx.scx_area.r_xbot = area->r_xbot - DRCTechHalo;
scx.scx_area.r_ybot = area->r_ybot - DRCTechHalo;
scx.scx_area.r_xtop = area->r_xtop + DRCTechHalo;
scx.scx_area.r_ytop = area->r_ytop + DRCTechHalo;
(void) DBCellCopyPaint(&scx, &DBAllButSpaceAndDRCBits, 0, plowYankUse);
DBReComputeBbox(plowYankDef);
DBWAreaChanged(plowYankDef,&TiPlaneRect,DBW_ALLWINDOWS,&DBAllButSpaceBits);
plowYankedArea = TiPlaneRect;
/* Reduce jogs */
changedArea.r_xbot = changedArea.r_xtop = 0;
changedArea.r_ybot = changedArea.r_ytop = 0;
plowCleanupJogs(area, &changedArea);
DBReComputeBbox(plowYankDef);
DBWAreaChanged(plowYankDef,&changedArea,DBW_ALLWINDOWS,&DBAllButSpaceBits);
UndoEnable();
/* Erase area in original def */
ui.pu_def = def;
for (ui.pu_pNum = PL_TECHDEPBASE; ui.pu_pNum < DBNumPlanes; ui.pu_pNum++)
DBPaintPlane(def->cd_planes[ui.pu_pNum], area,
DBWriteResultTbl[TT_SPACE], &ui);
/* Stuff from yank buffer back into original def */
scx.scx_area = *area;
scx.scx_use = plowYankUse;
scx.scx_trans = GeoIdentityTransform;
(void) DBCellCopyPaint(&scx, &DBAllButSpaceAndDRCBits, 0, plowDummyUse);
DBReComputeBbox(def);
DBWAreaChanged(def, area, DBW_ALLWINDOWS, &DBAllButSpaceBits);
DRCCheckThis(def, TT_CHECKPAINT, area);
}
/*
* ----------------------------------------------------------------------------
*
* plowDebugEdge --
*
* Display an edge for debugging purposes.
* This consists of showing the edge, and its final position, highlighted
* with feedback, then erasing the feedback after requesting "more" from
* the user.
*
* If the user responds with "d" to the "more" request, everything is forcibly
* redisplayed.
*
* Results:
* None.
*
* Side effects:
* None permanent.
*
* ----------------------------------------------------------------------------
*/
void
plowDebugEdge(edge, rtePtr, mesg)
Edge *edge;
RuleTableEntry *rtePtr;
char *mesg;
{
int scaleFactor = 10;
Rect edgeArea;
if (rtePtr)
TxPrintf("Rule being applied: \"%s\"\n", rtePtr->rte_name);
TxPrintf("%s edge (%s :: %s) YL=%d YH=%d X=%d XNEW=%d", mesg,
DBTypeShortName(edge->e_ltype), DBTypeShortName(edge->e_rtype),
edge->e_ybot, edge->e_ytop, edge->e_x, edge->e_newx);
/* LHS */
edgeArea.r_xbot = edge->e_x * scaleFactor - 1;
edgeArea.r_xtop = edge->e_x * scaleFactor + 1;
edgeArea.r_ybot = edge->e_ybot * scaleFactor;
edgeArea.r_ytop = edge->e_ytop * scaleFactor;
DBWFeedbackAdd(&edgeArea, "", plowYankDef,
scaleFactor, STYLE_SOLIDHIGHLIGHTS);
/* RHS */
edgeArea.r_xbot = edge->e_newx * scaleFactor - 1;
edgeArea.r_xtop = edge->e_newx * scaleFactor + 1;
edgeArea.r_ybot = edge->e_ybot * scaleFactor;
edgeArea.r_ytop = edge->e_ytop * scaleFactor;
DBWFeedbackAdd(&edgeArea, "", plowYankDef,
scaleFactor, STYLE_MEDIUMHIGHLIGHTS);
/* TOP */
edgeArea.r_xbot = edge->e_x * scaleFactor;
edgeArea.r_xtop = edge->e_newx * scaleFactor;
edgeArea.r_ybot = edge->e_ytop * scaleFactor - 1;
edgeArea.r_ytop = edge->e_ytop * scaleFactor + 1;
DBWFeedbackAdd(&edgeArea, "", plowYankDef,
scaleFactor, STYLE_MEDIUMHIGHLIGHTS);
/* BOTTOM */
edgeArea.r_xbot = edge->e_x * scaleFactor;
edgeArea.r_xtop = edge->e_newx * scaleFactor;
edgeArea.r_ybot = edge->e_ybot * scaleFactor - 1;
edgeArea.r_ytop = edge->e_ybot * scaleFactor + 1;
DBWFeedbackAdd(&edgeArea, "", plowYankDef,
scaleFactor, STYLE_MEDIUMHIGHLIGHTS);
WindUpdate();
plowDebugMore();
DBWFeedbackClear(NULL);
WindUpdate();
}
/*
* ----------------------------------------------------------------------------
*
* plowDebugMore --
*
* Request "more" from the user.
* If the user responds with "d" to the "more" request,
* everything is forcibly redisplayed.
*
* Results:
* None.
*
* Side effects:
* May cause redisplay.
*
* ----------------------------------------------------------------------------
*/
void
plowDebugMore()
{
char answer[100];
again:
if (TxGetLinePrompt(answer, sizeof answer, " -- more -- ") == NULL)
return;
if (answer[0] == 'd')
{
DBWAreaChanged(plowYankDef, &TiPlaneRect,
DBW_ALLWINDOWS, &DBAllButSpaceBits);
WindUpdate();
goto again;
}
}
/*
* ----------------------------------------------------------------------------
*
* plowShowOutline --
*
* Debug outline search. Called for each outline segment found, we display
* feedback over the area of the segment and then ask for more.
*
* Results:
* Normally returns 0, but will return 1 if the boundary segment
* leaves the clipping rectangle clipArea, or if its endpoint is
* the lower-left of the clipping rectangle.
*
* Side effects:
* Leaves feedback.
*
* ----------------------------------------------------------------------------
*/
int
plowShowOutline(outline, clipArea)
Outline *outline;
Rect *clipArea;
{
static char *dirNames[] = {
"center", "north", "northeast", "east",
"southeast", "south", "southwest", "west",
"northwest", "eastnorth", "eastsouth", "westnorth",
"westsouth"
};
char mesg[512], prompt[612], answer[128];
int scaleFactor = 10;
Rect edgeArea;
(void) sprintf(mesg, "%s/%s/%s segment in=%s out=%s",
dirNames[outline->o_prevDir],
dirNames[outline->o_currentDir],
dirNames[outline->o_nextDir],
DBTypeLongName(TiGetTypeExact(outline->o_inside)),
DBTypeLongName(TiGetTypeExact(outline->o_outside)));
switch (outline->o_currentDir)
{
case GEO_NORTH:
case GEO_SOUTH:
edgeArea.r_xbot = outline->o_rect.r_xbot * scaleFactor - 1;
edgeArea.r_xtop = outline->o_rect.r_xbot * scaleFactor + 1;
edgeArea.r_ybot = outline->o_rect.r_ybot * scaleFactor;
edgeArea.r_ytop = outline->o_rect.r_ytop * scaleFactor;
break;
case GEO_EAST:
case GEO_WEST:
edgeArea.r_xbot = outline->o_rect.r_xbot * scaleFactor;
edgeArea.r_xtop = outline->o_rect.r_xtop * scaleFactor;
edgeArea.r_ybot = outline->o_rect.r_ybot * scaleFactor - 1;
edgeArea.r_ytop = outline->o_rect.r_ytop * scaleFactor + 1;
break;
}
DBWFeedbackAdd(&edgeArea, mesg, EditCellUse->cu_def,
scaleFactor, STYLE_SOLIDHIGHLIGHTS);
WindUpdate();
(void) sprintf(prompt, "%s --more--", mesg);
(void) TxGetLinePrompt(answer, sizeof answer, prompt);
if (answer[0] == 'n')
return (1);
#ifdef notdef
/* Does this segment cross the clipping area? */
if (outline->o_rect.r_xtop >= clipArea->r_xtop
|| outline->o_rect.r_ytop >= clipArea->r_ytop
|| outline->o_rect.r_xbot < clipArea->r_xbot
|| outline->o_rect.r_ybot < clipArea->r_ybot)
return (1);
#endif /* notdef */
/* Are we back at the starting point? */
switch (outline->o_currentDir)
{
case GEO_NORTH:
case GEO_EAST:
if (outline->o_rect.r_xtop == clipArea->r_xbot
&& outline->o_rect.r_ytop == clipArea->r_ybot)
return (1);
break;
case GEO_SOUTH:
case GEO_WEST:
if (outline->o_rect.r_xbot == clipArea->r_xbot
&& outline->o_rect.r_ybot == clipArea->r_ybot)
return (1);
break;
}
return (0);
}
/*
* ----------------------------------------------------------------------------
*
* plowDisplay --
*
* Debugging procedure to redisplay the yank and spare buffers.
* If 'dodef' is TRUE, we also redisplay the original cell.
*
* Results:
* None.
*
* Side effects:
* Forces redisplay.
*
* ----------------------------------------------------------------------------
*/
void
plowDisplay(dodef)
bool dodef;
{
if (dodef)
DBWAreaChanged(plowDummyUse->cu_def, &TiPlaneRect,
DBW_ALLWINDOWS, &DBAllButSpaceBits);
DBWAreaChanged(plowYankDef, &TiPlaneRect,
DBW_ALLWINDOWS, &DBAllButSpaceBits);
DBWAreaChanged(plowSpareDef, &TiPlaneRect,
DBW_ALLWINDOWS, &DBAllButSpaceBits);
WindUpdate();
}
Reference in New Issue View Git Blame Copy Permalink