/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef _PSPRINT_PRINTERGFX_HXX_
#define _PSPRINT_PRINTERGFX_HXX_
#include "vcl/helper.hxx"
#include "sallayout.hxx"
#include "osl/file.hxx"
#include "tools/gen.hxx"
#include <list>
#include <hash_map>
namespace psp {
// forwards
class JobData;
/*
* lightweight container to handle RGB values
*/
class PrinterColor
{
public:
enum ColorSpace { eInvalid, eRGB };
private:
sal_uInt8 mnRed;
sal_uInt8 mnGreen;
sal_uInt8 mnBlue;
ColorSpace meColorspace;
public:
PrinterColor () :
meColorspace(eInvalid)
{}
PrinterColor (sal_uInt16 nRed, sal_uInt16 nGreen,
sal_uInt16 nBlue) :
mnRed (nRed),
mnGreen (nGreen),
mnBlue (nBlue),
meColorspace (eRGB)
{}
PrinterColor (sal_uInt32 nRGB) :
mnRed ((nRGB & 0x00ff0000) >> 16),
mnGreen ((nRGB & 0x0000ff00) >> 8),
mnBlue ((nRGB & 0x000000ff) ),
meColorspace (eRGB)
{}
~PrinterColor ()
{}
sal_Bool Is () const
{ return meColorspace != eInvalid; }
ColorSpace GetColorSpace () const
{ return meColorspace; }
sal_uInt16 GetRed () const
{ return mnRed; }
sal_uInt16 GetGreen () const
{ return mnGreen; }
sal_uInt16 GetBlue () const
{ return mnBlue; }
sal_Bool operator== (const PrinterColor& aColor) const
{
return aColor.Is() && this->Is()
&& mnRed == aColor.mnRed
&& mnGreen == aColor.mnGreen
&& mnBlue == aColor.mnBlue;
}
sal_Bool operator!= (const PrinterColor& aColor) const
{ return ! (aColor==*this); }
PrinterColor& operator= (const PrinterColor& aColor)
{
meColorspace = aColor.meColorspace;
mnRed = aColor.mnRed;
mnGreen = aColor.mnGreen;
mnBlue = aColor.mnBlue;
return *this;
}
PrinterColor& operator= (sal_uInt32 nRGB)
{
meColorspace = eRGB;
mnBlue = (nRGB & 0x000000ff);
mnGreen = (nRGB & 0x0000ff00) >> 8;
mnRed = (nRGB & 0x00ff0000) >> 16;
return *this;
}
};
/*
* forward declarations
*/
class Font3;
class GlyphSet;
class PrinterJob;
class PrintFontManager;
class KernPair;
struct CharacterMetric;
/*
* Bitmap Interface, this has to be filled with your actual bitmap implementation
* sample implementations can be found in:
* psprint/workben/cui/pspdem.cxx
* vcl/unx/source/gdi/salgdi2.cxx
*/
class PrinterBmp
{
public:
virtual ~PrinterBmp () = 0;
virtual sal_uInt32 GetPaletteColor (sal_uInt32 nIdx) const = 0;
virtual sal_uInt32 GetPaletteEntryCount () const = 0;
virtual sal_uInt32 GetPixelRGB (sal_uInt32 nRow, sal_uInt32 nColumn) const = 0;
virtual sal_uInt8 GetPixelGray (sal_uInt32 nRow, sal_uInt32 nColumn) const = 0;
virtual sal_uInt8 GetPixelIdx (sal_uInt32 nRow, sal_uInt32 nColumn) const = 0;
virtual sal_uInt32 GetWidth () const = 0;
virtual sal_uInt32 GetHeight () const = 0;
virtual sal_uInt32 GetDepth () const = 0;
};
typedef enum {
InvalidType = 0,
TrueColorImage,
MonochromeImage,
PaletteImage,
GrayScaleImage
} ImageType;
/*
* printer raster operations
*/
struct GraphicsStatus
{
rtl::OString maFont;
rtl_TextEncoding maEncoding;
bool mbArtItalic;
bool mbArtBold;
sal_Int32 mnTextHeight;
sal_Int32 mnTextWidth;
PrinterColor maColor;
double mfLineWidth;
GraphicsStatus();
};
class Font3;
class PrinterGfx
{
private:
/* common settings */
double mfScaleX;
double mfScaleY;
sal_uInt32 mnDpi;
sal_uInt16 mnDepth;
sal_uInt16 mnPSLevel;
sal_Bool mbColor;
sal_Bool mbUploadPS42Fonts;
osl::File* mpPageHeader;
osl::File* mpPageBody;
void TranslateCoordinates (sal_Int32 &rXOut, sal_Int32 &rYOut,
sal_Int32 nXIn, sal_Int32 nYIn )
{ rXOut = nXIn; rYOut = nYIn; }
void TranslateCoordinates (Point& rOut, const Point& rIn)
{ rOut = rIn; }
/* text/font related data, for a type1 font it has to be checked
whether this font has already been downloaded. A TrueType font
will be converted into one or more Type3 fonts, containing glyphs
in no particular order. In addition to the existence of the
glyph in one of the subfonts, the mapping from unicode to the
glyph has to be remembered */
std::list< sal_Int32 > maPS1Font;
std::list< GlyphSet > maPS3Font;
sal_Int32 mnFontID;
sal_Int32 mnFallbackID;
sal_Int32 mnTextAngle;
bool mbTextVertical;
PrintFontManager& mrFontMgr;
/* bitmap drawing implementation */
sal_Bool mbCompressBmp;
void DrawPS1GrayImage (const PrinterBmp& rBitmap, const Rectangle& rArea);
void writePS2ImageHeader (const Rectangle& rArea, psp::ImageType nType);
void writePS2Colorspace (const PrinterBmp& rBitmap, psp::ImageType nType);
void DrawPS2GrayImage (const PrinterBmp& rBitmap, const Rectangle& rArea);
void DrawPS2PaletteImage (const PrinterBmp& rBitmap, const Rectangle& rArea);
void DrawPS2TrueColorImage (const PrinterBmp& rBitmap, const Rectangle& rArea);
void DrawPS2MonoImage (const PrinterBmp& rBitmap, const Rectangle& rArea);
/* clip region */
std::list< Rectangle > maClipRegion;
sal_Bool JoinVerticalClipRectangles( std::list< Rectangle >::iterator& it,
Point& aOldPoint, sal_Int32& nColumn );
/* color settings */
PrinterColor maFillColor;
PrinterColor maTextColor;
PrinterColor maLineColor;
/* graphics state */
GraphicsStatus maVirtualStatus;
std::list< GraphicsStatus > maGraphicsStack;
GraphicsStatus& currentState() { return maGraphicsStack.front(); }
/* font / font substitution */
friend class Font3;
const ::std::hash_map< fontID, fontID >* mpFontSubstitutes;
int getCharWidth (sal_Bool b_vert, sal_Unicode n_char,
CharacterMetric *p_bbox);
fontID getCharMetric (const Font3 &rFont, sal_Unicode n_char,
CharacterMetric *p_bbox);
fontID getFontSubstitute () const;
fontID getFallbackID () const { return mnFallbackID; }
bool mbStrictSO52Compatibility;
public:
/* grahics status update */
void PSSetColor ();
void PSSetLineWidth ();
void PSSetFont ();
/* graphics status functions */
void PSSetColor (const PrinterColor& rColor)
{ maVirtualStatus.maColor = rColor; }
void PSUploadPS1Font (sal_Int32 nFontID);
void PSSetFont (const rtl::OString& rName,
rtl_TextEncoding nEncoding = RTL_TEXTENCODING_DONTKNOW)
{ maVirtualStatus.maFont = rName; maVirtualStatus.maEncoding = nEncoding; }
/* graphics status stack */
void PSGSave ();
void PSGRestore ();
/* PS helpers */
enum pspath_t { moveto = 0, lineto = 1 };
void PSBinLineTo (const Point& rCurrent, Point& rOld,
sal_Int32& nColumn);
void PSBinMoveTo (const Point& rCurrent, Point& rOld,
sal_Int32& nColumn);
void PSBinStartPath ();
void PSBinEndPath ();
void PSBinCurrentPath (sal_uInt32 nPoints, const Point* pPath);
void PSBinPath (const Point& rCurrent, Point& rOld,
pspath_t eType, sal_Int32& nColumn);
void PSRotate (sal_Int32 nAngle);
void PSTranslate (const Point& rPoint);
void PSMoveTo (const Point& rPoint);
void PSRMoveTo (sal_Int32 nDx, sal_Int32 nDy = 0);
void PSScale (double fScaleX, double fScaleY);
void PSLineTo(const Point& rPoint );
void PSPointOp (const Point& rPoint, const sal_Char* pOperator);
void PSHexString (const sal_uChar* pString, sal_Int16 nLen);
void PSDeltaArray (const sal_Int32 *pArray, sal_Int16 nEntries);
void PSShowText (const sal_uChar* pString,
sal_Int16 nGlyphs, sal_Int16 nBytes,
const sal_Int32* pDeltaArray = NULL);
void PSComment (const sal_Char* pComment );
void LicenseWarning (const Point& rPoint, const sal_Unicode* pStr,
sal_Int16 nLen, const sal_Int32* pDeltaArray);
void OnEndPage ();
void OnEndJob ();
void writeResources( osl::File* pFile, std::list< rtl::OString >& rSuppliedFonts, std::list< rtl::OString >& rNeededFonts );
PrintFontManager& GetFontMgr () { return mrFontMgr; }
void drawVerticalizedText (const Point& rPoint,
const sal_Unicode* pStr,
sal_Int16 nLen,
const sal_Int32* pDeltaArray );
void drawText (const Point& rPoint,
const sal_Unicode* pStr, sal_Int16 nLen,
const sal_Int32* pDeltaArray = NULL);
void drawGlyphs( const Point& rPoint,
sal_GlyphId* pGlyphIds,
sal_Unicode* pUnicodes,
sal_Int16 nLen,
sal_Int32* pDeltaArray );
public:
PrinterGfx();
~PrinterGfx();
sal_Bool Init (PrinterJob &rPrinterSpec);
sal_Bool Init (const JobData& rData);
void Clear();
// query depth and size
void GetResolution (sal_Int32 &rDpiX, sal_Int32 &rDpiY) const;
sal_uInt16 GetBitCount ();
// clip region
void ResetClipRegion ();
void BeginSetClipRegion (sal_uInt32);
sal_Bool UnionClipRegion (sal_Int32 nX, sal_Int32 nY,
sal_Int32 nDX, sal_Int32 nDY);
void EndSetClipRegion ();
// set xy color
void SetLineColor (const PrinterColor& rLineColor = PrinterColor())
{ maLineColor = rLineColor; }
void SetFillColor (const PrinterColor& rFillColor = PrinterColor())
{ maFillColor = rFillColor; }
// drawing primitives
void DrawPixel (const Point& rPoint, const PrinterColor& rPixelColor);
void DrawPixel (const Point& rPoint)
{ DrawPixel (rPoint, maLineColor); }
void DrawLine (const Point& rFrom, const Point& rTo);
void DrawRect (const Rectangle& rRectangle);
void DrawPolyLine (sal_uInt32 nPoints, const Point* pPath );
void DrawPolygon (sal_uInt32 nPoints, const Point* pPath);
void DrawPolyPolygon (sal_uInt32 nPoly,
const sal_uInt32 *pPolygonSize,
const Point** pPolygonList);
void DrawPolyLineBezier (sal_uInt32 nPoints,
const Point* pPath,
const sal_uInt8* pFlgAry );
void DrawPolygonBezier (sal_uInt32 nPoints,
const Point* pPath,
const sal_uInt8* pFlgAry);
void DrawPolyPolygonBezier (sal_uInt32 nPoly,
const sal_uInt32* pPoints,
const Point* const* pPtAry,
const sal_uInt8* const* pFlgAry);
// eps
sal_Bool DrawEPS ( const Rectangle& rBoundingBox, void* pPtr, sal_uInt32 nSize);
// image drawing
void DrawBitmap (const Rectangle& rDest, const Rectangle& rSrc,
const PrinterBmp& rBitmap);
void DrawBitmap (const Rectangle& rDest, const Rectangle& rSrc,
const PrinterBmp& rBitmap,
const PrinterBmp& rTransBitmap);
void DrawMask (const Rectangle& rDest, const Rectangle& rSrc,
const PrinterBmp &rBitmap, PrinterColor& rMaskColor);
// font and text handling
sal_uInt16 SetFont (
sal_Int32 nFontID,
sal_Int32 nPointHeight,
sal_Int32 nPointWidth,
sal_Int32 nAngle,
bool bVertical,
bool bArtItalic,
bool bArtBold
);
sal_uInt16 SetFallbackFont ( sal_Int32 nFontID );
sal_Int32 GetFontAngle () const
{ return mnTextAngle; }
sal_Int32 GetFontID () const
{ return mnFontID; }
bool GetFontVertical() const
{ return mbTextVertical; }
sal_Int32 GetFontHeight () const
{ return maVirtualStatus.mnTextHeight; }
sal_Int32 GetFontWidth () const
{ return maVirtualStatus.mnTextWidth; }
bool GetArtificialItalic() const
{ return maVirtualStatus.mbArtItalic; }
bool GetArtificialBold() const
{ return maVirtualStatus.mbArtBold; }
void DrawText (const Point& rPoint,
const sal_Unicode* pStr, sal_Int16 nLen,
const sal_Int32* pDeltaArray = NULL);
void SetTextColor (PrinterColor& rTextColor)
{ maTextColor = rTextColor; }
sal_Int32 GetCharWidth (sal_uInt16 nFrom, sal_uInt16 nTo,
long *pWidthArray);
const ::std::list< KernPair >& getKernPairs( bool bVertical = false ) const;
// advanced font handling
sal_Bool GetGlyphBoundRect (sal_Unicode c, Rectangle& rOutRect);
sal_uInt32 GetGlyphOutline (sal_Unicode c,
sal_uInt16 **ppPolySizes, Point **ppPoints,
sal_uInt8 **ppFlags);
// for CTL
void DrawGlyphs( const Point& rPoint,
sal_GlyphId* pGlyphIds,
sal_Unicode* pUnicodes,
sal_Int16 nLen,
sal_Int32* pDeltaArray );
bool getStrictSO52Compatibility() const;
void setStrictSO52Compatibility( bool );
};
} /* namespace psp */
#endif /* _PSPRINT_PRINTERGFX_HXX_ */