/*
 kate: mode C++; syntax C++; indent-mode none;
*/
#usage "<b>Encapsulated PostScript output</b>\n"
       "<p>This program creates a Encapsulated Postscript file from "
       "a board or a sheet. Program is based on <b>psdraw4.ulp</b> "
       "and adds drawing polygons and other shapes of pads. Many "
       "postscript operators were redefined to make file smaller.</p>\n"
       "<p>Mirror and/or upside-down operation of image can be done by "
       "uncommenting lines marked by <b>%MIRROR</b> and/or <b>%UPSIDE DOWN</b> "
       "resp. at the end.</p>\n"
       "<p>Run RATSNEST to calculate polygons before exporting!</p>\n"
       "<p>Tested on EAGLE v4.03.</p>\n"
       "<author>Author: Filip Kinovic, kinovicf@centrum.cz, 9.5.2004, v1.0</author>"

int i, LayerActive[];
int ifirst, iplunge;
real rcurx, rcury, rlastx, rlasty;
string fileName, ttext;
string excFileName;

void PSopen(string title, int L, int B, int R, int T, real scale)
{
  int xoffset = 30, yoffset = 30, bboffset = 3;

  printf("%%!PS-Adobe-3.0 EPSF-3.0\n"
         "%%%%Creator: EAGLE v%d.%02d\n"
         "%%%%Title: %s\n"
         "%%%%CreationDate: %s\n"
         "%%%%Pages: 0\n"
         "%%%%LanguageLevel: 2\n"
         "%%%%BoundingBox: %d %d %d %d\n"
         "%%%%EndComments\n"
         "\n",
         EAGLE_VERSION, EAGLE_RELEASE,
         title,
         t2string(time()),
         xoffset - bboffset,
         yoffset - bboffset,
         int((R - L) * u2inch(72) * scale) + xoffset + bboffset,
         int((T - B) * u2inch(72) * scale) + yoffset + bboffset);

  printf("%%%%BeginProlog\n"
         "%%redefination of operators\n"
         "/d /def load def\n"
         "/, /load load d\n"
         "/bd {bind d} bind d\n"
         "/ld {, d} bd\n"
         "/~ /exch ld\n"
         "/! /pop ld\n"
         "/@ /dup ld\n"
         "/V /div ld\n"
         "/: /gsave ld\n"
         "/; /grestore ld\n"
         "/` /begin ld\n"
         "/E /end ld\n"
         "/+ /translate ld\n"
         "/+S /scale ld\n"
         "/R /rotate ld\n"
         "/N /newpath ld\n"
         "/C /closepath ld\n"
         "/K /stroke ld\n"
         "/L /fill ld\n"
         "/O /eofill ld\n"
         "/S /show ld\n"
         "/LH /showpage ld\n"
         "/M /moveto ld\n"
         "/I /lineto ld\n"
         "/-M /rlineto ld\n"
         "/-c /curveto ld\n"
         "/Ac /arc ld\n"
         "/Lw /setlinewidth ld\n"
         "/Lc /setlinecap ld\n"
         "/Lj /setlinejoin ld\n"
         "/sd /setdash ld\n"
         "/sg /setgray ld\n"
         "/sr /setrgbcolor ld\n"
         "/Ji /setfont ld\n"
         "/FS {findfont ~ scalefont} bd\n"
         "%%%%EndProlog\n"
         "\n"
         "%%%%Page: 1 1\n");

  printf(":\n"
         "%d %d +\n"
         "1 Lc 1 Lj\n"
         "%%%d %d + %%MIRROR\n"
         "%%%d %d + %%UPSIDE DOWN\n"
         "%10.8f %10.8f +S %%normal\n"
         "%%%3.1f %3.1f +S %%MIRROR\n"
         "%%%3.1f %3.1f +S %%UPSIDE DOWN\n"
         "%d %d +\n\n",
         xoffset, yoffset,
         int((R - L) * u2inch(72) * scale), 0,
         0, int((T - B) * u2inch(72) * scale),
         scale * u2inch(72), scale * u2inch(72),
         -1.0, 1.0,
         1.0, -1.0,
         -L, -B);
}

void PSclose(void)
{
  printf("LH\n");
  printf(";\n");

  printf("\n%%%%EOF");
}

void DrawArc(UL_ARC A)
{
  if (LayerActive[A.layer])
  {
    printf("N %d %d %d %f %f Ac %d Lw K\n",
            A.xc, A.yc, A.radius, A.angle1, A.angle2, A.width);

    output(excFileName, "at")
    {
      int isegments;
      real radius, anginc, ang, xc, yc, xn, yn;
      isegments = (A.angle2 - A.angle1)/20.0;
      if( isegments < 2 ) { isegments = 2; }
      anginc = (A.angle2 - A.angle1)/isegments;
      radius = u2mm(A.radius);
      xc = u2mm(A.xc);
      yc = u2mm(A.yc);

      printf(";ARC x1,y1:%.3f %.3f\n",u2mm(A.x1),u2mm(A.y1));
      printf(";ARC x2,y2:%.3f %.3f\n",u2mm(A.x2),u2mm(A.y2));
      printf(";ARC xc,yc:%.3f %.3f\n",u2mm(A.xc),u2mm(A.yc));
      printf(";ARC a1,a2:%.3f %.3f\n",A.angle1,A.angle2);
      printf(";ARC radius:%.3f\n",u2mm(A.radius));

      printf("G00X%.3fY%.3f\n",u2mm(A.x1),u2mm(A.y1));
      printf("M15\n");
      for(i=0,ang=A.angle1; i<isegments; i++,ang+=anginc)
      {
        xn = radius * cos((ang*PI)/180.0);
        yn = radius * sin((ang*PI)/180.0);
        printf("G01X%.3fY%.3f\n",xc+xn,yc+yn);
      }
      xc = u2mm(A.x2);
      yc = u2mm(A.y2);
      printf("G01X%.3fY%.3f\n",xc,yc);
      printf("M16\n");

    }

  }
}

void DrawCircle(UL_CIRCLE C)
{
  if (LayerActive[C.layer])
     printf("N %d %d %d 0 360 Ac %d Lw K\n",
            C.x, C.y, C.radius, C.width);
}

void DrawPiece(UL_WIRE W)
{
  if (LayerActive[W.layer])
     printf("N %d %d M %d %d I %d Lw K\n",
          W.x1, W.y1, W.x2, W.y2, W.width);
}

void DrawWire(UL_WIRE W)
{
  if (LayerActive[W.layer])
  {
    if ( W.arc )
    {
      DrawArc(W.arc);
    }
    else
    {
      if (W.style == WIRE_STYLE_CONTINUOUS)
      {
        printf("N %d %d M %d %d I %d Lw K\n",
            W.x1, W.y1, W.x2, W.y2, W.width);

        output(excFileName, "at")
        {
          if( ifirst )
          {
            printf("G00X%.3fY%.3f\n",u2mm(W.x1),u2mm(W.y1));
            printf("M15\n");
            rlastx = u2mm(W.x2);
            rlasty = u2mm(W.y2);
            printf("G01X%.3fY%.3f\n",rlastx, rlasty );
            ifirst = 0;
            iplunge = 1;
          }
          else
          {
            rcurx = u2mm(W.x1);
            rcury = u2mm(W.y1);
            if( (rlastx == rcurx) && (rlasty == rcury) )
            {
              rlastx = u2mm(W.x2);
              rlasty = u2mm(W.y2);
              printf("G01X%.3fY%.3f\n",rlastx, rlasty );
              iplunge = 1;
            }
            else
            {
              rlastx = u2mm(W.x2);
              rlasty = u2mm(W.y2);
              printf("M16\n");
              printf("G00X%.3fY%.3f\n",rcurx, rcury );
              printf("M15\n");
              printf("G01X%.3fY%.3f\n",rlastx, rlasty );
              iplunge = 1;
            }          
          }
        }
      }
      else
      {
        W.pieces(WP) DrawPiece(WP);
      }
    }
  }
}

//*** draw via
void DrawVia(UL_VIA V)
{
  if (LayerActive[LAYER_VIAS]) {
    //via shape
    int r = V.diameter[LAYER_TOP] / 2;
    switch(V.shape[LAYER_TOP]) {
      case VIA_SHAPE_SQUARE:
        printf("N %d %d M %d %d -M %d %d -M %d %d -M C L\n",
               V.x - r, V.y - r,
               r + r, 0,
               0, r + r,
               -(r + r), 0);
        break;
      case VIA_SHAPE_ROUND:
        printf("N %d %d M %d %d %d 0 360 Ac C L\n",
               V.x + r, V.y, V.x, V.y, r);
        break;
      case VIA_SHAPE_OCTAGON:
        int dr = int(r * sin(PI / 8.0));
        printf("N %d %d M %d %d I %d %d I %d %d I %d %d I %d %d I %d %d I %d %d I C L\n",
               V.x + r, V.y + dr,
               V.x + dr, V.y + r,
               V.x - dr, V.y + r,
               V.x - r, V.y + dr,
               V.x - r, V.y - dr,
               V.x - dr, V.y - r,
               V.x + dr, V.y - r,
               V.x + r, V.y - dr);
        break;
    }
    //via drill
    printf("N %d %d M %d %d %d 0 360 Ac C : 1 sg L ;\n",
           V.x + V.drill / 2, V.y, V.x, V.y, V.drill / 2);
  }
  //pad drill symbol
  if (LayerActive[LAYER_DRILLS]) {
//  if (H.drillsymbol) {
    printf("N %d %d %d 0 360 Ac %d Lw K\n",
           V.x, V.y, V.drill/2, 1000);
    printf("N %d %d M %d %d I %d Lw K\n",
           V.x - V.drill/2, V.y - V.drill/2,
           V.x + V.drill/2, V.y + V.drill/2,
           1000);
//  }
  }
}

void DrawContact(UL_CONTACT C)
{
  if (C.pad) {
    if (LayerActive[LAYER_PADS]) {
      //pad shape
      int r = C.pad.diameter[LAYER_TOP] / 2;
      int dr = int(r * sin(PI / 8.0));
      switch(C.pad.shape[LAYER_TOP]) {
        case VIA_SHAPE_SQUARE:
          printf("N %d %d M %d %d -M %d %d -M %d %d -M C L\n",
                 C.x - r, C.y - r,
                 r + r, 0,
                 0, r + r,
                 -(r + r), 0);
          break;
        case VIA_SHAPE_ROUND:
          printf("N %d %d M %d %d %d 0 360 Ac C L\n",
                 C.x + r, C.y, C.x, C.y, r);
          break;
        case VIA_SHAPE_OCTAGON:
          printf("N %d %d M %d %d I %d %d I %d %d I %d %d I %d %d I %d %d I %d %d I C L\n",
                 C.x + r, C.y + dr,
                 C.x + dr, C.y + r,
                 C.x - dr, C.y + r,
                 C.x - r, C.y + dr,
                 C.x - r, C.y - dr,
                 C.x - dr, C.y - r,
                 C.x + dr, C.y - r,
                 C.x + r, C.y - dr);
          break;
      }
      //pad drill
      printf("N %d %d M %d %d %d 0 360 Ac C : 1 sg L ;\n",
                 C.pad.x + C.pad.drill / 2, C.pad.y, C.pad.x, C.pad.y, C.pad.drill / 2);
    }
    //pad drill symbol
    if (LayerActive[LAYER_DRILLS]) {
//    if (H.drillsymbol) {
      printf("N %d %d %d 0 360 Ac %d Lw K\n",
             C.pad.x, C.pad.y, C.pad.drill/2, 1000);
      printf("N %d %d M %d %d I %d Lw K\n",
             C.pad.x - C.pad.drill/2, C.pad.y - C.pad.drill/2,
             C.pad.x + C.pad.drill/2, C.pad.y + C.pad.drill/2,
             1000);
//    }
    }
  }
  else if (C.smd) {
     if (LayerActive[C.smd.layer]) {
        int dx2 = C.smd.dx / 2;
        int dy2 = C.smd.dy / 2;
        printf("N %d %d M %d %d I %d %d I %d %d I C L\n",
              C.x - dx2, C.y - dy2,
              C.x - dx2, C.y + dy2,
              C.x + dx2, C.y + dy2,
              C.x + dx2, C.y - dy2);
        }
     }
}

void DrawJunction(UL_JUNCTION J)
{
  if (LayerActive[LAYER_NETS])
     printf("N %d %d M %d %d %d 0 360 Ac C L\n",
            J.x + J.diameter / 2, J.y, J.x, J.y, J.diameter / 2);
}

void DrawVecText(UL_TEXT T)
{
  if (LayerActive[T.layer])
  {
    T.wires(W) DrawWire(W);
  }
}

void DrawText(UL_TEXT T)
{
  if (LayerActive[T.layer]) {
      T.wires(W) DrawWire(W);
  }
}

void DrawRectangle(UL_RECTANGLE R)
{
  if (LayerActive[R.layer]) {
     printf("N %d %d M %d %d I %d %d I %d %d I C L\n",
           R.x1, R.y1, R.x2, R.y1, R.x2, R.y2, R.x1, R.y2);
     }
}

void DrawPolygon(UL_POLYGON P)
{
  if (LayerActive[P.layer]) {
    int x0, y0, first;
    real vector;

    //user polygon
//    P.wires(PW) DrawWire(PW);
    //fill polygon
    first = 1;
    P.contours(PCW) {
      if (first) {    //a new partial polygon is starting
        vector = 0.0;
        x0 = PCW.x1;
        y0 = PCW.y1;
        printf("N %d %d M %d %d I ", PCW.x1, PCW.y1, PCW.x2, PCW.y2);
      }
      //
      printf("%d %d I ", PCW.x2, PCW.y2);

      if (first)
        first = 0;
      else if (PCW.x2 == x0 && PCW.y2 == y0) {    // this was the last wire of the partial polygon
        first = 1;
        if (vector <= 0.0) {    //if positive polygon (right rotation)
          printf("C %s%d Lw K\n",
                 P.pour == POLYGON_POUR_SOLID ? ": L ; " : "", P.width);   //fill in & draw contour
//          printf("C : %d Lw 1 0 0 sr K ;\n", P.width);   //draw red contour
        }
        else {    //negative polygon (left rotation)
          printf("C %s%d Lw K\n",
                 P.pour == POLYGON_POUR_SOLID ? ": 1 sg L ; " : "", P.width);   //fill in & draw contour
//          printf("C : %d Lw 0 1 0 sr K ;\n", P.width);   //draw green contour
        }
      }
      else {
        vector += real(PCW.x1-x0) * real(PCW.y2-PCW.y1) - real(PCW.y1-y0) * real(PCW.x2-PCW.x1);    //add vector mul.
      }
    }
    if (P.pour == POLYGON_POUR_HATCH)
      P.fillings(PFW) DrawWire(PFW);

  }
}

void DrawHole(UL_HOLE H)
{
  if (LayerActive[LAYER_DIMENSION]) {
     printf("N %d %d %d 0 360 Ac %d Lw K\n",
            H.x, H.y, H.drill/2, 1000);
  }
  if (LayerActive[LAYER_HOLES]) {
//    if (H.drillsymbol) {
       printf("N %d %d %d 0 360 Ac %d Lw K\n",
              H.x, H.y, H.drill/2, 1000);
       printf("N %d %d M %d %d I %d Lw K\n",
              H.x - H.drill/2, H.y - H.drill/2,
              H.x + H.drill/2, H.y + H.drill/2,
              1000);
       printf("N %d %d M %d %d I %d Lw K\n",
              H.x + H.drill/2, H.y - H.drill/2,
              H.x - H.drill/2, H.y + H.drill/2,
              1000);
//    }
  }

}

void DrawPin(UL_PIN P)
{
//  P.circles(X) DrawCircle(X);
  P.wires(X)   DrawWire(X);
  P.texts(X)   DrawVecText(X);
}

void DrawSymbol(UL_SYMBOL S)
{
//  S.circles(C)    DrawCircle(C);
//  S.polygons(P) DrawPolygon(P);
//  S.rectangles(R) DrawRectangle(R);
  S.wires(W)      DrawWire(W);
  S.pins(P)       DrawPin(P);
  S.texts(T)      DrawVecText(T);
}

void DrawPackage(UL_PACKAGE P)
{
//  P.contacts(C)   DrawContact(C);
//  P.circles(CC)    DrawCircle(CC);
//  P.polygons(PP) DrawPolygon(PP);
//  P.rectangles(R) DrawRectangle(R);
  output(excFileName, "at")
  {
    printf(";PACKAGE WIRES %s\n",P.name);
  }
  P.wires(W)      DrawWire(W);
  output(excFileName, "at")
  {
    printf(";PACKAGE TEXTS %s\n",P.name);
  }
  P.texts(T)      DrawText(T);
}

if (board) {
  board(B) {
//    B.layers(L) LayerActive[L.number] = L.visible;
    B.layers(L) {
      LayerActive[L.number] = 0;
      if( L.number == LAYER_TOP ) LayerActive[L.number] = 1;
      if( L.number == LAYER_TPLACE ) LayerActive[L.number] = 1;
      if( L.number == LAYER_BPLACE ) LayerActive[L.number] = 1;
      if( L.number == LAYER_TNAMES ) LayerActive[L.number] = 1;
      if( L.number == LAYER_BNAMES ) LayerActive[L.number] = 1;
      if( L.number == LAYER_TVALUES ) LayerActive[L.number] = 1;
      if( L.number == LAYER_BVALUES ) LayerActive[L.number] = 1;
      if( L.number == LAYER_TDOCU ) LayerActive[L.number] = 1;
      if( L.number == LAYER_BDOCU ) LayerActive[L.number] = 1;
    }
      
      
    sprintf(excFileName, "%s_brd.exc", filesetext(B.name, ""));
    output(excFileName, "wt")
    {
      printf("M48\nMETRIC\nFMAT,2\nM71\nDN,-0.2\nUP,0.5\nT01C0.25\nG00X0.0Y0.0\n%%\nT01\n");
    }
    
    sprintf(ttext, "%s_brd.eps", filesetext(B.name, ""));
    fileName = dlgFileSave("Save File", filesetext(ttext, ".eps"), "*.eps");
    if (fileName == "")
      exit(0);
    output(fileName) {
      PSopen(filename(fileName), B.area.x1, B.area.y1, B.area.x2, B.area.y2, 1.0);

      ifirst = 1;
      iplunge = 0;

      B.signals(S) {
        S.polygons(P) DrawPolygon(P);
        S.wires(W) DrawWire(W);
        S.vias(V)  DrawVia(V);
      }

      output(excFileName, "at")
      {
        if( iplunge )
        {
          printf("M16\n");
          iplunge = 0;
        }
      }

      ifirst = 1;

      B.elements(E)
      {
        output(excFileName, "at")
        {
          printf(";START %s\n",E.name);
        }
        E.texts(T) DrawText(T);
        DrawPackage(E.package);
      }

      output(excFileName, "at")
      {
        if( iplunge )
        {
          printf("M16\n");
          iplunge = 0;
        }
      }
      ifirst = 1;

      B.circles(BC) DrawCircle(BC);
      B.holes(BH) DrawHole(BH);
      B.polygons(BP) DrawPolygon(BP);
      B.rectangles(BR) DrawRectangle(BR);
      B.wires(BW) DrawWire(BW);
      B.texts(BT) DrawText(BT);

      PSclose();
      output(excFileName, "at")
      {
        if( iplunge )
        {
          printf("M16\n");
        }
        printf("M30\n");
      }

      sprintf(ttext, "Board exported to \"%s\".", filename(fileName));
      dlgMessageBox(ttext);
    }
  }
}