/**************************************************************
*
* 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "sal/alloca.h"
#include "sal/types.h"
#include "rtl/tencinfo.h"
#include "osl/file.hxx"
#include "tools/string.hxx"
#include "tools/debug.hxx"
#include "tools/stream.hxx"
#include "basegfx/polygon/b2dpolypolygon.hxx"
#include "i18npool/mslangid.hxx"
#include <vcl/sysdata.hxx>
#include "printergfx.hxx"
#include "vcl/fontmanager.hxx"
#include "vcl/jobdata.hxx"
#include "vcl/printerinfomanager.hxx"
#include "vcl/svapp.hxx"
#include "unx/salunx.h"
#include "unx/saldata.hxx"
#include "unx/saldisp.hxx"
#include "unx/salgdi.h"
#include "unx/pspgraphics.h"
#include "unx/salvd.h"
#include "salcvt.hxx"
#include "gcach_xpeer.hxx"
#include "xrender_peer.hxx"
#include "impfont.hxx"
#include "salframe.hxx"
#include "outdev.h"
#include <hash_set>
#ifdef ENABLE_GRAPHITE
#include <graphite_layout.hxx>
#include <graphite_serverfont.hxx>
#endif
struct cairo_surface_t;
struct cairo_t;
struct cairo_font_face_t;
typedef void* FT_Face;
struct cairo_matrix_t {
double xx; double yx;
double xy; double yy;
double x0; double y0;
};
struct cairo_glyph_t
{
unsigned long index;
double x;
double y;
};
struct BOX
{
short x1, x2, y1, y2;
};
struct _XRegion
{
long size;
long numRects;
BOX *rects;
BOX extents;
};
using namespace rtl;
// ===========================================================================
// PspKernInfo allows on-demand-querying of psprint provided kerning info (#i29881#)
class PspKernInfo : public ExtraKernInfo
{
public:
PspKernInfo( int nFontId ) : ExtraKernInfo(nFontId) {}
protected:
virtual void Initialize() const;
};
//--------------------------------------------------------------------------
void PspKernInfo::Initialize() const
{
mbInitialized = true;
// get the kerning pairs from psprint
const psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
typedef std::list< psp::KernPair > PspKernPairs;
const PspKernPairs& rKernPairs = rMgr.getKernPairs( mnFontId );
if( rKernPairs.empty() )
return;
// feed psprint's kerning list into a lookup-friendly container
maUnicodeKernPairs.rehash( rKernPairs.size() );
PspKernPairs::const_iterator it = rKernPairs.begin();
for(; it != rKernPairs.end(); ++it )
{
ImplKernPairData aKernPair = { it->first, it->second, it->kern_x };
maUnicodeKernPairs.insert( aKernPair );
}
}
// ----------------------------------------------------------------------------
//
// X11SalGraphics
//
// ----------------------------------------------------------------------------
GC
X11SalGraphics::GetFontGC()
{
Display *pDisplay = GetXDisplay();
if( !pFontGC_ )
{
XGCValues values;
values.subwindow_mode = ClipByChildren;
values.fill_rule = EvenOddRule; // Pict import/ Gradient
values.graphics_exposures = False;
values.foreground = nTextPixel_;
pFontGC_ = XCreateGC( pDisplay, hDrawable_,
GCSubwindowMode | GCFillRule
| GCGraphicsExposures | GCForeground,
&values );
}
if( !bFontGC_ )
{
XSetForeground( pDisplay, pFontGC_, nTextPixel_ );
SetClipRegion( pFontGC_ );
bFontGC_ = sal_True;
}
return pFontGC_;
}
//--------------------------------------------------------------------------
bool X11SalGraphics::setFont( const ImplFontSelectData *pEntry, int nFallbackLevel )
{
#ifdef HDU_DEBUG
ByteString aReqName( "NULL" );
if( pEntry )
aReqName = ByteString( pEntry->maName, RTL_TEXTENCODING_UTF8 );
ByteString aUseName( "NULL" );
if( pEntry && pEntry->mpFontData )
aUseName = ByteString( pEntry->mpFontData->GetFamilyName(), RTL_TEXTENCODING_UTF8 );
fprintf( stderr, "SetFont(lvl=%d,\"%s\", %d*%d, naa=%d,b=%d,i=%d) => \"%s\"\n",
nFallbackLevel, aReqName.GetBuffer(),
!pEntry?-1:pEntry->mnWidth, !pEntry?-1:pEntry->mnHeight,
!pEntry?-1:pEntry->mbNonAntialiased,
!pEntry?-1:pEntry->meWeight, !pEntry?-1:pEntry->meItalic,
aUseName.GetBuffer() );
#endif
// release all no longer needed font resources
for( int i = nFallbackLevel; i < MAX_FALLBACK; ++i )
{
if( mpServerFont[i] != NULL )
{
// old server side font is no longer referenced
GlyphCache::GetInstance().UncacheFont( *mpServerFont[i] );
mpServerFont[i] = NULL;
}
}
// return early if there is no new font
if( !pEntry )
return false;
bFontVertical_ = pEntry->mbVertical;
// return early if this is not a valid font for this graphics
if( !pEntry->mpFontData )
return false;
// handle the request for a non-native X11-font => use the GlyphCache
ServerFont* pServerFont = GlyphCache::GetInstance().CacheFont( *pEntry );
if( pServerFont != NULL )
{
// ignore fonts with e.g. corrupted font files
if( !pServerFont->TestFont() )
{
GlyphCache::GetInstance().UncacheFont( *pServerFont );
return false;
}
// register to use the font
mpServerFont[ nFallbackLevel ] = pServerFont;
// apply font specific-hint settings if needed
// TODO: also disable it for reference devices
if( !bPrinter_ )
{
ImplServerFontEntry* pSFE = static_cast<ImplServerFontEntry*>( pEntry->mpFontEntry );
pSFE->HandleFontOptions();
}
return true;
}
return false;
}
void ImplServerFontEntry::HandleFontOptions( void )
{
bool GetFCFontOptions( const ImplFontAttributes&, int nSize, ImplFontOptions& );
if( !mpServerFont )
return;
if( !mbGotFontOptions )
{
// get and cache the font options
mbGotFontOptions = true;
mbValidFontOptions = GetFCFontOptions( *maFontSelData.mpFontData,
maFontSelData.mnHeight, maFontOptions );
}
// apply the font options
if( mbValidFontOptions )
mpServerFont->SetFontOptions( maFontOptions );
}
//--------------------------------------------------------------------------
namespace {
class CairoWrapper
{
private:
oslModule mpCairoLib;
cairo_surface_t* (*mp_xlib_surface_create_with_xrender_format)(Display *, Drawable , Screen *, XRenderPictFormat *, int , int );
void (*mp_surface_destroy)(cairo_surface_t *);
cairo_t* (*mp_create)(cairo_surface_t *);
void (*mp_destroy)(cairo_t*);
void (*mp_clip)(cairo_t*);
void (*mp_rectangle)(cairo_t*, double, double, double, double);
cairo_font_face_t * (*mp_ft_font_face_create_for_ft_face)(FT_Face, int);
void (*mp_set_font_face)(cairo_t *, cairo_font_face_t *);
void (*mp_font_face_destroy)(cairo_font_face_t *);
void (*mp_matrix_init_identity)(cairo_matrix_t *);
void (*mp_matrix_scale)(cairo_matrix_t *, double, double);
void (*mp_matrix_rotate)(cairo_matrix_t *, double);
void (*mp_set_font_matrix)(cairo_t *, const cairo_matrix_t *);
void (*mp_show_glyphs)(cairo_t *, const cairo_glyph_t *, int );
void (*mp_set_source_rgb)(cairo_t *, double , double , double );
void (*mp_set_font_options)(cairo_t *, const void *);
void (*mp_ft_font_options_substitute)(const void*, void*);
bool canEmbolden() const { return false; }
CairoWrapper();
public:
static CairoWrapper& get();
bool isValid() const { return (mpCairoLib != NULL); }
bool isCairoRenderable(const ServerFont& rFont);
cairo_surface_t* xlib_surface_create_with_xrender_format(Display *pDisplay, Drawable drawable, Screen *pScreen, XRenderPictFormat *pFormat, int width, int height)
{ return (*mp_xlib_surface_create_with_xrender_format)(pDisplay, drawable, pScreen, pFormat, width, height); }
void surface_destroy(cairo_surface_t *surface) { (*mp_surface_destroy)(surface); }
cairo_t* create(cairo_surface_t *surface) { return (*mp_create)(surface); }
void destroy(cairo_t *cr) { (*mp_destroy)(cr); }
void clip(cairo_t *cr) { (*mp_clip)(cr); }
void rectangle(cairo_t *cr, double x, double y, double width, double height)
{ (*mp_rectangle)(cr, x, y, width, height); }
cairo_font_face_t* ft_font_face_create_for_ft_face(FT_Face face, int load_flags)
{ return (*mp_ft_font_face_create_for_ft_face)(face, load_flags); }
void set_font_face(cairo_t *cr, cairo_font_face_t *font_face)
{ (*mp_set_font_face)(cr, font_face); }
void font_face_destroy(cairo_font_face_t *font_face)
{ (*mp_font_face_destroy)(font_face); }
void matrix_init_identity(cairo_matrix_t *matrix)
{ (*mp_matrix_init_identity)(matrix); }
void matrix_scale(cairo_matrix_t *matrix, double sx, double sy)
{ (*mp_matrix_scale)(matrix, sx, sy); }
void matrix_rotate(cairo_matrix_t *matrix, double radians)
{ (*mp_matrix_rotate)(matrix, radians); }
void set_font_matrix(cairo_t *cr, const cairo_matrix_t *matrix)
{ (*mp_set_font_matrix)(cr, matrix); }
void show_glyphs(cairo_t *cr, const cairo_glyph_t *glyphs, int no_glyphs)
{ (*mp_show_glyphs)(cr, glyphs, no_glyphs); }
void set_source_rgb(cairo_t *cr, double red, double green, double blue)
{ (*mp_set_source_rgb)(cr, red, green, blue); }
void set_font_options(cairo_t *cr, const void *options)
{ (*mp_set_font_options)(cr, options); }
void ft_font_options_substitute(const void *options, void *pattern)
{ (*mp_ft_font_options_substitute)(options, pattern); }
};
static CairoWrapper* pCairoInstance = NULL;
CairoWrapper& CairoWrapper::get()
{
if( ! pCairoInstance )
pCairoInstance = new CairoWrapper();
return *pCairoInstance;
}
CairoWrapper::CairoWrapper()
: mpCairoLib( NULL )
{
static const char* pDisableCairoText = getenv( "SAL_DISABLE_CAIROTEXT" );
if( pDisableCairoText && (pDisableCairoText[0] != '0') )
return;
int nDummy;
if( !XQueryExtension( GetX11SalData()->GetDisplay()->GetDisplay(), "RENDER", &nDummy, &nDummy, &nDummy ) )
return;
mpCairoLib = osl_loadAsciiModule( "libcairo.so.2", SAL_LOADMODULE_DEFAULT );
if( !mpCairoLib )
return;
#ifdef DEBUG
// check cairo version
int (*p_version)();
p_version = (int(*)()) osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_version" );
const int nVersion = p_version ? (*p_version)() : 0;
fprintf( stderr, "CAIRO version=%d\n", nVersion );
#endif
mp_xlib_surface_create_with_xrender_format = (cairo_surface_t* (*)(Display *, Drawable , Screen *, XRenderPictFormat *, int , int ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_xlib_surface_create_with_xrender_format" );
mp_surface_destroy = (void(*)(cairo_surface_t*))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_surface_destroy" );
mp_create = (cairo_t*(*)(cairo_surface_t*))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_create" );
mp_destroy = (void(*)(cairo_t*))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_destroy" );
mp_clip = (void(*)(cairo_t*))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_clip" );
mp_rectangle = (void(*)(cairo_t*, double, double, double, double))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_rectangle" );
mp_ft_font_face_create_for_ft_face = (cairo_font_face_t * (*)(FT_Face, int))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_ft_font_face_create_for_ft_face" );
mp_set_font_face = (void (*)(cairo_t *, cairo_font_face_t *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_font_face" );
mp_font_face_destroy = (void (*)(cairo_font_face_t *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_font_face_destroy" );
mp_matrix_init_identity = (void (*)(cairo_matrix_t *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_matrix_init_identity" );
mp_matrix_scale = (void (*)(cairo_matrix_t *, double, double))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_matrix_scale" );
mp_matrix_rotate = (void (*)(cairo_matrix_t *, double))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_matrix_rotate" );
mp_set_font_matrix = (void (*)(cairo_t *, const cairo_matrix_t *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_font_matrix" );
mp_show_glyphs = (void (*)(cairo_t *, const cairo_glyph_t *, int ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_show_glyphs" );
mp_set_source_rgb = (void (*)(cairo_t *, double , double , double ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_source_rgb" );
mp_set_font_options = (void (*)(cairo_t *, const void *options ))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_set_font_options" );
mp_ft_font_options_substitute = (void (*)(const void *, void *))
osl_getAsciiFunctionSymbol( mpCairoLib, "cairo_ft_font_options_substitute" );
if( !(
mp_xlib_surface_create_with_xrender_format &&
mp_surface_destroy &&
mp_create &&
mp_destroy &&
mp_clip &&
mp_rectangle &&
mp_ft_font_face_create_for_ft_face &&
mp_set_font_face &&
mp_font_face_destroy &&
mp_matrix_init_identity &&
mp_matrix_scale &&
mp_matrix_rotate &&
mp_set_font_matrix &&
mp_show_glyphs &&
mp_set_source_rgb &&
mp_set_font_options &&
mp_ft_font_options_substitute
) )
{
osl_unloadModule( mpCairoLib );
mpCairoLib = NULL;
#if OSL_DEBUG_LEVEL > 1
fprintf( stderr, "not all needed symbols were found\n" );
#endif
}
}
bool CairoWrapper::isCairoRenderable(const ServerFont& rFont)
{
return rFont.GetFtFace() && isValid() && rFont.GetAntialiasAdvice() &&
(rFont.NeedsArtificialBold() ? canEmbolden() : true);
}
} //namespace
CairoFontsCache::LRUFonts CairoFontsCache::maLRUFonts;
int CairoFontsCache::mnRefCount = 0;
CairoFontsCache::CairoFontsCache()
{
++mnRefCount;
}
CairoFontsCache::~CairoFontsCache()
{
--mnRefCount;
if (!mnRefCount && !maLRUFonts.empty())
{
CairoWrapper &rCairo = CairoWrapper::get();
LRUFonts::iterator aEnd = maLRUFonts.end();
for (LRUFonts::iterator aI = maLRUFonts.begin(); aI != aEnd; ++aI)
rCairo.font_face_destroy((cairo_font_face_t*)aI->first);
}
}
void CairoFontsCache::CacheFont(void *pFont, void* pId)
{
maLRUFonts.push_front( std::pair<void*, void *>(pFont, pId) );
if (maLRUFonts.size() > 8)
{
CairoWrapper &rCairo = CairoWrapper::get();
rCairo.font_face_destroy((cairo_font_face_t*)maLRUFonts.back().first);
maLRUFonts.pop_back();
}
}
void* CairoFontsCache::FindCachedFont(void *pId)
{
LRUFonts::iterator aEnd = maLRUFonts.end();
for (LRUFonts::iterator aI = maLRUFonts.begin(); aI != aEnd; ++aI)
if (aI->second == pId)
return aI->first;
return NULL;
}
void X11SalGraphics::DrawCairoAAFontString( const ServerFontLayout& rLayout )
{
std::vector<cairo_glyph_t> cairo_glyphs;
cairo_glyphs.reserve( 256 );
Point aPos;
sal_GlyphId aGlyphId;
for( int nStart = 0; rLayout.GetNextGlyphs( 1, &aGlyphId, aPos, nStart ); )
{
cairo_glyph_t aGlyph;
aGlyph.index = aGlyphId & GF_IDXMASK;
aGlyph.x = aPos.X();
aGlyph.y = aPos.Y();
cairo_glyphs.push_back(aGlyph);
}
if (cairo_glyphs.empty())
return;
// find a XRenderPictFormat compatible with the Drawable
XRenderPictFormat* pVisualFormat = static_cast<XRenderPictFormat*>(GetXRenderFormat());
if( !pVisualFormat )
{
Visual* pVisual = GetDisplay()->GetVisual( m_nScreen ).GetVisual();
pVisualFormat = XRenderPeer::GetInstance().FindVisualFormat( pVisual );
// cache the XRenderPictFormat
SetXRenderFormat( static_cast<void*>(pVisualFormat) );
}
DBG_ASSERT( pVisualFormat!=NULL, "no matching XRenderPictFormat for text" );
if( !pVisualFormat )
return;
CairoWrapper &rCairo = CairoWrapper::get();
Display* pDisplay = GetXDisplay();
cairo_surface_t *surface = rCairo.xlib_surface_create_with_xrender_format (pDisplay,
hDrawable_, ScreenOfDisplay(pDisplay, m_nScreen), pVisualFormat, SAL_MAX_INT16, SAL_MAX_INT16);
/*
* It might be ideal to cache surface and cairo context between calls and
* only destroy it when the drawable changes, but to do that we need to at
* least change the SalFrame etc impls to dtor the SalGraphics *before* the
* destruction of the windows they reference
*/
cairo_t *cr = rCairo.create(surface);
rCairo.surface_destroy(surface);
if (const void *pOptions = Application::GetSettings().GetStyleSettings().GetCairoFontOptions())
rCairo.set_font_options( cr, pOptions);
if( mpClipRegion && !XEmptyRegion( mpClipRegion ) )
{
for (long i = 0; i < mpClipRegion->numRects; ++i)
{
rCairo.rectangle(cr,
mpClipRegion->rects[i].x1,
mpClipRegion->rects[i].y1,
mpClipRegion->rects[i].x2 - mpClipRegion->rects[i].x1,
mpClipRegion->rects[i].y2 - mpClipRegion->rects[i].y1);
}
rCairo.clip(cr);
}
rCairo.set_source_rgb(cr,
SALCOLOR_RED(nTextColor_)/255.0,
SALCOLOR_GREEN(nTextColor_)/255.0,
SALCOLOR_BLUE(nTextColor_)/255.0);
ServerFont& rFont = rLayout.GetServerFont();
cairo_font_face_t* font_face = NULL;
void *pId = rFont.GetFtFace();
font_face = (cairo_font_face_t*)m_aCairoFontsCache.FindCachedFont(pId);
if (!font_face)
{
font_face = rCairo.ft_font_face_create_for_ft_face(pId, rFont.GetLoadFlags());
m_aCairoFontsCache.CacheFont(font_face, pId);
}
rCairo.set_font_face(cr, font_face);
cairo_matrix_t m;
const ImplFontSelectData& rFSD = rFont.GetFontSelData();
int nWidth = rFSD.mnWidth ? rFSD.mnWidth : rFSD.mnHeight;
rCairo.matrix_init_identity(&m);
if (rLayout.GetOrientation())
rCairo.matrix_rotate(&m, (3600 - rLayout.GetOrientation()) * M_PI / 1800.0);
rCairo.matrix_scale(&m, nWidth, rFSD.mnHeight);
if (rFont.NeedsArtificialItalic())
m.xy = -m.xx * 0x6000L / 0x10000L;
rCairo.set_font_matrix(cr, &m);
rCairo.show_glyphs(cr, &cairo_glyphs[0], cairo_glyphs.size());
rCairo.destroy(cr);
}
//--------------------------------------------------------------------------
void X11SalGraphics::DrawServerAAFontString( const ServerFontLayout& rLayout )
{
// get xrender target for this drawable
Picture aDstPic = GetXRenderPicture();
if( !aDstPic )
return;
// get a XRenderPicture for the font foreground
// TODO: move into own method
XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
XRenderPictFormat* pVisualFormat = (XRenderPictFormat*)GetXRenderFormat();
DBG_ASSERT( pVisualFormat, "we already have a render picture, but XRenderPictFormat==NULL???");
const int nVisualDepth = pVisualFormat->depth;
SalDisplay::RenderEntry& rEntry = GetDisplay()->GetRenderEntries( m_nScreen )[ nVisualDepth ];
if( !rEntry.m_aPicture )
{
// create and cache XRenderPicture for the font foreground
Display* pDisplay = GetXDisplay();
#ifdef DEBUG
int iDummy;
unsigned uDummy;
XLIB_Window wDummy;
unsigned int nDrawDepth;
::XGetGeometry( pDisplay, hDrawable_, &wDummy, &iDummy, &iDummy,
&uDummy, &uDummy, &uDummy, &nDrawDepth );
DBG_ASSERT( static_cast<unsigned>(nVisualDepth) == nDrawDepth, "depth messed up for XRender" );
#endif
rEntry.m_aPixmap = ::XCreatePixmap( pDisplay, hDrawable_, 1, 1, nVisualDepth );
XRenderPictureAttributes aAttr;
aAttr.repeat = true;
rEntry.m_aPicture = rRenderPeer.CreatePicture ( rEntry.m_aPixmap, pVisualFormat, CPRepeat, &aAttr );
}
// set font foreground color and opacity
XRenderColor aRenderColor = GetXRenderColor( nTextColor_ );
rRenderPeer.FillRectangle( PictOpSrc, rEntry.m_aPicture, &aRenderColor, 0, 0, 1, 1 );
// set clipping
// TODO: move into GetXRenderPicture()?
if( mpClipRegion && !XEmptyRegion( mpClipRegion ) )
rRenderPeer.SetPictureClipRegion( aDstPic, mpClipRegion );
ServerFont& rFont = rLayout.GetServerFont();
X11GlyphPeer& rGlyphPeer = X11GlyphCache::GetInstance().GetPeer();
GlyphSet aGlyphSet = rGlyphPeer.GetGlyphSet( rFont, m_nScreen );
Point aPos;
static const int MAXGLYPHS = 160;
sal_GlyphId aGlyphAry[ MAXGLYPHS ];
int nMaxGlyphs = rLayout.GetOrientation() ? 1 : MAXGLYPHS;
for( int nStart = 0;;)
{
int nGlyphs = rLayout.GetNextGlyphs( nMaxGlyphs, aGlyphAry, aPos, nStart );
if( !nGlyphs )
break;
// #i51924# avoid 32->16bit coordinate truncation problem in X11
// TODO: reevaluate once displays with >30000 pixels are available
if( aPos.X() >= 30000 || aPos.Y() >= 30000 )
continue;
unsigned int aRenderAry[ MAXGLYPHS ];
for( int i = 0; i < nGlyphs; ++i )
aRenderAry[ i ] = rGlyphPeer.GetXRGlyph( rFont, aGlyphAry[i] );
rRenderPeer.CompositeString32( rEntry.m_aPicture, aDstPic,
aGlyphSet, aPos.X(), aPos.Y(), aRenderAry, nGlyphs );
}
}
//--------------------------------------------------------------------------
bool X11SalGraphics::DrawServerAAForcedString( const ServerFontLayout& rLayout )
{
ServerFont& rFont = rLayout.GetServerFont();
// prepare glyphs and get extent of operation
X11GlyphPeer& rGlyphPeer = X11GlyphCache::GetInstance().GetPeer();
int nXmin = 0;
int nXmax = 0;
int nYmin = 0;
int nYmax = 0;
int nStart = 0;
Point aPos;
sal_GlyphId nGlyph;
for( bool bFirst=true; rLayout.GetNextGlyphs( 1, &nGlyph, aPos, nStart ); )
{
const RawBitmap* const pRawBitmap = rGlyphPeer.GetRawBitmap( rFont, nGlyph );
if( !pRawBitmap )
continue;
const int nX1 = aPos.X() + pRawBitmap->mnXOffset;
const int nY1 = aPos.Y() + pRawBitmap->mnYOffset;
const int nX2 = nX1 + pRawBitmap->mnWidth;
const int nY2 = nY1 + pRawBitmap->mnHeight;
if( bFirst )
{
bFirst = false;
nXmin = nX1;
nXmax = nX2;
nYmin = nY1;
nYmax = nY2;
}
else
{
if( nXmin > nX1 ) nXmin = nX1;
if( nXmax < nX2 ) nXmax = nX2;
if( nYmin > nY1 ) nYmin = nY1;
if( nYmax < nY2 ) nYmax = nY2;
}
}
// get XImage
GetDisplay()->GetXLib()->PushXErrorLevel( true );
Display* pDisplay = GetXDisplay();
XRectangle aXRect;
long nWidth = 1, nHeight = 1;
if( m_pFrame )
nWidth = m_pFrame->maGeometry.nWidth, nHeight = m_pFrame->maGeometry.nHeight;
else if( m_pVDev )
nWidth = m_pVDev->GetWidth(), nHeight = m_pVDev->GetHeight();
if( mpClipRegion && !XEmptyRegion( mpClipRegion ) )
{
// get bounding box
XClipBox( mpClipRegion, &aXRect );
// clip with window
if( aXRect.x < 0 ) aXRect.x = 0;
if( aXRect.y < 0 ) aXRect.y = 0;
if( aXRect.width+aXRect.x > nWidth ) aXRect.width = nWidth-aXRect.x;
if( aXRect.height+aXRect.y > nHeight ) aXRect.height = nHeight-aXRect.y;
}
else
{
aXRect.x = 0;
aXRect.y = 0;
aXRect.width = nWidth;
aXRect.height = nHeight;
}
if( m_pFrame )
{
// clip with screen
int nScreenX = m_pFrame->maGeometry.nX+aXRect.x;
int nScreenY = m_pFrame->maGeometry.nY+aXRect.y;
const Size& rScreenSize = GetDisplay()->getDataForScreen( m_nScreen ).m_aSize;
int nScreenW = rScreenSize.Width();
int nScreenH = rScreenSize.Height();
if( nScreenX < 0 )
aXRect.x -= nScreenX, aXRect.width += nScreenX;
if( nScreenX+aXRect.width > nScreenW )
aXRect.width = nScreenW-nScreenX;
if( nScreenY < 0 )
aXRect.y -= nScreenY, aXRect.height += nScreenY;
if( nScreenY+aXRect.height > nScreenH )
aXRect.height = nScreenH-nScreenY;
}
if( nXmin < aXRect.x ) nXmin = aXRect.x;
if( nYmin < aXRect.y ) nYmin = aXRect.y;
if( nXmax >= aXRect.x+aXRect.width ) nXmax = aXRect.x + aXRect.width - 1;
if( nYmax >= aXRect.y+aXRect.height ) nYmax = aXRect.y + aXRect.height - 1;
if( nXmin > nXmax )
return false;
if( nYmin > nYmax )
return false;
XImage* pImg = XGetImage( pDisplay, hDrawable_,
nXmin, nYmin,
(nXmax-nXmin+1), (nYmax-nYmin+1),
~0, ZPixmap );
if( pImg == NULL )
{
if( m_pFrame )
{
// the reason we did not get an image could be that the frame
// geometry changed in the meantime; lets get the current geometry
// and clip against the current window size as well as the screen
// with the current frame position
const Size& rScreenSize = GetDisplay()->getDataForScreen(m_nScreen).m_aSize;
int nScreenW = rScreenSize.Width();
int nScreenH = rScreenSize.Height();
XLIB_Window aRoot = None;
int x = 0, y = 0;
unsigned int w = 0, h = 0, bw = 0, d;
XGetGeometry( pDisplay, hDrawable_, &aRoot, &x, &y, &w, &h, &bw, &d );
XTranslateCoordinates( pDisplay, hDrawable_, aRoot, 0, 0, &x, &y, &aRoot );
if( nXmin + x < 0 ) // clip on left screen edge
nXmin += x-nXmin;
if( nYmin + y < 0 ) // clip on top screen edge
nYmin += y-nYmin;
if( nXmax >= int(w) ) // clip on right window egde
nXmax = w-1;
if( nYmax >= int(h) ) // clip on bottom window edge
nYmax = h-1;
if( nXmax + x >= nScreenW ) // clip on right screen edge
nXmax -= (nXmax + x - nScreenW)+1;
if( nYmax + y >= nScreenH ) // clip on bottom screen edge
nYmax -= (nYmax + y - nScreenH)+1;
if( nXmax >= nXmin && nYmax >= nYmin )
{
// try again to get the image
pImg = XGetImage( pDisplay, hDrawable_,
nXmin, nYmin,
(nXmax-nXmin+1), (nYmax-nYmin+1),
~0, ZPixmap );
}
}
if( pImg == NULL )
{
GetDisplay()->GetXLib()->PopXErrorLevel();
return false;
}
}
// prepare context
GC nGC = GetFontGC();
XGCValues aGCVal;
XGetGCValues( pDisplay, nGC, GCForeground, &aGCVal );
unsigned long nOrigColor = XGetPixel( pImg, 0, 0 );
XPutPixel( pImg, 0, 0, aGCVal.foreground );
unsigned char aColor[4];
aColor[0] = pImg->data[0];
aColor[1] = pImg->data[1];
aColor[2] = pImg->data[2];
aColor[3] = pImg->data[3];
XPutPixel( pImg, 0, 0, nOrigColor );
// work on XImage
const int bpp = pImg->bits_per_pixel >> 3;
for( nStart = 0; rLayout.GetNextGlyphs( 1, &nGlyph, aPos, nStart ); )
{
const RawBitmap* const pRawBitmap = rGlyphPeer.GetRawBitmap( rFont, nGlyph );
if( !pRawBitmap )
continue;
const int nX1 = aPos.X() + pRawBitmap->mnXOffset;
const int nY1 = aPos.Y() + pRawBitmap->mnYOffset;
if( (nX1 <= nXmax) && (int(nX1 + pRawBitmap->mnWidth) > nXmin)
&& (nY1 <= nYmax) && (int(nY1 + pRawBitmap->mnHeight) > nYmin) )
{
const unsigned char* p10 = pRawBitmap->mpBits;
unsigned char* p20 = (unsigned char*)pImg->data; // dest left limit
p20 += (nY1 - nYmin) * pImg->bytes_per_line;
unsigned char* p21 = p20 + (nX1 - nXmin + pImg->xoffset) * bpp;
int y = pRawBitmap->mnHeight;
if( y > nYmax - nY1 )
y = nYmax - nY1 + 1;
while( --y >= 0 )
{
if( p20 >= (unsigned char*)pImg->data )
{
unsigned char* const p22 = p20 + pImg->width * bpp; // dest right limit
unsigned char* pDst = p21;
const unsigned char* pSrc = p10;
for( int x = pRawBitmap->mnWidth; (--x >= 0) && (p22 > pDst); ++pSrc )
{
if( (*pSrc == 0) || (p20 > pDst) ) // keep background
pDst += bpp;
else if( *pSrc == 0xFF ) // paint foreground
{
const unsigned char* pColor = aColor;
for( int z = bpp; --z >= 0; ++pColor, ++pDst )
*pDst = *pColor;
}
else // blend fg into bg
{
const unsigned char* pColor = aColor;
for( int z = bpp; --z >= 0; ++pColor, ++pDst )
// theoretically it should be *257) >> 16
// but the error is <0.4% worst case and we are in
// the innermost loop of very perf-sensitive code
*pDst += (*pSrc * ((int)*pColor - *pDst)) >> 8;
}
}
}
p10 += pRawBitmap->mnScanlineSize;
p20 += pImg->bytes_per_line;
p21 += pImg->bytes_per_line;
}
}
}
// put XImage
XPutImage( pDisplay, hDrawable_, nGC, pImg,
0, 0, nXmin, nYmin, (nXmax - nXmin + 1), (nYmax - nYmin + 1) );
XDestroyImage( pImg );
GetDisplay()->GetXLib()->PopXErrorLevel();
return true;
}
//--------------------------------------------------------------------------
void X11SalGraphics::DrawServerSimpleFontString( const ServerFontLayout& rSalLayout )
{
ServerFont& rFont = rSalLayout.GetServerFont();
X11GlyphPeer& rGlyphPeer = X11GlyphCache::GetInstance().GetPeer();
Display* pDisplay = GetXDisplay();
GC nGC = GetFontGC();
XGCValues aGCVal;
aGCVal.fill_style = FillStippled;
aGCVal.line_width = 0;
GC tmpGC = XCreateGC( pDisplay, hDrawable_, GCFillStyle|GCLineWidth, &aGCVal );
XCopyGC( pDisplay, nGC, (1<<GCLastBit)-(1+GCFillStyle+GCLineWidth), tmpGC );
Point aPos;
sal_GlyphId nGlyph;
for( int nStart = 0; rSalLayout.GetNextGlyphs( 1, &nGlyph, aPos, nStart ); )
{
// #i51924# avoid 32->16bit coordinate truncation problem in X11
// TODO: reevaluate once displays with >30000 pixels are available
if( aPos.X() >= 30000 || aPos.Y() >= 30000 )
continue;
Pixmap aStipple = rGlyphPeer.GetPixmap( rFont, nGlyph, m_nScreen );
const GlyphMetric& rGM = rFont.GetGlyphMetric( nGlyph );
if( aStipple != None )
{
const int nDestX = aPos.X() + rGM.GetOffset().X();
const int nDestY = aPos.Y() + rGM.GetOffset().Y();
aGCVal.stipple = aStipple;
aGCVal.ts_x_origin = nDestX;
aGCVal.ts_y_origin = nDestY;
XChangeGC( pDisplay, tmpGC, GCStipple|GCTileStipXOrigin|GCTileStipYOrigin, &aGCVal );
const int nWidth = rGM.GetSize().Width();
const int nHeight = rGM.GetSize().Height();
XFillRectangle( pDisplay, hDrawable_, tmpGC, nDestX, nDestY, nWidth, nHeight );
}
}
XFreeGC( pDisplay, tmpGC );
}
//--------------------------------------------------------------------------
void X11SalGraphics::DrawServerFontLayout( const ServerFontLayout& rLayout )
{
// draw complex text
ServerFont& rFont = rLayout.GetServerFont();
const bool bVertical = rFont.GetFontSelData().mbVertical;
if( !bVertical && CairoWrapper::get().isCairoRenderable(rFont) )
DrawCairoAAFontString( rLayout );
else
{
X11GlyphPeer& rGlyphPeer = X11GlyphCache::GetInstance().GetPeer();
if( rGlyphPeer.GetGlyphSet( rFont, m_nScreen ) )
DrawServerAAFontString( rLayout );
else if( !rGlyphPeer.ForcedAntialiasing( rFont, m_nScreen ) )
DrawServerSimpleFontString( rLayout );
else
DrawServerAAForcedString( rLayout );
}
}
//--------------------------------------------------------------------------
const ImplFontCharMap* X11SalGraphics::GetImplFontCharMap() const
{
if( !mpServerFont[0] )
return NULL;
const ImplFontCharMap* pIFCMap = mpServerFont[0]->GetImplFontCharMap();
return pIFCMap;
}
// ----------------------------------------------------------------------------
//
// SalGraphics
//
// ----------------------------------------------------------------------------
sal_uInt16 X11SalGraphics::SetFont( ImplFontSelectData *pEntry, int nFallbackLevel )
{
sal_uInt16 nRetVal = 0;
if( !setFont( pEntry, nFallbackLevel ) )
nRetVal |= SAL_SETFONT_BADFONT;
if( bPrinter_ || (mpServerFont[ nFallbackLevel ] != NULL) )
nRetVal |= SAL_SETFONT_USEDRAWTEXTARRAY;
return nRetVal;
}
// ----------------------------------------------------------------------------
void
X11SalGraphics::SetTextColor( SalColor nSalColor )
{
if( nTextColor_ != nSalColor )
{
nTextColor_ = nSalColor;
nTextPixel_ = GetPixel( nSalColor );
bFontGC_ = sal_False;
}
}
// ----------------------------------------------------------------------------
bool X11SalGraphics::AddTempDevFont( ImplDevFontList* pFontList,
const String& rFileURL, const String& rFontName )
{
// inform PSP font manager
rtl::OUString aUSystemPath;
OSL_VERIFY( !osl::FileBase::getSystemPathFromFileURL( rFileURL, aUSystemPath ) );
rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
OString aOFileName( OUStringToOString( aUSystemPath, aEncoding ) );
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
int nFontId = rMgr.addFontFile( aOFileName, 0 );
if( !nFontId )
return false;
// prepare font data
psp::FastPrintFontInfo aInfo;
rMgr.getFontFastInfo( nFontId, aInfo );
aInfo.m_aFamilyName = rFontName;
// inform glyph cache of new font
ImplDevFontAttributes aDFA = PspGraphics::Info2DevFontAttributes( aInfo );
aDFA.mnQuality += 5800;
int nFaceNum = rMgr.getFontFaceNumber( aInfo.m_nID );
if( nFaceNum < 0 )
nFaceNum = 0;
GlyphCache& rGC = X11GlyphCache::GetInstance();
const rtl::OString& rFileName = rMgr.getFontFileSysPath( aInfo.m_nID );
rGC.AddFontFile( rFileName, nFaceNum, aInfo.m_nID, aDFA );
// announce new font to device's font list
rGC.AnnounceFonts( pFontList );
return true;
}
// ----------------------------------------------------------------------------
void RegisterFontSubstitutors( ImplDevFontList* );
void X11SalGraphics::GetDevFontList( ImplDevFontList *pList )
{
// prepare the GlyphCache using psprint's font infos
X11GlyphCache& rGC = X11GlyphCache::GetInstance();
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
::std::list< psp::fontID > aList;
::std::list< psp::fontID >::iterator it;
psp::FastPrintFontInfo aInfo;
rMgr.getFontList( aList );
for( it = aList.begin(); it != aList.end(); ++it )
{
if( !rMgr.getFontFastInfo( *it, aInfo ) )
continue;
// the GlyphCache must not bother with builtin fonts because
// it cannot access or use them anyway
if( aInfo.m_eType == psp::fonttype::Builtin )
continue;
// normalize face number to the GlyphCache
int nFaceNum = rMgr.getFontFaceNumber( aInfo.m_nID );
if( nFaceNum < 0 )
nFaceNum = 0;
// for fonts where extra kerning info can be provided on demand
// an ExtraKernInfo object is supplied
const ExtraKernInfo* pExtraKernInfo = NULL;
if( aInfo.m_eType == psp::fonttype::Type1 )
pExtraKernInfo = new PspKernInfo( *it );
// inform GlyphCache about this font provided by the PsPrint subsystem
ImplDevFontAttributes aDFA = PspGraphics::Info2DevFontAttributes( aInfo );
aDFA.mnQuality += 4096;
const rtl::OString& rFileName = rMgr.getFontFileSysPath( aInfo.m_nID );
rGC.AddFontFile( rFileName, nFaceNum, aInfo.m_nID, aDFA, pExtraKernInfo );
}
// announce glyphcache fonts
rGC.AnnounceFonts( pList );
// register platform specific font substitutions if available
if( rMgr.hasFontconfig() )
RegisterFontSubstitutors( pList );
ImplGetSVData()->maGDIData.mbNativeFontConfig = rMgr.hasFontconfig();
}
// ----------------------------------------------------------------------------
void X11SalGraphics::GetDevFontSubstList( OutputDevice* )
{
// no device specific font substitutions on X11 needed
}
// ----------------------------------------------------------------------------
void cairosubcallback( void* pPattern )
{
CairoWrapper& rCairo = CairoWrapper::get();
if( !rCairo.isValid() )
return;
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
const void* pFontOptions = rStyleSettings.GetCairoFontOptions();
if( !pFontOptions )
return;
rCairo.ft_font_options_substitute( pFontOptions, pPattern );
}
bool GetFCFontOptions( const ImplFontAttributes& rFontAttributes, int nSize,
ImplFontOptions& rFontOptions)
{
// TODO: get rid of these insane enum-conversions
// e.g. by using the classic vclenum values inside VCL
psp::FastPrintFontInfo aInfo;
// set family name
aInfo.m_aFamilyName = rFontAttributes.GetFamilyName();
// set italic
switch( rFontAttributes.GetSlant() )
{
case ITALIC_NONE:
aInfo.m_eItalic = psp::italic::Upright;
break;
case ITALIC_NORMAL:
aInfo.m_eItalic = psp::italic::Italic;
break;
case ITALIC_OBLIQUE:
aInfo.m_eItalic = psp::italic::Oblique;
break;
default:
aInfo.m_eItalic = psp::italic::Unknown;
break;
}
// set weight
switch( rFontAttributes.GetWeight() )
{
case WEIGHT_THIN:
aInfo.m_eWeight = psp::weight::Thin;
break;
case WEIGHT_ULTRALIGHT:
aInfo.m_eWeight = psp::weight::UltraLight;
break;
case WEIGHT_LIGHT:
aInfo.m_eWeight = psp::weight::Light;
break;
case WEIGHT_SEMILIGHT:
aInfo.m_eWeight = psp::weight::SemiLight;
break;
case WEIGHT_NORMAL:
aInfo.m_eWeight = psp::weight::Normal;
break;
case WEIGHT_MEDIUM:
aInfo.m_eWeight = psp::weight::Medium;
break;
case WEIGHT_SEMIBOLD:
aInfo.m_eWeight = psp::weight::SemiBold;
break;
case WEIGHT_BOLD:
aInfo.m_eWeight = psp::weight::Bold;
break;
case WEIGHT_ULTRABOLD:
aInfo.m_eWeight = psp::weight::UltraBold;
break;
case WEIGHT_BLACK:
aInfo.m_eWeight = psp::weight::Black;
break;
default:
aInfo.m_eWeight = psp::weight::Unknown;
break;
}
// set width
switch( rFontAttributes.GetWidthType() )
{
case WIDTH_ULTRA_CONDENSED:
aInfo.m_eWidth = psp::width::UltraCondensed;
break;
case WIDTH_EXTRA_CONDENSED:
aInfo.m_eWidth = psp::width::ExtraCondensed;
break;
case WIDTH_CONDENSED:
aInfo.m_eWidth = psp::width::Condensed;
break;
case WIDTH_SEMI_CONDENSED:
aInfo.m_eWidth = psp::width::SemiCondensed;
break;
case WIDTH_NORMAL:
aInfo.m_eWidth = psp::width::Normal;
break;
case WIDTH_SEMI_EXPANDED:
aInfo.m_eWidth = psp::width::SemiExpanded;
break;
case WIDTH_EXPANDED:
aInfo.m_eWidth = psp::width::Expanded;
break;
case WIDTH_EXTRA_EXPANDED:
aInfo.m_eWidth = psp::width::ExtraExpanded;
break;
case WIDTH_ULTRA_EXPANDED:
aInfo.m_eWidth = psp::width::UltraExpanded;
break;
default:
aInfo.m_eWidth = psp::width::Unknown;
break;
}
const psp::PrintFontManager& rPFM = psp::PrintFontManager::get();
bool bOK = rPFM.getFontOptions( aInfo, nSize, cairosubcallback, rFontOptions);
return bOK;
}
// ----------------------------------------------------------------------------
void
X11SalGraphics::GetFontMetric( ImplFontMetricData *pMetric, int nFallbackLevel )
{
if( nFallbackLevel >= MAX_FALLBACK )
return;
if( mpServerFont[nFallbackLevel] != NULL )
{
long rDummyFactor;
mpServerFont[nFallbackLevel]->FetchFontMetric( *pMetric, rDummyFactor );
}
}
// ---------------------------------------------------------------------------
sal_uLong
X11SalGraphics::GetKernPairs( sal_uLong nPairs, ImplKernPairData *pKernPairs )
{
if( ! bPrinter_ )
{
if( mpServerFont[0] != NULL )
{
ImplKernPairData* pTmpKernPairs;
sal_uLong nGotPairs = mpServerFont[0]->GetKernPairs( &pTmpKernPairs );
for( unsigned int i = 0; i < nPairs && i < nGotPairs; ++i )
pKernPairs[ i ] = pTmpKernPairs[ i ];
delete[] pTmpKernPairs;
return nGotPairs;
}
}
return 0;
}
// ---------------------------------------------------------------------------
bool X11SalGraphics::GetGlyphBoundRect( sal_GlyphId aGlyphId, Rectangle& rRect )
{
const int nLevel = aGlyphId >> GF_FONTSHIFT;
if( nLevel >= MAX_FALLBACK )
return false;
ServerFont* pSF = mpServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= ~GF_FONTMASK;
const GlyphMetric& rGM = pSF->GetGlyphMetric( aGlyphId );
rRect = Rectangle( rGM.GetOffset(), rGM.GetSize() );
return true;
}
// ---------------------------------------------------------------------------
bool X11SalGraphics::GetGlyphOutline( sal_GlyphId aGlyphId,
::basegfx::B2DPolyPolygon& rPolyPoly )
{
const int nLevel = aGlyphId >> GF_FONTSHIFT;
if( nLevel >= MAX_FALLBACK )
return false;
ServerFont* pSF = mpServerFont[ nLevel ];
if( !pSF )
return false;
aGlyphId &= ~GF_FONTMASK;
bool bOK = pSF->GetGlyphOutline( aGlyphId, rPolyPoly );
return bOK;
}
//--------------------------------------------------------------------------
SalLayout* X11SalGraphics::GetTextLayout( ImplLayoutArgs& rArgs, int nFallbackLevel )
{
SalLayout* pLayout = NULL;
if( mpServerFont[ nFallbackLevel ]
&& !(rArgs.mnFlags & SAL_LAYOUT_DISABLE_GLYPH_PROCESSING) )
{
#ifdef ENABLE_GRAPHITE
// Is this a Graphite font?
if (!bDisableGraphite_ &&
GraphiteFontAdaptor::IsGraphiteEnabledFont(*mpServerFont[nFallbackLevel]))
{
sal_Int32 xdpi, ydpi;
xdpi = GetDisplay()->GetResolution().A();
ydpi = GetDisplay()->GetResolution().B();
GraphiteFontAdaptor * pGrfont = new GraphiteFontAdaptor( *mpServerFont[nFallbackLevel], xdpi, ydpi);
if (!pGrfont) return NULL;
pLayout = new GraphiteServerFontLayout(pGrfont);
}
else
#endif
pLayout = new ServerFontLayout( *mpServerFont[ nFallbackLevel ] );
}
return pLayout;
}
//--------------------------------------------------------------------------
SystemFontData X11SalGraphics::GetSysFontData( int nFallbacklevel ) const
{
SystemFontData aSysFontData;
aSysFontData.nSize = sizeof( SystemFontData );
aSysFontData.nFontId = 0;
if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
if (nFallbacklevel < 0 ) nFallbacklevel = 0;
if (mpServerFont[nFallbacklevel] != NULL)
{
ServerFont* rFont = mpServerFont[nFallbacklevel];
aSysFontData.nFontId = rFont->GetFtFace();
aSysFontData.nFontFlags = rFont->GetLoadFlags();
aSysFontData.bFakeBold = rFont->NeedsArtificialBold();
aSysFontData.bFakeItalic = rFont->NeedsArtificialItalic();
aSysFontData.bAntialias = rFont->GetAntialiasAdvice();
aSysFontData.bVerticalCharacterType = rFont->GetFontSelData().mbVertical;
}
return aSysFontData;
}
//--------------------------------------------------------------------------
sal_Bool X11SalGraphics::CreateFontSubset(
const rtl::OUString& rToFile,
const ImplFontData* pFont,
sal_GlyphId* pGlyphIds,
sal_uInt8* pEncoding,
sal_Int32* pWidths,
int nGlyphCount,
FontSubsetInfo& rInfo
)
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the ImplFontData pFont
psp::fontID aFont = pFont->GetFontId();
psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
bool bSuccess = rMgr.createFontSubset( rInfo,
aFont,
rToFile,
pGlyphIds,
pEncoding,
pWidths,
nGlyphCount );
return bSuccess;
}
//--------------------------------------------------------------------------
const void* X11SalGraphics::GetEmbedFontData( const ImplFontData* pFont, const sal_Ucs* pUnicodes, sal_Int32* pWidths, FontSubsetInfo& rInfo, long* pDataLen )
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the ImplFontData pFont
psp::fontID aFont = pFont->GetFontId();
return PspGraphics::DoGetEmbedFontData( aFont, pUnicodes, pWidths, rInfo, pDataLen );
}
//--------------------------------------------------------------------------
void X11SalGraphics::FreeEmbedFontData( const void* pData, long nLen )
{
PspGraphics::DoFreeEmbedFontData( pData, nLen );
}
//--------------------------------------------------------------------------
const Ucs2SIntMap* X11SalGraphics::GetFontEncodingVector( const ImplFontData* pFont, const Ucs2OStrMap** pNonEncoded )
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the ImplFontData pFont
psp::fontID aFont = pFont->GetFontId();
return PspGraphics::DoGetFontEncodingVector( aFont, pNonEncoded );
}
//--------------------------------------------------------------------------
void X11SalGraphics::GetGlyphWidths( const ImplFontData* pFont,
bool bVertical,
Int32Vector& rWidths,
Ucs2UIntMap& rUnicodeEnc )
{
// in this context the pFont->GetFontId() is a valid PSP
// font since they are the only ones left after the PDF
// export has filtered its list of subsettable fonts (for
// which this method was created). The correct way would
// be to have the GlyphCache search for the ImplFontData pFont
psp::fontID aFont = pFont->GetFontId();
PspGraphics::DoGetGlyphWidths( aFont, bVertical, rWidths, rUnicodeEnc );
}
// ===========================================================================
// platform specific font substitution hooks
class FcPreMatchSubstititution
: public ImplPreMatchFontSubstitution
{
public:
bool FindFontSubstitute( ImplFontSelectData& ) const;
};
class FcGlyphFallbackSubstititution
: public ImplGlyphFallbackFontSubstitution
{
// TODO: add a cache
public:
bool FindFontSubstitute( ImplFontSelectData&, OUString& rMissingCodes ) const;
};
void RegisterFontSubstitutors( ImplDevFontList* pList )
{
// init font substitution defaults
int nDisableBits = 0;
#ifdef SOLARIS
nDisableBits = 1; // disable "font fallback" here on default
#endif
// apply the environment variable if any
const char* pEnvStr = ::getenv( "SAL_DISABLE_FC_SUBST" );
if( pEnvStr )
{
if( (*pEnvStr >= '0') && (*pEnvStr <= '9') )
nDisableBits = (*pEnvStr - '0');
else
nDisableBits = ~0U; // no specific bits set: disable all
}
// register font fallback substitutions (unless disabled by bit0)
if( (nDisableBits & 1) == 0 )
{
static FcPreMatchSubstititution aSubstPreMatch;
pList->SetPreMatchHook( &aSubstPreMatch );
}
// register glyph fallback substitutions (unless disabled by bit1)
if( (nDisableBits & 2) == 0 )
{
static FcGlyphFallbackSubstititution aSubstFallback;
pList->SetFallbackHook( &aSubstFallback );
}
}
// -----------------------------------------------------------------------
static ImplFontSelectData GetFcSubstitute(const ImplFontSelectData &rFontSelData, OUString& rMissingCodes )
{
ImplFontSelectData aRet(rFontSelData);
const rtl::OString aLangAttrib = MsLangId::convertLanguageToIsoByteString( rFontSelData.meLanguage );
psp::italic::type eItalic = psp::italic::Unknown;
if( rFontSelData.GetSlant() != ITALIC_DONTKNOW )
{
switch( rFontSelData.GetSlant() )
{
case ITALIC_NONE: eItalic = psp::italic::Upright; break;
case ITALIC_NORMAL: eItalic = psp::italic::Italic; break;
case ITALIC_OBLIQUE: eItalic = psp::italic::Oblique; break;
default:
break;
}
}
psp::weight::type eWeight = psp::weight::Unknown;
if( rFontSelData.GetWeight() != WEIGHT_DONTKNOW )
{
switch( rFontSelData.GetWeight() )
{
case WEIGHT_THIN: eWeight = psp::weight::Thin; break;
case WEIGHT_ULTRALIGHT: eWeight = psp::weight::UltraLight; break;
case WEIGHT_LIGHT: eWeight = psp::weight::Light; break;
case WEIGHT_SEMILIGHT: eWeight = psp::weight::SemiLight; break;
case WEIGHT_NORMAL: eWeight = psp::weight::Normal; break;
case WEIGHT_MEDIUM: eWeight = psp::weight::Medium; break;
case WEIGHT_SEMIBOLD: eWeight = psp::weight::SemiBold; break;
case WEIGHT_BOLD: eWeight = psp::weight::Bold; break;
case WEIGHT_ULTRABOLD: eWeight = psp::weight::UltraBold; break;
case WEIGHT_BLACK: eWeight = psp::weight::Black; break;
default:
break;
}
}
psp::width::type eWidth = psp::width::Unknown;
if( rFontSelData.GetWidthType() != WIDTH_DONTKNOW )
{
switch( rFontSelData.GetWidthType() )
{
case WIDTH_ULTRA_CONDENSED: eWidth = psp::width::UltraCondensed; break;
case WIDTH_EXTRA_CONDENSED: eWidth = psp::width::ExtraCondensed; break;
case WIDTH_CONDENSED: eWidth = psp::width::Condensed; break;
case WIDTH_SEMI_CONDENSED: eWidth = psp::width::SemiCondensed; break;
case WIDTH_NORMAL: eWidth = psp::width::Normal; break;
case WIDTH_SEMI_EXPANDED: eWidth = psp::width::SemiExpanded; break;
case WIDTH_EXPANDED: eWidth = psp::width::Expanded; break;
case WIDTH_EXTRA_EXPANDED: eWidth = psp::width::ExtraExpanded; break;
case WIDTH_ULTRA_EXPANDED: eWidth = psp::width::UltraExpanded; break;
default:
break;
}
}
psp::pitch::type ePitch = psp::pitch::Unknown;
if( rFontSelData.GetPitch() != PITCH_DONTKNOW )
{
switch( rFontSelData.GetPitch() )
{
case PITCH_FIXED: ePitch=psp::pitch::Fixed; break;
case PITCH_VARIABLE: ePitch=psp::pitch::Variable; break;
default:
break;
}
}
const psp::PrintFontManager& rMgr = psp::PrintFontManager::get();
aRet.maSearchName = rMgr.Substitute( rFontSelData.maTargetName, rMissingCodes, aLangAttrib, eItalic, eWeight, eWidth, ePitch);
switch (eItalic)
{
case psp::italic::Upright: aRet.meItalic = ITALIC_NONE; break;
case psp::italic::Italic: aRet.meItalic = ITALIC_NORMAL; break;
case psp::italic::Oblique: aRet.meItalic = ITALIC_OBLIQUE; break;
default:
break;
}
switch (eWeight)
{
case psp::weight::Thin: aRet.meWeight = WEIGHT_THIN; break;
case psp::weight::UltraLight: aRet.meWeight = WEIGHT_ULTRALIGHT; break;
case psp::weight::Light: aRet.meWeight = WEIGHT_LIGHT; break;
case psp::weight::SemiLight: aRet.meWeight = WEIGHT_SEMILIGHT; break;
case psp::weight::Normal: aRet.meWeight = WEIGHT_NORMAL; break;
case psp::weight::Medium: aRet.meWeight = WEIGHT_MEDIUM; break;
case psp::weight::SemiBold: aRet.meWeight = WEIGHT_SEMIBOLD; break;
case psp::weight::Bold: aRet.meWeight = WEIGHT_BOLD; break;
case psp::weight::UltraBold: aRet.meWeight = WEIGHT_ULTRABOLD; break;
case psp::weight::Black: aRet.meWeight = WEIGHT_BLACK; break;
default:
break;
}
switch (eWidth)
{
case psp::width::UltraCondensed: aRet.meWidthType = WIDTH_ULTRA_CONDENSED; break;
case psp::width::ExtraCondensed: aRet.meWidthType = WIDTH_EXTRA_CONDENSED; break;
case psp::width::Condensed: aRet.meWidthType = WIDTH_CONDENSED; break;
case psp::width::SemiCondensed: aRet.meWidthType = WIDTH_SEMI_CONDENSED; break;
case psp::width::Normal: aRet.meWidthType = WIDTH_NORMAL; break;
case psp::width::SemiExpanded: aRet.meWidthType = WIDTH_SEMI_EXPANDED; break;
case psp::width::Expanded: aRet.meWidthType = WIDTH_EXPANDED; break;
case psp::width::ExtraExpanded: aRet.meWidthType = WIDTH_EXTRA_EXPANDED; break;
case psp::width::UltraExpanded: aRet.meWidthType = WIDTH_ULTRA_EXPANDED; break;
default:
break;
}
switch (ePitch)
{
case psp::pitch::Fixed: aRet.mePitch = PITCH_FIXED; break;
case psp::pitch::Variable: aRet.mePitch = PITCH_VARIABLE; break;
default:
break;
}
return aRet;
}
namespace
{
bool uselessmatch(const ImplFontSelectData &rOrig, const ImplFontSelectData &rNew)
{
return
(
rOrig.maTargetName == rNew.maSearchName &&
rOrig.meWeight == rNew.meWeight &&
rOrig.meItalic == rNew.meItalic &&
rOrig.mePitch == rNew.mePitch &&
rOrig.meWidthType == rNew.meWidthType
);
}
}
//--------------------------------------------------------------------------
bool FcPreMatchSubstititution::FindFontSubstitute( ImplFontSelectData &rFontSelData ) const
{
// We dont' actually want to talk to Fontconfig at all for symbol fonts
if( rFontSelData.IsSymbolFont() )
return false;
// StarSymbol is a unicode font, but it still deserves the symbol flag
if( 0 == rFontSelData.maSearchName.CompareIgnoreCaseToAscii( "starsymbol", 10)
|| 0 == rFontSelData.maSearchName.CompareIgnoreCaseToAscii( "opensymbol", 10) )
return false;
rtl::OUString aDummy;
const ImplFontSelectData aOut = GetFcSubstitute( rFontSelData, aDummy );
// TODO: cache the font substitution suggestion
// FC doing it would be preferable because it knows the invariables
// e.g. FC knows the FC rule that all Arial gets replaced by LiberationSans
// whereas we would have to check for every size or attribute
if( !aOut.maSearchName.Len() )
return false;
const bool bHaveSubstitute = !uselessmatch( rFontSelData, aOut );
#ifdef DEBUG
const ByteString aOrigName( rFontSelData.maTargetName, RTL_TEXTENCODING_UTF8 );
const ByteString aSubstName( aOut.maSearchName, RTL_TEXTENCODING_UTF8 );
printf( "FcPreMatchSubstititution \"%s\" bipw=%d%d%d%d -> ",
aOrigName.GetBuffer(), rFontSelData.meWeight, rFontSelData.meItalic,
rFontSelData.mePitch, rFontSelData.meWidthType );
if( !bHaveSubstitute )
printf( "no substitute available\n" );
else
printf( "\"%s\" bipw=%d%d%d%d\n", aSubstName.GetBuffer(),
aOut.meWeight, aOut.meItalic, aOut.mePitch, aOut.meWidthType );
#endif
if( bHaveSubstitute )
rFontSelData = aOut;
return bHaveSubstitute;
}
// -----------------------------------------------------------------------
bool FcGlyphFallbackSubstititution::FindFontSubstitute( ImplFontSelectData& rFontSelData,
rtl::OUString& rMissingCodes ) const
{
// We dont' actually want to talk to Fontconfig at all for symbol fonts
if( rFontSelData.IsSymbolFont() )
return false;
// StarSymbol is a unicode font, but it still deserves the symbol flag
if( 0 == rFontSelData.maSearchName.CompareIgnoreCaseToAscii( "starsymbol", 10)
|| 0 == rFontSelData.maSearchName.CompareIgnoreCaseToAscii( "opensymbol", 10) )
return false;
const ImplFontSelectData aOut = GetFcSubstitute( rFontSelData, rMissingCodes );
// TODO: cache the unicode + srcfont specific result
// FC doing it would be preferable because it knows the invariables
// e.g. FC knows the FC rule that all Arial gets replaced by LiberationSans
// whereas we would have to check for every size or attribute
if( !aOut.maSearchName.Len() )
return false;
const bool bHaveSubstitute = !uselessmatch( rFontSelData, aOut );
#ifdef DEBUG
const ByteString aOrigName( rFontSelData.maTargetName, RTL_TEXTENCODING_UTF8 );
const ByteString aSubstName( aOut.maSearchName, RTL_TEXTENCODING_UTF8 );
printf( "FcGFSubstititution \"%s\" bipw=%d%d%d%d ->",
aOrigName.GetBuffer(), rFontSelData.meWeight, rFontSelData.meItalic,
rFontSelData.mePitch, rFontSelData.meWidthType );
if( !bHaveSubstitute )
printf( "no substitute available\n" );
else
printf( "\"%s\" bipw=%d%d%d%d\n", aSubstName.GetBuffer(),
aOut.meWeight, aOut.meItalic, aOut.mePitch, aOut.meWidthType );
#endif
if( bHaveSubstitute )
rFontSelData = aOut;
return bHaveSubstitute;
}
// ===========================================================================