diff options
Diffstat (limited to 'app/bin/cdraw.c')
| -rw-r--r-- | app/bin/cdraw.c | 3304 |
1 files changed, 2756 insertions, 548 deletions
diff --git a/app/bin/cdraw.c b/app/bin/cdraw.c index 9bddcaf..4d52408 100644 --- a/app/bin/cdraw.c +++ b/app/bin/cdraw.c @@ -2,72 +2,89 @@ * Drawing of geometric elements */ - /* XTrkCad - Model Railroad CAD - * Copyright (C) 2005 Dave Bullis - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#include <math.h> -#include <stdint.h> -#include <string.h> +/* XTrkCad - Model Railroad CAD + * Copyright (C) 2005 Dave Bullis + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#include "common.h" #include "ccurve.h" #include "cbezier.h" #include "drawgeom.h" #include "fileio.h" -#include "i18n.h" -#include "messages.h" #include "param.h" #include "track.h" -#include "utility.h" +#include "tbezier.h" #include "misc.h" +#include "cselect.h" +#include "cundo.h" +#include "common-ui.h" + +static wMenu_p drawModDelMI; +static wMenu_p drawModLinMI; +static wMenuPush_p drawModDel; +static wMenuPush_p drawModSmooth; +static wMenuPush_p drawModVertex; +static wMenuPush_p drawModRound; +static wMenuPush_p drawModriginMode; +static wMenuPush_p drawModPointsMode; +static wMenuPush_p drawModOrigin; +static wMenuPush_p drawModLast; +static wMenuPush_p drawModCenter; +static wMenuPush_p drawModClose; +static wMenuPush_p drawModOpen; +static wMenuPush_p drawModFill; +static wMenuPush_p drawModEmpty; +static wMenuPush_p drawModSolid; +static wMenuPush_p drawModDot; +static wMenuPush_p drawModDash; +static wMenuPush_p drawModDashDot; +static wMenuPush_p drawModDashDotDot; +static wMenuPush_p drawModCenterDot; +static wMenuPush_p drawModPhantom; -extern TRKTYP_T T_BZRLIN; - -extern void wSetSelectedFontSize(int size); static long fontSizeList[] = { - 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 32, 36, - 40, 48, 56, 64, 72, 80, 90, 100, 120, 140, 160, 180, - 200, 250, 300, 350, 400, 450, 500 }; + 4, 5, 6, 7, 8, 10, 12, 14, 16, 18, 20, 24, 28, 32, 36, + 40, 48, 56, 64, 72, 80, 90, 100, 120, 140, 160, 180, + 200, 250, 300, 350, 400, 450, 500 +}; EXPORT void LoadFontSizeList( - wList_p list, - long curFontSize) + wList_p list, + long curFontSize) { wIndex_t curInx = 0, inx1; int inx; wListClear(list); - for (inx = 0; inx < sizeof fontSizeList / sizeof fontSizeList[0]; inx++) - { + for (inx = 0; inx < COUNT( fontSizeList ); inx++) { if ((inx == 0 || curFontSize > fontSizeList[inx - 1]) && - (curFontSize < fontSizeList[inx])) - { + (curFontSize < fontSizeList[inx])) { sprintf(message, "%ld", curFontSize); - curInx = wListAddValue(list, message, NULL, (void*)curFontSize); + curInx = wListAddValue(list, message, NULL, I2VP(curFontSize)); } sprintf(message, "%ld", fontSizeList[inx]); - inx1 = wListAddValue(list, message, NULL, (void*)fontSizeList[inx]); - if (curFontSize == fontSizeList[inx]) + inx1 = wListAddValue(list, message, NULL, I2VP(fontSizeList[inx])); + if (curFontSize == fontSizeList[inx]) { curInx = inx1; + } } - if (curFontSize > fontSizeList[(sizeof fontSizeList / sizeof fontSizeList[0]) - 1]) - { + if (curFontSize > fontSizeList[ COUNT( fontSizeList ) - 1]) { sprintf(message, "%ld", curFontSize); - curInx = wListAddValue(list, message, NULL, (void*)curFontSize); + curInx = wListAddValue(list, message, NULL, I2VP(curFontSize)); } wListSetIndex(list, curInx); wFlush(); @@ -81,23 +98,25 @@ long GetFontSize(wIndex_t inx) long GetFontSizeIndex(long size) { int i; - for (i = 0; i < sizeof fontSizeList / sizeof fontSizeList[0]; i++) - { - if (fontSizeList[i] == size) + for (i = 0; i < COUNT( fontSizeList ); i++) { + if (fontSizeList[i] == size) { return(i); + } } return(-1); } EXPORT void UpdateFontSizeList( - long * fontSizeR, - wList_p list, - wIndex_t listInx ) + long * fontSizeR, + wList_p list, + wIndex_t listInx ) { long fontSize; + long largeFontSize; + wPrefGetInteger( "misc", "large-font-size", &largeFontSize, 500 ); if ( listInx >= 0 ) { - *fontSizeR = (long)wListGetItemContext( list, listInx ); + *fontSizeR = VP2L( wListGetItemContext( list, listInx )); } else { wListGetValues( list, message, sizeof message, NULL, NULL ); if ( message[0] != '\0' ) { @@ -107,11 +126,16 @@ EXPORT void UpdateFontSizeList( sprintf( message, "%ld", *fontSizeR ); wListSetValue( list, message ); } else { - if ( fontSize <= 500 || NoticeMessage( MSG_LARGE_FONT, _("Yes"), _("No") ) > 0 ) { - + if ( fontSize <= largeFontSize + || NoticeMessage( MSG_LARGE_FONT, _("Yes"), _("No") ) > 0 ) { + + if ( fontSize > largeFontSize ) { + largeFontSize = fontSize; + wPrefSetInteger( "misc", "large-font-size", largeFontSize ); + } *fontSizeR = fontSize; /* inform gtkfont dialog from change */ - wSetSelectedFontSize((int)fontSize); + wSetSelectedFontSize((wFontSize_t)fontSize); /*LoadFontSizeList( list, *fontSizeR );*/ } else { sprintf( message, "%ld", *fontSizeR ); @@ -128,12 +152,15 @@ EXPORT void UpdateFontSizeList( * */ -struct extraData { - coOrd orig; - ANGLE_T angle; - wIndex_t segCnt; - trkSeg_t segs[1]; - }; + +typedef struct extraDataDraw_t { + extraDataBase_t base; + coOrd orig; + ANGLE_T angle; + drawLineType_e lineType; + wIndex_t segCnt; + trkSeg_t segs[1]; +} extraDataDraw_t; static TRKTYP_T T_DRAW = -1; static track_p ignoredTableEdge; @@ -142,7 +169,7 @@ static track_p ignoredDraw; static void ComputeDrawBoundingBox( track_p t ) { - struct extraData * xx = GetTrkExtraData(t); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(t, T_DRAW, extraDataDraw_t); coOrd lo, hi; GetSegBounds( xx->orig, xx->angle, xx->segCnt, xx->segs, &lo, &hi ); @@ -153,26 +180,36 @@ static void ComputeDrawBoundingBox( track_p t ) static track_p MakeDrawFromSeg1( - wIndex_t index, - coOrd pos, - ANGLE_T angle, - trkSeg_p sp ) + wIndex_t index, + coOrd pos, + ANGLE_T angle, + trkSeg_p sp ) { - struct extraData * xx; + struct extraDataDraw_t * xx; track_p trk; - if ( sp->type == ' ' ) + if ( sp->type == ' ' ) { return NULL; + } + if (sp->type == SEG_BEZLIN) { + trk = NewBezierLine(sp->u.l.pos, NULL, 0, sp->color, sp->lineWidth); + trkSeg_p spb = &DYNARR_N(trkSeg_t, sp->bezSegs, 0); + FixUpBezierSegs(spb, sp->bezSegs.cnt); + MoveBezier(trk, pos); + RotateBezier(trk, pos, angle); + return trk; + } trk = NewTrack( index, T_DRAW, 0, sizeof *xx ); - xx = GetTrkExtraData( trk ); + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); xx->orig = pos; xx->angle = angle; xx->segCnt = 1; + xx->lineType = DRAWLINESOLID; memcpy( xx->segs, sp, sizeof *(trkSeg_p)0 ); if (xx->segs[0].type == SEG_POLY || - xx->segs[0].type == SEG_FILPOLY) { - xx->segs[0].u.p.pts = (coOrd*)MyMalloc( (sp->u.p.cnt) * sizeof (coOrd) ); - memcpy(xx->segs[0].u.p.pts, sp->u.p.pts, sp->u.p.cnt * sizeof (coOrd) ); + xx->segs[0].type == SEG_FILPOLY ) { + xx->segs[0].u.p.pts = (pts_t*)MyMalloc( (sp->u.p.cnt) * sizeof (pts_t) ); + memcpy(xx->segs[0].u.p.pts, sp->u.p.pts, sp->u.p.cnt * sizeof (pts_t) ); } if (xx->segs[0].type == SEG_TEXT) { xx->segs[0].u.t.string = MyStrdup(sp->u.t.string); @@ -182,72 +219,369 @@ static track_p MakeDrawFromSeg1( } EXPORT track_p MakeDrawFromSeg( - coOrd pos, - ANGLE_T angle, - trkSeg_p sp ) + coOrd pos, + ANGLE_T angle, + trkSeg_p sp ) { return MakeDrawFromSeg1( 0, pos, angle, sp ); } +int SliceCuts(ANGLE_T a, DIST_T radius) +{ + double Error = 0.05; + double Error_angle = acos(1-(Error/fabs(radius))); + if (Error_angle <0.0001) { return 0; } + return (int)(floor(D2R(a)/(2*Error_angle))); +} + +/* Only straight, curved and PolyLine */ +EXPORT track_p MakePolyLineFromSegs( + coOrd pos, + ANGLE_T angle, + dynArr_t * segsArr) +{ + struct extraDataDraw_t * xx; + track_p trk; + trk = NewTrack( 0, T_DRAW, 0, sizeof *xx ); + xx = GET_EXTRA_DATA( trk, T_DRAW, extraDataDraw_t ); + xx->orig = pos; + xx->angle = angle; + xx->lineType = DRAWLINESOLID; + xx->segCnt = 1; + xx->segs[0].type = SEG_POLY; + xx->segs[0].lineWidth = 0; + xx->segs[0].u.p.polyType = POLYLINE; + xx->segs[0].color = wDrawColorBlack; + coOrd last; + BOOL_T first = TRUE; + int cnt = 0; + for (int i=0; i<segsArr->cnt; i++) { + trkSeg_p sp = &DYNARR_N(trkSeg_t,*segsArr,i); + if (sp->type == SEG_BEZLIN || sp->type == SEG_BEZTRK ) { + for (int j=0; j<sp->bezSegs.cnt; j++) { + trkSeg_p spb = &DYNARR_N(trkSeg_t,sp->bezSegs,j); + if (spb->type == SEG_STRLIN || spb->type == SEG_STRTRK) { + if (!first && IsClose(FindDistance(spb->u.l.pos[0], last))) { + cnt++; + } else { + cnt=cnt+2; + } + last = spb->u.l.pos[1]; + first = FALSE; + } else if (spb->type == SEG_CRVLIN || spb->type == SEG_CRVTRK) { + coOrd this; + if (spb->u.c.radius >= 0.0) { + Translate(&this, spb->u.c.center, spb->u.c.a0, fabs(spb->u.c.radius)); + } else { + Translate(&this, spb->u.c.center, spb->u.c.a0+spb->u.c.a1, + fabs(spb->u.c.radius)); + } + if (first || !IsClose(FindDistance(this, last))) { + cnt++; //Add first point + } + cnt += 1 + SliceCuts(spb->u.c.a1,spb->u.c.radius); + if (spb->u.c.radius >= 0.0) { + Translate(&last, spb->u.c.center, spb->u.c.a0+spb->u.c.a1, + fabs(spb->u.c.radius)); + } else { + Translate(&last, spb->u.c.center, spb->u.c.a0, fabs(spb->u.c.radius)); + } + first = FALSE; + } + } + } else if (sp->type == SEG_STRLIN || sp->type == SEG_STRTRK) { + if (!first && IsClose(FindDistance(sp->u.l.pos[0], last))) { + cnt++; + } else { + cnt=cnt+2; + } + last = sp->u.l.pos[1]; + first = FALSE; + } else if (sp->type == SEG_CRVLIN || sp->type == SEG_CRVTRK) { + coOrd this; + if (sp->u.c.radius >= 0.0) { + Translate(&this, sp->u.c.center, sp->u.c.a0, fabs(sp->u.c.radius)); + } else { + Translate(&this, sp->u.c.center, sp->u.c.a0+sp->u.c.a1, fabs(sp->u.c.radius)); + } + if (first || !IsClose(FindDistance(this, last))) { + cnt++; //Add first point + } + cnt += 1+ SliceCuts(sp->u.c.a1,sp->u.c.radius); + if (sp->u.c.radius >= 0.0) { + Translate(&last, sp->u.c.center, sp->u.c.a0+sp->u.c.a1, fabs(sp->u.c.radius)); + } else { + Translate(&last, sp->u.c.center, sp->u.c.a0, fabs(sp->u.c.radius)); + } + first = FALSE; + } else if (sp->type == SEG_POLY) { + if (!first && IsClose(FindDistance(sp->u.p.pts[0].pt, last))) { + cnt = cnt + sp->u.p.cnt-1; + } else { + cnt = cnt + sp->u.p.cnt; + } + last = sp->u.p.pts[sp->u.p.cnt-1].pt; + first = FALSE; + } + } + xx->segs[0].u.p.cnt = cnt; + xx->segs[0].u.p.pts = (pts_t*)MyMalloc( (cnt) * sizeof (pts_t) ); + first = TRUE; + int j =0; + for (int i=0; i<segsArr->cnt; i++) { + trkSeg_p sp = &DYNARR_N(trkSeg_t,*segsArr,i); + if (sp->type == SEG_BEZLIN || sp->type == SEG_BEZTRK ) { + for (int l=0; l<sp->bezSegs.cnt; l++) { + trkSeg_p spb = &DYNARR_N(trkSeg_t,sp->bezSegs,l); + if (spb->type == SEG_STRLIN || spb->type == SEG_STRTRK) { + if (first || !IsClose(FindDistance(spb->u.l.pos[0], last))) { + xx->segs[0].u.p.pts[j].pt = spb->u.l.pos[0]; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + j++; + } + xx->segs[0].u.p.pts[j].pt = spb->u.l.pos[1]; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + last = xx->segs[0].u.p.pts[j].pt; + j ++; + first = FALSE; + } + if (spb->type == SEG_CRVLIN || spb->type == SEG_CRVTRK) { + coOrd this; + if (spb->u.c.radius>=0.0) { + Translate(&this, spb->u.c.center, spb->u.c.a0, fabs(spb->u.c.radius)); + } else { + Translate(&this, spb->u.c.center, spb->u.c.a0+spb->u.c.a1, + fabs(spb->u.c.radius)); + } + if (first || !IsClose(FindDistance(this, last))) { + xx->segs[0].u.p.pts[j].pt= this; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + j++; + } + int slices = SliceCuts(spb->u.c.a1,spb->u.c.radius); + for (int k=1; k<slices; k++) { + if (spb->u.c.radius>=0.0) { + Translate(&xx->segs[0].u.p.pts[j].pt, spb->u.c.center, + spb->u.c.a0+(k*(spb->u.c.a1/(slices))), fabs(spb->u.c.radius)); + } else { + Translate(&xx->segs[0].u.p.pts[j].pt, spb->u.c.center, + spb->u.c.a0+((slices-k)*(spb->u.c.a1/(slices))), fabs(spb->u.c.radius)); + } + xx->segs[0].u.p.pts[j].pt_type = wPolyLineSmooth; + j++; + } + if (spb->u.c.radius>=0.0) { + Translate(&xx->segs[0].u.p.pts[j].pt, spb->u.c.center, spb->u.c.a0+spb->u.c.a1, + fabs(spb->u.c.radius)); + } else { + Translate(&xx->segs[0].u.p.pts[j].pt, spb->u.c.center, spb->u.c.a0, + fabs(spb->u.c.radius)); + } + + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + last = xx->segs[0].u.p.pts[j].pt; + j++; + first = FALSE; + } + } + } + if (sp->type == SEG_STRLIN || sp->type == SEG_STRTRK) { + if (first || !IsClose(FindDistance(sp->u.l.pos[0], last))) { + xx->segs[0].u.p.pts[j].pt = sp->u.l.pos[0]; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + j++; + } + xx->segs[0].u.p.pts[j].pt = last = sp->u.l.pos[1]; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + last = xx->segs[0].u.p.pts[j].pt; + j++; + first = FALSE; + } + if (sp->type == SEG_CRVLIN || sp->type == SEG_CRVTRK) { + coOrd this; + if (sp->u.c.radius>0) { + Translate(&this, sp->u.c.center, sp->u.c.a0, fabs(sp->u.c.radius)); + } else { + Translate(&this, sp->u.c.center, sp->u.c.a0+sp->u.c.a1, fabs(sp->u.c.radius)); + } + if (first || !IsClose(FindDistance(this, last))) { + xx->segs[0].u.p.pts[j].pt= this; + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + j++; + } + int slices = SliceCuts(sp->u.c.a1,sp->u.c.radius); + + for (int k=1; k<slices; k++) { + if (sp->u.c.radius>0) { + Translate(&xx->segs[0].u.p.pts[j].pt, sp->u.c.center, + sp->u.c.a0+(k*(sp->u.c.a1/(slices))), fabs(sp->u.c.radius)); + } else { + Translate(&xx->segs[0].u.p.pts[j].pt, sp->u.c.center, + sp->u.c.a0+((slices-k)*(sp->u.c.a1/(slices))), fabs(sp->u.c.radius)); + } + xx->segs[0].u.p.pts[j].pt_type = wPolyLineSmooth; + j++; + } + if (sp->u.c.radius>0) { + Translate(&xx->segs[0].u.p.pts[j].pt, sp->u.c.center, sp->u.c.a0+sp->u.c.a1, + fabs(sp->u.c.radius)); + } else { + Translate(&xx->segs[0].u.p.pts[j].pt, sp->u.c.center, sp->u.c.a0, + fabs(sp->u.c.radius)); + } + + xx->segs[0].u.p.pts[j].pt_type = wPolyLineStraight; + last = xx->segs[0].u.p.pts[j].pt; + j++; + first = FALSE; + } + if (sp->type == SEG_POLY) { + if (first || !IsClose(FindDistance(sp->u.p.pts[0].pt, last))) { + xx->segs[0].u.p.pts[j] = sp->u.p.pts[0]; + j++; + } + memcpy(&xx->segs[0].u.p.pts[j],&sp->u.p.pts[1], + (sp->u.p.cnt-1) * sizeof (pts_t)); + last = xx->segs[0].u.p.pts[sp->u.p.cnt-1].pt; + j +=sp->u.p.cnt-1; + first = FALSE; + } + CHECK(j<=cnt); + } + xx->segs[0].u.p.cnt = j; + + if (IsClose(FindDistance(xx->segs[0].u.p.pts[0].pt, + xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1].pt))) { + xx->segs[0].u.p.polyType = FREEFORM; + xx->segs[0].u.p.cnt = xx->segs[0].u.p.cnt-1; + } + + ComputeDrawBoundingBox( trk ); + return trk; +} + + +static dynArr_t anchors_da; +#define anchors(N) DYNARR_N(trkSeg_t,anchors_da,N) + +void static CreateOriginAnchor(coOrd origin, wBool_t trans_selected) +{ + double d = tempD.scale*0.15; + DYNARR_APPEND(trkSeg_t,anchors_da,2); + int i = anchors_da.cnt-1; + coOrd p0,p1; + Translate(&p0,origin,0,d*4); + Translate(&p1,origin,0,-d*4); + anchors(i).type = SEG_STRLIN; + anchors(i).u.l.pos[0] = p0; + anchors(i).u.l.pos[1] = p1; + anchors(i).color = wDrawColorBlue; + anchors(i).lineWidth = 0; + DYNARR_APPEND(trkSeg_t,anchors_da,1); + Translate(&p0,origin,90,d*4); + Translate(&p1,origin,90,-d*4); + i = anchors_da.cnt-1; + anchors(i).type = SEG_STRLIN; + anchors(i).u.l.pos[0] = p0; + anchors(i).u.l.pos[1] = p1; + anchors(i).color = wDrawColorBlue; + anchors(i).lineWidth = 0; +} + +EXPORT void DrawOriginAnchor(track_p trk) +{ + if (!trk || GetTrkType(trk) != T_DRAW) { return; } + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + if ((xx->orig.x != 0.0) || (xx->orig.y !=0.0) ) { + DYNARR_RESET(trkSeg_t,anchors_da); + CreateOriginAnchor(xx->orig,FALSE); + DrawSegsDA(&tempD, NULL, zero, 0.0, &anchors_da, trackGauge, wDrawColorBlue, 0); + } +} static DIST_T DistanceDraw( track_p t, coOrd * p ) { - struct extraData * xx = GetTrkExtraData(t); - if ( ignoredTableEdge == t && xx->segs[0].type == SEG_TBLEDGE ) - return 100000.0; - if ( ignoredDraw == t ) - return 100000.0; + struct extraDataDraw_t * xx = GET_EXTRA_DATA(t, T_DRAW, extraDataDraw_t); + if ( ignoredTableEdge == t && xx->segs[0].type == SEG_TBLEDGE ) { + return DIST_INF; + } + if ( ignoredDraw == t ) { + return DIST_INF; + } return DistanceSegs( xx->orig, xx->angle, xx->segCnt, xx->segs, p, NULL ); } static struct { - coOrd endPt[2]; - FLOAT_T length; - coOrd center; - DIST_T radius; - ANGLE_T angle0; - ANGLE_T angle1; - ANGLE_T angle; - long pointCount; - long lineWidth; - wDrawColor color; - wIndex_t benchChoice; - wIndex_t benchOrient; - wIndex_t dimenSize; - descPivot_t pivot; - wIndex_t fontSizeInx; - char text[STR_LONG_SIZE]; - unsigned int layer; - char polyType[STR_SIZE]; - } drawData; -typedef enum { E0, E1, CE, RA, LN, AL, A1, A2, VC, LW, CO, BE, OR, DS, TP, TA, TS, TX, PV, LY, PT } drawDesc_e; + coOrd endPt[4]; + coOrd origin; + coOrd oldOrigin; + coOrd oldE0; + coOrd oldE1; + FLOAT_T length; + FLOAT_T height; + FLOAT_T width; + coOrd center; + DIST_T radius; + ANGLE_T angle0; + ANGLE_T angle1; + ANGLE_T angle; + ANGLE_T rotate_angle; + ANGLE_T oldAngle; + long pointCount; + LWIDTH_T lineWidth; + BOOL_T boxed; + BOOL_T filled; + BOOL_T open; + BOOL_T lock_origin; + wDrawColor color; + wIndex_t benchChoice; + wIndex_t benchOrient; + wIndex_t dimenSize; + descPivot_t pivot; + wIndex_t fontSizeInx; + char text[STR_HUGE_SIZE]; + unsigned int layer; + wIndex_t lineType; +} drawData; +typedef enum { E0, E1, PP, CE, AL, LA, A1, A2, RD, LN, HT, WT, PV, VC, LW, LT, CO, FL, OP, BX, BE, OR, DS, TP, TA, TS, TX, LK, OI, RA, LY } drawDesc_e; static descData_t drawDesc[] = { -/*E0*/ { DESC_POS, N_("End Pt 1: X,Y"), &drawData.endPt[0] }, -/*E1*/ { DESC_POS, N_("End Pt 2: X,Y"), &drawData.endPt[1] }, -/*CE*/ { DESC_POS, N_("Center: X,Y"), &drawData.center }, -/*RA*/ { DESC_DIM, N_("Radius"), &drawData.radius }, -/*LN*/ { DESC_DIM, N_("Length"), &drawData.length }, -/*AL*/ { DESC_FLOAT, N_("Angle"), &drawData.angle }, -/*A1*/ { DESC_ANGLE, N_("CCW Angle"), &drawData.angle0 }, -/*A2*/ { DESC_ANGLE, N_("CW Angle"), &drawData.angle1 }, -/*VC*/ { DESC_LONG, N_("Point Count"), &drawData.pointCount }, -/*LW*/ { DESC_LONG, N_("Line Width"), &drawData.lineWidth }, -/*CO*/ { DESC_COLOR, N_("Color"), &drawData.color }, -/*BE*/ { DESC_LIST, N_("Lumber"), &drawData.benchChoice }, -/*OR*/ { DESC_LIST, N_("Orientation"), &drawData.benchOrient }, -/*DS*/ { DESC_LIST, N_("Size"), &drawData.dimenSize }, -/*TP*/ { DESC_POS, N_("Origin: X,Y"), &drawData.endPt[0] }, -/*TA*/ { DESC_FLOAT, N_("Angle"), &drawData.angle }, -/*TS*/ { DESC_EDITABLELIST, N_("Font Size"), &drawData.fontSizeInx }, -/*TX*/ { DESC_TEXT, N_("Text"), &drawData.text }, -/*PV*/ { DESC_PIVOT, N_("Pivot"), &drawData.pivot }, -/*LY*/ { DESC_LAYER, N_("Layer"), &drawData.layer }, -/*PT*/ { DESC_STRING, N_("Type"), &drawData.polyType }, - { DESC_NULL } }; -int drawSegInx; + /*E0*/ { DESC_POS, N_("End Pt 1: X,Y"), &drawData.endPt[0] }, + /*E1*/ { DESC_POS, N_("End Pt 2: X,Y"), &drawData.endPt[1] }, + /*PP*/ { DESC_POS, N_("First Point: X,Y"), &drawData.endPt[0] }, + /*CE*/ { DESC_POS, N_("Center: X,Y"), &drawData.center }, + /*AL*/ { DESC_FLOAT, N_("Angular Length"), &drawData.angle }, + /*LA*/ { DESC_FLOAT, N_("Line Angle"), &drawData.angle }, + /*A1*/ { DESC_ANGLE, N_("CCW Angle"), &drawData.angle0 }, + /*A2*/ { DESC_ANGLE, N_("CW Angle"), &drawData.angle1 }, + /*RD*/ { DESC_DIM, N_("Radius"), &drawData.radius }, + /*LN*/ { DESC_DIM, N_("Length"), &drawData.length }, + /*HT*/ { DESC_DIM, N_("Height"), &drawData.height }, + /*WT*/ { DESC_DIM, N_("Width"), &drawData.width }, + /*PV*/ { DESC_PIVOT, N_("Pivot"), &drawData.pivot }, + /*VC*/ { DESC_LONG, N_("Point Count"), &drawData.pointCount }, + /*LW*/ { DESC_FLOAT, N_("Line Width"), &drawData.lineWidth }, + /*LT*/ { DESC_LIST, N_("Line Type"), &drawData.lineType }, + /*CO*/ { DESC_COLOR, N_("Color"), &drawData.color }, + /*FL*/ { DESC_BOXED, N_("Filled"), &drawData.filled }, + /*OP*/ { DESC_BOXED, N_("Open End"), &drawData.open }, + /*BX*/ { DESC_BOXED, N_("Boxed"), &drawData.boxed }, + /*BE*/ { DESC_LIST, N_("Lumber"), &drawData.benchChoice }, + /*OR*/ { DESC_LIST, N_("Orientation"), &drawData.benchOrient }, + /*DS*/ { DESC_LIST, N_("Size"), &drawData.dimenSize }, + /*TP*/ { DESC_POS, N_("Text Origin: X,Y"), &drawData.endPt[0] }, + /*TA*/ { DESC_FLOAT, N_("Text Angle"), &drawData.angle }, + /*TS*/ { DESC_EDITABLELIST, N_("Font Size"), &drawData.fontSizeInx }, + /*TX*/ { DESC_TEXT, N_("Text"), &drawData.text }, + /*LK*/ { DESC_BOXED, N_("Lock To Origin"), &drawData.lock_origin}, + /*OI*/ { DESC_POS, N_("Rot Origin: X,Y"), &drawData.origin }, + /*RA*/ { DESC_FLOAT, N_("Rotate By"), &drawData.rotate_angle }, + /*LY*/ { DESC_LAYER, N_("Layer"), &drawData.layer }, + { DESC_NULL } +}; +static int drawSegInx; #define UNREORIGIN( Q, P, A, O ) { \ (Q) = (P); \ @@ -257,26 +591,47 @@ int drawSegInx; Rotate( &(Q), zero, -(A) ); \ } +/* + * Notes - + * + * In V5.1, Origin was always {0,0} and Angle 0.0 after editing a Draw object. + * This did not allow for the use of the objects in other contexts (such as Signal Arms). + * + * In V5.2 - + * + * OI - Origin will be adjusted if it is locked to remain relative to the end point - this equally applies when moving the object points. + * If not locked, the object points will be set relative to the new origin value, + * so that the object remains at the same place as the user specifies. + * If the edit starts with origin {0,0}, it will be set unlocked, otherwise set locked. + * + * RA - Rotate By Angle will only be active if the Origin is locked. + * It will be set to 0.0 whenever the object is modified. + * + * At the end of the operations, the points of the objects will be rotated so that + * rotated and adjusted so they don't need rotation to lie where the user left them. + * + */ static void UpdateDraw( track_p trk, int inx, descData_p descUpd, BOOL_T final ) { - struct extraData *xx = GetTrkExtraData(trk); + struct extraDataDraw_t *xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); trkSeg_p segPtr; coOrd mid; long fontSize; - if ( drawSegInx==-1 ) + if ( drawSegInx==-1 ) { return; + } segPtr = &xx->segs[drawSegInx]; if ( inx == -1 ) { - if (segPtr->type != SEG_TEXT) return; - else inx = TX; //Always look at TextField for SEG_TEXT on "Done" + if (segPtr->type != SEG_TEXT) { return; } + else { inx = TX; } //Always look at TextField for SEG_TEXT on "Done" } - MainRedraw(); - MapRedraw(); UndrawNewTrack( trk ); + coOrd pt; + coOrd off; switch ( inx ) { case LW: - segPtr->width = drawData.lineWidth/mainD.dpi; + segPtr->lineWidth = drawData.lineWidth; break; case CO: segPtr->color = drawData.color; @@ -284,46 +639,268 @@ static void UpdateDraw( track_p trk, int inx, descData_p descUpd, BOOL_T final ) case E0: case E1: if ( inx == E0 ) { - UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], xx->angle, xx->orig ); + coOrd off; + off.x = drawData.endPt[0].x - drawData.oldE0.x; + off.y = drawData.endPt[0].y - drawData.oldE0.y; + switch(segPtr->type) { //E0 does not alter length - translates + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig ); + drawData.endPt[1].x = off.x+drawData.endPt[1].x; + drawData.endPt[1].y = off.y+drawData.endPt[1].y; + UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); + drawDesc[E1].mode |= DESC_CHANGE; + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + UNREORIGIN( segPtr->u.c.center, drawData.endPt[0], 0.0, xx->orig ); + break; + case SEG_POLY: + case SEG_FILPOLY: + break; //Note not used by POLYGONS + default:; + } } else { - UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], xx->angle, xx->orig ); + UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); } drawData.length = FindDistance( drawData.endPt[0], drawData.endPt[1] ); - drawData.angle = FindAngle( drawData.endPt[0], drawData.endPt[1] ); drawDesc[LN].mode |= DESC_CHANGE; - drawDesc[AL].mode |= DESC_CHANGE; break; - case LN: - case AL: - if ( segPtr->type == SEG_CRVLIN && inx == AL ) { - if ( drawData.angle <= 0.0 || drawData.angle >= 360.0 ) { - ErrorMessage( MSG_CURVE_OUT_OF_RANGE ); - drawData.angle = segPtr->u.c.a1; - drawDesc[AL].mode |= DESC_CHANGE; + case OI: ; + off.x = drawData.origin.x-xx->orig.x; + off.y = drawData.origin.y-xx->orig.y; + xx->orig = drawData.origin; + if (!drawData.lock_origin) { //Move the points so that the object is not moved + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + for (int i=0; i<segPtr->u.p.cnt; i++) { + UNREORIGIN( segPtr->u.p.pts[i].pt, segPtr->u.p.pts[i].pt, 0.0, off ); + } + break; + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + for (int i=0; i<2; i++) { + UNREORIGIN( segPtr->u.l.pos[i], segPtr->u.l.pos[i], 0.0, off ); + } + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + UNREORIGIN( segPtr->u.c.center, segPtr->u.c.center, 0.0, off ); break; + case SEG_TEXT: + UNREORIGIN( segPtr->u.t.pos, segPtr->u.t.pos, 0.0, off ); + default:; } } else { - if ( drawData.length <= minLength ) { - ErrorMessage( MSG_OBJECT_TOO_SHORT ); - if ( segPtr->type != SEG_CRVLIN ) { - drawData.length = FindDistance( drawData.endPt[0], drawData.endPt[1] ); + switch(segPtr->type) { + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + REORIGIN( drawData.endPt[0], segPtr->u.l.pos[0], 0.0, xx->orig ); + REORIGIN( drawData.endPt[1], segPtr->u.l.pos[1], 0.0, xx->orig ); + drawDesc[E0].mode |= DESC_CHANGE; + drawDesc[E1].mode |= DESC_CHANGE; + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + REORIGIN( drawData.center, segPtr->u.c.center, 0.0, xx->orig ); + drawDesc[CE].mode |= DESC_CHANGE; + break; + case SEG_TEXT: + REORIGIN( drawData.endPt[0], segPtr->u.t.pos, 0.0, xx->orig ); + drawDesc[TP].mode |= DESC_CHANGE; + break; + case SEG_POLY: + case SEG_FILPOLY: + REORIGIN(drawData.endPt[0], segPtr->u.p.pts[0].pt, 0.0, xx->orig); + drawDesc[PP].mode |= DESC_CHANGE; + break; + default:; + } + } + break; + case HT: + case WT: + if ((segPtr->type == SEG_POLY) || (segPtr->type == SEG_FILPOLY)) { + if (segPtr->u.p.polyType == RECTANGLE) { + if (inx == HT) { + ANGLE_T angle = NormalizeAngle(FindAngle(drawData.endPt[0],drawData.endPt[3])); + Translate( &drawData.endPt[3], drawData.endPt[0], angle, drawData.height); + UNREORIGIN( segPtr->u.p.pts[3].pt, drawData.endPt[3], xx->angle, xx->orig ); + Translate( &drawData.endPt[2], drawData.endPt[1], angle, drawData.height); + UNREORIGIN( segPtr->u.p.pts[2].pt, drawData.endPt[2], xx->angle, xx->orig ); } else { - drawData.length = fabs(segPtr->u.c.radius)*2*M_PI*segPtr->u.c.a1/360.0; + ANGLE_T angle = NormalizeAngle(FindAngle(drawData.endPt[0],drawData.endPt[1]));; + Translate( &drawData.endPt[1], drawData.endPt[0], angle, drawData.width); + UNREORIGIN( segPtr->u.p.pts[1].pt, drawData.endPt[1], xx->angle, xx->orig ); + Translate( &drawData.endPt[2], drawData.endPt[3], angle, drawData.width); + UNREORIGIN( segPtr->u.p.pts[2].pt, drawData.endPt[2], xx->angle, xx->orig ); + } + drawDesc[E0].mode |= DESC_CHANGE; + } + } + break; + case RA:; //Only applies if "Lock" has been set + if (drawData.lock_origin) { + ANGLE_T angle = NormalizeAngle(drawData.rotate_angle); + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + for (int i=0; i<segPtr->u.p.cnt; i++) { + UNREORIGIN(pt, segPtr->u.p.pts[i].pt, angle, drawData.origin); + REORIGIN(segPtr->u.p.pts[i].pt, pt, 0.0, drawData.origin); + if (i == 0) { drawData.endPt[0] = pt; } + } + drawDesc[PP].mode |= DESC_CHANGE; + break; + case SEG_CRVLIN:; + coOrd end0, end1; + Translate(&end0,segPtr->u.c.center,segPtr->u.c.a0,segPtr->u.c.radius); + Translate(&end1,segPtr->u.c.center,segPtr->u.c.a0+segPtr->u.c.a1, + segPtr->u.c.radius); + REORIGIN(drawData.center, segPtr->u.c.center, angle, drawData.origin); + REORIGIN(end0, end0, angle, drawData.origin); + REORIGIN(end1, end1, angle, drawData.origin); + segPtr->u.c.a0 = drawData.angle0 = FindAngle( drawData.center, end0); + drawData.angle1 = FindAngle( drawData.center, end1); + UNREORIGIN(segPtr->u.c.center,drawData.center,0.0,drawData.origin); + drawDesc[CE].mode |= DESC_CHANGE; + drawDesc[A1].mode |= DESC_CHANGE; + /*no break*/ + case SEG_FILCRCL: + REORIGIN(drawData.center, segPtr->u.c.center, angle, + drawData.origin); //Remove angle + UNREORIGIN(segPtr->u.c.center, drawData.center, 0.0, drawData.origin); + drawDesc[CE].mode |= DESC_CHANGE; + break; + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + for (int i=0; i<2; i++) { + REORIGIN( drawData.endPt[i], segPtr->u.l.pos[i], angle, drawData.origin ); + UNREORIGIN( segPtr->u.l.pos[i], drawData.endPt[i], 0.0, drawData.origin ); } - drawDesc[LN].mode |= DESC_CHANGE; + drawDesc[E0].mode |= DESC_CHANGE; + drawDesc[E1].mode |= DESC_CHANGE; + break; + case SEG_TEXT:; + coOrd tp; + REORIGIN( tp, segPtr->u.t.pos, angle, drawData.origin ); + UNREORIGIN( segPtr->u.t.pos, tp, 0.0, drawData.origin ); + drawData.endPt[0] = tp; + drawData.angle = segPtr->u.t.angle += angle; + drawDesc[TA].mode |= DESC_CHANGE; + drawDesc[TP].mode |= DESC_CHANGE; + break; + default:; + } + } + xx->angle = drawData.rotate_angle = 0.0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + drawDesc[RA].mode |= DESC_CHANGE; + break; + case AL: //Uses Pivot Point + case LA:; + ANGLE_T angle = NormalizeAngle(drawData.angle); + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + break; //Doesn't Use + case SEG_CRVLIN: //Uses as swept angle + switch ( drawData.pivot ) { + case DESC_PIVOT_FIRST: + segPtr->u.c.a1 = drawData.angle; + drawData.angle1 = NormalizeAngle( drawData.angle0+segPtr->u.c.a1 ); + drawDesc[A2].mode |= DESC_CHANGE; + break; + case DESC_PIVOT_SECOND: + segPtr->u.c.a0 = NormalizeAngle( segPtr->u.c.a1+segPtr->u.c.a0-drawData.angle); + segPtr->u.c.a1 = drawData.angle; + drawData.angle0 = NormalizeAngle( segPtr->u.c.a0 ); + drawData.angle1 = NormalizeAngle( drawData.angle0+segPtr->u.c.a1 ); + drawDesc[A1].mode |= DESC_CHANGE; + drawDesc[A2].mode |= DESC_CHANGE; + break; + case DESC_PIVOT_MID: + segPtr->u.c.a0 = NormalizeAngle( segPtr->u.c.a0+segPtr->u.c.a1/2.0 + -drawData.angle/2.0); + segPtr->u.c.a1 = drawData.angle; + drawData.angle0 = NormalizeAngle( segPtr->u.c.a0 ); + drawData.angle1 = NormalizeAngle( drawData.angle0+segPtr->u.c.a1 ); + drawDesc[A1].mode |= DESC_CHANGE; + drawDesc[A2].mode |= DESC_CHANGE; + break; + default: break; } + drawData.length = 2*M_PI*segPtr->u.c.radius*segPtr->u.c.a1/360; + drawDesc[LN].mode = DESC_RO|DESC_CHANGE; + break; + case SEG_FILCRCL: + break; //Doesn't Use + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + switch ( drawData.pivot ) { + case DESC_PIVOT_FIRST: + Translate(&drawData.endPt[1],drawData.endPt[0],angle,drawData.length); + UNREORIGIN(segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); + drawDesc[E1].mode |= DESC_CHANGE; + break; + case DESC_PIVOT_MID:; + coOrd middle; + middle.x = (drawData.endPt[1].x+drawData.endPt[0].x)/2; + middle.y = (drawData.endPt[1].y+drawData.endPt[0].y)/2; + Translate(&drawData.endPt[0],middle,NormalizeAngle(angle+180), + drawData.length/2); + Translate(&drawData.endPt[1],middle,angle,drawData.length/2); + UNREORIGIN(segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig ); + UNREORIGIN(segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); + drawDesc[E0].mode |= DESC_CHANGE; + drawDesc[E1].mode |= DESC_CHANGE; + break; + case DESC_PIVOT_SECOND: + Translate(&drawData.endPt[0],drawData.endPt[1],NormalizeAngle(angle+180), + drawData.length); + UNREORIGIN(segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig ); + drawDesc[E0].mode |= DESC_CHANGE; + break; + default: + break; + } + break; + case SEG_TEXT: + break; //Doesnt Use + default:; + } + break; + case LN: + if ( drawData.length <= minLength ) { + ErrorMessage( MSG_OBJECT_TOO_SHORT ); + drawData.length = fabs(segPtr->u.c.radius)*2*M_PI*segPtr->u.c.a1/360.0; + drawDesc[LN].mode |= DESC_CHANGE; + break; } - if ( segPtr->type != SEG_CRVLIN ) { + if ( segPtr->type != SEG_CRVLIN ) { switch ( drawData.pivot ) { case DESC_PIVOT_FIRST: - Translate( &drawData.endPt[1], drawData.endPt[0], drawData.angle, drawData.length ); - UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], xx->angle, xx->orig ); + Translate( &drawData.endPt[1], drawData.endPt[0], drawData.angle, + drawData.length ); + UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); drawDesc[E1].mode |= DESC_CHANGE; break; case DESC_PIVOT_SECOND: - Translate( &drawData.endPt[0], drawData.endPt[1], drawData.angle+180.0, drawData.length ); - UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], xx->angle, xx->orig ); + Translate( &drawData.endPt[0], drawData.endPt[1], drawData.angle+180.0, + drawData.length ); + UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig ); drawDesc[E0].mode |= DESC_CHANGE; break; case DESC_PIVOT_MID: @@ -331,75 +908,160 @@ static void UpdateDraw( track_p trk, int inx, descData_p descUpd, BOOL_T final ) mid.y = (drawData.endPt[0].y+drawData.endPt[1].y)/2.0; Translate( &drawData.endPt[0], mid, drawData.angle+180.0, drawData.length/2.0 ); Translate( &drawData.endPt[1], mid, drawData.angle, drawData.length/2.0 ); - UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], xx->angle, xx->orig ); - UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], xx->angle, xx->orig ); + UNREORIGIN( segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig ); + UNREORIGIN( segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig ); drawDesc[E0].mode |= DESC_CHANGE; drawDesc[E1].mode |= DESC_CHANGE; break; default: break; } - } else { - if ( drawData.angle < 0.0 || drawData.angle >= 360.0 ) { - ErrorMessage( MSG_CURVE_OUT_OF_RANGE ); - drawData.angle = segPtr->u.c.a1; - drawDesc[AL].mode |= DESC_CHANGE; - } else { - segPtr->u.c.a0 = NormalizeAngle( segPtr->u.c.a0+segPtr->u.c.a1/2.0-drawData.angle/2.0); - segPtr->u.c.a1 = drawData.angle; - drawData.angle0 = NormalizeAngle( segPtr->u.c.a0+xx->angle ); - drawData.angle1 = NormalizeAngle( drawData.angle0+segPtr->u.c.a1 ); - drawDesc[A1].mode |= DESC_CHANGE; - drawDesc[A2].mode |= DESC_CHANGE; - } } break; case CE: - UNREORIGIN( segPtr->u.c.center, drawData.center, xx->angle, xx->orig ); + UNREORIGIN( segPtr->u.c.center, drawData.center, 0.0, xx->orig ); break; - case RA: + case RD: + if ( drawData.pivot == DESC_PIVOT_FIRST ) { + Translate( &segPtr->u.c.center, segPtr->u.c.center, segPtr->u.c.a0, + segPtr->u.c.radius-drawData.radius ); + } else if ( drawData.pivot == DESC_PIVOT_SECOND ) { + Translate( &segPtr->u.c.center, segPtr->u.c.center, + segPtr->u.c.a0+segPtr->u.c.a1, segPtr->u.c.radius-drawData.radius ); + } else { + Translate( &segPtr->u.c.center, segPtr->u.c.center, + (segPtr->u.c.a0+segPtr->u.c.a1)/2.0, segPtr->u.c.radius-drawData.radius ); + } + drawDesc[CE].mode |= DESC_CHANGE; segPtr->u.c.radius = drawData.radius; + drawData.length = 2*M_PI*segPtr->u.c.radius*(segPtr->type==SEG_CRVLIN + ?segPtr->u.c.a1/360:1.0); + drawDesc[LN].mode = DESC_RO|DESC_CHANGE; break; - case A1: - segPtr->u.c.a0 = NormalizeAngle( drawData.angle0-xx->angle ); - drawData.angle1 = NormalizeAngle( drawData.angle0+drawData.angle ); + case A1: //Angle of first point of curve + segPtr->u.c.a0 = NormalizeAngle(drawData.angle0); + drawData.angle1 = NormalizeAngle(segPtr->u.c.a0+segPtr->u.c.a1); drawDesc[A2].mode |= DESC_CHANGE; break; case A2: - segPtr->u.c.a0 = NormalizeAngle( drawData.angle1-segPtr->u.c.a1-xx->angle ); - drawData.angle0 = NormalizeAngle( segPtr->u.c.a0+xx->angle ); + segPtr->u.c.a0 = NormalizeAngle( drawData.angle1-segPtr->u.c.a1); + drawData.angle0 = NormalizeAngle( segPtr->u.c.a0 ); drawDesc[A1].mode |= DESC_CHANGE; break; case BE: - BenchUpdateOrientationList( (long)wListGetItemContext((wList_p)drawDesc[BE].control0, drawData.benchChoice ), (wList_p)drawDesc[OR].control0 ); - if ( drawData.benchOrient < wListGetCount( (wList_p)drawDesc[OR].control0 ) ) + BenchUpdateOrientationList( VP2L( wListGetItemContext((wList_p) + drawDesc[BE].control0, drawData.benchChoice)), (wList_p)drawDesc[OR].control0 ); + if ( drawData.benchOrient < wListGetCount( (wList_p)drawDesc[OR].control0 ) ) { wListSetIndex( (wList_p)drawDesc[OR].control0, drawData.benchOrient ); - else + } else { drawData.benchOrient = 0; - segPtr->u.l.option = GetBenchData( (long)wListGetItemContext((wList_p)drawDesc[BE].control0, drawData.benchChoice ), drawData.benchOrient ); + } + segPtr->u.l.option = GetBenchData( VP2L(wListGetItemContext(( + wList_p)drawDesc[BE].control0, drawData.benchChoice)), drawData.benchOrient ); break; case OR: - segPtr->u.l.option = GetBenchData( (long)wListGetItemContext((wList_p)drawDesc[BE].control0, drawData.benchChoice ), drawData.benchOrient ); + segPtr->u.l.option = GetBenchData( VP2L(wListGetItemContext(( + wList_p)drawDesc[BE].control0, drawData.benchChoice)), drawData.benchOrient ); break; case DS: segPtr->u.l.option = drawData.dimenSize; break; - case TP: - UNREORIGIN( segPtr->u.t.pos, drawData.endPt[0], xx->angle, xx->orig ); + case TP:; + UNREORIGIN(segPtr->u.t.pos, drawData.endPt[0], 0.0, xx->orig ); + break; + case PP: + off.x = drawData.endPt[0].x - drawData.oldE0.x; + off.y = drawData.endPt[0].y - drawData.oldE0.y; + for (int i=0; i<segPtr->u.p.cnt; i++) { + REORIGIN( pt, segPtr->u.p.pts[i].pt, 0.0, xx->orig ); + pt.x += off.x; + pt.y += off.y; + if (i<5) { + drawData.endPt[i] = pt; + } + UNREORIGIN( segPtr->u.p.pts[i].pt, pt, 0.0, xx->orig ); + } break; case TA: - //segPtr->u.t.angle = NormalizeAngle( drawData.angle ); - xx->angle = NormalizeAngle( drawData.angle ); + segPtr->u.t.angle = NormalizeAngle( drawData.angle ); break; case TS: fontSize = (long)segPtr->u.t.fontSize; - UpdateFontSizeList( &fontSize, (wList_p)drawDesc[TS].control0, drawData.fontSizeInx ); + UpdateFontSizeList( &fontSize, (wList_p)drawDesc[TS].control0, + drawData.fontSizeInx ); segPtr->u.t.fontSize = fontSize; break; + case FL: + if (segPtr->type == SEG_POLY && drawData.open) { + segPtr->u.p.polyType = POLYLINE; + drawData.filled = FALSE; + drawDesc[FL].mode = DESC_RO|DESC_CHANGE; + break; + } + if(drawData.filled) { + if (segPtr->type == SEG_POLY) { + segPtr->type = SEG_FILPOLY; + drawData.open = FALSE; + drawDesc[OP].mode = DESC_RO|DESC_CHANGE; + } + if (segPtr->type == SEG_CRVLIN) { + segPtr->type = SEG_FILCRCL; + drawData.length = 0.0; + drawDesc[LN].mode = DESC_RO|DESC_CHANGE; + } + } else { + if (segPtr->type == SEG_FILPOLY) { + segPtr->type = SEG_POLY; + drawData.open = FALSE; + drawDesc[OP].mode = DESC_CHANGE; + } + if (segPtr->type == SEG_FILCRCL) { + segPtr->type = SEG_CRVLIN; + segPtr->u.c.a0 = 0.0; + segPtr->u.c.a1 = 360.0; + drawData.length = 2*M_PI*segPtr->u.c.radius; + drawDesc[LN].mode = DESC_RO|DESC_CHANGE; + } + } + break; + case OP: + if (drawData.filled || (segPtr->type != SEG_POLY)) { + drawData.open = FALSE; + drawDesc[OP].mode |= DESC_CHANGE; + break; + } + if (drawData.open) { + if (segPtr->type == SEG_POLY && segPtr->u.p.polyType == FREEFORM) { + segPtr->u.p.polyType = POLYLINE; + drawData.filled = FALSE; + drawDesc[FL].mode = DESC_RO|DESC_CHANGE; + } + } else { + if (segPtr->type == SEG_POLY && segPtr->u.p.polyType == POLYLINE) { + segPtr->u.p.polyType = FREEFORM; + drawData.filled = FALSE; + drawDesc[FL].mode = DESC_CHANGE; + } + } + break; + case BX: + segPtr->u.t.boxed = drawData.boxed; + break; case TX: - if ( wTextGetModified((wText_p)drawDesc[TX].control0 )) { + if ( wTextGetModified((wText_p)drawDesc[TX].control0 ) || + inPlayback ) { int len = wTextGetSize((wText_p)drawDesc[TX].control0); - MyFree( segPtr->u.t.string ); + // TODO - minor memory leak, but this allows Undo on text object. See BUG-527 + // MyFree( segPtr->u.t.string ); + if ( !descUndoStarted ) { + UndoStart( _("Change Track"), "Change Track"); + descUndoStarted = TRUE; + } + UndoModify( trk ); + if (len>STR_HUGE_SIZE-8) { //Truncate string to max + len = STR_HUGE_SIZE-8; + ErrorMessage( MSG_TEXT_TOO_LONG ); + } segPtr->u.t.string = (char *)MyMalloc(len+1); wTextGetText((wText_p)drawDesc[TX].control0, segPtr->u.t.string, len+1); segPtr->u.t.string[len] = '\0'; //Make sure of null term @@ -409,42 +1071,69 @@ static void UpdateDraw( track_p trk, int inx, descData_p descUpd, BOOL_T final ) case LY: SetTrkLayer( trk, drawData.layer); break; + case LK: + if (drawData.lock_origin) { + drawDesc[RA].mode = 0; + } else { + drawDesc[RA].mode = DESC_RO; + } + drawData.rotate_angle = 0.0; + drawDesc[RA].mode |= DESC_CHANGE; + break; + case LT: + xx->lineType = drawData.lineType; + break; default: - AbortProg( "bad op" ); + CHECKMSG( FALSE, ( "bad op: %d", inx ) ); } + drawData.oldE0 = drawData.endPt[0]; + drawData.oldE1 = drawData.endPt[1]; + drawData.oldAngle = drawData.rotate_angle; + drawData.oldOrigin = drawData.origin; ComputeDrawBoundingBox( trk ); DrawNewTrack( trk ); - DoCurCommand( C_REDRAW, zero ); + TempRedraw(); // UpdateDraw } + static void DescribeDraw( track_p trk, char * str, CSIZE_T len ) { - struct extraData *xx = GetTrkExtraData(trk); + struct extraDataDraw_t *xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); coOrd pos = oldMarker; trkSeg_p segPtr; int inx; char * title = NULL; - char * polyType = NULL; +// char * polyType = NULL; DistanceSegs( xx->orig, xx->angle, xx->segCnt, xx->segs, &pos, &drawSegInx ); - if ( drawSegInx==-1 ) + if ( drawSegInx==-1 ) { return; + } segPtr = &xx->segs[drawSegInx]; - for ( inx=0; inx<sizeof drawDesc/sizeof drawDesc[0]; inx++ ) { + for ( inx=0; inx<COUNT( drawDesc ); inx++ ) { drawDesc[inx].mode = DESC_IGNORE; drawDesc[inx].control0 = NULL; } drawData.color = segPtr->color; drawData.layer = GetTrkLayer(trk); drawDesc[CO].mode = 0; - drawData.lineWidth = (long)floor(segPtr->width*mainD.dpi+0.5); + drawData.lineWidth = segPtr->lineWidth; drawDesc[LW].mode = 0; drawDesc[LY].mode = DESC_NOREDRAW; drawDesc[BE].mode = - drawDesc[OR].mode = - drawDesc[DS].mode = DESC_IGNORE; + drawDesc[OR].mode = + drawDesc[LT].mode = + drawDesc[DS].mode = DESC_IGNORE; drawData.pivot = DESC_PIVOT_MID; + + if ((xx->orig.x == 0.0) && (xx->orig.y == 0.0)) { drawData.lock_origin = FALSE; } + else { drawData.lock_origin = TRUE; } + + drawData.rotate_angle = 0.0; + + drawDesc[LK].mode = 0; + switch ( segPtr->type ) { case SEG_STRLIN: case SEG_DIMLIN: @@ -454,32 +1143,52 @@ static void DescribeDraw( track_p trk, char * str, CSIZE_T len ) REORIGIN( drawData.endPt[1], segPtr->u.l.pos[1], xx->angle, xx->orig ); drawData.length = FindDistance( drawData.endPt[0], drawData.endPt[1] ); drawData.angle = FindAngle( drawData.endPt[0], drawData.endPt[1] ); + drawData.origin = xx->orig; + //Remove input Angle (if any) + UNREORIGIN(segPtr->u.l.pos[0], drawData.endPt[0], 0.0, xx->orig); + UNREORIGIN(segPtr->u.l.pos[1], drawData.endPt[1], 0.0, xx->orig); + xx->angle = 0.0; drawDesc[LN].mode = - drawDesc[AL].mode = - drawDesc[PV].mode = 0; + drawDesc[LA].mode = + drawDesc[PV].mode = 0; drawDesc[E0].mode = + drawDesc[OI].mode = 0; drawDesc[E1].mode = 0; + drawDesc[RA].mode = 0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + else { drawDesc[RA].mode = 0; } switch (segPtr->type) { case SEG_STRLIN: title = _("Straight Line"); + drawDesc[LT].mode = 0; + drawData.lineType = (wIndex_t)xx->lineType; break; case SEG_DIMLIN: title = _("Dimension Line"); - drawDesc[CO].mode = DESC_IGNORE; - drawDesc[LW].mode = DESC_IGNORE; + drawDesc[CO].mode = + drawDesc[LW].mode = + drawDesc[LK].mode = + drawDesc[OI].mode = + drawDesc[RA].mode = DESC_IGNORE; drawData.dimenSize = (wIndex_t)segPtr->u.l.option; drawDesc[DS].mode = 0; break; case SEG_BENCH: title = _("Lumber"); - drawDesc[LW].mode = DESC_IGNORE; + drawDesc[LK].mode = + drawDesc[OI].mode = + drawDesc[RA].mode = + drawDesc[LW].mode = DESC_IGNORE; drawDesc[BE].mode = - drawDesc[OR].mode = 0; + drawDesc[OR].mode = 0; drawData.benchChoice = GetBenchListIndex( segPtr->u.l.option ); drawData.benchOrient = (wIndex_t)(segPtr->u.l.option&0xFF); break; case SEG_TBLEDGE: title = _("Table Edge"); + drawDesc[LK].mode = + drawDesc[OI].mode = + drawDesc[RA].mode = DESC_IGNORE; drawDesc[CO].mode = DESC_IGNORE; drawDesc[LW].mode = DESC_IGNORE; break; @@ -487,90 +1196,177 @@ static void DescribeDraw( track_p trk, char * str, CSIZE_T len ) break; case SEG_CRVLIN: REORIGIN( drawData.center, segPtr->u.c.center, xx->angle, xx->orig ); + //Remove input Angle (if any) + UNREORIGIN(segPtr->u.c.center, drawData.center, 0.0, xx->orig); + xx->angle = 0.0; drawData.radius = fabs(segPtr->u.c.radius); + drawData.origin = xx->orig; + drawDesc[OI].mode = 0; drawDesc[CE].mode = - drawDesc[RA].mode = 0; + drawDesc[RD].mode = 0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + else { drawDesc[RA].mode = 0; } + drawDesc[LT].mode = 0; + drawData.lineType = (wIndex_t)xx->lineType; if ( segPtr->u.c.a1 >= 360.0 ) { title = _("Circle"); + drawDesc[FL].mode = 0; + drawData.filled = FALSE; + drawDesc[LN].mode = DESC_RO; + drawData.length = 2*M_PI*segPtr->u.c.radius; } else { drawData.angle = segPtr->u.c.a1; drawData.angle0 = NormalizeAngle( segPtr->u.c.a0+xx->angle ); drawData.angle1 = NormalizeAngle( drawData.angle0+drawData.angle ); + drawDesc[LN].mode = DESC_RO; + drawData.length = 2*M_PI*segPtr->u.c.radius*segPtr->u.c.a1/360; drawDesc[AL].mode = - drawDesc[A1].mode = - drawDesc[A2].mode = 0; + drawDesc[A1].mode = + drawDesc[A2].mode = 0; + drawDesc[PV].mode = 0; title = _("Curved Line"); } break; case SEG_FILCRCL: REORIGIN( drawData.center, segPtr->u.c.center, xx->angle, xx->orig ); + //Remove input Angle (if any) + UNREORIGIN(segPtr->u.c.center, drawData.center, 0.0, xx->orig); + xx->angle = 0.0; drawData.radius = fabs(segPtr->u.c.radius); + drawData.origin = xx->orig; + drawDesc[OI].mode = + drawDesc[FL].mode = 0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + else { drawDesc[RA].mode = 0; } + drawData.filled = TRUE; + drawData.length = 0.0; + drawDesc[LN].mode = DESC_RO; drawDesc[CE].mode = - drawDesc[RA].mode = 0; + drawDesc[RD].mode = 0; + drawDesc[PV].mode = 0; + drawDesc[OI].mode = 0; drawDesc[LW].mode = DESC_IGNORE; title = _("Filled Circle"); break; case SEG_POLY: - drawData.pointCount = segPtr->u.p.cnt; - drawDesc[VC].mode = DESC_RO; - drawDesc[PT].mode = DESC_RO; - switch (segPtr->u.p.polyType) { - case RECTANGLE: - polyType = _("Rectangle"); - break; - default: - polyType = _("Freeform"); + case SEG_FILPOLY:; + BOOL_T filled = FALSE; + if (segPtr->type == SEG_FILPOLY) { filled = TRUE; } + REORIGIN(drawData.endPt[0],segPtr->u.p.pts[0].pt, xx->angle, xx->orig); + //Remove input Angle (if any) + for (int i=0; i<segPtr->u.p.cnt; i++) { + coOrd pt; + REORIGIN(pt,segPtr->u.p.pts[i].pt, xx->angle, xx->orig); + UNREORIGIN(segPtr->u.p.pts[i].pt, pt, 0.0, xx->orig); } - strncpy( drawData.polyType, polyType, sizeof drawData.polyType ); - title = _("Polygonal Line"); - break; - case SEG_FILPOLY: + xx->angle = 0.0; + drawDesc[PP].mode = 0; drawData.pointCount = segPtr->u.p.cnt; drawDesc[VC].mode = DESC_RO; - drawDesc[LW].mode = DESC_IGNORE; - drawDesc[PT].mode = DESC_RO; + drawData.filled = filled; + drawDesc[FL].mode = 0; + drawData.angle = 0.0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + else { drawDesc[RA].mode = 0; } + drawData.origin = xx->orig; + drawDesc[OI].mode = 0; + drawData.open= FALSE; + drawDesc[OP].mode = filled?DESC_RO:0; + drawDesc[LT].mode = 0; + drawData.lineType = (wIndex_t)xx->lineType; switch (segPtr->u.p.polyType) { - case RECTANGLE: - polyType =_("Rectangle"); - break; - default: - polyType = _("Freeform"); + case RECTANGLE: + title = filled?_("Filled Rectangle"):_("Rectangle"); + drawDesc[OP].mode = DESC_IGNORE; + drawDesc[VC].mode = DESC_IGNORE; + drawData.width = FindDistance(segPtr->u.p.pts[0].pt, segPtr->u.p.pts[1].pt); + drawDesc[WT].mode = 0; + drawData.height = FindDistance(segPtr->u.p.pts[0].pt, segPtr->u.p.pts[3].pt); + drawDesc[HT].mode = 0; + for(int i=0; i<4; i++) { + REORIGIN( drawData.endPt[i], segPtr->u.p.pts[i].pt, xx->angle, xx->orig ); + } + drawDesc[E0].mode = DESC_IGNORE; + drawData.origin = xx->orig; + break; + case POLYLINE: + title = _("Polyline"); + drawData.open=TRUE; + drawData.filled= FALSE; + drawDesc[FL].mode = DESC_RO; + drawDesc[OP].mode = 0; + break; + default: + title = filled?_("Filled Polygon"):_("Polygon"); } - strncpy( drawData.polyType, polyType, sizeof drawData.polyType ); - title = _("Polygon"); break; case SEG_TEXT: REORIGIN( drawData.endPt[0], segPtr->u.t.pos, xx->angle, xx->orig ); - drawData.angle = NormalizeAngle( xx->angle ); + UNREORIGIN( segPtr->u.t.pos, drawData.endPt[0], 0.0, xx->orig ); + xx->angle = 0.0; + drawData.angle = segPtr->u.t.angle; //Text Angle + drawData.origin = xx->orig; strncpy( drawData.text, segPtr->u.t.string, sizeof drawData.text ); drawData.text[sizeof drawData.text-1] ='\0'; + drawData.boxed = segPtr->u.t.boxed; drawDesc[TP].mode = - drawDesc[TS].mode = - drawDesc[TX].mode = - drawDesc[TA].mode = - drawDesc[CO].mode = 0; /*Allow Text color setting*/ + drawDesc[TS].mode = + drawDesc[TX].mode = + drawDesc[TA].mode = + drawDesc[LK].mode = + drawDesc[OI].mode = + drawDesc[BX].mode = 0; + if (!drawData.lock_origin) { drawDesc[RA].mode = DESC_RO; } + else { drawDesc[RA].mode = 0; } + drawDesc[E0].mode = DESC_IGNORE; + drawDesc[CO].mode = 0; /*Allow Text color setting*/ drawDesc[LW].mode = DESC_IGNORE; title = _("Text"); break; default: - AbortProg( "bad seg type" ); + ; } - sprintf( str, _("%s: Layer=%d"), title, GetTrkLayer(trk)+1 ); + snprintf( str, len, _("%s(%d) Layer=%d"), title, GetTrkIndex(trk), + GetTrkLayer(trk)+1 ); + + if (!inDescribeCmd) { return; } + + drawData.oldE0 = drawData.endPt[0]; + drawData.oldE1 = drawData.endPt[1]; + drawData.oldAngle = drawData.rotate_angle; + drawData.oldOrigin = drawData.origin; + + DoDescribe( title, trk, drawDesc, UpdateDraw ); - if ( segPtr->type==SEG_BENCH && drawDesc[BE].control0!=NULL && drawDesc[OR].control0!=NULL) { - BenchLoadLists( (wList_p)drawDesc[BE].control0, (wList_p)drawDesc[OR].control0 ); + if ( segPtr->type==SEG_BENCH && drawDesc[BE].control0!=NULL + && drawDesc[OR].control0!=NULL) { + BenchLoadLists( (wList_p)drawDesc[BE].control0, + (wList_p)drawDesc[OR].control0 ); wListSetIndex( (wList_p)drawDesc[BE].control0, drawData.benchChoice ); - BenchUpdateOrientationList( (long)wListGetItemContext((wList_p)drawDesc[BE].control0, drawData.benchChoice ), (wList_p)drawDesc[OR].control0 ); + BenchUpdateOrientationList( VP2L(wListGetItemContext((wList_p) + drawDesc[BE].control0, drawData.benchChoice)), (wList_p)drawDesc[OR].control0 ); wListSetIndex( (wList_p)drawDesc[OR].control0, drawData.benchOrient ); } + if ( (segPtr->type==SEG_STRLIN || segPtr->type==SEG_CRVLIN + || segPtr->type==SEG_POLY) && drawDesc[LT].control0!=NULL) { + wListClear( (wList_p)drawDesc[LT].control0 ); + wListAddValue( (wList_p)drawDesc[LT].control0, _("Solid"), NULL, I2VP(0 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("Dash"), NULL, I2VP(1 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("Dot"), NULL, I2VP(2 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("DashDot"), NULL, I2VP(3 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("DashDotDot"), NULL, I2VP(4 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("CenterDot"), NULL, I2VP(5 )); + wListAddValue( (wList_p)drawDesc[LT].control0, _("PhantomDot"), NULL, I2VP(6 )); + wListSetIndex( (wList_p)drawDesc[LT].control0, drawData.lineType ); + } if ( segPtr->type==SEG_DIMLIN && drawDesc[DS].control0!=NULL ) { wListClear( (wList_p)drawDesc[DS].control0 ); - wListAddValue( (wList_p)drawDesc[DS].control0, _("Tiny"), NULL, (void*)0 ); - wListAddValue( (wList_p)drawDesc[DS].control0, _("Small"), NULL, (void*)1 ); - wListAddValue( (wList_p)drawDesc[DS].control0, _("Medium"), NULL, (void*)2 ); - wListAddValue( (wList_p)drawDesc[DS].control0, _("Large"), NULL, (void*)3 ); + wListAddValue( (wList_p)drawDesc[DS].control0, _("Tiny"), NULL, I2VP(0 )); + wListAddValue( (wList_p)drawDesc[DS].control0, _("Small"), NULL, I2VP(1 )); + wListAddValue( (wList_p)drawDesc[DS].control0, _("Medium"), NULL, I2VP(2 )); + wListAddValue( (wList_p)drawDesc[DS].control0, _("Large"), NULL, I2VP(3 )); wListSetIndex( (wList_p)drawDesc[DS].control0, drawData.dimenSize ); } if ( segPtr->type==SEG_TEXT && drawDesc[TS].control0!=NULL ) { @@ -581,35 +1377,47 @@ static void DescribeDraw( track_p trk, char * str, CSIZE_T len ) static void DrawDraw( track_p t, drawCmd_p d, wDrawColor color ) { - struct extraData * xx = GetTrkExtraData(t); - if ( (d->funcs->options&DC_QUICK) == 0 ) - DrawSegs( d, xx->orig, xx->angle, xx->segs, xx->segCnt, 0.0, color ); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(t, T_DRAW, extraDataDraw_t); + unsigned long NotSolid = ~(DC_NOTSOLIDLINE); + d->options &= NotSolid; + if (xx->lineType == DRAWLINESOLID) {} + else if (xx->lineType == DRAWLINEDASH) { d->options |= DC_DASH; } + else if (xx->lineType == DRAWLINEDOT) { d->options |= DC_DOT; } + else if (xx->lineType == DRAWLINEDASHDOT) { d->options |= DC_DASHDOT; } + else if (xx->lineType == DRAWLINEDASHDOTDOT) { d->options |= DC_DASHDOTDOT; } + else if (xx->lineType == DRAWLINECENTER) { d->options |= DC_CENTER; } + else if (xx->lineType == DRAWLINEPHANTOM) { d->options |= DC_PHANTOM; } + DrawSegs( d, xx->orig, xx->angle, xx->segs, xx->segCnt, 0.0, color ); + d->options = d->options&~(DC_NOTSOLIDLINE); } static void DeleteDraw( track_p t ) { /* Get rid of points if specified */ - struct extraData * xx = GetTrkExtraData(t); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(t, T_DRAW, extraDataDraw_t); if (xx->segs[0].type == SEG_POLY || - xx->segs[0].type == SEG_FILPOLY) { + xx->segs[0].type == SEG_FILPOLY) { MyFree(xx->segs[0].u.p.pts); + xx->segs[0].u.p.pts = NULL; } } static BOOL_T WriteDraw( track_p t, FILE * f ) { - struct extraData * xx = GetTrkExtraData(t); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(t, T_DRAW, extraDataDraw_t); BOOL_T rc = TRUE; - rc &= fprintf(f, "DRAW %d %d 0 0 0 %0.6f %0.6f 0 %0.6f\n", GetTrkIndex(t), GetTrkLayer(t), - xx->orig.x, xx->orig.y, xx->angle )>0; + rc &= fprintf(f, "DRAW %d %d %d 0 0 %0.6f %0.6f 0 %0.6f\n", GetTrkIndex(t), + GetTrkLayer(t), + xx->lineType, + xx->orig.x, xx->orig.y, xx->angle )>0; rc &= WriteSegs( f, xx->segCnt, xx->segs ); return rc; } -static void ReadDraw( char * header ) +static BOOL_T ReadDraw( char * header ) { track_p trk; wIndex_t index; @@ -617,70 +1425,434 @@ static void ReadDraw( char * header ) DIST_T elev; ANGLE_T angle; wIndex_t layer; - struct extraData * xx; + int lineType; + struct extraDataDraw_t * xx; - if ( !GetArgs( header+5, paramVersion<3?"dXpYf":paramVersion<9?"dL000pYf":"dL000pff", - &index, &layer, &orig, &elev, &angle ) ) - return; - ReadSegs(); + if ( !GetArgs( header+5, + paramVersion<3?"dXXpYf":paramVersion<9?"dLX00pYf":"dLd00pff", + &index, &layer, &lineType, &orig, &elev, &angle ) ) { + return FALSE; + } + if ( !ReadSegs() ) { + return FALSE; + } if (tempSegs_da.cnt == 1) { trk = MakeDrawFromSeg1( index, orig, angle, &tempSegs(0) ); + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + xx->lineType = lineType; SetTrkLayer( trk, layer ); } else { - trk = NewTrack( index, T_DRAW, 0, sizeof *xx + (tempSegs_da.cnt-1) * sizeof *(trkSeg_p)0 ); + trk = NewTrack( index, T_DRAW, 0, + sizeof *xx + (tempSegs_da.cnt-1) * sizeof *(trkSeg_p)0 ); SetTrkLayer( trk, layer ); - xx = GetTrkExtraData(trk); + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); xx->orig = orig; xx->angle = angle; xx->segCnt = tempSegs_da.cnt; - memcpy( xx->segs, tempSegs_da.ptr, tempSegs_da.cnt * sizeof *(trkSeg_p)0 ); + xx->lineType = lineType; + memcpy( xx->segs, &tempSegs(0), tempSegs_da.cnt * sizeof *(trkSeg_p)0 ); ComputeDrawBoundingBox( trk ); } + return TRUE; } -static void MoveDraw( track_p trk, coOrd orig ) +static void MoveDraw( track_p trk, coOrd off ) { - struct extraData * xx = GetTrkExtraData(trk); - xx->orig.x += orig.x; - xx->orig.y += orig.y; + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + + trkSeg_p segPtr = &xx->segs[0]; + + if (xx->orig.x == 0.0 && xx->orig.y == 0.0) { //No origin set + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + for (int i=0; i<segPtr->u.p.cnt; i++) { + REORIGIN( segPtr->u.p.pts[i].pt, segPtr->u.p.pts[i].pt, 0.0, off ); + } + break; + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + for (int i=0; i<2; i++) { + REORIGIN( segPtr->u.l.pos[i], segPtr->u.l.pos[i], 0.0, off ); + } + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + REORIGIN( segPtr->u.c.center, segPtr->u.c.center, 0.0, off ); + break; + case SEG_TEXT: + REORIGIN( segPtr->u.t.pos, segPtr->u.t.pos, 0.0, off ); + break; + default:; + } + + } else { + xx->orig.x += off.x; + xx->orig.y += off.y; + } ComputeDrawBoundingBox( trk ); } static void RotateDraw( track_p trk, coOrd orig, ANGLE_T angle ) { - struct extraData * xx = GetTrkExtraData(trk); - Rotate( &xx->orig, orig, angle ); - xx->angle = NormalizeAngle( xx->angle + angle ); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + trkSeg_p segPtr = &xx->segs[0]; + if (xx->orig.x == 0.0 && xx->orig.y == 0.0) { //No origin set + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + for (int i=0; i<segPtr->u.p.cnt; i++) { + Rotate(&segPtr->u.p.pts[i].pt, orig, angle ); + } + break; + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + for (int i=0; i<2; i++) { + Rotate( &segPtr->u.l.pos[i], orig, angle ); + } + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + Rotate( &segPtr->u.c.center, orig, angle ); + segPtr->u.c.a0 = NormalizeAngle(segPtr->u.c.a0 + angle); + break; + case SEG_TEXT: + Rotate( &segPtr->u.t.pos, orig, angle ); + segPtr->u.t.angle = NormalizeAngle(segPtr->u.t.angle+angle+xx->angle); + break; + default:; + } + } else { + Rotate( &xx->orig, orig, angle ); + xx->angle = NormalizeAngle( xx->angle + angle ); + } ComputeDrawBoundingBox( trk ); } static void RescaleDraw( track_p trk, FLOAT_T ratio ) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); xx->orig.x *= ratio; xx->orig.y *= ratio; RescaleSegs( xx->segCnt, xx->segs, ratio, ratio, ratio ); } +#if 0 +static void DoConvertFill(void) +{ + +} +#endif + +static drawModContext_t drawModCmdContext = { + InfoMessage, + DoRedraw, + &mainD +}; + + +static BOOL_T infoSubst = FALSE; + +static paramFloatRange_t r100_100 = { -100.0, 100.0, 50 }; //Allow negative numbers +static paramFloatRange_t r0d001_10000 = { 0.001, 10000 }; +//static paramFloatRange_t r1_10000 = { 1, 10000 }; +static paramFloatRange_t r0_10000 = { 0, 10000 }; +//static paramFloatRange_t r10000_10000 = {-10000, 10000}; +static paramFloatRange_t r360_360 = { -360, 360, 80 }; +static paramFloatRange_t r0_360 = { 0, 360, 80 }; +static paramData_t drawModPLs[] = { + +#define drawModLengthPD (drawModPLs[0]) + { PD_FLOAT, &drawModCmdContext.length, "Length", PDO_NOPREF|PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Length") }, +#define drawModAnglePD (drawModPLs[1]) + { PD_FLOAT, &drawModCmdContext.abs_angle, "Angle", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r360_360, N_("Angle") }, +#define drawModRelAnglePD (drawModPLs[2]) +#define drawModRelAngle 2 + { PD_FLOAT, &drawModCmdContext.rel_angle, "RelAngle", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r360_360, N_("Relative Angle") }, +#define drawModWidthPD (drawModPLs[3]) + { PD_FLOAT, &drawModCmdContext.width, "Width", PDO_NOPREF|PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Width") }, +#define drawModHeightPD (drawModPLs[4]) + { PD_FLOAT, &drawModCmdContext.height, "Height", PDO_NOPREF|PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Height") }, +#define drawModRadiusPD (drawModPLs[5]) +#define drawModRadius 5 + { PD_FLOAT, &drawModCmdContext.radius, "Radius", PDO_NOPREF|PDO_DIM|PDO_NORECORD|BO_ENTER, &r0d001_10000, N_("Radius") }, +#define drawModArcAnglePD (drawModPLs[6]) + { PD_FLOAT, &drawModCmdContext.arc_angle, "ArcAngle", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r360_360, N_("Arc Angle") }, +#define drawModRotAnglePD (drawModPLs[7) + { PD_FLOAT, &drawModCmdContext.rot_angle, "RotAngle", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r0_360, N_("Rotate Angle") }, +#define drawModRotCenterXPD (drawModPLs[8]) +#define drawModRotCenterInx 8 + { PD_FLOAT, &drawModCmdContext.rot_center.x, "RotCenterx", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Rot Center X,Y") }, +#define drawModRotCenterYPD (drawModPLs[9]) + { PD_FLOAT, &drawModCmdContext.rot_center.y, "RotCentery", PDO_NOPREF|PDO_NORECORD|BO_ENTER, &r0_10000, NULL }, + +}; +static paramGroup_t drawModPG = { "drawMod", 0, drawModPLs, COUNT( drawModPLs ) }; + +static void DrawModDlgUpdate( + paramGroup_p pg, + int inx, + void * valueP ) +{ + DrawGeomModify(C_UPDATE,zero,&drawModCmdContext); + ParamLoadControl(&drawModPG, + drawModRotCenterInx-1); //Make sure the angle is updated in case center moved + ParamLoadControl(&drawModPG,drawModRadius); // Make sure Radius updated + ParamLoadControl(&drawModPG,drawModRelAngle); //Relative Angle as well + MainRedraw(); + +} static STATUS_T ModifyDraw( track_p trk, wAction_t action, coOrd pos ) { - struct extraData * xx = GetTrkExtraData(trk); - STATUS_T rc; + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + STATUS_T rc = C_CONTINUE; - if (action == C_DOWN) { - //UndrawNewTrack( trk ); - } - if ( action == C_MOVE ) + wControl_p controls[5]; //Always needs a NULL last entry + char * labels[4]; + + drawModCmdContext.trk = trk; + drawModCmdContext.orig = xx->orig; + drawModCmdContext.angle = xx->angle; + drawModCmdContext.segCnt = xx->segCnt; + drawModCmdContext.segPtr = xx->segs; + drawModCmdContext.selected = GetTrkSelected(trk); + + + switch(action&0xFF) { //Remove Text value + case C_START: + for (int inx = 0; inx < COUNT(drawModPLs); ++inx ) { + drawModPLs[inx].option |= PDO_DLGIGNORE; + } + drawModCmdContext.type = xx->segs[0].type; + switch(drawModCmdContext.type) { + case SEG_POLY: + case SEG_FILPOLY: + drawModCmdContext.filled = (drawModCmdContext.type==SEG_FILPOLY)?TRUE:FALSE; + drawModCmdContext.subtype = xx->segs[0].u.p.polyType; + drawModCmdContext.open = (drawModCmdContext.subtype==POLYLINE)?TRUE:FALSE; + break; + case SEG_TEXT: + InfoMessage("Text can only be modified in Describe Mode"); + wBeep(); + return C_ERROR; + default: + break; + + } + drawModCmdContext.rot_moved = FALSE; + drawModCmdContext.rotate_state = FALSE; + + infoSubst = FALSE; + rc = DrawGeomModify( C_START, pos, &drawModCmdContext ); + break; + case C_DOWN: + rc = DrawGeomModify( C_DOWN, pos, &drawModCmdContext ); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + case C_LDOUBLE: + rc = DrawGeomModify( C_LDOUBLE, pos, &drawModCmdContext ); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + case wActionMove: + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + break; + case C_REDRAW: + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + break; + case C_MOVE: ignoredDraw = trk; - rc = DrawGeomModify( xx->orig, xx->angle, xx->segCnt, xx->segs, action, pos, GetTrkSelected(trk) ); - ignoredDraw = NULL; - if (action == C_UP) { + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + ignoredDraw = NULL; + break; + case C_UP: + ignoredDraw = trk; + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + ignoredDraw = NULL; ComputeDrawBoundingBox( trk ); + if (drawModCmdContext.state == MOD_AFTER_PT) { + switch(drawModCmdContext.type) { + case SEG_POLY: + case SEG_FILPOLY: + if (xx->segs[0].u.p.polyType != RECTANGLE) { + if (drawModCmdContext.prev_inx >= 0) { + controls[0] = drawModLengthPD.control; + controls[1] = drawModRelAnglePD.control; + drawModLengthPD.option &= ~PDO_DLGIGNORE; + drawModRelAnglePD.option &= ~PDO_DLGIGNORE; + controls[2] = NULL; + labels[0] = N_("Seg Lth"); + labels[1] = N_("Rel Ang"); + ParamLoadControls( &drawModPG ); + InfoSubstituteControls( controls, labels ); + drawModLengthPD.option &= ~PDO_NORECORD; + drawModRelAnglePD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + } + } else { + controls[0] = drawModWidthPD.control; + controls[1] = drawModHeightPD.control; + drawModWidthPD.option &= ~PDO_DLGIGNORE; + drawModHeightPD.option &= ~PDO_DLGIGNORE; + controls[2] = NULL; + labels[0] = N_("Width"); + labels[1] = N_("Height"); + ParamLoadControls( &drawModPG ); + InfoSubstituteControls( controls, labels ); + drawModWidthPD.option &= ~PDO_NORECORD; + drawModHeightPD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + } + break; + case SEG_STRLIN: + case SEG_BENCH: + case SEG_DIMLIN: + case SEG_TBLEDGE: + controls[0] = drawModLengthPD.control; + controls[1] = drawModAnglePD.control; + drawModLengthPD.option &= ~PDO_DLGIGNORE; + drawModAnglePD.option &= ~PDO_DLGIGNORE; + controls[2] = NULL; + labels[0] = N_("Length"); + labels[1] = N_("Angle"); + ParamLoadControls( &drawModPG ); + InfoSubstituteControls( controls, labels ); + drawModLengthPD.option &= ~PDO_NORECORD; + drawModAnglePD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + controls[0] = drawModRadiusPD.control; + drawModRadiusPD.option &= ~PDO_DLGIGNORE; + controls[1] = NULL; + labels[0] = N_("Radius"); + if ((drawModCmdContext.type == SEG_CRVLIN) && xx->segs[0].u.c.a1>0.0 + && xx->segs[0].u.c.a1 <360.0) { + controls[1] = drawModArcAnglePD.control; + controls[2] = NULL; + labels[1] = N_("Arc Angle"); + } + ParamLoadControls( &drawModPG ); + InfoSubstituteControls( controls, labels ); + drawModArcAnglePD.option &= ~PDO_NORECORD; + if (drawModCmdContext.type == SEG_CRVLIN) { + drawModArcAnglePD.option &= ~PDO_NORECORD; + } + infoSubst = TRUE; + break; + default: + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + break; + } + } else { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + case C_CMDMENU: + menuPos = pos; + wMenuPopupShow( drawModDelMI ); + wMenuPushEnable( drawModPointsMode,drawModCmdContext.rotate_state); + wMenuPushEnable( drawModriginMode,!drawModCmdContext.rotate_state); + wMenuPushEnable( drawModRound, FALSE); + wMenuPushEnable( drawModVertex, FALSE); + wMenuPushEnable( drawModSmooth, FALSE); + wMenuPushEnable( drawModDel, FALSE); + wMenuPushEnable( drawModFill, FALSE); + wMenuPushEnable( drawModEmpty, FALSE); + wMenuPushEnable( drawModClose, FALSE); + wMenuPushEnable( drawModOpen, FALSE); + wMenuPushEnable( drawModSolid, TRUE); + wMenuPushEnable( drawModDot, TRUE); + wMenuPushEnable( drawModDash, TRUE); + wMenuPushEnable( drawModDashDot, TRUE); + wMenuPushEnable( drawModDashDotDot, TRUE); + wMenuPushEnable( drawModCenterDot, TRUE); + wMenuPushEnable( drawModPhantom, TRUE); + if (!drawModCmdContext.rotate_state && (drawModCmdContext.type == SEG_POLY + || drawModCmdContext.type == SEG_FILPOLY)) { + wMenuPushEnable( drawModFill, (!drawModCmdContext.open) + && (!drawModCmdContext.filled)); + wMenuPushEnable( drawModEmpty, (!drawModCmdContext.open) + && (drawModCmdContext.filled)); + if (drawModCmdContext.subtype != RECTANGLE) { + wMenuPushEnable( drawModDel,drawModCmdContext.prev_inx>=0); + if ((!drawModCmdContext.open && drawModCmdContext.prev_inx>=0) || + ((drawModCmdContext.prev_inx>0) + && (drawModCmdContext.prev_inx<drawModCmdContext.max_inx))) { + wMenuPushEnable( drawModRound,TRUE); + wMenuPushEnable( drawModVertex, TRUE); + wMenuPushEnable( drawModSmooth, TRUE); + wMenuPushEnable( drawModClose, drawModCmdContext.open); + wMenuPushEnable( drawModOpen, !drawModCmdContext.open); + } + } + } + wMenuPushEnable( drawModOrigin,drawModCmdContext.rotate_state); + wMenuPushEnable( drawModLast,drawModCmdContext.rotate_state + && (drawModCmdContext.prev_inx>=0)); + wMenuPushEnable( drawModCenter,drawModCmdContext.rotate_state); + break; + case wActionExtKey: + case C_TEXT: + ignoredDraw = trk ; + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + ignoredDraw = NULL; + if (rc == C_CONTINUE) { break; } + /* no break*/ + case C_FINISH: + ignoredDraw = trk; + rc = DrawGeomModify( C_FINISH, pos, &drawModCmdContext ); + xx->angle = drawModCmdContext.angle; + xx->orig = drawModCmdContext.orig; + ignoredDraw = NULL; DrawNewTrack( trk ); + ComputeDrawBoundingBox( trk ); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + case C_CONFIRM: + case C_OK: + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + ComputeDrawBoundingBox( trk ); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + case C_CANCEL: + rc = DrawGeomModify( action, pos, &drawModCmdContext ); + drawModCmdContext.state = MOD_NONE; + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + break; + + default: + + break; } return rc; } @@ -688,10 +1860,11 @@ static STATUS_T ModifyDraw( track_p trk, wAction_t action, coOrd pos ) static void UngroupDraw( track_p trk ) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); int inx; - if ( xx->segCnt <= 1 ) + if ( xx->segCnt <= 1 ) { return; + } DeleteTrack( trk, FALSE ); for ( inx=0; inx<xx->segCnt; inx++ ) { trk = MakeDrawFromSeg( xx->orig, xx->angle, &xx->segs[inx] ); @@ -704,42 +1877,47 @@ static void UngroupDraw( track_p trk ) static ANGLE_T GetAngleDraw( - track_p trk, - coOrd pos, - EPINX_T * ep0, - EPINX_T * ep1 ) + track_p trk, + coOrd pos, + EPINX_T * ep0, + EPINX_T * ep1 ) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); ANGLE_T angle; pos.x -= xx->orig.x; pos.y -= xx->orig.y; Rotate( &pos, zero, -xx->angle ); angle = GetAngleSegs( xx->segCnt, xx->segs, &pos, NULL, NULL, NULL, NULL, NULL); - if ( ep0 ) *ep0 = -1; - if ( ep1 ) *ep1 = -1; + if ( ep0 ) { *ep0 = -1; } + if ( ep1 ) { *ep1 = -1; } return NormalizeAngle( angle + xx->angle ); } static BOOL_T EnumerateDraw( - track_p trk ) + track_p trk ) { - struct extraData * xx; + struct extraDataDraw_t * xx; int inx; trkSeg_p segPtr; if ( trk ) { - xx = GetTrkExtraData(trk); - if ( xx->segCnt < 1 ) - return TRUE; + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + if ( xx->segCnt < 1 ) { + return FALSE; + } + BOOL_T content = FALSE; for ( inx=0; inx<xx->segCnt; inx++ ) { segPtr = &xx->segs[inx]; if ( segPtr->type == SEG_BENCH ) { - CountBench( segPtr->u.l.option, FindDistance( segPtr->u.l.pos[0], segPtr->u.l.pos[1] ) ); + CountBench( segPtr->u.l.option, FindDistance( segPtr->u.l.pos[0], + segPtr->u.l.pos[1] ) ); + content = TRUE; } } + return content; } else { TotalBench(); } @@ -748,40 +1926,77 @@ static BOOL_T EnumerateDraw( static void FlipDraw( - track_p trk, - coOrd orig, - ANGLE_T angle ) + track_p trk, + coOrd orig, + ANGLE_T angle ) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + + trkSeg_p segPtr = &xx->segs[0]; + BOOL_T reorigin = FALSE; + if (xx->orig.x == 0.0 && xx->orig.y == 0.0) { + reorigin = TRUE; + } FlipPoint( &xx->orig, orig, angle ); xx->angle = NormalizeAngle( 2*angle - xx->angle + 180.0 ); FlipSegs( xx->segCnt, xx->segs, zero, angle ); + + + if (reorigin) { + switch(segPtr->type) { + case SEG_POLY: + case SEG_FILPOLY: + for (int i=0; i<segPtr->u.p.cnt; i++) { + REORIGIN( segPtr->u.p.pts[i].pt, segPtr->u.p.pts[i].pt, xx->angle, xx->orig); + } + break; + case SEG_STRLIN: + case SEG_DIMLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + for (int i=0; i<2; i++) { + REORIGIN( segPtr->u.l.pos[i], segPtr->u.l.pos[i], xx->angle, xx->orig); + } + break; + case SEG_CRVLIN: + case SEG_FILCRCL: + REORIGIN( segPtr->u.c.center, segPtr->u.c.center, xx->angle, xx->orig); + segPtr->u.c.a0 = NormalizeAngle(segPtr->u.c.a0 + xx->angle); + break; + case SEG_TEXT: + REORIGIN( segPtr->u.t.pos, segPtr->u.t.pos, xx->angle, xx->orig ); + break; + default:; + } + xx->orig.x = 0.0, xx->orig.y = 0.0, xx->angle = 0.0; + } + ComputeDrawBoundingBox( trk ); } static BOOL_T StoreDraw( - track_p trk, - void **data, - long * len) + track_p trk, + void **data, + long * len) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); if (xx->segs[0].type == SEG_POLY || - xx->segs[0].type == SEG_FILPOLY) { + xx->segs[0].type == SEG_FILPOLY) { *data = xx->segs[0].u.p.pts; - *len = xx->segs[0].u.p.cnt* sizeof (coOrd); + *len = xx->segs[0].u.p.cnt* sizeof (pts_t); return TRUE; } return FALSE; } static BOOL_T ReplayDraw( - track_p trk, - void * data, - long len) + track_p trk, + void * data, + long len) { - struct extraData * xx = GetTrkExtraData(trk); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); if (xx->segs[0].type == SEG_POLY || - xx->segs[0].type == SEG_FILPOLY) { + xx->segs[0].type == SEG_FILPOLY) { xx->segs[0].u.p.pts = MyMalloc(len); memcpy(xx->segs[0].u.p.pts,data,len); return TRUE; @@ -789,56 +2004,732 @@ static BOOL_T ReplayDraw( return FALSE; } +static BOOL_T QueryDraw( track_p trk, int query ) +{ + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + switch(query) { + case Q_IS_DRAW: + return TRUE; + case Q_IS_POLY: + if ((xx->segs[0].type == SEG_POLY) || (xx->segs[0].type == SEG_FILPOLY) ) { + return TRUE; + } else { + return FALSE; + } + case Q_IS_TEXT: + if (xx->segs[0].type== SEG_TEXT) { return TRUE; } + else { return FALSE; } + case Q_GET_NODES: + return TRUE; + case Q_CAN_PARALLEL: + case Q_MODIFY_CAN_SPLIT: + if ((xx->segs[0].type == SEG_STRLIN) || + (xx->segs[0].type == SEG_CRVLIN) || + (xx->segs[0].type == SEG_BEZLIN) || + (xx->segs[0].type == SEG_FILCRCL) || + (xx->segs[0].type == SEG_FILPOLY) || + (xx->segs[0].type == SEG_POLY) || + (xx->segs[0].type == SEG_BENCH) || + (xx->segs[0].type == SEG_TBLEDGE) + ) { return TRUE; } + else { return FALSE; } + default: + return FALSE; + } +} + +static wBool_t CompareDraw( track_cp trk1, track_cp trk2 ) +{ + struct extraDataDraw_t *xx1 = GET_EXTRA_DATA( trk1, T_DRAW, extraDataDraw_t ); + struct extraDataDraw_t *xx2 = GET_EXTRA_DATA( trk2, T_DRAW, extraDataDraw_t ); + char * cp = message + strlen(message); + REGRESS_CHECK_POS( "Orig", xx1, xx2, orig ) + REGRESS_CHECK_ANGLE( "Angle", xx1, xx2, angle ) + REGRESS_CHECK_INT( "LineType", xx1, xx2, lineType ) + return CompareSegs( xx1->segs, xx1->segCnt, xx2->segs, xx2->segCnt ); +} + +static BOOL_T GetParamsDraw( int inx, track_p trk, coOrd pos, + trackParams_t * params ) +{ + + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + if (inx != PARAMS_NODES ) { return FALSE; } + DYNARR_RESET(coOrd,params->nodes); + BOOL_T back = FALSE; + coOrd start,end; + switch (xx->segs[0].type) { + case SEG_POLY: + if (xx->segs[0].u.p.polyType != POLYLINE) { return FALSE; } + REORIGIN(start,xx->segs[0].u.p.pts[0].pt,xx->angle,xx->orig); + REORIGIN(end,xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1].pt,xx->angle,xx->orig); + params->ep = 1; + if (FindDistance(pos,start)>FindDistance(pos,end)) { back = TRUE; } + for (int i=0; i<xx->segs[0].u.p.cnt; i++) { + DYNARR_APPEND(coOrd,params->nodes,xx->segs[0].u.p.cnt); + if (back) { + DYNARR_LAST(coOrd,params->nodes) = xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1 + -i].pt; + } else { + DYNARR_LAST(coOrd,params->nodes) = xx->segs[0].u.p.pts[i].pt; + } + REORIGIN(DYNARR_LAST(coOrd,params->nodes),DYNARR_LAST(coOrd,params->nodes), + xx->angle,xx->orig); + } + params->lineOrig = DYNARR_N(coOrd,params->nodes,0); + params->lineEnd = DYNARR_LAST(coOrd,params->nodes); + return TRUE; + + case SEG_STRLIN:; + REORIGIN(start,xx->segs[0].u.l.pos[0],xx->angle,xx->orig); + REORIGIN(end,xx->segs[0].u.l.pos[1],xx->angle,xx->orig); + params->ep = 1; + if (FindDistance(pos,start)>FindDistance(pos,end)) { + back = TRUE; + } + for (int i=0; i<2; i++) { + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),xx->segs[0].u.l.pos[back?1-i:i], + xx->angle,xx->orig); + } + params->lineOrig = DYNARR_N(coOrd,params->nodes,0); + params->lineEnd = DYNARR_LAST(coOrd,params->nodes); + return TRUE; + + case SEG_CRVLIN:; + Translate(&start,xx->segs[0].u.c.center,xx->segs[0].u.c.a0, + fabs(xx->segs[0].u.c.radius)); + REORIGIN(start,start,xx->angle,xx->orig); + Translate(&end,xx->segs[0].u.c.center,xx->segs[0].u.c.a0+xx->segs[0].u.c.a1, + fabs(xx->segs[0].u.c.radius)); + REORIGIN(end,end,xx->angle,xx->orig); + if (FindDistance(start,pos) > FindDistance(end,pos)) { back = TRUE; } + if (fabs(xx->segs[0].u.c.radius) > 0.5) { + double min_angle = R2D(2*acos(1.0-(0.1/fabs( + xx->segs[0].u.c.radius)))); //Error max is 0.1" + int number = (int) ceil(xx->segs[0].u.c.a1/min_angle); + double arc_size = xx->segs[0].u.c.a1/number; + for (int i=0; i<=number; i++) { + DYNARR_APPEND(coOrd,params->nodes,number); + if (back) { + Translate(&DYNARR_LAST(coOrd,params->nodes),xx->segs[0].u.c.center, + xx->segs[0].u.c.a0+xx->segs[0].u.c.a1-(i*arc_size), + fabs(xx->segs[0].u.c.radius)); + } else { + Translate(&DYNARR_LAST(coOrd,params->nodes),xx->segs[0].u.c.center, + xx->segs[0].u.c.a0+(i*arc_size),fabs(xx->segs[0].u.c.radius)); + } + REORIGIN(DYNARR_LAST(coOrd,params->nodes),DYNARR_LAST(coOrd,params->nodes), + xx->angle,xx->orig); + } + } else { + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),back?end:start,xx->angle,xx->orig); + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),back?start:end,xx->angle,xx->orig); + } + params->lineOrig = DYNARR_N(coOrd,params->nodes,0); + params->lineEnd = DYNARR_LAST(coOrd,params->nodes); + params->ep = 1; + return TRUE; + + case SEG_BEZLIN: + REORIGIN(start,xx->segs[0].u.b.pos[0],xx->angle,xx->orig); + REORIGIN(end,xx->segs[0].u.b.pos[3],xx->angle,xx->orig); + if (FindDistance(pos,start) < FindDistance(pos,end)) { + params->ep = 0; + } else { params->ep = 1; } + BOOL_T back = FALSE; + coOrd curr_pos = params->bezierPoints[params->ep*3]; + BOOL_T first = TRUE; + for (int i = 0; i<xx->segs[0].bezSegs.cnt; i++) { + trkSeg_p segPtr = &DYNARR_N(trkSeg_t,xx->segs[0].bezSegs, + params->ep?xx->segs[0].bezSegs.cnt-1-i:i); + if (segPtr->type == SEG_STRLIN) { + back = FindDistance(segPtr->u.l.pos[0], + curr_pos)>FindDistance(segPtr->u.l.pos[1],curr_pos); + if (first) { + first = FALSE; + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),segPtr->u.l.pos[back],xx->angle, + xx->orig); + } + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),segPtr->u.l.pos[1-back],xx->angle, + xx->orig); + curr_pos = DYNARR_LAST(coOrd,params->nodes); + } else { + coOrd start,end; + Translate(&start,segPtr->u.c.center,segPtr->u.c.a0,segPtr->u.c.radius); + Translate(&end,segPtr->u.c.center,segPtr->u.c.a0+segPtr->u.c.a1, + segPtr->u.c.radius); + back = FindDistance(start,curr_pos)>FindDistance(end,curr_pos); + if (fabs(segPtr->u.c.radius) > 0.2) { + double min_angle = 360*acos(1.0-(0.1/fabs( + segPtr->u.c.radius)))/M_PI; //Error max is 0.1" + int number = (int)ceil(segPtr->u.c.a1/min_angle); + double arc_size = segPtr->u.c.a1/number; + for (int j=1-first; j<number; j++) { + DYNARR_APPEND(coOrd,params->nodes,number-first); + if (back == params->ep) { + Translate(&DYNARR_LAST(coOrd,params->nodes),segPtr->u.c.center, + segPtr->u.c.a0+(j*arc_size),fabs(segPtr->u.c.radius) ); + } else { + Translate(&DYNARR_LAST(coOrd,params->nodes),segPtr->u.c.center, + segPtr->u.c.a0+segPtr->u.c.a1-(j*arc_size),fabs(segPtr->u.c.radius) ); + } + REORIGIN(DYNARR_LAST(coOrd,params->nodes),DYNARR_LAST(coOrd,params->nodes), + xx->angle,xx->orig); + } + first = FALSE; + } else { + if (first) { + first = FALSE; + DYNARR_APPEND(coOrd,params->nodes,2); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),start,xx->angle,xx->orig); + } + DYNARR_APPEND(coOrd,params->nodes,1); + REORIGIN(DYNARR_LAST(coOrd,params->nodes),end,xx->angle,xx->orig); + first = FALSE; + } + curr_pos = DYNARR_LAST(coOrd,params->nodes); + } + } + params->lineOrig = DYNARR_N(coOrd,params->nodes,0); + params->lineEnd = DYNARR_LAST(coOrd,params->nodes); + return TRUE; + + default: + return FALSE; + } + return FALSE; + + +} + +static BOOL_T SplitDraw( track_p trk, coOrd pos, EPINX_T ep, track_p *leftover, + EPINX_T * ep0, EPINX_T * ep1 ) +{ + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + + coOrd p0,p1; + DIST_T d; + BOOL_T polyline_trim = FALSE, new_last = ep; + + + DYNARR_SET(trkSeg_t, tempSegs_da, 1); + + tempSegs(0).type = -1; + + switch (xx->segs[0].type) { + case SEG_STRLIN: + case SEG_BENCH: + case SEG_TBLEDGE: + REORIGIN(p0,xx->segs[0].u.l.pos[0],xx->angle,xx->orig); + REORIGIN(p1,xx->segs[0].u.l.pos[1],xx->angle,xx->orig); + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = xx->segs[0].type; + tempSegs(0).u.l.pos[0] = 1-ep?p0:pos; + tempSegs(0).u.l.pos[1] = 1-ep?pos:p1; + xx->segs[0].u.l.pos[0] = 1-ep?pos:p0; + xx->segs[0].u.l.pos[1] = 1-ep?p1:pos; + break; + case SEG_CRVLIN: + case SEG_FILCRCL: ; + coOrd c; + REORIGIN(c, xx->segs[0].u.c.center, xx->angle, xx->orig); + coOrd c0,c1; + if (xx->segs[0].type == SEG_FILCRCL || + (xx->segs[0].type == SEG_CRVLIN && xx->segs[0].u.c.a1 >= 360.0)) { + Translate(&c0,c,FindAngle(c,pos),xx->segs[0].u.c.radius); + c1 = c0; + xx->segs[0].type = SEG_CRVLIN; + xx->segs[0].u.c.a0 = FindAngle(c,c0); + xx->segs[0].u.c.a1 = 355.0; + } else { + Translate(&c0,c,xx->segs[0].u.c.a0+xx->angle,xx->segs[0].u.c.radius); + Translate(&c1,c,xx->segs[0].u.c.a1+xx->segs[0].u.c.a0+xx->angle, + xx->segs[0].u.c.radius); + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_CRVLIN; + tempSegs(0).u.c.center = c; + tempSegs(0).u.c.radius = xx->segs[0].u.c.radius; + if (ep) { + tempSegs(0).u.c.a0 = FindAngle(c,c0); + tempSegs(0).u.c.a1 = NormalizeAngle(FindAngle(c,pos)-tempSegs(0).u.c.a0); + } else { + tempSegs(0).u.c.a0 = FindAngle(c,pos); + tempSegs(0).u.c.a1 = NormalizeAngle(FindAngle(c,c1)-tempSegs(0).u.c.a0); + } + xx->segs[0].u.c.center = c; + if (ep) { + xx->segs[0].u.c.a0 = FindAngle(c,pos); + xx->segs[0].u.c.a1 = NormalizeAngle(FindAngle(c,c1)-xx->segs[0].u.c.a0); + } else { + xx->segs[0].u.c.a0 = FindAngle(c,c0); + xx->segs[0].u.c.a1 = NormalizeAngle(FindAngle(c,pos)-xx->segs[0].u.c.a0); + } + } + break; + case SEG_POLY: + case SEG_FILPOLY: + d = DIST_INF; + DIST_T dd; + BOOL_T onPoint = FALSE; +// BOOL_T closeSeg = FALSE; + coOrd end; + int polyInx = -1; + for ( int inx=0; inx<xx->segs[0].u.p.cnt-1; inx++ ) { + p0 = pos; + coOrd pl0,pl1; + REORIGIN(pl0,xx->segs[0].u.p.pts[inx].pt,xx->angle,xx->orig); + REORIGIN(pl1,xx->segs[0].u.p.pts[inx+1].pt,xx->angle,xx->orig); + dd = LineDistance( &p0, pl0, pl1 ); + if ( d > dd ) { + d = dd; + if (IsClose(FindDistance(pos,pl1))) { + polyInx = inx; + REORIGIN(pos,xx->segs[0].u.p.pts[inx].pt,xx->angle,xx->orig); + onPoint = TRUE; + break; + } else if (IsClose(FindDistance(pos,pl1))) { + polyInx = inx+1; + REORIGIN(pos,xx->segs[0].u.p.pts[inx+1].pt,xx->angle,xx->orig); + onPoint=TRUE; + break; + } else { + if (!IsClose(d)) { continue; } + polyInx = inx; + pos = p0; + break; + } + } + } + //If Closed, look at closing line + if ( !onPoint && (xx->segs[0].u.p.polyType != POLYLINE)) { + coOrd pl0,pl1; + p0 = pos; + REORIGIN(pl0,xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1].pt,xx->angle,xx->orig); + REORIGIN(pl1,xx->segs[0].u.p.pts[0].pt,xx->angle,xx->orig); + dd = LineDistance( &p0, pl0, pl1 ); + if (d > dd) { + d = dd; + if (IsClose(d)) { + polyInx = xx->segs[0].u.p.cnt-1; +// closeSeg=TRUE; + pos = p0; + } + } + } + //If Closed, split into a PolyLine + if (xx->segs[0].u.p.polyType != POLYLINE) { + if (!IsClose(d)) { + *leftover = NULL; + return FALSE; + } + end = pos; + REORIGIN(end,end,xx->angle,xx->orig); + + trkSeg_t temp; //Buffer for expanded array + temp.u.p.cnt = xx->segs[0].u.p.cnt + 2 - onPoint; + temp.u.p.pts = MyMalloc(temp.u.p.cnt*sizeof(pts_t)); + int j = 0; + temp.u.p.pts[j].pt = end; + temp.u.p.pts[j].pt_type = wPolyLineStraight; + j++; + /* After split */ + for (int i=polyInx+1; i<=xx->segs[0].u.p.cnt-1; i++,j++) { + temp.u.p.pts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(temp.u.p.pts[j].pt,temp.u.p.pts[j].pt,xx->angle,xx->orig); + } + /* Before split */ + for (int i=0; i<=polyInx; i++,j++) { + temp.u.p.pts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(temp.u.p.pts[j].pt,temp.u.p.pts[j].pt,xx->angle,xx->orig); + } + if (!onPoint) { + temp.u.p.pts[temp.u.p.cnt-1].pt = end; + } + temp.u.p.pts[temp.u.p.cnt-1].pt_type = wPolyLineStraight; + + //Swap Pts Array into existing track + MyFree(xx->segs[0].u.p.pts); + xx->segs[0].u.p.pts = temp.u.p.pts; + xx->segs[0].u.p.cnt = temp.u.p.cnt; + xx->segs[0].u.p.polyType = POLYLINE; + break; + } + //Check if on an end-point -> reject + if ((polyInx <= 0 || polyInx >= xx->segs[0].u.p.cnt-1) && onPoint ) { + *leftover = NULL; + return FALSE; + } + if (polyInx == 0 || (polyInx == 1 && onPoint )) { + //Between First End and Next -> Trim end + end = xx->segs[0].u.p.pts[0].pt; + REORIGIN(end,end,xx->angle,xx->orig); + if (onPoint) { + for (int i=0; i< xx->segs[0].u.p.cnt-1; i++) { + xx->segs[0].u.p.pts[i] = xx->segs[0].u.p.pts[i+1]; + REORIGIN(xx->segs[0].u.p.pts[i].pt,xx->segs[0].u.p.pts[i].pt,xx->angle, + xx->orig); + } + --xx->segs[0].u.p.cnt; + } else { + xx->segs[0].u.p.pts[0].pt = pos; + for (int i=1; i< xx->segs[0].u.p.cnt; i++) { + REORIGIN(xx->segs[0].u.p.pts[i].pt,xx->segs[0].u.p.pts[i].pt,xx->angle, + xx->orig); + } + } + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_STRLIN; + tempSegs(0).u.l.pos[0] = pos; + tempSegs(0).u.l.pos[1] = end; + polyline_trim = TRUE; + new_last = FALSE; + } else if (polyInx == xx->segs[0].u.p.cnt-2) { + //Between second last and last -> Trim the other end + end = xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1].pt; + REORIGIN(end,end,xx->angle,xx->orig); + if (onPoint) { + --xx->segs[0].u.p.cnt; + for (int i=0; i<xx->segs[0].u.p.cnt; i++) { + REORIGIN(xx->segs[0].u.p.pts[i].pt,xx->segs[0].u.p.pts[i].pt,xx->angle, + xx->orig); + } + } else { + xx->segs[0].u.p.pts[xx->segs[0].u.p.cnt-1].pt = pos; + for (int i=0; i<xx->segs[0].u.p.cnt; i++) { + REORIGIN(xx->segs[0].u.p.pts[i].pt,xx->segs[0].u.p.pts[i].pt,xx->angle, + xx->orig); + } + } + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_STRLIN; + tempSegs(0).u.l.pos[0] = end; + tempSegs(0).u.l.pos[1] = pos; + polyline_trim = TRUE; + new_last = TRUE; + } else { + //Check that new line will have >=3 spots if not -> reject + if (xx->segs[0].u.p.cnt >3) { + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_POLY; + tempSegs(0).u.p.polyType = POLYLINE; + if (1-ep) { + tempSegs(0).u.p.cnt = xx->segs[0].u.p.cnt - polyInx; + } else { + tempSegs(0).u.p.cnt = polyInx + 2 - onPoint; + } + tempSegs(0).u.p.pts = MyMalloc(tempSegs(0).u.p.cnt*sizeof(pts_t)); + int j = 0; + if (1-ep) { + tempSegs(0).u.p.pts[0].pt=pos; + tempSegs(0).u.p.pts[0].pt_type = wPolyLineStraight; + j = 1; + for (int i=polyInx+1; i<xx->segs[0].u.p.cnt; i++,j++) { + tempSegs(0).u.p.pts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(tempSegs(0).u.p.pts[j].pt,tempSegs(0).u.p.pts[j].pt,xx->angle, + xx->orig); + } + } else { + for (int i=0; i<=polyInx+1; i++,j++) { + tempSegs(0).u.p.pts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(tempSegs(0).u.p.pts[j].pt,tempSegs(0).u.p.pts[j].pt,xx->angle, + xx->orig); + } + if (!onPoint) { + tempSegs(0).u.p.pts[tempSegs(0).u.p.cnt-1].pt = pos; + tempSegs(0).u.p.pts[tempSegs(0).u.p.cnt-1].pt_type = wPolyLineStraight; + } + } + } else { + *leftover = NULL; + return FALSE; + } + polyline_trim = TRUE; + new_last = 1-ep; + int new_cnt, old_cnt = xx->segs[0].u.p.cnt; + if (1-ep) { + new_cnt = polyInx + 2 - onPoint; + } else { + new_cnt = xx->segs[0].u.p.cnt-polyInx; + } + pts_t * newpts = MyMalloc(new_cnt*sizeof(pts_t)); + int j = 0; + if (1-ep) { + for (int i = 0; i<polyInx+1; i++,j++) { + newpts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(newpts[j].pt,newpts[i].pt,xx->angle,xx->orig); + } + if (!onPoint) { + newpts[new_cnt-1].pt = pos; + newpts[new_cnt-1].pt_type = wPolyLineStraight; + } + } else { + newpts[0].pt = pos; + newpts[0].pt_type = wPolyLineStraight; + j = 1; + for (int i=polyInx+1; i<old_cnt; i++,j++) { + newpts[j] = xx->segs[0].u.p.pts[i]; + REORIGIN(newpts[j].pt,newpts[j].pt,xx->angle,xx->orig); + } + } + MyFree(xx->segs[0].u.p.pts); + xx->segs[0].u.p.cnt = new_cnt; + xx->segs[0].u.p.pts = newpts; + } + break; + default: + return FALSE; + } + *leftover = NULL; + if (tempSegs(0).type != -1) { + *leftover = MakeDrawFromSeg( zero, 0.0, &tempSegs(0) ); + struct extraDataDraw_t * yy = GET_EXTRA_DATA(*leftover, T_DRAW, + extraDataDraw_t); + yy->lineType = xx->lineType; + if (tempSegs(0).type == SEG_POLY && tempSegs(0).u.p.pts) { + MyFree(tempSegs(0).u.p.pts); + tempSegs(0).u.p.cnt = 0; + tempSegs(0).u.p.pts = NULL; + } + } + + if (*leftover) { + //Polyline sets new_last to the end of the extra + if (polyline_trim && (ep != new_last)) { + *leftover = trk; + } + } + xx->orig = zero; + xx->angle = 0.0; + ComputeDrawBoundingBox(trk); + *ep0 = 1-ep; + *ep1 = ep; + return TRUE; +} + +static BOOL_T MakeParallelDraw( + track_p trk, + coOrd pos, + DIST_T sep, + DIST_T factor, + track_p * newTrkR, + coOrd * p0R, + coOrd * p1R, + BOOL_T track) +{ + if (track) { return FALSE; } + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + + ANGLE_T angle; + DIST_T rad; + + DYNARR_SET(trkSeg_t, tempSegs_da, 1); + + switch (xx->segs[0].type) { + case SEG_STRLIN: + angle = NormalizeAngle(FindAngle(xx->segs[0].u.l.pos[0], + xx->segs[0].u.l.pos[1])+xx->angle); + if ( NormalizeAngle( FindAngle( xx->segs[0].u.l.pos[0], + pos ) - angle ) < 180.0 ) { + angle += 90; + } else { + angle -= 90; + } + coOrd p0,p1; + REORIGIN(p0,xx->segs[0].u.l.pos[0],xx->angle,xx->orig); + REORIGIN(p1,xx->segs[0].u.l.pos[1],xx->angle,xx->orig); + Translate(&p0,p0, angle, sep); + Translate(&p1,p1, angle, sep); + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_STRLIN; + tempSegs(0).u.l.pos[0] = p0; + tempSegs(0).u.l.pos[1] = p1; + if (newTrkR) { + *newTrkR = MakeDrawFromSeg( zero, 0.0, &tempSegs(0) ); + struct extraDataDraw_t * yy = GET_EXTRA_DATA(*newTrkR, T_DRAW, extraDataDraw_t); + yy->lineType = xx->lineType; + } + + if ( p0R ) { *p0R = p0; } + if ( p1R ) { *p1R = p1; } + return TRUE; + break; + case SEG_CRVLIN: + case SEG_FILCRCL:; + coOrd c; + REORIGIN(c, xx->segs[0].u.c.center, xx->angle, xx->orig); + rad = FindDistance( pos, c ); + if ( rad > xx->segs[0].u.c.radius ) { + rad = xx->segs[0].u.c.radius + sep; + } else { + rad = xx->segs[0].u.c.radius - sep; + } + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_CRVLIN; + tempSegs(0).u.c.center = c; + tempSegs(0).u.c.radius = rad; + tempSegs(0).u.c.a0 = xx->segs[0].u.c.a0 + xx->angle; + tempSegs(0).u.c.a1 = xx->segs[0].u.c.a1; + if (newTrkR) { + *newTrkR = MakeDrawFromSeg( zero, 0.0, &tempSegs(0) ); + struct extraDataDraw_t * yy = GET_EXTRA_DATA(*newTrkR, T_DRAW, extraDataDraw_t); + yy->lineType = xx->lineType; + } + if ( p0R ) { PointOnCircle( p0R, xx->segs[0].u.c.center, rad, xx->segs[0].u.c.a0 ); } + if ( p1R ) { PointOnCircle( p1R, xx->segs[0].u.c.center, rad, xx->segs[0].u.c.a0+xx->segs[0].u.c.a1 ); } + return TRUE; + break; + case SEG_POLY: + case SEG_FILPOLY: + pos.x -= xx->orig.x; + pos.y -= xx->orig.y; + Rotate( &pos, zero, -xx->angle ); + coOrd p = pos; + int inx2; + angle = NormalizeAngle(GetAngleSegs(1,&xx->segs[0],&p,NULL,NULL,NULL,&inx2, + NULL)+xx->angle); + if ( NormalizeAngle( FindAngle( p, pos ) - angle ) < 180.0 ) { + angle = +90.0; + } else { + angle = -90.0; + } + DYNARR_SET( trkSeg_t, tempSegs_da, 1 ); + tempSegs(0).color = xx->segs[0].color; + tempSegs(0).lineWidth = xx->segs[0].lineWidth; + tempSegs(0).type = SEG_POLY; + tempSegs(0).u.p.polyType = xx->segs[0].type==SEG_POLY?xx->segs[0].u.p.polyType: + POLYLINE; + tempSegs(0).u.p.pts = memdup( xx->segs[0].u.p.pts, + xx->segs[0].u.p.cnt*sizeof (pts_t) ); + tempSegs(0).u.p.cnt = xx->segs[0].u.p.cnt; + ANGLE_T a,b; + for (int i=0; i<xx->segs[0].u.p.cnt; i++) { + REORIGIN(tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[i].pt,xx->angle, + xx->orig); + } + for (int i=0; i<xx->segs[0].u.p.cnt; i++) { + if (xx->segs[0].u.p.polyType == POLYLINE) { + if (i==0) { + a = FindAngle(tempSegs(0).u.p.pts[0].pt,tempSegs(0).u.p.pts[1].pt); + b = 0; + } else if (i==xx->segs[0].u.p.cnt-1) { + a = NormalizeAngle(FindAngle(tempSegs(0).u.p.pts[i].pt, + tempSegs(0).u.p.pts[i-1].pt)+180.0); + b = 0; + } else { + a = FindAngle(tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[i+1].pt); + b = DifferenceBetweenAngles(a,FindAngle(tempSegs(0).u.p.pts[i].pt, + tempSegs(0).u.p.pts[i-1].pt)+180.0)/2; + a = a + b; + } + } else { + if (i==0) { + a = FindAngle(tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[i+1].pt); + b = DifferenceBetweenAngles(a,FindAngle(tempSegs(0).u.p.pts[i].pt, + tempSegs(0).u.p.pts[xx->segs[0].u.p.cnt-1].pt)+180.0)/2; + a = a+b; + } else if (i==xx->segs[0].u.p.cnt-1) { + a = FindAngle(tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[0].pt); + b = DifferenceBetweenAngles(a,FindAngle(tempSegs(0).u.p.pts[i].pt, + tempSegs(0).u.p.pts[i-1].pt)+180.0)/2; + a = a+b; + } else { + a = FindAngle(tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[i+1].pt); + b = DifferenceBetweenAngles(a,FindAngle(tempSegs(0).u.p.pts[i].pt, + tempSegs(0).u.p.pts[i-1].pt)+180.0)/2; + a = a+b; + } + } + + Translate(&tempSegs(0).u.p.pts[i].pt,tempSegs(0).u.p.pts[i].pt,a+angle, + fabs(sep/cos(D2R(b)))); + } + if (newTrkR) { + *newTrkR = MakeDrawFromSeg( zero, 0.0, &tempSegs(0) ); + struct extraDataDraw_t * yy = GET_EXTRA_DATA(*newTrkR, T_DRAW, extraDataDraw_t); + yy->lineType = xx->lineType; + if (tempSegs(0).u.p.pts) { MyFree(tempSegs(0).u.p.pts); } + } + if (p0R) { *p0R = tempSegs(0).u.p.pts[0].pt; } + if (p1R) { *p1R = tempSegs(0).u.p.pts[tempSegs(0).u.p.cnt-1].pt; } + return TRUE; + break; + default: + return FALSE; + } + return FALSE; +} static trackCmd_t drawCmds = { - "DRAW", - DrawDraw, - DistanceDraw, - DescribeDraw, - DeleteDraw, - WriteDraw, - ReadDraw, - MoveDraw, - RotateDraw, - RescaleDraw, - NULL, - GetAngleDraw, /* getAngle */ - NULL, /* split */ - NULL, /* traverse */ - EnumerateDraw, - NULL, /* redraw */ - NULL, /* trim */ - NULL, /* merge */ - ModifyDraw, - NULL, /* getLength */ - NULL, /* getTrackParams */ - NULL, /* moveEndPt */ - NULL, /* query */ - UngroupDraw, - FlipDraw, - NULL, - NULL, - NULL, - NULL, /*Parallel*/ - NULL, - NULL, /*MakeSegs*/ - ReplayDraw, - StoreDraw - }; + "DRAW", + DrawDraw, + DistanceDraw, + DescribeDraw, + DeleteDraw, + WriteDraw, + ReadDraw, + MoveDraw, + RotateDraw, + RescaleDraw, + NULL, + GetAngleDraw, /* getAngle */ + SplitDraw, /* split */ + NULL, /* traverse */ + EnumerateDraw, + NULL, /* redraw */ + NULL, /* trim */ + NULL, /* merge */ + ModifyDraw, + NULL, /* getLength */ + GetParamsDraw, /* getTrackParams */ + NULL, /* moveEndPt */ + QueryDraw, /* query */ + UngroupDraw, + FlipDraw, + NULL, + NULL, + NULL, + MakeParallelDraw, /*Parallel*/ + NULL, + NULL, /*MakeSegs*/ + ReplayDraw, + StoreDraw, + NULL, + CompareDraw +}; EXPORT BOOL_T OnTableEdgeEndPt( track_p trk, coOrd * pos ) { track_p trk1; - struct extraData *xx; + struct extraDataDraw_t *xx; coOrd pos1 = *pos; ignoredTableEdge = trk; if ((trk1 = OnTrack( &pos1, FALSE, FALSE )) != NULL && - GetTrkType(trk1) == T_DRAW) { + GetTrkType(trk1) == T_DRAW) { ignoredTableEdge = NULL; - xx = GetTrkExtraData(trk1); - if (xx->segCnt < 1) + xx = GET_EXTRA_DATA(trk1, T_DRAW, extraDataDraw_t); + if (xx->segCnt < 1) { return FALSE; + } if (xx->segs[0].type == SEG_TBLEDGE) { if ( IsClose( FindDistance( *pos, xx->segs[0].u.l.pos[0] ) ) ) { *pos = xx->segs[0].u.l.pos[0]; @@ -855,13 +2746,14 @@ EXPORT BOOL_T OnTableEdgeEndPt( track_p trk, coOrd * pos ) EXPORT BOOL_T GetClosestEndPt( track_p trk, coOrd * pos) { - struct extraData *xx; + struct extraDataDraw_t *xx; if (GetTrkType(trk) == T_DRAW) { ignoredTableEdge = NULL; - xx = GetTrkExtraData(trk); - if (xx->segCnt < 1) + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + if (xx->segCnt < 1) { return FALSE; + } DIST_T dd0,dd1; coOrd p00,p0,p1; p00 = *pos; @@ -870,26 +2762,28 @@ EXPORT BOOL_T GetClosestEndPt( track_p trk, coOrd * pos) p00.x -= xx->orig.x; p00.y -= xx->orig.y; switch (xx->segs[0].type) { - case SEG_CRVLIN: - PointOnCircle( &p0, xx->segs[0].u.c.center, fabs(xx->segs[0].u.c.radius), xx->segs[0].u.c.a0 ); - dd0 = FindDistance( p00, p0); - PointOnCircle( &p1, xx->segs[0].u.c.center, fabs(xx->segs[0].u.c.radius), xx->segs[0].u.c.a0 + xx->segs[0].u.c.a1); - dd1 = FindDistance( p00, p1); + case SEG_CRVLIN: + PointOnCircle( &p0, xx->segs[0].u.c.center, fabs(xx->segs[0].u.c.radius), + xx->segs[0].u.c.a0 ); + dd0 = FindDistance( p00, p0); + PointOnCircle( &p1, xx->segs[0].u.c.center, fabs(xx->segs[0].u.c.radius), + xx->segs[0].u.c.a0 + xx->segs[0].u.c.a1); + dd1 = FindDistance( p00, p1); break; - case SEG_STRLIN: - dd0 = FindDistance( p00, xx->segs[0].u.l.pos[0]); - p0 = xx->segs[0].u.l.pos[0]; - dd1 = FindDistance( p00, xx->segs[0].u.l.pos[1]); - p1 = xx->segs[0].u.l.pos[1]; + case SEG_STRLIN: + dd0 = FindDistance( p00, xx->segs[0].u.l.pos[0]); + p0 = xx->segs[0].u.l.pos[0]; + dd1 = FindDistance( p00, xx->segs[0].u.l.pos[1]); + p1 = xx->segs[0].u.l.pos[1]; break; - case SEG_BEZLIN: - dd0 = FindDistance( p00, xx->segs[0].u.b.pos[0]); - p0 = xx->segs[0].u.b.pos[0]; - dd1 = FindDistance( p00, xx->segs[0].u.b.pos[3]); - p1 = xx->segs[0].u.b.pos[3]; + case SEG_BEZLIN: + dd0 = FindDistance( p00, xx->segs[0].u.b.pos[0]); + p0 = xx->segs[0].u.b.pos[0]; + dd1 = FindDistance( p00, xx->segs[0].u.b.pos[3]); + p1 = xx->segs[0].u.b.pos[3]; break; - default: - return FALSE; + default: + return FALSE; } p0.x += xx->orig.x; p0.y += xx->orig.y; @@ -899,12 +2793,12 @@ EXPORT BOOL_T GetClosestEndPt( track_p trk, coOrd * pos) Rotate(&p1,xx->orig,xx->angle); } else if (GetTrkType(trk) == T_BZRLIN) { coOrd p0,p1; - xx = GetTrkExtraData(trk); + xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); p0 = xx->segs[0].u.b.pos[0]; p1 = xx->segs[0].u.b.pos[3]; dd0 = FindDistance(p00,p0); dd1 = FindDistance(p00,p1); - } else return FALSE; + } else { return FALSE; } if (dd0>dd1) { * pos = p1; return TRUE; @@ -918,79 +2812,87 @@ EXPORT BOOL_T GetClosestEndPt( track_p trk, coOrd * pos) } -static void DrawRedraw(void); static drawContext_t drawCmdContext = { - InfoMessage, - DrawRedraw, - &mainD, - OP_LINE }; - -static void DrawRedraw( void ) -{ - MainRedraw(); - MapRedraw(); -} + InfoMessage, + DoRedraw, + &mainD, + OP_LINE +}; static wIndex_t benchChoice; static wIndex_t benchOrient; static wIndex_t dimArrowSize; wDrawColor lineColor = 1; -long lineWidth = 0; -static wDrawColor benchColor; +LWIDTH_T lineWidth = 0; +wDrawColor benchColor; + -static paramIntegerRange_t i0_100 = { 0, 100, 25 }; static paramData_t drawPLs[] = { -#define drawWidthPD (drawPLs[0]) - { PD_LONG, &drawCmdContext.Width, "linewidth", PDO_NORECORD, &i0_100, N_("Line Width") }, +#define drawLineWidthPD (drawPLs[0]) + { PD_FLOAT, &lineWidth, "linewidth", PDO_NORECORD, &r100_100, N_("Line Width") }, #define drawColorPD (drawPLs[1]) { PD_COLORLIST, &lineColor, "linecolor", PDO_NORECORD, NULL, N_("Color") }, #define drawBenchColorPD (drawPLs[2]) { PD_COLORLIST, &benchColor, "benchcolor", PDO_NORECORD, NULL, N_("Color") }, #define drawBenchChoicePD (drawPLs[3]) #ifdef WINDOWS - { PD_DROPLIST, &benchChoice, "benchlist", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, (void*)120, N_("Lumber Type") }, -#else - { PD_DROPLIST, &benchChoice, "benchlist", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, (void*)145, N_("Lumber Type") }, -#endif + { PD_DROPLIST, &benchChoice, "benchlist", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, I2VP(120), N_("Lumber Type") }, +#else + { PD_DROPLIST, &benchChoice, "benchlist", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, I2VP(145), N_("Lumber Type") }, +#endif #define drawBenchOrientPD (drawPLs[4]) #ifdef WINDOWS - { PD_DROPLIST, &benchOrient, "benchorient", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, (void*)45, "", 0 }, + { PD_DROPLIST, &benchOrient, "benchorient", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, I2VP(45), "", 0 }, #else - { PD_DROPLIST, &benchOrient, "benchorient", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, (void*)105, "", 0 }, + { PD_DROPLIST, &benchOrient, "benchorient", PDO_NOPREF|PDO_NORECORD|PDO_LISTINDEX, I2VP(105), "", 0 }, #endif #define drawDimArrowSizePD (drawPLs[5]) - { PD_DROPLIST, &dimArrowSize, "arrowsize", PDO_NORECORD|PDO_LISTINDEX, (void*)80, N_("Size") } }; -static paramGroup_t drawPG = { "draw", 0, drawPLs, sizeof drawPLs/sizeof drawPLs[0] }; + { PD_DROPLIST, &dimArrowSize, "arrowsize", PDO_NORECORD|PDO_LISTINDEX, I2VP(80), N_("Size") }, +#define drawLengthPD (drawPLs[6]) + { PD_FLOAT, &drawCmdContext.length, "length", PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Length") }, +#define drawWidthPD (drawPLs[7]) + { PD_FLOAT, &drawCmdContext.width, "width", PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Width") }, +#define drawAnglePD (drawPLs[8]) +#define drawAngleInx 8 + { PD_FLOAT, &drawCmdContext.angle, "angle", PDO_NORECORD|BO_ENTER, &r360_360, N_("Angle") }, +#define drawRadiusPD (drawPLs[9]) + { PD_FLOAT, &drawCmdContext.radius, "radius", PDO_DIM|PDO_NORECORD|BO_ENTER, &r0_10000, N_("Radius") }, +#define drawLineTypePD (drawPLs[10]) + { PD_DROPLIST, &drawCmdContext.lineType, "type", PDO_DIM|PDO_NORECORD|BO_ENTER, I2VP(0), N_("Line Type") }, +}; +static paramGroup_t drawPG = { "draw", 0, drawPLs, COUNT( drawPLs ) }; static char * objectName[] = { - N_("Straight"), - N_("Dimension"), - N_("Lumber"), - N_("Table Edge"), - N_("Curved"), - N_("Curved"), - N_("Curved"), - N_("Curved"), - N_("Circle"), - N_("Circle"), - N_("Circle"), - N_("Box"), - N_("Polyline"), - N_("Filled Circle"), - N_("Filled Circle"), - N_("Filled Circle"), - N_("Filled Box"), - N_("Polygon"), - N_("Bezier Line"), - NULL}; + N_("Straight"), + N_("Dimension"), + N_("Lumber"), + N_("Table Edge"), + N_("Curved"), + N_("Curved"), + N_("Curved"), + N_("Curved"), + N_("Circle"), + N_("Circle"), + N_("Circle"), + N_("Box"), + N_("Polygon"), + N_("Filled Circle"), + N_("Filled Circle"), + N_("Filled Circle"), + N_("Filled Box"), + N_("Filled Polygon"), + N_("Bezier Line"), + N_("Polyline"), + NULL +}; static STATUS_T CmdDraw( wAction_t action, coOrd pos ) { static BOOL_T infoSubst = FALSE; - wControl_p controls[4]; - char * labels[3]; + wControl_p controls[5]; //Always needs a NULL last entry + char * labels[4]; static char labelName[40]; wAction_t act2 = (action&0xFF) | (bezCmdCreateLine<<8); @@ -1000,18 +2902,19 @@ static STATUS_T CmdDraw( wAction_t action, coOrd pos ) case C_START: ParamLoadControls( &drawPG ); /*drawContext = &drawCmdContext;*/ - drawWidthPD.option |= PDO_NORECORD; + drawLineWidthPD.option |= PDO_NORECORD; drawColorPD.option |= PDO_NORECORD; drawBenchColorPD.option |= PDO_NORECORD; drawBenchChoicePD.option |= PDO_NORECORD; drawBenchOrientPD.option |= PDO_NORECORD; drawDimArrowSizePD.option |= PDO_NORECORD; - drawCmdContext.Op = (wIndex_t)(long)commandContext; + drawCmdContext.Op = (wIndex_t)VP2L(commandContext); if ( drawCmdContext.Op < 0 || drawCmdContext.Op > OP_LAST ) { NoticeMessage( "cmdDraw: Op %d", _("Ok"), NULL, drawCmdContext.Op ); drawCmdContext.Op = OP_LINE; } - /*DrawGeomOp( (void*)(drawCmdContext.Op>=0?drawCmdContext.Op:OP_LINE) );*/ + SetAllTrackSelect( FALSE ); + /*DrawGeomOp( (drawCmdContext.Op>=0?drawCmdContext.Op:OP_LINE) );*/ infoSubst = TRUE; switch( drawCmdContext.Op ) { case OP_LINE: @@ -1021,19 +2924,29 @@ static STATUS_T CmdDraw( wAction_t action, coOrd pos ) case OP_CURVE4: case OP_CIRCLE2: case OP_CIRCLE3: + case OP_BEZLIN: case OP_BOX: case OP_POLY: - case OP_BEZLIN: - controls[0] = drawWidthPD.control; + case OP_POLYLINE: + controls[0] = drawLineWidthPD.control; controls[1] = drawColorPD.control; + controls[2] = drawLineTypePD.control; controls[2] = NULL; sprintf( labelName, _("%s Line Width"), _(objectName[drawCmdContext.Op]) ); labels[0] = labelName; labels[1] = N_("Color"); + labels[2] = N_("Type"); + if ( wListGetCount( (wList_p)drawLineTypePD.control ) == 0 ) { + wListAddValue( (wList_p)drawLineTypePD.control, _("Solid"), NULL, NULL ); + wListAddValue( (wList_p)drawLineTypePD.control, _("Dot"), NULL, NULL ); + wListAddValue( (wList_p)drawLineTypePD.control, _("Dash"), NULL, NULL ); + wListAddValue( (wList_p)drawLineTypePD.control, _("Dash-Dot"), NULL, NULL ); + wListAddValue( (wList_p)drawLineTypePD.control, _("Dash-Dot-Dot"), NULL, NULL ); + } InfoSubstituteControls( controls, labels ); - drawWidthPD.option &= ~PDO_NORECORD; + drawLineWidthPD.option &= ~PDO_NORECORD; drawColorPD.option &= ~PDO_NORECORD; - lineWidth = drawCmdContext.Width; + drawLineTypePD.option &= ~PDO_NORECORD; break; case OP_FILLCIRCLE2: case OP_FILLCIRCLE3: @@ -1055,16 +2968,20 @@ static STATUS_T CmdDraw( wAction_t action, coOrd pos ) labels[0] = N_("Lumber Type"); labels[1] = ""; labels[2] = N_("Color"); - if ( wListGetCount( (wList_p)drawBenchChoicePD.control ) == 0 ) - BenchLoadLists( (wList_p)drawBenchChoicePD.control, (wList_p)drawBenchOrientPD.control ); + if ( wListGetCount( (wList_p)drawBenchChoicePD.control ) == 0 ) { + BenchLoadLists( (wList_p)drawBenchChoicePD.control, + (wList_p)drawBenchOrientPD.control ); + } ParamLoadControls( &drawPG ); - BenchUpdateOrientationList( (long)wListGetItemContext( (wList_p)drawBenchChoicePD.control, benchChoice ), (wList_p)drawBenchOrientPD.control ); + BenchUpdateOrientationList( VP2L(wListGetItemContext( (wList_p) + drawBenchChoicePD.control, benchChoice )), (wList_p)drawBenchOrientPD.control ); wListSetIndex( (wList_p)drawBenchOrientPD.control, benchOrient ); InfoSubstituteControls( controls, labels ); drawBenchColorPD.option &= ~PDO_NORECORD; drawBenchChoicePD.option &= ~PDO_NORECORD; drawBenchOrientPD.option &= ~PDO_NORECORD; + drawLengthPD.option &= ~PDO_NORECORD; break; case OP_DIMLINE: controls[0] = drawDimArrowSizePD.control; @@ -1081,18 +2998,15 @@ static STATUS_T CmdDraw( wAction_t action, coOrd pos ) drawDimArrowSizePD.option &= ~PDO_NORECORD; break; case OP_TBLEDGE: - InfoSubstituteControls( NULL, NULL ); InfoMessage( _("Drag to create Table Edge") ); - drawColorPD.option &= ~PDO_NORECORD; break; default: InfoSubstituteControls( NULL, NULL ); infoSubst = FALSE; } ParamGroupRecord( &drawPG ); - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - DrawGeomMouse( C_START, pos, &drawCmdContext ); - + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + DrawGeomMouse( C_START, pos, &drawCmdContext); return C_CONTINUE; case wActionLDown: @@ -1102,129 +3016,234 @@ static STATUS_T CmdDraw( wAction_t action, coOrd pos ) return CmdBezCurve(act2, pos); } if ( drawCmdContext.Op == OP_BENCH ) { - drawCmdContext.benchOption = GetBenchData( (long)wListGetItemContext((wList_p)drawBenchChoicePD.control, benchChoice ), benchOrient ); - drawCmdContext.Color = benchColor; + drawCmdContext.benchOption = GetBenchData( VP2L(wListGetItemContext(( + wList_p)drawBenchChoicePD.control, benchChoice )), benchOrient ); + lineColor = benchColor; } else if ( drawCmdContext.Op == OP_DIMLINE ) { + lineColor = wDrawColorBlack; drawCmdContext.benchOption = dimArrowSize; + } else if ( drawCmdContext.Op == OP_TBLEDGE ) { + lineColor = wDrawColorBlack; } else { - drawCmdContext.Color = lineColor; + lineColor = lineColor; } if ( infoSubst ) { InfoSubstituteControls( NULL, NULL ); infoSubst = FALSE; } + /* no break */ case wActionLDrag: ParamLoadData( &drawPG ); + /* no break */ case wActionMove: - case wActionLUp: case wActionRDown: case wActionRDrag: + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( action, pos, &drawCmdContext); + case wActionLUp: case wActionRUp: - case wActionText: - case C_CMDMENU: - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - if (!((MyGetKeyState() & WKEY_SHIFT) != 0)) { - SnapPos( &pos ); + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + drawCmdContext.show = TRUE; + int rc = DrawGeomMouse( action, pos, &drawCmdContext); + // Put up text entry boxes ready for updates if the result was continue + if (rc == C_CONTINUE && drawCmdContext.show) { + switch( drawCmdContext.Op ) { + case OP_CIRCLE1: + case OP_CIRCLE2: + case OP_CIRCLE3: + case OP_FILLCIRCLE1: + case OP_FILLCIRCLE2: + case OP_FILLCIRCLE3: + controls[0] = drawRadiusPD.control; + controls[1] = NULL; + labels[0] = N_("Radius"); + ParamLoadControls( &drawPG ); + InfoSubstituteControls( controls, labels ); + drawRadiusPD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + break; + case OP_CURVE1: + case OP_CURVE2: + case OP_CURVE3: + case OP_CURVE4: + if (drawCmdContext.ArcData.type == curveTypeCurve) { + controls[0] = drawRadiusPD.control; + controls[1] = drawAnglePD.control; + controls[2] = NULL; + labels[0] = N_("Radius"); + labels[1] = N_("Arc Angle"); + } else { + controls[0] = drawLengthPD.control; + controls[1] = drawAnglePD.control; + controls[2] = NULL; + labels[0] = N_("Length"); + labels[1] = N_("Angle"); + } + ParamLoadControls( &drawPG ); + InfoSubstituteControls( controls, labels ); + drawLengthPD.option &= ~PDO_NORECORD; + drawRadiusPD.option &= ~PDO_NORECORD; + drawAnglePD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + break; + case OP_LINE: + case OP_BENCH: + case OP_TBLEDGE: + case OP_POLY: + case OP_FILLPOLY: + case OP_POLYLINE: + controls[0] = drawLengthPD.control; + controls[1] = drawAnglePD.control; + controls[2] = NULL; + labels[0] = N_("Seg Length"); + if (drawCmdContext.Op == OP_LINE || drawCmdContext.Op == OP_BENCH + || drawCmdContext.Op == OP_TBLEDGE) { + labels[1] = N_("Angle"); + } else if (drawCmdContext.index > 0 ) { + labels[1] = N_("Rel Angle"); + } else { + labels[1] = N_("Angle"); + } + ParamLoadControls( &drawPG ); + InfoSubstituteControls( controls, labels ); + drawLengthPD.option &= ~PDO_NORECORD; + drawAnglePD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + break; + case OP_BOX: + case OP_FILLBOX: + controls[0] = drawLengthPD.control; + controls[1] = drawWidthPD.control; + controls[2] = NULL; + labels[0] = N_("Length"); + labels[1] = N_("Width"); + ParamLoadControls( &drawPG ); + InfoSubstituteControls( controls, labels ); + drawLengthPD.option &= ~PDO_NORECORD; + drawWidthPD.option &= ~PDO_NORECORD; + infoSubst = TRUE; + break; + default: + break; + } } - return DrawGeomMouse( action, pos, &drawCmdContext ); + return rc; case C_CANCEL: InfoSubstituteControls( NULL, NULL ); - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - return DrawGeomMouse( action, pos, &drawCmdContext ); - + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( action, pos, &drawCmdContext); + case C_TEXT: + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(action, pos); } + return DrawGeomMouse( action, pos, &drawCmdContext); case C_OK: - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - return DrawGeomMouse( (0x0D<<8|wActionText), pos, &drawCmdContext ); - /*DrawOk( NULL );*/ + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( (0x0D<<8|wActionText), pos, &drawCmdContext); + case C_CONFIRM: + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( (0x0D<<8|wActionText), pos, &drawCmdContext); case C_FINISH: - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - return DrawGeomMouse( (0x0D<<8|wActionText), pos, &drawCmdContext ); - /*DrawOk( NULL );*/ + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( (0x0D<<8|wActionText), pos, &drawCmdContext); + /*DrawOk( NULL );*/ case C_REDRAW: - if (drawCmdContext.Op == OP_BEZLIN) return CmdBezCurve(act2, pos); - return DrawGeomMouse( action, pos, &drawCmdContext ); + if (drawCmdContext.Op == OP_BEZLIN) { return CmdBezCurve(act2, pos); } + return DrawGeomMouse( action, pos, &drawCmdContext); + + case C_CMDMENU: + if (drawCmdContext.Op == OP_BEZLIN) { return C_CONTINUE; } + return DrawGeomMouse( action, pos, &drawCmdContext); default: return C_CONTINUE; } } -#include "bitmaps/dline.xpm" -#include "bitmaps/ddimlin.xpm" -#include "bitmaps/dbench.xpm" -#include "bitmaps/dtbledge.xpm" -#include "bitmaps/dcurve1.xpm" -#include "bitmaps/dcurve2.xpm" -#include "bitmaps/dcurve3.xpm" -#include "bitmaps/dcurve4.xpm" +#include "bitmaps/straight-line.xpm3" +#include "bitmaps/dimension.xpm3" +#include "bitmaps/benchwork.xpm3" +#include "bitmaps/table-edge.xpm3" + +#include "bitmaps/curved-line-end.xpm3" +#include "bitmaps/curved-line-tangent.xpm3" +#include "bitmaps/curved-line-middle.xpm3" +#include "bitmaps/curved-line-chord.xpm3" + /*#include "bitmaps/dcircle1.xpm"*/ -#include "bitmaps/dcircle2.xpm" -#include "bitmaps/dcircle3.xpm" +#include "bitmaps/circle-line-center.xpm3" +#include "bitmaps/circle-line-tangent.xpm3" /*#include "bitmaps/dflcrcl1.xpm"*/ -#include "bitmaps/dflcrcl2.xpm" -#include "bitmaps/dflcrcl3.xpm" -#include "bitmaps/dbox.xpm" -#include "bitmaps/dfilbox.xpm" -#include "bitmaps/dpoly.xpm" -#include "bitmaps/dfilpoly.xpm" -#include "bitmaps/dbezier.xpm" +#include "bitmaps/circle-filled-center.xpm3" +#include "bitmaps/circle-filled-tangent.xpm3" + +#include "bitmaps/box.xpm3" +#include "bitmaps/filled-box.xpm3" +#include "bitmaps/polygon.xpm3" +#include "bitmaps/filled-polygon.xpm3" +#include "bitmaps/bezier-line.xpm3" +#include "bitmaps/polyline.xpm3" typedef struct { - char **xpm; - int OP; - char * shortName; - char * cmdName; - char * helpKey; - long acclKey; - } drawData_t; + char ***xpm; + int OP; + char * shortName; + char * cmdName; + char * helpKey; + long acclKey; +} drawData_t; static drawData_t dlineCmds[] = { - { dline_xpm, OP_LINE, N_("Line"), N_("Draw Line"), "cmdDrawLine", ACCL_DRAWLINE }, - { ddimlin_xpm, OP_DIMLINE, N_("Dimension Line"), N_("Draw Dimension Line"), "cmdDrawDimLine", ACCL_DRAWDIMLINE }, - { dbench_xpm, OP_BENCH, N_("Benchwork"), N_("Draw Benchwork"), "cmdDrawBench", ACCL_DRAWBENCH }, - { dtbledge_xpm, OP_TBLEDGE, N_("Table Edge"), N_("Draw Table Edge"), "cmdDrawTableEdge", ACCL_DRAWTBLEDGE } }; + { straight_line_xpm3, OP_LINE, N_("Line"), N_("Draw Line"), "cmdDrawLine", ACCL_DRAWLINE }, + { dimension_xpm3, OP_DIMLINE, N_("Dimension Line"), N_("Draw Dimension Line"), "cmdDrawDimLine", ACCL_DRAWDIMLINE }, + { benchwork_xpm3, OP_BENCH, N_("Benchwork"), N_("Draw Benchwork"), "cmdDrawBench", ACCL_DRAWBENCH }, + { table_edge_xpm3, OP_TBLEDGE, N_("Table Edge"), N_("Draw Table Edge"), "cmdDrawTableEdge", ACCL_DRAWTBLEDGE } +}; static drawData_t dcurveCmds[] = { - { dcurve1_xpm, OP_CURVE1, N_("Curve End"), N_("Draw Curve from End"), "cmdDrawCurveEndPt", ACCL_DRAWCURVE1 }, - { dcurve2_xpm, OP_CURVE2, N_("Curve Tangent"), N_("Draw Curve from Tangent"), "cmdDrawCurveTangent", ACCL_DRAWCURVE2 }, - { dcurve3_xpm, OP_CURVE3, N_("Curve Center"), N_("Draw Curve from Center"), "cmdDrawCurveCenter", ACCL_DRAWCURVE3 }, - { dcurve4_xpm, OP_CURVE4, N_("Curve Chord"), N_("Draw Curve from Chord"), "cmdDrawCurveChord", ACCL_DRAWCURVE4 }, - { dbezier_xpm, OP_BEZLIN, N_("Bezier Curve"), N_("Draw Bezier"), "cmdDrawBezierCurve", ACCL_DRAWBEZLINE } }; + { curved_line_end_xpm3, OP_CURVE1, N_("Curve End"), N_("Draw Curve from End"), "cmdDrawCurveEndPt", ACCL_DRAWCURVE1 }, + { curved_line_tangent_xpm3, OP_CURVE2, N_("Curve Tangent"), N_("Draw Curve from Tangent"), "cmdDrawCurveTangent", ACCL_DRAWCURVE2 }, + { curved_line_middle_xpm3, OP_CURVE3, N_("Curve Center"), N_("Draw Curve from Center"), "cmdDrawCurveCenter", ACCL_DRAWCURVE3 }, + { curved_line_chord_xpm3, OP_CURVE4, N_("Curve Chord"), N_("Draw Curve from Chord"), "cmdDrawCurveChord", ACCL_DRAWCURVE4 }, + { bezier_line_xpm3, OP_BEZLIN, N_("Bezier Curve"), N_("Draw Bezier"), "cmdDrawBezierCurve", ACCL_DRAWBEZLINE } +}; static drawData_t dcircleCmds[] = { - /*{ dcircle1_xpm, OP_CIRCLE1, "Circle Fixed Radius", "Draw Fixed Radius Circle", "cmdDrawCircleFixedRadius", ACCL_DRAWCIRCLE1 },*/ - { dcircle2_xpm, OP_CIRCLE3, N_("Circle Tangent"), N_("Draw Circle from Tangent"), "cmdDrawCircleTangent", ACCL_DRAWCIRCLE2 }, - { dcircle3_xpm, OP_CIRCLE2, N_("Circle Center"), N_("Draw Circle from Center"), "cmdDrawCircleCenter", ACCL_DRAWCIRCLE3 }, - /*{ dflcrcl1_xpm, OP_FILLCIRCLE1, "Circle Filled Fixed Radius", "Draw Fixed Radius Filled Circle", "cmdDrawFilledCircleFixedRadius", ACCL_DRAWFILLCIRCLE1 },*/ - { dflcrcl2_xpm, OP_FILLCIRCLE3, N_("Circle Filled Tangent"), N_("Draw Filled Circle from Tangent"), "cmdDrawFilledCircleTangent", ACCL_DRAWFILLCIRCLE2 }, - { dflcrcl3_xpm, OP_FILLCIRCLE2, N_("Circle Filled Center"), N_("Draw Filled Circle from Center"), "cmdDrawFilledCircleCenter", ACCL_DRAWFILLCIRCLE3 } }; + /*{ dcircle1_xpm, OP_CIRCLE1, "Circle Fixed Radius", "Draw Fixed Radius Circle", "cmdDrawCircleFixedRadius", ACCL_DRAWCIRCLE1 },*/ + { circle_line_center_xpm3, OP_CIRCLE3, N_("Circle Center"), N_("Draw Circle from Center"), "cmdDrawCircleCenter", ACCL_DRAWCIRCLE2 }, + { circle_line_tangent_xpm3, OP_CIRCLE2, N_("Circle Tangent"), N_("Draw Circle from Tangent"), "cmdDrawCircleTangent", ACCL_DRAWCIRCLE3 }, + /*{ dflcrcl1_xpm, OP_FILLCIRCLE1, "Circle Filled Fixed Radius", "Draw Fixed Radius Filled Circle", "cmdDrawFilledCircleFixedRadius", ACCL_DRAWFILLCIRCLE1 },*/ + { circle_filled_center_xpm3, OP_FILLCIRCLE3, N_("Circle Filled Center"), N_("Draw Filled Circle from Center"), "cmdDrawFilledCircleCenter", ACCL_DRAWFILLCIRCLE2 }, + { circle_filled_tangent_xpm3, OP_FILLCIRCLE2, N_("Circle Filled Tangent"), N_("Draw Filled Circle from Tangent"), "cmdDrawFilledCircleTangent", ACCL_DRAWFILLCIRCLE3 } +}; static drawData_t dshapeCmds[] = { - { dbox_xpm, OP_BOX, N_("Box"), N_("Draw Box"), "cmdDrawBox", ACCL_DRAWBOX }, - { dfilbox_xpm, OP_FILLBOX, N_("Filled Box"), N_("Draw Filled Box"), "cmdDrawFilledBox", ACCL_DRAWFILLBOX }, - { dpoly_xpm, OP_POLY, N_("Poly Line"), N_("Draw Polyline"), "cmdDrawPolyline", ACCL_DRAWPOLYLINE }, - { dfilpoly_xpm, OP_FILLPOLY, N_("Polygon"), N_("Draw Polygon"), "cmdDrawPolygon", ACCL_DRAWPOLYGON } }; + { box_xpm3, OP_BOX, N_("Box"), N_("Draw Box"), "cmdDrawBox", ACCL_DRAWBOX }, + { filled_box_xpm3, OP_FILLBOX, N_("Filled Box"), N_("Draw Filled Box"), "cmdDrawFilledBox", ACCL_DRAWFILLBOX }, + { polygon_xpm3, OP_POLY, N_("Polygon"), N_("Draw Polygon"), "cmdDrawPolygon", ACCL_DRAWPOLY }, + { filled_polygon_xpm3, OP_FILLPOLY, N_("Filled Polygon"), N_("Draw Filled Polygon"), "cmdDrawFilledPolygon", ACCL_DRAWFILLPOLYGON }, + { polyline_xpm3, OP_POLYLINE, N_("PolyLine"), N_("Draw PolyLine"), "cmdDrawPolyline", ACCL_DRAWPOLYLINE }, +}; typedef struct { - char * helpKey; - char * menuTitle; - char * stickyLabel; - int cnt; - drawData_t * data; - long acclKey; - wIndex_t cmdInx; - int curr; - } drawStuff_t; + char * helpKey; + char * menuTitle; + char * stickyLabel; + int cnt; + drawData_t * data; + long acclKey; + wIndex_t cmdInx; + int curr; +} drawStuff_t; static drawStuff_t drawStuff[4]; static drawStuff_t drawStuff[4] = { - { "cmdDrawLineSetCmd", N_("Straight Objects"), N_("Draw Straight Objects"), 4, dlineCmds }, - { "cmdDrawCurveSetCmd", N_("Curved Lines"), N_("Draw Curved Lines"), 5, dcurveCmds }, - { "cmdDrawCircleSetCmd", N_("Circle Lines"), N_("Draw Circles"), 4, dcircleCmds }, - { "cmdDrawShapeSetCmd", N_("Shapes"), N_("Draw Shapes"), 4, dshapeCmds} }; - + { "cmdDrawLineSetCmd", N_("Straight Objects"), N_("Draw Straight Objects"), 4, dlineCmds }, + { "cmdDrawCurveSetCmd", N_("Curved Lines"), N_("Draw Curved Lines"), 5, dcurveCmds }, + { "cmdDrawCircleSetCmd", N_("Circle Lines"), N_("Draw Circles"), 4, dcircleCmds }, + { "cmdDrawShapeSetCmd", N_("Shapes"), N_("Draw Shapes"), 5, dshapeCmds} +}; + static void ChangeDraw( long changes ) { @@ -1233,7 +3252,8 @@ static void ChangeDraw( long changes ) if ( drawBenchChoicePD.control && drawBenchOrientPD.control ) { choice = wListGetIndex( (wList_p)drawBenchChoicePD.control ); orient = wListGetIndex( (wList_p)drawBenchOrientPD.control ); - BenchLoadLists( (wList_p)drawBenchChoicePD.control, (wList_p)drawBenchOrientPD.control ); + BenchLoadLists( (wList_p)drawBenchChoicePD.control, + (wList_p)drawBenchOrientPD.control ); wListSetIndex( (wList_p)drawBenchChoicePD.control, choice ); wListSetIndex( (wList_p)drawBenchOrientPD.control, orient ); } @@ -1243,21 +3263,59 @@ static void ChangeDraw( long changes ) static void DrawDlgUpdate( - paramGroup_p pg, - int inx, - void * valueP ) + paramGroup_p pg, + int inx, + void * valueP ) { - if (drawCmdContext.Op == OP_BEZLIN) { - if ( (inx == 0 && pg->paramPtr[inx].valueP == &drawCmdContext.Width) || - (inx == 1 && pg->paramPtr[inx].valueP == &lineColor)) - { - lineWidth = drawCmdContext.Width; - UpdateParms(lineColor, lineWidth); - } + if (inx >=6 ) { + if (drawCmdContext.Op == OP_CIRCLE1 || + drawCmdContext.Op == OP_FILLCIRCLE1 || + drawCmdContext.Op == OP_CIRCLE2 || + drawCmdContext.Op == OP_FILLCIRCLE2 || + drawCmdContext.Op == OP_CIRCLE3 || + drawCmdContext.Op == OP_FILLCIRCLE3) { + coOrd pos = zero; + DrawGeomMouse(C_UPDATE,pos,&drawCmdContext); + } + if (drawCmdContext.Op == OP_CURVE1 || + drawCmdContext.Op == OP_CURVE2 || + drawCmdContext.Op == OP_CURVE3 || + drawCmdContext.Op == OP_CURVE4 ) { + coOrd pos = zero; + DrawGeomMouse(C_UPDATE,pos,&drawCmdContext); + } + if (drawCmdContext.Op == OP_LINE || + drawCmdContext.Op == OP_BENCH|| + drawCmdContext.Op == OP_TBLEDGE) { + coOrd pos = zero; + DrawGeomMouse(C_UPDATE,pos,&drawCmdContext); + } + + if (drawCmdContext.Op == OP_BOX || + drawCmdContext.Op == OP_FILLBOX ) { + coOrd pos = zero; + DrawGeomMouse(C_UPDATE,pos,&drawCmdContext); + } + + if (drawCmdContext.Op == OP_POLY || + drawCmdContext.Op == OP_FILLPOLY || + drawCmdContext.Op == OP_POLYLINE) { + coOrd pos = zero; + DrawGeomMouse(C_UPDATE,pos,&drawCmdContext); + } + ParamLoadControl(&drawPG,drawAngleInx); //Force Angle change out + //if (pg->paramPtr[inx].enter_pressed) { + // coOrd pos = zero; + // DrawGeomMouse((0x0D<<8)|(C_TEXT&0xFF),pos,&drawCmdContext); + // CmdDraw(C_START,pos); + //} } - if ( inx >= 0 && pg->paramPtr[inx].valueP == &benchChoice ) - BenchUpdateOrientationList( (long)wListGetItemContext( (wList_p)drawBenchChoicePD.control, (wIndex_t)*(long*)valueP ), (wList_p)drawBenchOrientPD.control ); + if ( inx >= 0 && pg->paramPtr[inx].valueP == &benchChoice ) { + BenchUpdateOrientationList( VP2L(wListGetItemContext( (wList_p) + drawBenchChoicePD.control, (wIndex_t)*(long*)valueP )), + (wList_p)drawBenchOrientPD.control ); + } } EXPORT void InitCmdDraw( wMenu_p menu ) @@ -1267,18 +3325,20 @@ EXPORT void InitCmdDraw( wMenu_p menu ) drawData_t * ddp; wIcon_p icon; - drawCmdContext.Color = wDrawColorBlack; lineColor = wDrawColorBlack; benchColor = wDrawFindColor( wRGB(255,192,0) ); ParamCreateControls( &drawPG, DrawDlgUpdate ); + ParamCreateControls( &drawModPG, DrawModDlgUpdate) ; + for ( inx1=0; inx1<4; inx1++ ) { dsp = &drawStuff[inx1]; ButtonGroupBegin( _(dsp->menuTitle), dsp->helpKey, _(dsp->stickyLabel) ); for ( inx2=0; inx2<dsp->cnt; inx2++ ) { ddp = &dsp->data[inx2]; - icon = wIconCreatePixMap( ddp->xpm ); - AddMenuButton( menu, CmdDraw, ddp->helpKey, _(ddp->cmdName), icon, LEVEL0_50, IC_STICKY|IC_POPUP2, ddp->acclKey, (void *)(intptr_t)ddp->OP ); + icon = wIconCreatePixMap( ddp->xpm[iconSize] ); + AddMenuButton( menu, CmdDraw, ddp->helpKey, _(ddp->cmdName), icon, LEVEL0_50, + IC_STICKY|IC_POPUP2|IC_WANT_MOVE, ddp->acclKey, I2VP(ddp->OP) ); } ButtonGroupEnd(); } @@ -1297,12 +3357,14 @@ BOOL_T ReadTableEdge( char * line ) trkSeg_t seg; wIndex_t layer; - if ( !GetArgs( line, paramVersion<3?"dXpYpY":paramVersion<9?"dL000pYpY":"dL000pfpf", - &index, &layer, &seg.u.l.pos[0], &elev0, &seg.u.l.pos[1], &elev1 ) ) + if ( !GetArgs( line, paramVersion<3?"dXpYpY":paramVersion<9 + ?"dL000pYpY":"dL000pfpf", + &index, &layer, &seg.u.l.pos[0], &elev0, &seg.u.l.pos[1], &elev1 ) ) { return FALSE; + } seg.type = SEG_TBLEDGE; seg.color = wDrawColorBlack; - seg.width = 0; + seg.lineWidth = 0; trk = MakeDrawFromSeg1( index, zero, 0.0, &seg ); SetTrkLayer(trk, layer); return TRUE; @@ -1310,11 +3372,11 @@ BOOL_T ReadTableEdge( char * line ) /** * Create a new segment for text. The data are stored in a trk structure. - * Storage for the string is dynamically allocated. + * Storage for the string is dynamically allocated. * * \param index IN of new element * \param pos IN coordinates of element - * \param angle IN orientation + * \param angle IN orientation * \param text IN text itself * \param textSize IN font size in pts * \param color IN text color @@ -1322,24 +3384,26 @@ BOOL_T ReadTableEdge( char * line ) */ EXPORT track_p NewText( - wIndex_t index, - coOrd pos, - ANGLE_T angle, - char * text, - CSIZE_T textSize, - wDrawColor color ) + wIndex_t index, + coOrd pos, + ANGLE_T angle, + char * text, + CSIZE_T textSize, + wDrawColor color, + BOOL_T boxed) { trkSeg_t tempSeg; track_p trk; tempSeg.type = SEG_TEXT; tempSeg.color = color; - tempSeg.width = 0; - tempSeg.u.t.pos = zero; + tempSeg.lineWidth = 0; + tempSeg.u.t.pos = pos; tempSeg.u.t.angle = angle; tempSeg.u.t.fontP = NULL; tempSeg.u.t.fontSize = textSize; tempSeg.u.t.string = MyStrdup( text ); - trk = MakeDrawFromSeg1( index, pos, angle, &tempSeg ); + tempSeg.u.t.boxed = boxed; + trk = MakeDrawFromSeg1( index, zero, 0.0, &tempSeg ); return trk; } @@ -1352,32 +3416,176 @@ EXPORT BOOL_T ReadText( char * line ) wIndex_t layer; track_p trk; ANGLE_T angle; - wDrawColor color = wDrawColorBlack; - if ( paramVersion<3 ) { - if (!GetArgs( line, "XXpYql", &index, &layer, &pos, &angle, &text, &textSize )) - return FALSE; - } else if (paramVersion<9 ) { - if (!GetArgs(line, "dL000pYql", &index, &layer, &pos, &angle, &text, &textSize)) - return FALSE; - } else { - if (!GetArgs(line, "dLl00pfql", &index, &layer, &color, &pos, &angle, &text, &textSize )) - return FALSE; - } - - char * old = text; - text = ConvertFromEscapedText(text); - MyFree(old); - - trk = NewText( index, pos, angle, text, textSize, color ); + wDrawColor color = wDrawColorBlack; + if ( paramVersion<3 ) { + if (!GetArgs( line, "XXpYql", &index, &layer, &pos, &angle, &text, + &textSize )) { + return FALSE; + } + } else if (paramVersion<9 ) { + if (!GetArgs(line, "dL000pYql", &index, &layer, &pos, &angle, &text, + &textSize)) { + return FALSE; + } + } else { + if (!GetArgs(line, "dLl00pfql", &index, &layer, &color, &pos, &angle, &text, + &textSize )) { + return FALSE; + } + } + + trk = NewText( index, pos, angle, text, textSize, color, FALSE ); SetTrkLayer( trk, layer ); MyFree(text); return TRUE; } +void MenuMode(void * modeVP ) +{ + int mode = (int)VP2L(modeVP); + if ( infoSubst ) { + InfoSubstituteControls( NULL, NULL ); + infoSubst = FALSE; + } + if (mode == 1) { + DrawGeomOriginMove(C_START,zero,&drawModCmdContext); + InfoMessage("Origin Mode"); + } else { + DrawGeomModify(C_START,zero,&drawModCmdContext); + InfoMessage("Points Mode"); + } +} + +void MenuEnter( void * keyVP ) +{ + int key = (int)VP2L(keyVP); + int action; + action = C_TEXT; + action |= key<<8; + if (drawModCmdContext.rotate_state) { + DrawGeomOriginMove(action,zero,&drawModCmdContext); + } else { + DrawGeomModify(action,zero,&drawModCmdContext); + } +} + +void MenuLine( void * keyVP ) +{ + int key = (int)VP2L(keyVP); + struct extraDataDraw_t * xx = GET_EXTRA_DATA(drawModCmdContext.trk, T_DRAW, + extraDataDraw_t); + if ( drawModCmdContext.type==SEG_STRLIN || drawModCmdContext.type==SEG_CRVLIN + || drawModCmdContext.type==SEG_POLY ) { + switch(key) { + case '0': + xx->lineType = DRAWLINESOLID; + break; + case '1': + xx->lineType = DRAWLINEDASH; + break; + case '2': + xx->lineType = DRAWLINEDOT; + break; + case '3': + xx->lineType = DRAWLINEDASHDOT; + break; + case '4': + xx->lineType = DRAWLINEDASHDOTDOT; + break; + case '5': + xx->lineType = DRAWLINECENTER; + break; + case '6': + xx->lineType = DRAWLINEPHANTOM; + break; + } + MainRedraw(); // MenuLine + } +} + +EXPORT void SetLineType( track_p trk, int width ) +{ + if (QueryTrack(trk, Q_IS_DRAW)) { + struct extraDataDraw_t * xx = GET_EXTRA_DATA(trk, T_DRAW, extraDataDraw_t); + if ( xx->segs[0].type==SEG_STRLIN || xx->segs[0].type==SEG_CRVLIN + || xx->segs[0].type==SEG_POLY) { + switch(width) { + case 0: + xx->lineType = DRAWLINESOLID; + break; + case 1: + xx->lineType = DRAWLINEDASH; + break; + case 2: + xx->lineType = DRAWLINEDOT; + break; + case 3: + xx->lineType = DRAWLINEDASHDOT; + break; + case 4: + xx->lineType = DRAWLINEDASHDOTDOT; + break; + case 5: + xx->lineType = DRAWLINECENTER; + break; + case 6: + xx->lineType = DRAWLINEPHANTOM; + break; + } + } + } +} EXPORT void InitTrkDraw( void ) { T_DRAW = InitObject( &drawCmds ); AddParam( "TABLEEDGE", ReadTableEdge ); AddParam( "TEXT", ReadText ); + + drawModDelMI = MenuRegister( "Modify Draw Edit Menu" ); + drawModClose = wMenuPushCreate( drawModDelMI, "", _("Close Polygon - 'g'"), 0, + MenuEnter, I2VP( 'g')); + drawModOpen = wMenuPushCreate( drawModDelMI, "", _("Make PolyLine - 'l'"), 0, + MenuEnter, I2VP( 'l')); + drawModFill = wMenuPushCreate( drawModDelMI, "", _("Fill Polygon - 'f'"), 0, + MenuEnter, I2VP( 'f')); + drawModEmpty = wMenuPushCreate( drawModDelMI, "", _("Empty Polygon - 'u'"), 0, + MenuEnter, I2VP( 'u')); + wMenuSeparatorCreate( drawModDelMI ); + drawModPointsMode = wMenuPushCreate( drawModDelMI, "", _("Points Mode - 'p'"), + 0, MenuMode, I2VP( 0 )); + drawModDel = wMenuPushCreate( drawModDelMI, "", + _("Delete Selected Point - 'Del'"), 0, MenuEnter, I2VP( 127 )); + drawModVertex = wMenuPushCreate( drawModDelMI, "", _("Vertex Point - 'v'"), 0, + MenuEnter, I2VP( 'v' )); + drawModRound = wMenuPushCreate( drawModDelMI, "", _("Round Corner - 'r'"), 0, + MenuEnter, I2VP( 'r' )); + drawModSmooth = wMenuPushCreate( drawModDelMI, "", _("Smooth Corner - 's'"), 0, + MenuEnter, I2VP( 's' )); + wMenuSeparatorCreate( drawModDelMI ); + drawModLinMI = wMenuMenuCreate( drawModDelMI, "", _("LineType...") ); + drawModSolid = wMenuPushCreate( drawModLinMI, "", _("Solid Line"), 0, MenuLine, + I2VP( '0' )); + drawModDot = wMenuPushCreate( drawModLinMI, "", _("Dashed Line"), 0, MenuLine, + I2VP( '1' )); + drawModDash = wMenuPushCreate( drawModLinMI, "", _("Dotted Line"), 0, MenuLine, + I2VP( '2' )); + drawModDashDot = wMenuPushCreate( drawModLinMI, "", _("Dash-Dot Line"), 0, + MenuLine, I2VP( '3' )); + drawModDashDotDot = wMenuPushCreate( drawModLinMI, "", _("Dash-Dot-Dot Line"), + 0, MenuLine, I2VP( '4' )); + drawModCenterDot = wMenuPushCreate( drawModLinMI, "", _("Center-Dot Line"), 0, + MenuLine, I2VP( '5' )); + drawModPhantom = wMenuPushCreate( drawModLinMI, "", _("Phantom-Dot Line"), 0, + MenuLine, I2VP( '6' )); + wMenuSeparatorCreate( drawModDelMI ); + drawModriginMode = wMenuPushCreate( drawModDelMI, "", _("Origin Mode - 'o'"), 0, + MenuMode, I2VP( 1 )); + drawModOrigin = wMenuPushCreate( drawModDelMI, "", _("Reset Origin - '0'"), 0, + MenuEnter, I2VP( '0' )); + drawModLast = wMenuPushCreate( drawModDelMI, "", _("Origin to Selected - 'l'"), + 0, MenuEnter, I2VP( 'l' )); + drawModCenter = wMenuPushCreate( drawModDelMI, "", _("Origin to Middle - 'm'"), + 0, MenuEnter, I2VP( 'm')); + } |