← Back to branch summary

~ubuntu-branches/ubuntu/precise/poppler/precise-security

« back to all changes in this revision

Viewing changes to .pc/10_fix-a4-page-shift-on-brother-ps-printers.patch/poppler/PSOutputDev.cc

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2011-03-08 10:46:40 UTC
  • mfrom: (1.5.5) (4.3.2 experimental)
  • Revision ID: package-import@ubuntu.com-20110308104640-de1rwygu2cx2t0yt
Tags: 0.16.3-1ubuntu1
* Merge with Debian experimental. Remaining Ubuntu changes:
  - debian/control: Lower poppler-data to Suggests: (handled by
    language-selector).
  - Add 10_fix-a4-page-shift-on-brother-ps-printers.patch: Fix page shifts
    when printing on A4 paper with Brother PostScript printers.
    (LP #293832)
  - debian/control, debian/rules: Disable OpenJPEG, it's in universe.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/10_fix-a4-page-shift-on-brother-ps-printers.patch/poppler/PSOutputDev.cc
1350
1350
               (int)floor(x1), (int)floor(y1), (int)ceil(x2), (int)ceil(y2));
1351
1351
    if (floor(x1) != ceil(x1) || floor(y1) != ceil(y1) ||
1352
1352
        floor(x2) != ceil(x2) || floor(y2) != ceil(y2)) {
1353
 
      writePSFmt("%%HiResBoundingBox: {0:.4g} {1:.4g} {2:.4g} {3:.4g}\n",
 
1353
      writePSFmt("%%HiResBoundingBox: {0:.6g} {1:.6g} {2:.6g} {3:.6g}\n",
1354
1354
                 x1, y1, x2, y2);
1355
1355
    }
1356
1356
    writePS("%%DocumentSuppliedResources: (atend)\n");
1875
1875
                 font->getWMode());
1876
1876
    }
1877
1877
  } else {
1878
 
    writePSFmt("/F{0:d}_{1:d} /{2:t} {3:.4g} {4:.4g}\n",
 
1878
    writePSFmt("/F{0:d}_{1:d} /{2:t} {3:.6g} {4:.6g}\n",
1879
1879
               font->getID()->num, font->getID()->gen, psName, xs, ys);
1880
1880
    for (i = 0; i < 256; i += 8) {
1881
1881
      writePS((char *)((i == 0) ? "[ " : "  "));
2573
2573
  writePS("8 dict begin\n");
2574
2574
  writePS("/FontType 3 def\n");
2575
2575
  m = font->getFontMatrix();
2576
 
  writePSFmt("/FontMatrix [{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g}] def\n",
 
2576
  writePSFmt("/FontMatrix [{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g}] def\n",
2577
2577
             m[0], m[1], m[2], m[3], m[4], m[5]);
2578
2578
  m = font->getFontBBox();
2579
 
  writePSFmt("/FontBBox [{0:.4g} {1:.4g} {2:.4g} {3:.4g}] def\n",
 
2579
  writePSFmt("/FontBBox [{0:.6g} {1:.6g} {2:.6g} {3:.6g}] def\n",
2580
2580
             m[0], m[1], m[2], m[3]);
2581
2581
  writePS("/Encoding 256 array def\n");
2582
2582
  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
2608
2608
      charProc.free();
2609
2609
      if (t3String) {
2610
2610
        if (t3Cacheable) {
2611
 
          buf = GooString::format("{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g} setcachedevice\n",
 
2611
          buf = GooString::format("{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g} setcachedevice\n",
2612
2612
                                t3WX, t3WY, t3LLX, t3LLY, t3URX, t3URY);
2613
2613
        } else {
2614
 
          buf = GooString::format("{0:.4g} {1:.4g} setcharwidth\n", t3WX, t3WY);
 
2614
          buf = GooString::format("{0:.6g} {1:.6g} setcharwidth\n", t3WX, t3WY);
2615
2615
        }
2616
2616
        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
2617
2617
        delete buf;
2931
2931
 
2932
2932
  writePSFmt("/f_{0:d}_{1:d} {{\n", id.num, id.gen);
2933
2933
  writePS("q\n");
2934
 
  writePSFmt("[{0:.4gs} {1:.4gs} {2:.4gs} {3:.4gs} {4:.4gs} {5:.4gs}] cm\n",
 
2934
  writePSFmt("[{0:.6gs} {1:.6gs} {2:.6gs} {3:.6gs} {4:.6gs} {5:.6gs}] cm\n",
2935
2935
             m[0], m[1], m[2], m[3], m[4], m[5]);
2936
2936
 
2937
2937
  box.x1 = bbox[0];
2977
2977
    page->displaySlice(scan, 72, 72, rotateA, useMediaBox, crop,
2978
2978
                     sliceX, sliceY, sliceW, sliceH,
2979
2979
                     printing, catalog, abortCheckCbk, abortCheckCbkData);
2980
 
    rasterize = scan->usesTransparency();
 
2980
    rasterize = scan->usesTransparency() || scan->hasLevel1PSBug();
2981
2981
    delete scan;
2982
2982
  } else {
2983
2983
    rasterize = gTrue;
3067
3067
  w = bitmap->getWidth();
3068
3068
  h = bitmap->getHeight();
3069
3069
  writePS("gsave\n");
3070
 
  writePSFmt("[{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g}] concat\n",
 
3070
  writePSFmt("[{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g}] concat\n",
3071
3071
             m0, m1, m2, m3, m4, m5);
3072
3072
  switch (level) {
3073
3073
  case psLevel1:
3365
3365
    tx += rotate == 0 ? imgLLX : imgLLY;
3366
3366
    ty += rotate == 0 ? imgLLY : -imgLLX;
3367
3367
    if (tx != 0 || ty != 0) {
3368
 
      writePSFmt("{0:.4g} {1:.4g} translate\n", tx, ty);
 
3368
      writePSFmt("{0:.6g} {1:.6g} translate\n", tx, ty);
3369
3369
    }
3370
3370
    if (xScale != 1 || yScale != 1) {
3371
 
      writePSFmt("{0:.4f} {1:.4f} scale\n", xScale, yScale);
 
3371
      writePSFmt("{0:.6f} {1:.6f} scale\n", xScale, yScale);
3372
3372
    }
3373
3373
    if (clipLLX0 < clipURX0 && clipLLY0 < clipURY0) {
3374
 
      writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re W\n",
 
3374
      writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re W\n",
3375
3375
                 clipLLX0, clipLLY0, clipURX0 - clipLLX0, clipURY0 - clipLLY0);
3376
3376
    } else {
3377
3377
      writePSFmt("{0:d} {1:d} {2:d} {3:d} re W\n", x1, y1, x2 - x1, y2 - y1);
3400
3400
      ty = -epsY1;
3401
3401
    }
3402
3402
    if (tx != 0 || ty != 0) {
3403
 
      writePSFmt("{0:.4g} {1:.4g} translate\n", tx, ty);
 
3403
      writePSFmt("{0:.6g} {1:.6g} translate\n", tx, ty);
3404
3404
    }
3405
3405
    xScale = yScale = 1;
3406
3406
    break;
3449
3449
 
3450
3450
void PSOutputDev::updateCTM(GfxState *state, double m11, double m12,
3451
3451
                            double m21, double m22, double m31, double m32) {
3452
 
  writePSFmt("[{0:.4gs} {1:.4gs} {2:.4gs} {3:.4gs} {4:.4gs} {5:.4gs}] cm\n",
 
3452
  writePSFmt("[{0:.6gs} {1:.6gs} {2:.6gs} {3:.6gs} {4:.6gs} {5:.6gs}] cm\n",
3453
3453
             m11, m12, m21, m22, m31, m32);
3454
3454
}
3455
3455
 
3461
3461
  state->getLineDash(&dash, &length, &start);
3462
3462
  writePS("[");
3463
3463
  for (i = 0; i < length; ++i) {
3464
 
    writePSFmt("{0:.4g}{1:w}",
 
3464
    writePSFmt("{0:.6g}{1:w}",
3465
3465
               dash[i] < 0 ? 0 : dash[i],
3466
3466
               (i == length-1) ? 0 : 1);
3467
3467
  }
3468
 
  writePSFmt("] {0:.4g} d\n", start);
 
3468
  writePSFmt("] {0:.6g} d\n", start);
3469
3469
}
3470
3470
 
3471
3471
void PSOutputDev::updateFlatness(GfxState *state) {
3481
3481
}
3482
3482
 
3483
3483
void PSOutputDev::updateMiterLimit(GfxState *state) {
3484
 
  writePSFmt("{0:.4g} M\n", state->getMiterLimit());
 
3484
  writePSFmt("{0:.6g} M\n", state->getMiterLimit());
3485
3485
}
3486
3486
 
3487
3487
void PSOutputDev::updateLineWidth(GfxState *state) {
3488
 
  writePSFmt("{0:.4g} w\n", state->getLineWidth());
 
3488
  writePSFmt("{0:.6g} w\n", state->getLineWidth());
3489
3489
}
3490
3490
 
3491
3491
void PSOutputDev::updateFillColorSpace(GfxState *state) {
3721
3721
 
3722
3722
void PSOutputDev::updateFont(GfxState *state) {
3723
3723
  if (state->getFont()) {
3724
 
    writePSFmt("/F{0:d}_{1:d} {2:.4g} Tf\n",
 
3724
    writePSFmt("/F{0:d}_{1:d} {2:.6g} Tf\n",
3725
3725
               state->getFont()->getID()->num, state->getFont()->getID()->gen,
3726
3726
               fabs(state->getFontSize()) < 0.00001 ? 0.00001
3727
3727
                                                    : state->getFontSize());
3734
3734
  mat = state->getTextMat();
3735
3735
  if (fabs(mat[0] * mat[3] - mat[1] * mat[2]) < 0.00001) {
3736
3736
    // avoid a singular (or close-to-singular) matrix
3737
 
    writePSFmt("[0.00001 0 0 0.00001 {0:.4g} {1:.4g}] Tm\n", mat[4], mat[5]);
 
3737
    writePSFmt("[0.00001 0 0 0.00001 {0:.6g} {1:.6g}] Tm\n", mat[4], mat[5]);
3738
3738
  } else {
3739
 
    writePSFmt("[{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g}] Tm\n",
 
3739
    writePSFmt("[{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g}] Tm\n",
3740
3740
               mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
3741
3741
  }
3742
3742
}
3743
3743
 
3744
3744
void PSOutputDev::updateCharSpace(GfxState *state) {
3745
 
  writePSFmt("{0:.4g} Tc\n", state->getCharSpace());
 
3745
  writePSFmt("{0:.6g} Tc\n", state->getCharSpace());
3746
3746
}
3747
3747
 
3748
3748
void PSOutputDev::updateRender(GfxState *state) {
3757
3757
}
3758
3758
 
3759
3759
void PSOutputDev::updateRise(GfxState *state) {
3760
 
  writePSFmt("{0:.4g} Ts\n", state->getRise());
 
3760
  writePSFmt("{0:.6g} Ts\n", state->getRise());
3761
3761
}
3762
3762
 
3763
3763
void PSOutputDev::updateWordSpace(GfxState *state) {
3764
 
  writePSFmt("{0:.4g} Tw\n", state->getWordSpace());
 
3764
  writePSFmt("{0:.6g} Tw\n", state->getWordSpace());
3765
3765
}
3766
3766
 
3767
3767
void PSOutputDev::updateHorizScaling(GfxState *state) {
3771
3771
  if (fabs(h) < 0.01) {
3772
3772
    h = 0.01;
3773
3773
  }
3774
 
  writePSFmt("{0:.4g} Tz\n", h);
 
3774
  writePSFmt("{0:.6g} Tz\n", h);
3775
3775
}
3776
3776
 
3777
3777
void PSOutputDev::updateTextPos(GfxState *state) {
3778
 
  writePSFmt("{0:.4g} {1:.4g} Td\n", state->getLineX(), state->getLineY());
 
3778
  writePSFmt("{0:.6g} {1:.6g} Td\n", state->getLineX(), state->getLineY());
3779
3779
}
3780
3780
 
3781
3781
void PSOutputDev::updateTextShift(GfxState *state, double shift) {
3782
3782
  if (state->getFont()->getWMode()) {
3783
 
    writePSFmt("{0:.4g} TJmV\n", shift);
 
3783
    writePSFmt("{0:.6g} TJmV\n", shift);
3784
3784
  } else {
3785
 
    writePSFmt("{0:.4g} TJm\n", shift);
 
3785
    writePSFmt("{0:.6g} TJm\n", shift);
3786
3786
  }
3787
3787
}
3788
3788
 
3819
3819
  writePS("8 dict begin\n");
3820
3820
  writePS("/FontType 3 def\n");
3821
3821
  writePS("/FontMatrix [1 0 0 1 0 0] def\n");
3822
 
  writePSFmt("/FontBBox [{0:.4g} {1:.4g} {2:.4g} {3:.4g}] def\n",
 
3822
  writePSFmt("/FontBBox [{0:.6g} {1:.6g} {2:.6g} {3:.6g}] def\n",
3823
3823
             bbox[0], bbox[1], bbox[2], bbox[3]);
3824
3824
  writePS("/Encoding 256 array def\n");
3825
3825
  writePS("  0 1 255 { Encoding exch /.notdef put } for\n");
3842
3842
  gfx = new Gfx(xref, this, resDict, m_catalog, &box, NULL);
3843
3843
  writePS("/x {\n");
3844
3844
  if (paintType == 2) {
3845
 
    writePSFmt("{0:.4g} 0 {1:.4g} {2:.4g} {3:.4g} {4:.4g} setcachedevice\n",
 
3845
    writePSFmt("{0:.6g} 0 {1:.6g} {2:.6g} {3:.6g} {4:.6g} setcachedevice\n",
3846
3846
               xStep, bbox[0], bbox[1], bbox[2], bbox[3]);
3847
3847
  } else
3848
3848
  {
3849
3849
    if (x1 - 1 <= x0) {
3850
3850
      writePS("1 0 setcharwidth\n");
3851
3851
    } else {
3852
 
      writePSFmt("{0:.4g} 0 setcharwidth\n", xStep);
 
3852
      writePSFmt("{0:.6g} 0 setcharwidth\n", xStep);
3853
3853
    }
3854
3854
  }
3855
3855
  inType3Char = gTrue;
3865
3865
 
3866
3866
  // draw the tiles
3867
3867
  writePSFmt("/xpdfTile{0:d} findfont setfont\n", numTilingPatterns);
3868
 
  writePSFmt("gsave [{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g}] concat\n",
 
3868
  writePSFmt("gsave [{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g}] concat\n",
3869
3869
             mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
3870
 
  writePSFmt("{0:d} 1 {1:d} {{ {2:.4g} exch {3:.4g} mul m {4:d} 1 {5:d} {{ pop (x) show }} for }} for\n",
 
3870
  writePSFmt("{0:d} 1 {1:d} {{ {2:.6g} exch {3:.6g} mul m {4:d} 1 {5:d} {{ pop (x) show }} for }} for\n",
3871
3871
             y0, y1 - 1, x0 * xStep, yStep, x0, x1 - 1);
3872
3872
  writePS("grestore\n");
3873
3873
 
3889
3889
 
3890
3890
  shading->getDomain(&x0, &y0, &x1, &y1);
3891
3891
  mat = shading->getMatrix();
3892
 
  writePSFmt("/mat [{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g}] def\n",
 
3892
  writePSFmt("/mat [{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g}] def\n",
3893
3893
             mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
3894
3894
  writePSFmt("/n {0:d} def\n", shading->getColorSpace()->getNComps());
3895
3895
  if (shading->getNFuncs() == 1) {
3910
3910
    }
3911
3911
    writePS("} def\n");
3912
3912
  }
3913
 
  writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} 0 funcSH\n", x0, y0, x1, y1);
 
3913
  writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} 0 funcSH\n", x0, y0, x1, y1);
3914
3914
 
3915
3915
  return gTrue;
3916
3916
}
3972
3972
  t1 = shading->getDomain1();
3973
3973
 
3974
3974
  // generate the PS code
3975
 
  writePSFmt("/t0 {0:.4g} def\n", t0);
3976
 
  writePSFmt("/t1 {0:.4g} def\n", t1);
3977
 
  writePSFmt("/dt {0:.4g} def\n", t1 - t0);
3978
 
  writePSFmt("/x0 {0:.4g} def\n", x0);
3979
 
  writePSFmt("/y0 {0:.4g} def\n", y0);
3980
 
  writePSFmt("/dx {0:.4g} def\n", x1 - x0);
3981
 
  writePSFmt("/x1 {0:.4g} def\n", x1);
3982
 
  writePSFmt("/y1 {0:.4g} def\n", y1);
3983
 
  writePSFmt("/dy {0:.4g} def\n", y1 - y0);
3984
 
  writePSFmt("/xMin {0:.4g} def\n", xMin);
3985
 
  writePSFmt("/yMin {0:.4g} def\n", yMin);
3986
 
  writePSFmt("/xMax {0:.4g} def\n", xMax);
3987
 
  writePSFmt("/yMax {0:.4g} def\n", yMax);
 
3975
  writePSFmt("/t0 {0:.6g} def\n", t0);
 
3976
  writePSFmt("/t1 {0:.6g} def\n", t1);
 
3977
  writePSFmt("/dt {0:.6g} def\n", t1 - t0);
 
3978
  writePSFmt("/x0 {0:.6g} def\n", x0);
 
3979
  writePSFmt("/y0 {0:.6g} def\n", y0);
 
3980
  writePSFmt("/dx {0:.6g} def\n", x1 - x0);
 
3981
  writePSFmt("/x1 {0:.6g} def\n", x1);
 
3982
  writePSFmt("/y1 {0:.6g} def\n", y1);
 
3983
  writePSFmt("/dy {0:.6g} def\n", y1 - y0);
 
3984
  writePSFmt("/xMin {0:.6g} def\n", xMin);
 
3985
  writePSFmt("/yMin {0:.6g} def\n", yMin);
 
3986
  writePSFmt("/xMax {0:.6g} def\n", xMax);
 
3987
  writePSFmt("/yMax {0:.6g} def\n", yMax);
3988
3988
  writePSFmt("/n {0:d} def\n", shading->getColorSpace()->getNComps());
3989
3989
  if (shading->getNFuncs() == 1) {
3990
3990
    writePS("/func ");
4004
4004
    }
4005
4005
    writePS("} def\n");
4006
4006
  }
4007
 
  writePSFmt("{0:.4g} {1:.4g} 0 axialSH\n", tMin, tMax);
 
4007
  writePSFmt("{0:.6g} {1:.6g} 0 axialSH\n", tMin, tMax);
4008
4008
 
4009
4009
  return gTrue;
4010
4010
}
4122
4122
  }
4123
4123
 
4124
4124
  // generate the PS code
4125
 
  writePSFmt("/x0 {0:.4g} def\n", x0);
4126
 
  writePSFmt("/x1 {0:.4g} def\n", x1);
4127
 
  writePSFmt("/dx {0:.4g} def\n", x1 - x0);
4128
 
  writePSFmt("/y0 {0:.4g} def\n", y0);
4129
 
  writePSFmt("/y1 {0:.4g} def\n", y1);
4130
 
  writePSFmt("/dy {0:.4g} def\n", y1 - y0);
4131
 
  writePSFmt("/r0 {0:.4g} def\n", r0);
4132
 
  writePSFmt("/r1 {0:.4g} def\n", r1);
4133
 
  writePSFmt("/dr {0:.4g} def\n", r1 - r0);
4134
 
  writePSFmt("/t0 {0:.4g} def\n", t0);
4135
 
  writePSFmt("/t1 {0:.4g} def\n", t1);
4136
 
  writePSFmt("/dt {0:.4g} def\n", t1 - t0);
 
4125
  writePSFmt("/x0 {0:.6g} def\n", x0);
 
4126
  writePSFmt("/x1 {0:.6g} def\n", x1);
 
4127
  writePSFmt("/dx {0:.6g} def\n", x1 - x0);
 
4128
  writePSFmt("/y0 {0:.6g} def\n", y0);
 
4129
  writePSFmt("/y1 {0:.6g} def\n", y1);
 
4130
  writePSFmt("/dy {0:.6g} def\n", y1 - y0);
 
4131
  writePSFmt("/r0 {0:.6g} def\n", r0);
 
4132
  writePSFmt("/r1 {0:.6g} def\n", r1);
 
4133
  writePSFmt("/dr {0:.6g} def\n", r1 - r0);
 
4134
  writePSFmt("/t0 {0:.6g} def\n", t0);
 
4135
  writePSFmt("/t1 {0:.6g} def\n", t1);
 
4136
  writePSFmt("/dt {0:.6g} def\n", t1 - t0);
4137
4137
  writePSFmt("/n {0:d} def\n", shading->getColorSpace()->getNComps());
4138
4138
  writePSFmt("/encl {0:s} def\n", enclosed ? "true" : "false");
4139
 
  writePSFmt("/a1 {0:.4g} def\n", a1);
4140
 
  writePSFmt("/a2 {0:.4g} def\n", a2);
 
4139
  writePSFmt("/a1 {0:.6g} def\n", a1);
 
4140
  writePSFmt("/a2 {0:.6g} def\n", a2);
4141
4141
  if (shading->getNFuncs() == 1) {
4142
4142
    writePS("/func ");
4143
4143
    cvtFunction(shading->getFunc(0));
4156
4156
    }
4157
4157
    writePS("} def\n");
4158
4158
  }
4159
 
  writePSFmt("{0:.4g} {1:.4g} 0 radialSH\n", sMin, sMax);
 
4159
  writePSFmt("{0:.6g} {1:.6g} 0 radialSH\n", sMin, sMax);
4160
4160
 
4161
4161
  // extend the 'enclosed' case
4162
4162
  if (enclosed) {
4175
4175
        ya = y1;
4176
4176
      }
4177
4177
      if (level == psLevel2Sep || level == psLevel3Sep) {
4178
 
        writePSFmt("{0:.4g} radialCol aload pop k\n", ta);
 
4178
        writePSFmt("{0:.6g} radialCol aload pop k\n", ta);
4179
4179
      } else {
4180
 
        writePSFmt("{0:.4g} radialCol sc\n", ta);
 
4180
        writePSFmt("{0:.6g} radialCol sc\n", ta);
4181
4181
      }
4182
 
      writePSFmt("{0:.4g} {1:.4g} {2:.4g} 0 360 arc h f*\n", xa, ya, ra);
 
4182
      writePSFmt("{0:.6g} {1:.6g} {2:.6g} 0 360 arc h f*\n", xa, ya, ra);
4183
4183
    }
4184
4184
 
4185
4185
    // extend the larger circle
4197
4197
        ya = y1;
4198
4198
      }
4199
4199
      if (level == psLevel2Sep || level == psLevel3Sep) {
4200
 
        writePSFmt("{0:.4g} radialCol aload pop k\n", ta);
 
4200
        writePSFmt("{0:.6g} radialCol aload pop k\n", ta);
4201
4201
      } else {
4202
 
        writePSFmt("{0:.4g} radialCol sc\n", ta);
 
4202
        writePSFmt("{0:.6g} radialCol sc\n", ta);
4203
4203
      }
4204
 
      writePSFmt("{0:.4g} {1:.4g} {2:.4g} 0 360 arc h\n", xa, ya, ra);
4205
 
      writePSFmt("{0:.4g} {1:.4g} m {2:.4g} {3:.4g} l {4:.4g} {5:.4g} l {6:.4g} {7:.4g} l h f*\n",
 
4204
      writePSFmt("{0:.6g} {1:.6g} {2:.6g} 0 360 arc h\n", xa, ya, ra);
 
4205
      writePSFmt("{0:.6g} {1:.6g} m {2:.6g} {3:.6g} l {4:.6g} {5:.6g} l {6:.6g} {7:.6g} l h f*\n",
4206
4206
                 xMin, yMin, xMin, yMax, xMax, yMax, xMax, yMin);
4207
4207
    }
4208
4208
  }
4246
4246
      x3 = subpath->getX(3);
4247
4247
      y3 = subpath->getY(3);
4248
4248
      if (x0 == x1 && x2 == x3 && y0 == y3 && y1 == y2) {
4249
 
        writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re\n",
 
4249
        writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re\n",
4250
4250
                   x0 < x2 ? x0 : x2, y0 < y1 ? y0 : y1,
4251
4251
                   fabs(x2 - x0), fabs(y1 - y0));
4252
4252
        return;
4253
4253
      } else if (x0 == x3 && x1 == x2 && y0 == y1 && y2 == y3) {
4254
 
        writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re\n",
 
4254
        writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re\n",
4255
4255
                   x0 < x1 ? x0 : x1, y0 < y2 ? y0 : y2,
4256
4256
                   fabs(x1 - x0), fabs(y2 - y0));
4257
4257
        return;
4262
4262
  for (i = 0; i < n; ++i) {
4263
4263
    subpath = path->getSubpath(i);
4264
4264
    m = subpath->getNumPoints();
4265
 
    writePSFmt("{0:.4g} {1:.4g} m\n", subpath->getX(0), subpath->getY(0));
 
4265
    writePSFmt("{0:.6g} {1:.6g} m\n", subpath->getX(0), subpath->getY(0));
4266
4266
    j = 1;
4267
4267
    while (j < m) {
4268
4268
      if (subpath->getCurve(j)) {
4269
 
        writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g} c\n",
 
4269
        writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g} c\n",
4270
4270
                   subpath->getX(j), subpath->getY(j),
4271
4271
                   subpath->getX(j+1), subpath->getY(j+1),
4272
4272
                   subpath->getX(j+2), subpath->getY(j+2));
4273
4273
        j += 3;
4274
4274
      } else {
4275
 
        writePSFmt("{0:.4g} {1:.4g} l\n", subpath->getX(j), subpath->getY(j));
 
4275
        writePSFmt("{0:.6g} {1:.6g} l\n", subpath->getX(j), subpath->getY(j));
4276
4276
        ++j;
4277
4277
      }
4278
4278
    }
4387
4387
    writePSString(s2);
4388
4388
    if (font->isCIDFont()) {
4389
4389
      if (wMode) {
4390
 
        writePSFmt(" {0:d} {1:.4g} Tj16V\n", nChars, dy);
 
4390
        writePSFmt(" {0:d} {1:.6g} Tj16V\n", nChars, dy);
4391
4391
      } else {
4392
 
        writePSFmt(" {0:d} {1:.4g} Tj16\n", nChars, dx);
 
4392
        writePSFmt(" {0:d} {1:.6g} Tj16\n", nChars, dx);
4393
4393
      }
4394
4394
    } else {
4395
 
      writePSFmt(" {0:.4g} Tj\n", dx);
 
4395
      writePSFmt(" {0:.6g} Tj\n", dx);
4396
4396
    }
4397
4397
  }
4398
4398
  delete s2;
4418
4418
      if (state->getFillColorSpace()->getMode() != csPattern) {
4419
4419
        double cxMin, cyMin, cxMax, cyMax;
4420
4420
        state->getClipBBox(&cxMin, &cyMin, &cxMax, &cyMax);
4421
 
        writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re\n",
 
4421
        writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re\n",
4422
4422
                   cxMin, cyMin,
4423
4423
                   cxMax, cyMax);
4424
4424
        writePS("f*\n");
4866
4866
    //  make each rectangle path and clip.
4867
4867
    writePS("gsave newpath\n");
4868
4868
    for (i = 0; i < rectsOutLen; ++i) {
4869
 
      writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re\n",
 
4869
      writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re\n",
4870
4870
                 ((double)rectsOut[i].x0)/maskWidth,
4871
4871
                 ((double)rectsOut[i].y0)/maskHeight,
4872
4872
                 ((double)(rectsOut[i].x1 - rectsOut[i].x0))/maskWidth,
5048
5048
      //  make each rectangle path and clip.
5049
5049
      writePS("gsave newpath\n");
5050
5050
      for (i = 0; i < rectsOutLen; ++i) {
5051
 
        writePSFmt("{0:.4g} {1:.4g} {2:.4g} {3:.4g} re\n",
 
5051
        writePSFmt("{0:.6g} {1:.6g} {2:.6g} {3:.6g} re\n",
5052
5052
                   ((double)rectsOut[i].x0)/width,
5053
5053
                   ((double)rectsOut[i].y0)/height,
5054
5054
                   ((double)(rectsOut[i].x1 - rectsOut[i].x0))/width,
5989
5989
    obj1.arrayGet(1, &obj2);
5990
5990
    height = obj2.getNum();
5991
5991
    obj2.free();
5992
 
    writePSFmt("%%ImageDimensions: {0:.4g} {1:.4g}\n", width, height);
 
5992
    writePSFmt("%%ImageDimensions: {0:.6g} {1:.6g}\n", width, height);
5993
5993
  }
5994
5994
  obj1.free();
5995
5995
 
6007
6007
    obj1.arrayGet(3, &obj2);
6008
6008
    bottom = obj2.getNum();
6009
6009
    obj2.free();
6010
 
    writePSFmt("%%ImageCropRect: {0:.4g} {1:.4g} {2:.4g} {3:.4g}\n",
 
6010
    writePSFmt("%%ImageCropRect: {0:.6g} {1:.6g} {2:.6g} {3:.6g}\n",
6011
6011
               left, top, right, bottom);
6012
6012
  }
6013
6013
  obj1.free();
6032
6032
        if (obj3.isString() && obj4.isNum()) {
6033
6033
          writePS(" ");
6034
6034
          writePSString(obj3.getString());
6035
 
          writePSFmt(" {0:.4g}", obj4.getNum());
 
6035
          writePSFmt(" {0:.6g}", obj4.getNum());
6036
6036
        }
6037
6037
        obj3.free();
6038
6038
        obj4.free();
6061
6061
 
6062
6062
  dict->lookup("IncludedImageQuality", &obj1);
6063
6063
  if (obj1.isNum()) {
6064
 
    writePSFmt("%%IncludedImageQuality: {0:.4g}\n", obj1.getNum());
 
6064
    writePSFmt("%%IncludedImageQuality: {0:.6g}\n", obj1.getNum());
6065
6065
  }
6066
6066
  obj1.free();
6067
6067
 
6155
6155
    obj1.arrayGet(3, &obj2);
6156
6156
    lry = obj2.getNum();
6157
6157
    obj2.free();
6158
 
    writePSFmt("%ALDImageCropFixed: {0:.4g} {1:.4g} {2:.4g} {3:.4g}\n",
 
6158
    writePSFmt("%ALDImageCropFixed: {0:.6g} {1:.6g} {2:.6g} {3:.6g}\n",
6159
6159
               ulx, uly, lrx, lry);
6160
6160
  }
6161
6161
  obj1.free();
6232
6232
    opiTransform(state, ulx, uly, &tulx, &tuly);
6233
6233
    opiTransform(state, urx, ury, &turx, &tury);
6234
6234
    opiTransform(state, lrx, lry, &tlrx, &tlry);
6235
 
    writePSFmt("%ALDImagePosition: {0:.4g} {1:.4g} {2:.4g} {3:.4g} {4:.4g} {5:.4g} {6:.4g} {7:.4g}\n",
 
6235
    writePSFmt("%ALDImagePosition: {0:.6g} {1:.6g} {2:.6g} {3:.6g} {4:.6g} {5:.6g} {6:.6g} {7:.6g}\n",
6236
6236
               tllx, tlly, tulx, tuly, turx, tury, tlrx, tlry);
6237
6237
    obj2.free();
6238
6238
  }
6246
6246
    obj1.arrayGet(1, &obj2);
6247
6247
    vert = obj2.getNum();
6248
6248
    obj2.free();
6249
 
    writePSFmt("%ALDImageResoution: {0:.4g} {1:.4g}\n", horiz, vert);
 
6249
    writePSFmt("%ALDImageResoution: {0:.6g} {1:.6g}\n", horiz, vert);
6250
6250
    obj2.free();
6251
6251
  }
6252
6252
  obj1.free();
6268
6268
 
6269
6269
  dict->lookup("Tint", &obj1);
6270
6270
  if (obj1.isNum()) {
6271
 
    writePSFmt("%ALDImageTint: {0:.4g}\n", obj1.getNum());
 
6271
    writePSFmt("%ALDImageTint: {0:.6g}\n", obj1.getNum());
6272
6272
  }
6273
6273
  obj1.free();
6274
6274
 
6336
6336
#endif // OPI_SUPPORT
6337
6337
 
6338
6338
void PSOutputDev::type3D0(GfxState *state, double wx, double wy) {
6339
 
  writePSFmt("{0:.4g} {1:.4g} setcharwidth\n", wx, wy);
 
6339
  writePSFmt("{0:.6g} {1:.6g} setcharwidth\n", wx, wy);
6340
6340
  writePS("q\n");
6341
6341
  t3NeedsRestore = gTrue;
6342
6342
}
6401
6401
    }
6402
6402
    writePSFmt("/xpdfSamples{0:d} [\n", thisFunc);
6403
6403
    for (i = 0; i < nSamples; ++i) {
6404
 
      writePSFmt("{0:.4g}\n", func0->getSamples()[i]);
 
6404
      writePSFmt("{0:.6g}\n", func0->getSamples()[i]);
6405
6405
    }
6406
6406
    writePS("] def\n");
6407
6407
    writePSFmt("{{ {0:d} array {1:d} array {2:d} 2 roll\n", 2*m, m, m+2);
6408
6408
    // [e01] [efrac] x0 x1 ... xm-1
6409
6409
    for (i = m-1; i >= 0; --i) {
6410
6410
      // [e01] [efrac] x0 x1 ... xi
6411
 
      writePSFmt("{0:.4g} sub {1:.4g} mul {2:.4g} add\n",
 
6411
      writePSFmt("{0:.6g} sub {1:.6g} mul {2:.6g} add\n",
6412
6412
              func0->getDomainMin(i),
6413
6413
              (func0->getEncodeMax(i) - func0->getEncodeMin(i)) /
6414
6414
                (func0->getDomainMax(i) - func0->getDomainMin(i)),
6458
6458
        // [e01] [efrac] s'(0) s'(1) ... s(2^(m-j-1)-1)
6459
6459
      }
6460
6460
      // [e01] [efrac] y(0) ... y(i-1) s
6461
 
      writePSFmt("{0:.4g} mul {1:.4g} add\n",
 
6461
      writePSFmt("{0:.6g} mul {1:.6g} add\n",
6462
6462
                 func0->getDecodeMax(i) - func0->getDecodeMin(i),
6463
6463
                 func0->getDecodeMin(i));
6464
 
      writePSFmt("dup {0:.4g} lt {{ pop {1:.4g} }} {{ dup {2:.4g} gt {{ pop {3:.4g} }} if }} ifelse\n",
 
6464
      writePSFmt("dup {0:.6g} lt {{ pop {1:.6g} }} {{ dup {2:.6g} gt {{ pop {3:.6g} }} if }} ifelse\n",
6465
6465
                 func0->getRangeMin(i), func0->getRangeMin(i),
6466
6466
                 func0->getRangeMax(i), func0->getRangeMax(i));
6467
6467
      // [e01] [efrac] y(0) ... y(i-1) y(i)
6473
6473
  case 2:                       // exponential
6474
6474
    func2 = (ExponentialFunction *)func;
6475
6475
    n = func2->getOutputSize();
6476
 
    writePSFmt("{{ dup {0:.4g} lt {{ pop {1:.4g} }} {{ dup {2:.4g} gt {{ pop {3:.4g} }} if }} ifelse\n",
 
6476
    writePSFmt("{{ dup {0:.6g} lt {{ pop {1:.6g} }} {{ dup {2:.6g} gt {{ pop {3:.6g} }} if }} ifelse\n",
6477
6477
               func2->getDomainMin(0), func2->getDomainMin(0),
6478
6478
               func2->getDomainMax(0), func2->getDomainMax(0));
6479
6479
    // x
6480
6480
    for (i = 0; i < n; ++i) {
6481
6481
      // x y(0) .. y(i-1)
6482
 
      writePSFmt("{0:d} index {1:.4g} exp {2:.4g} mul {3:.4g} add\n",
 
6482
      writePSFmt("{0:d} index {1:.6g} exp {2:.6g} mul {3:.6g} add\n",
6483
6483
                 i, func2->getE(), func2->getC1()[i] - func2->getC0()[i],
6484
6484
                 func2->getC0()[i]);
6485
6485
      if (func2->getHasRange()) {
6486
 
        writePSFmt("dup {0:.4g} lt {{ pop {1:.4g} }} {{ dup {2:.4g} gt {{ pop {3:.4g} }} if }} ifelse\n",
 
6486
        writePSFmt("dup {0:.6g} lt {{ pop {1:.6g} }} {{ dup {2:.6g} gt {{ pop {3:.6g} }} if }} ifelse\n",
6487
6487
                   func2->getRangeMin(i), func2->getRangeMin(i),
6488
6488
                   func2->getRangeMax(i), func2->getRangeMax(i));
6489
6489
      }
6499
6499
      cvtFunction(func3->getFunc(i));
6500
6500
      writePSFmt("/xpdfFunc{0:d}_{1:d} exch def\n", thisFunc, i);
6501
6501
    }
6502
 
    writePSFmt("{{ dup {0:.4g} lt {{ pop {1:.4g} }} {{ dup {2:.4g} gt {{ pop {3:.4g} }} if }} ifelse\n",
 
6502
    writePSFmt("{{ dup {0:.6g} lt {{ pop {1:.6g} }} {{ dup {2:.6g} gt {{ pop {3:.6g} }} if }} ifelse\n",
6503
6503
               func3->getDomainMin(0), func3->getDomainMin(0),
6504
6504
               func3->getDomainMax(0), func3->getDomainMax(0));
6505
6505
    for (i = 0; i < func3->getNumFuncs() - 1; ++i) {
6506
 
      writePSFmt("dup {0:.4g} lt {{ {1:.4g} sub {2:.4g} mul {3:.4g} add xpdfFunc{4:d}_{5:d} }} {{\n",
 
6506
      writePSFmt("dup {0:.6g} lt {{ {1:.6g} sub {2:.6g} mul {3:.6g} add xpdfFunc{4:d}_{5:d} }} {{\n",
6507
6507
                 func3->getBounds()[i+1],
6508
6508
                 func3->getBounds()[i],
6509
6509
                 func3->getScale()[i],
6510
6510
                 func3->getEncode()[2*i],
6511
6511
                 thisFunc, i);
6512
6512
    }
6513
 
    writePSFmt("{0:.4g} sub {1:.4g} mul {2:.4g} add xpdfFunc{3:d}_{4:d}\n",
 
6513
    writePSFmt("{0:.6g} sub {1:.6g} mul {2:.6g} add xpdfFunc{3:d}_{4:d}\n",
6514
6514
               func3->getBounds()[i],
6515
6515
               func3->getScale()[i],
6516
6516
               func3->getEncode()[2*i],