static void 

static void

FaxPhoneComment( Display* pDisplay, const sal_Unicode* pStr, USHORT nLen )

FaxPhoneComment (Display * pDisplay, const sal_Unicode * pStr, USHORT nLen)

	#define FAX_PHONE_TOKEN          "@@#"

#define FAX_PHONE_TOKEN          "@@#"

	#define FAX_PHONE_TOKEN_LENGTH   3

#define FAX_PHONE_TOKEN_LENGTH   3

	#define FAX_END_TOKEN            "@@"

#define FAX_END_TOKEN            "@@"

	USHORT nPos;

  USHORT nPos;

	ByteString aPhone( pStr, nLen, gsl_getSystemTextEncoding() );

  ByteString aPhone (pStr, nLen, gsl_getSystemTextEncoding ());

	static ByteString aPhoneNumber;

  static ByteString aPhoneNumber;

	static BOOL   bIsCollecting = FALSE;

  static BOOL bIsCollecting = FALSE;

	if( ! bIsCollecting )

  if (!bIsCollecting)

	{

    {

		if( ( nPos = aPhone.Search( FAX_PHONE_TOKEN ) ) != STRING_NOTFOUND )

      if ((nPos = aPhone.Search (FAX_PHONE_TOKEN)) != STRING_NOTFOUND)

		{

	{

			aPhone.Erase( 0, nPos + FAX_PHONE_TOKEN_LENGTH );

	  aPhone.Erase (0, nPos + FAX_PHONE_TOKEN_LENGTH);

			bIsCollecting = TRUE;

	  bIsCollecting = TRUE;

			aPhoneNumber.Erase();

	  aPhoneNumber.Erase ();

		}

	}

	}

    }

	if( bIsCollecting )

  if (bIsCollecting)

	{

    {

		if( ( nPos = aPhone.Search( FAX_END_TOKEN ) ) != STRING_NOTFOUND )

      if ((nPos = aPhone.Search (FAX_END_TOKEN)) != STRING_NOTFOUND)

		{

	{

			aPhone.Erase( nPos );

	  aPhone.Erase (nPos);

			bIsCollecting = FALSE;

	  bIsCollecting = FALSE;

		}

	}

		aPhoneNumber += aPhone;

      aPhoneNumber += aPhone;

		if( ! bIsCollecting )

      if (!bIsCollecting)

		{

	{

			aPhone = "PhoneNumber(";

	  aPhone = "PhoneNumber(";

			aPhone += aPhoneNumber;

	  aPhone += aPhoneNumber;

			aPhone += ")\n";

	  aPhone += ")\n";

			XpPSComment( pDisplay, aPhone.GetBuffer() );

	  XpPSComment (pDisplay, aPhone.GetBuffer ());

			aPhoneNumber = ByteString();

	  aPhoneNumber = ByteString ();

		}

	}

	}

    }

	if( aPhoneNumber.Len() > 1024 )

  if (aPhoneNumber.Len () > 1024)

	{

    {

		bIsCollecting = FALSE;

      bIsCollecting = FALSE;

		aPhoneNumber = ByteString();

      aPhoneNumber = ByteString ();

	}

    }

XlfdStorage*

XlfdStorage *

SalDisplay::GetXlfdList()

SalDisplay::GetXlfdList ()

	if ( mpFontList != NULL )

  if (mpFontList != NULL)

	{

    {

		return mpFontList;

      return mpFontList;

	}

    }

	else

  else

	{

    {

		// on a display an xlfd of *-0-0-75-75-* means this is a scalable

      // on a display an xlfd of *-0-0-75-75-* means this is a scalable

		// bitmap font, thus it is ugly and thus to avoid. On a printer 

      // bitmap font, thus it is ugly and thus to avoid. On a printer 

		// *-0-0-300-300-* means this is a printer resident font thus nice

      // *-0-0-300-300-* means this is a printer resident font thus nice

		// thus to prefer :-(

      // thus to prefer :-(

		eDeviceT eDevice = this->IsDisplay() ? eDeviceDisplay : eDevicePrinter;

      eDeviceT eDevice = this->IsDisplay ()? eDeviceDisplay : eDevicePrinter;

		mpFactory  = new AttributeProvider( eDevice );

      mpFactory = new AttributeProvider (eDevice);

		mpFontList = new XlfdStorage();

      mpFontList = new XlfdStorage ();

		int i, nFontCount;

      int i, nFontCount;

		const int nMaxCount  = 64 * 1024 - 1;

      const int nMaxCount = 64 * 1024 - 1;

		Display *pDisplay = GetDisplay();

      Display *pDisplay = GetDisplay ();

		char **ppFontList = XListFonts(pDisplay, "-*", nMaxCount, &nFontCount);

      char **ppFontList = XListFonts (pDisplay, "-*", nMaxCount, &nFontCount);

		//

      //

		// create a list of simple Xlfd font information

      // create a list of simple Xlfd font information

		//

      //

      Xlfd *pXlfdList = (Xlfd *) malloc (nFontCount * sizeof (Xlfd));

      int nXlfdCount = 0;

      for (i = 0; i < nFontCount; i++)

	{

	  if (pXlfdList[nXlfdCount].FromString (ppFontList[i], mpFactory))

	    ++nXlfdCount;

	}

      XFreeFontNames (ppFontList);

      // classification information is needed for sorting, classification

      // of charset (i.e. iso8859-1 <-> ansi-1252) depends on wether the

      // display points to a printer or to a real display. On a printer all

      // iso8859-1 fonts are really capable of ansi-1252      

      mpFactory->AddClassification ();

      // add some pretty print description

      mpFactory->AddAnnotation ();

      // misc feature checking

      mpFactory->TagFeature ();

      // sort according to font style

      qsort (pXlfdList, nXlfdCount, sizeof (Xlfd), XlfdCompare);

      //

      // create a font list with merged encoding information 

      //

      BitmapXlfdStorage aBitmapList;

      ScalableXlfd *pScalableFont = NULL;

      PrinterFontXlfd *pPrinterFont = NULL;

      int nFrom = 0;

      for (i = 0; i < nXlfdCount; i++)

	{

	  // exclude openlook glyph and cursor

	  Attribute *pAttr =

	    mpFactory->RetrieveFamily (pXlfdList[i].mnFamily);

	  if (pAttr->

	      HasFeature (XLFD_FEATURE_OL_GLYPH | XLFD_FEATURE_OL_CURSOR))

	    {

	      continue;

	    }

	  // exclude fonts with unknown encoding

	  if (pXlfdList[i].GetEncoding () == RTL_TEXTENCODING_DONTKNOW)

	    {

	      continue;

	    }

	  Bool bSameOutline =

	    pXlfdList[i].SameFontoutline (pXlfdList + nFrom);

	  XlfdFonttype eType = pXlfdList[i].Fonttype ();

	  // flush the old merged font list if the name doesn't match any more

	  if (!bSameOutline)

	    {

	      mpFontList->Add (pScalableFont);

	      pScalableFont = NULL;

	      mpFontList->Add (pPrinterFont);

	      pPrinterFont = NULL;

	      mpFontList->Add (&aBitmapList);

	      aBitmapList.Reset ();

	    }

	  // merge the font or generate a new one

	  switch (eType)

	    {

	    case eTypeScalable:

	      if (pScalableFont == NULL)

		pScalableFont = new ScalableXlfd;

	      pScalableFont->AddEncoding (pXlfdList + i);

	      break;

	    case eTypeBitmap:

	      aBitmapList.AddBitmapFont (pXlfdList + i);

	      break;

	    case eTypePrinterBuiltIn:

	    case eTypePrinterDownload:

	      if (pPrinterFont == NULL)

		pPrinterFont = new PrinterFontXlfd;

	      pPrinterFont->AddEncoding (pXlfdList + i);

	      break;

	    case eTypeScalableBitmap:

	    default:

	      break;

	    }

	  nFrom = i;

	}

      // flush the merged list into the global list

      mpFontList->Add (pScalableFont);

      mpFontList->Add (pPrinterFont);

      mpFontList->Add (&aBitmapList);

      // cleanup the list of simple font information

      if (pXlfdList != NULL)

	free (pXlfdList);

		Xlfd  *pXlfdList = (Xlfd*)malloc( nFontCount * sizeof(Xlfd) );

      return mpFontList;

		int    nXlfdCount = 0;

    }

		for ( i = 0; i < nFontCount; i++ )

		{

			if ( pXlfdList[ nXlfdCount ].FromString(ppFontList[i], mpFactory) )

				++nXlfdCount;

		}

		XFreeFontNames( ppFontList );

		// classification information is needed for sorting, classification

		// of charset (i.e. iso8859-1 <-> ansi-1252) depends on wether the

		// display points to a printer or to a real display. On a printer all

		// iso8859-1 fonts are really capable of ansi-1252 	

		mpFactory->AddClassification();

		// add some pretty print description

		mpFactory->AddAnnotation();

		// misc feature checking

		mpFactory->TagFeature();

		// sort according to font style

		qsort( pXlfdList, nXlfdCount, sizeof(Xlfd), XlfdCompare );

		//

		// create a font list with merged encoding information 

		//

		BitmapXlfdStorage   aBitmapList;

		ScalableXlfd  	   *pScalableFont = NULL;

		PrinterFontXlfd	   *pPrinterFont  = NULL;

		int nFrom = 0;

		for ( i = 0; i < nXlfdCount; i++ )

		{

			// exclude openlook glyph and cursor

			Attribute *pAttr = mpFactory->RetrieveFamily(pXlfdList[i].mnFamily);

			if ( pAttr->HasFeature(   XLFD_FEATURE_OL_GLYPH 

									| XLFD_FEATURE_OL_CURSOR) )

			{

				continue;

			}

			// exclude fonts with unknown encoding

			if ( pXlfdList[i].GetEncoding()	== RTL_TEXTENCODING_DONTKNOW )

			{

				continue;

			}

			Bool bSameOutline = pXlfdList[i].SameFontoutline(pXlfdList + nFrom);

			XlfdFonttype eType = pXlfdList[i].Fonttype();

			// flush the old merged font list if the name doesn't match any more

			if ( !bSameOutline )

			{

				mpFontList->Add( pScalableFont ); pScalableFont = NULL;

				mpFontList->Add( pPrinterFont );  pPrinterFont  = NULL;

				mpFontList->Add( &aBitmapList );  aBitmapList.Reset();

			}

			// merge the font or generate a new one

			switch( eType )

			{

				case eTypeScalable:

					if ( pScalableFont == NULL )	

						pScalableFont = new ScalableXlfd;

					pScalableFont->AddEncoding(pXlfdList + i);

					break;

				case eTypeBitmap:

					aBitmapList.AddBitmapFont( pXlfdList + i );

					break;

				case eTypePrinterBuiltIn:

				case eTypePrinterDownload: 

					if ( pPrinterFont == NULL )

						pPrinterFont = new PrinterFontXlfd;

					pPrinterFont->AddEncoding( pXlfdList + i );

					break;

				case eTypeScalableBitmap: 

				default:

					break;

			}

			nFrom = i;

		}

		// flush the merged list into the global list

		mpFontList->Add( pScalableFont );

		mpFontList->Add( pPrinterFont );

		mpFontList->Add( &aBitmapList );

		// cleanup the list of simple font information

		if ( pXlfdList != NULL )

			free( pXlfdList );

		return mpFontList;

	}

ExtendedFontStruct*

ExtendedFontStruct *

SalDisplay::GetFont( ExtendedXlfd *pRequestedFont, int nPixelSize )

SalDisplay::GetFont (ExtendedXlfd * pRequestedFont, int nPixelSize)

	if( !pFontCache_ )

  if (!pFontCache_)

	{

    {

		mpCvtCache = new SalConverterCache;

      mpCvtCache = new SalConverterCache;

		pFontCache_ = new SalFontCache( 64, 64, 16 ); // ???

      pFontCache_ = new SalFontCache (64, 64, 16);	// ???

	}

    }

	else

  else

	{

    {

		ExtendedFontStruct *pItem;

      ExtendedFontStruct *pItem;

		for ( pItem  = pFontCache_->First(); 

      for (pItem = pFontCache_->First ();

			  pItem != NULL; 

	   pItem != NULL; pItem = pFontCache_->Next ())

			  pItem  = pFontCache_->Next() )

	{

		{

	  if (pItem->Match (pRequestedFont, nPixelSize))

			if ( pItem->Match(pRequestedFont, nPixelSize) )

	    {

			{

	      if (pFontCache_->GetCurPos ())

				if( pFontCache_->GetCurPos() )

		{

				{

		  pFontCache_->Remove (pItem);

					pFontCache_->Remove( pItem );

		  pFontCache_->Insert (pItem, 0UL);

					pFontCache_->Insert( pItem, 0UL );

		}

				}

	      return pItem;

				return pItem;

	    }

			}

	}

		}

    }

	}

  // before we expand the cache, we look for very old and unused items 

	// before we expand the cache, we look for very old and unused items 

  if (pFontCache_->Count () >= 64)

	if( pFontCache_->Count() >= 64 )

    {

	{

      ExtendedFontStruct *pItem;

		ExtendedFontStruct *pItem;

      for (pItem = pFontCache_->Last ();

		for ( pItem = pFontCache_->Last();

	   pItem != NULL; pItem = pFontCache_->Prev ())

			  pItem != NULL;

	{

			  pItem = pFontCache_->Prev() )

	  if (1 == pItem->GetRefCount ())

		{

	    {

			if( 1 == pItem->GetRefCount() )

	      pFontCache_->Remove (pItem);

			{

	      pItem->ReleaseRef ();

				pFontCache_->Remove( pItem );

				pItem->ReleaseRef();

	      if (pFontCache_->Count () < 64)

		break;

				if( pFontCache_->Count() < 64 )

	    }

					break;

	}

			}

    }

		}

	}

  ExtendedFontStruct *pItem = new ExtendedFontStruct (GetDisplay (),

						      nPixelSize,

	ExtendedFontStruct *pItem = new ExtendedFontStruct( GetDisplay(), 

						      pRequestedFont,

									nPixelSize, pRequestedFont, mpCvtCache );

						      mpCvtCache);

	pFontCache_->Insert( pItem, 0UL );

  pFontCache_->Insert (pItem, 0UL);

	pItem->AddRef();

  pItem->AddRef ();

	return pItem;

  return pItem;

void 

void

SalDisplay::DestroyFontCache()

SalDisplay::DestroyFontCache ()

	if( pFontCache_ )

  if (pFontCache_)

	{

    {

		ExtendedFontStruct *pItem = pFontCache_->First();

      ExtendedFontStruct *pItem = pFontCache_->First ();

		while( pItem )

      while (pItem)

		{

	{

			delete pItem;

	  delete pItem;

			pItem = pFontCache_->Next();

	  pItem = pFontCache_->Next ();

		}

	}

		delete pFontCache_;

      delete pFontCache_;

	}

    }

	if( mpFontList )

  if (mpFontList)

	{

    {

		mpFontList->Dispose(); 

      mpFontList->Dispose ();

		delete mpFontList;

      delete mpFontList;

	}

    }

	if ( mpFactory )

  if (mpFactory)

	{

    {

		delete mpFactory;

      delete mpFactory;

	}

    }

	if ( mpCvtCache )

  if (mpCvtCache)

	{

    {

		delete mpCvtCache;

      delete mpCvtCache;

	}

    }

	pFontCache_ = (SalFontCache*)NULL;

  pFontCache_ = (SalFontCache *) NULL;

	mpFontList = (XlfdStorage*)NULL;

  mpFontList = (XlfdStorage *) NULL;

	mpFactory  = (AttributeProvider*)NULL;

  mpFactory = (AttributeProvider *) NULL;

	mpCvtCache = (SalConverterCache*)NULL;

  mpCvtCache = (SalConverterCache *) NULL;

GC 

GC SalGraphicsData::SelectFont ()

SalGraphicsData::SelectFont()

	Display *pDisplay = GetXDisplay();

  Display *

    pDisplay = GetXDisplay ();

	if( !pFontGC_ )

	{

		XGCValues values;

		values.subwindow_mode		= IncludeInferiors;

		values.fill_rule			= EvenOddRule;		// Pict import/ Gradient

		values.graphics_exposures	= True;

		values.foreground			= nTextPixel_;

		pFontGC_ = XCreateGC( pDisplay, hDrawable_,

							    GCSubwindowMode | GCFillRule 

							  | GCGraphicsExposures | GCForeground,

							  &values );

	}

	if( !bFontGC_ )

  if (!pFontGC_)

	{

    {

		XSetForeground( pDisplay, pFontGC_, nTextPixel_ );

      XGCValues

		SetClipRegion( pFontGC_ );

	values;

		bFontGC_ = TRUE;

      values.subwindow_mode = IncludeInferiors;

	}

      values.fill_rule = EvenOddRule;	// Pict import/ Gradient

      values.graphics_exposures = True;

      values.foreground = nTextPixel_;

      pFontGC_ = XCreateGC (pDisplay, hDrawable_,

			    GCSubwindowMode | GCFillRule

			    | GCGraphicsExposures | GCForeground, &values);

    }

  if (!bFontGC_)

    {

      XSetForeground (pDisplay, pFontGC_, nTextPixel_);

      SetClipRegion (pFontGC_);

      bFontGC_ = TRUE;

    }

	return pFontGC_;

  return pFontGC_;

static int 

static int

GetMaxFontHeight()

GetMaxFontHeight ()

	#define DEFAULT_MAXFONTHEIGHT 250

#define DEFAULT_MAXFONTHEIGHT 250

	int  nMaxFontHeight = 0;

  int

    nMaxFontHeight = 0;

	char *FontHeight = getenv ("SAL_MAXFONTHEIGHT");

  char *

	if (FontHeight)

    FontHeight = getenv ("SAL_MAXFONTHEIGHT");

		nMaxFontHeight = atoi (FontHeight);

  if (FontHeight)

    nMaxFontHeight = atoi (FontHeight);

	if (nMaxFontHeight <= 0)

  if (nMaxFontHeight <= 0)

		nMaxFontHeight = DEFAULT_MAXFONTHEIGHT;

    nMaxFontHeight = DEFAULT_MAXFONTHEIGHT;

	return nMaxFontHeight;

  return nMaxFontHeight;

void 

void

SalGraphicsData::SetFont( const ImplFontSelectData *pEntry )

SalGraphicsData::SetFont (const ImplFontSelectData * pEntry)

	bFontGC_	= FALSE;

  bFontGC_ = FALSE;

	xFont_		= NULL; // ->ReleaseRef()

  xFont_ = NULL;		// ->ReleaseRef()

	aScale_		= Fraction( 1, 1 );

  aScale_ = Fraction (1, 1);

	nFontOrientation_ = pEntry->mnOrientation;

  nFontOrientation_ = pEntry->mnOrientation;

	bFontVertical_	= pEntry->mbVertical; 

  bFontVertical_ = pEntry->mbVertical;

	if( pEntry->mpFontData && pEntry->mpFontData->mpSysData )

  if (pEntry->mpFontData && pEntry->mpFontData->mpSysData)

	{

    {

		ExtendedXlfd *pSysFont = (ExtendedXlfd*)pEntry->mpFontData->mpSysData;

      ExtendedXlfd *pSysFont = (ExtendedXlfd *) pEntry->mpFontData->mpSysData;

		static int nMaxFontHeight = GetMaxFontHeight();

      static int nMaxFontHeight = GetMaxFontHeight ();

		USHORT         nH, nW;

      USHORT nH, nW;

		if( bWindow_ )

      if (bWindow_)

		{

	{

			// see BugId #44528# FontWork (-> #45038#) and as well Bug #47127# 

	  // see BugId #44528# FontWork (-> #45038#) and as well Bug #47127# 

			if( pEntry->mnHeight > nMaxFontHeight )

	  if (pEntry->mnHeight > nMaxFontHeight)

				nH = nMaxFontHeight;

	    nH = nMaxFontHeight;

			else if( pEntry->mnHeight > 2 )

	  else if (pEntry->mnHeight > 2)

				nH = pEntry->mnHeight;

	    nH = pEntry->mnHeight;

			else

	  else

				nH = 2;

	    nH = 2;

			nW = 0; // pEntry->mnWidth;

	  nW = 0;		// pEntry->mnWidth;

		}

	}

		else

      else

		{

	{

			nH = pEntry->mnHeight;

	  nH = pEntry->mnHeight;

			nW = pEntry->mnWidth;

	  nW = pEntry->mnWidth;

		}

	}

		xFont_ = GetDisplay()->GetFont( pSysFont, nH );

      xFont_ = GetDisplay ()->GetFont (pSysFont, nH);

		if( pEntry->mnHeight > nMaxFontHeight || pEntry->mnHeight < 2 )

      if (pEntry->mnHeight > nMaxFontHeight || pEntry->mnHeight < 2)

			aScale_	= Fraction( pEntry->mnHeight, nH );

	aScale_ = Fraction (pEntry->mnHeight, nH);

	}

    }

	else

  else

	{	

    {

		#ifdef DEBUG

#ifdef DEBUG

		// XXX Fix me: provide a fallback for poor font installations

      // XXX Fix me: provide a fallback for poor font installations

		// we may be reach this if no font matches the GUI font 

      // we may be reach this if no font matches the GUI font 

		// MS Sans Serif;Geneva;Helv;WarpSans;Dialog;Lucida; ... */

      // MS Sans Serif;Geneva;Helv;WarpSans;Dialog;Lucida; ... */

		fprintf( stderr, "SalGraphicsData::SetFont: Invalid Font Selection\n" );

      fprintf (stderr, "SalGraphicsData::SetFont: Invalid Font Selection\n");

		#endif

#endif

	}

    }

SwapBytes( const sal_Unicode nIn )

SwapBytes (const sal_Unicode nIn)

	return ((nIn >> 8) & 0x00ff) | ((nIn << 8) & 0xff00);

  return ((nIn >> 8) & 0x00ff) | ((nIn << 8) & 0xff00);

ConvertTextItem16( XTextItem16* pTextItem, 

ConvertTextItem16 (XTextItem16 * pTextItem,

		SalConverterCache* pCvt, rtl_TextEncoding nEncoding )

		   SalConverterCache * pCvt, rtl_TextEncoding nEncoding)

	if ( pTextItem && pTextItem->nchars > 0 )

  if (pTextItem && pTextItem->nchars > 0)

	{

    {

		// convert the string into the font encoding

      // convert the string into the font encoding

		sal_Size  nSize;

      sal_Size nSize;

		sal_Size  nBufferSize = pTextItem->nchars * 2;

      sal_Size nBufferSize = pTextItem->nchars * 2;

		sal_Char *pBuffer = (sal_Char*)alloca( nBufferSize );

      sal_Char *pBuffer = (sal_Char *) alloca (nBufferSize);

		nSize = ConvertStringUTF16( (sal_Unicode*)pTextItem->chars, pTextItem->nchars, 

      nSize =

						pBuffer, nBufferSize, pCvt->GetU2TConverter(nEncoding));

	ConvertStringUTF16 ((sal_Unicode *) pTextItem->chars,

			    pTextItem->nchars, pBuffer, nBufferSize,

		sal_Char *pTextChars = (sal_Char*)pTextItem->chars;

			    pCvt->GetU2TConverter (nEncoding));

		int n = 0, m = 0;

      sal_Char *pTextChars = (sal_Char *) pTextItem->chars;

		if (   nEncoding == RTL_TEXTENCODING_GB_2312

      int n = 0, m = 0;

			|| nEncoding == RTL_TEXTENCODING_GBT_12345

			|| nEncoding == RTL_TEXTENCODING_GBK 

      if (nEncoding == RTL_TEXTENCODING_GB_2312

			|| nEncoding == RTL_TEXTENCODING_BIG5 )

	  || nEncoding == RTL_TEXTENCODING_GBT_12345

		{

	  || nEncoding == RTL_TEXTENCODING_GBK

			// GB and Big5 needs special treatment since chars can be single or

	  || nEncoding == RTL_TEXTENCODING_BIG5)

			// double byte: encoding is 

	{

			// [ 0x00 - 0x7f ] | [ 0x81 - 0xfe ] [ 0x40 - 0x7e 0x80 - 0xfe ]

	  // GB and Big5 needs special treatment since chars can be single or

			while ( n < nSize )

	  // double byte: encoding is 

			{

	  // [ 0x00 - 0x7f ] | [ 0x81 - 0xfe ] [ 0x40 - 0x7e 0x80 - 0xfe ]

				if ( (unsigned char)pBuffer[ n ] < 0x80 )

	  while (n < nSize)

				{

	    {

					pTextChars[ m++ ] = 0x0;

	      if ((unsigned char) pBuffer[n] & 0x80)

					pTextChars[ m++ ] = pBuffer[ n++ ];

		{

				}

		  switch (nEncoding)

				else

		    {

				{

		    case RTL_TEXTENCODING_GB_2312:	//The font are store in cjk iso2022  mode do some translation

					pTextChars[ m++ ] = pBuffer[ n++ ];

		      pTextChars[m++] = pBuffer[n++] & 0x7f;

					pTextChars[ m++ ] = pBuffer[ n++ ];

		      pTextChars[m++] = pBuffer[n++] & 0x7f;

				}

		      break;

			}

			pTextItem->nchars = m / 2;

		    default:

		}	

		      pTextChars[m++] = pBuffer[n++];

		else

		      pTextChars[m++] = 0x0;

		if ( pCvt->IsSingleByteEncoding(nEncoding) )

		      break;

		{

		    }

			// Single Byte encoding has to be padded

		}

			while ( n < nSize )

	      else

			{

		{

				pTextChars[ m++ ] = 0x0;

		  pTextChars[m++] = pBuffer[n++];

				pTextChars[ m++ ] = pBuffer[ n++ ];

		  pTextChars[m++] = pBuffer[n++];

			}

		}

			pTextItem->nchars = nSize;

	    }

		}

	  pTextItem->nchars = m / 2;

		else

	}

		{

      else if (pCvt->IsSingleByteEncoding (nEncoding))

			while ( n < nSize )

	{

			{

	  // Single Byte encoding has to be padded

				pTextChars[ m++ ] = pBuffer[ n++ ];

	  while (n < nSize)

			}

	    {

			pTextItem->nchars = nSize / 2;

	      pTextChars[m++] = 0x0;

		}

	      pTextChars[m++] = pBuffer[n++];

	    }

	  pTextItem->nchars = nSize;

	}

      else

	{

	  while (n < nSize)

	    {

	      pTextChars[m++] = pBuffer[n++];

	    }

	  pTextItem->nchars = nSize / 2;

XPrinterDrawText16( Display* pDisplay, Drawable nDrawable, GC nGC, 

XPrinterDrawText16 (Display * pDisplay, Drawable nDrawable, GC nGC,

		int nX, int nY, int nAngle, XTextItem16 *pTextItem16, int nItem )

		    int nX, int nY, int nAngle, XTextItem16 * pTextItem16,

{

		    int nItem)

	// convert XTextItem16 to XTextItem

{

	XTextItem *pTextItem = (XTextItem*)alloca( nItem * sizeof(XTextItem) );

  // convert XTextItem16 to XTextItem

  XTextItem *pTextItem = (XTextItem *) alloca (nItem * sizeof (XTextItem));

	for ( int nCurItem = 0; nCurItem < nItem; nCurItem++ )

	{

  for (int nCurItem = 0; nCurItem < nItem; nCurItem++)

		int      nChars      = pTextItem16[ nCurItem ].nchars;

    {

		char*    pDstCharPtr = (char*)alloca( nChars * sizeof(char) ); 

      int nChars = pTextItem16[nCurItem].nchars;

		XChar2b* pSrcCharPtr = pTextItem16[ nCurItem ].chars;

      char *pDstCharPtr = (char *) alloca (nChars * sizeof (char));

      XChar2b *pSrcCharPtr = pTextItem16[nCurItem].chars;

		pTextItem[ nCurItem ].chars  = pDstCharPtr;

		pTextItem[ nCurItem ].nchars = nChars;

      pTextItem[nCurItem].chars = pDstCharPtr;

		pTextItem[ nCurItem ].delta  = pTextItem16[ nCurItem ].delta;

      pTextItem[nCurItem].nchars = nChars;

		pTextItem[ nCurItem ].font   = pTextItem16[ nCurItem ].font;

      pTextItem[nCurItem].delta = pTextItem16[nCurItem].delta;

      pTextItem[nCurItem].font = pTextItem16[nCurItem].font;

		for ( int nCurChar = 0; 

			  nCurChar < nChars; 

      for (int nCurChar = 0;

			  nCurChar++, pDstCharPtr++, pSrcCharPtr++ )

	   nCurChar < nChars; nCurChar++, pDstCharPtr++, pSrcCharPtr++)

		{

	{

			*pDstCharPtr = (char)pSrcCharPtr->byte2; 

	  *pDstCharPtr = (char) pSrcCharPtr->byte2;

		}

	}

	}

    }

	if ( nAngle != 0 )

  if (nAngle != 0)

	{

    {

		for ( int nCurItem = 0; nCurItem < nItem; nCurItem++ )

      for (int nCurItem = 0; nCurItem < nItem; nCurItem++)

		{

	{

			// XXX FIXME this is broken, because nX and nY is not sufficiently updated 

	  // XXX FIXME this is broken, because nX and nY is not sufficiently updated 

			XSetFont( pDisplay, nGC, pTextItem[ nItem ].font );

	  XSetFont (pDisplay, nGC, pTextItem[nItem].font);

			if ( XSalCanDrawRotString(pDisplay, nGC) )

	  if (XSalCanDrawRotString (pDisplay, nGC))

			{

	    {

				XSalDrawRotString( pDisplay, nDrawable, nGC, nX, nY,

	      XSalDrawRotString (pDisplay, nDrawable, nGC, nX, nY,

					pTextItem[ nCurItem ].chars, pTextItem[ nCurItem ].nchars, nAngle );

				 pTextItem[nCurItem].chars,

			}

				 pTextItem[nCurItem].nchars, nAngle);

			else

	    }

			{

	  else

				XDrawString( pDisplay, nDrawable, nGC, nX, nY, 

	    {

					pTextItem[ nCurItem ].chars, pTextItem[ nCurItem ].nchars );

	      XDrawString (pDisplay, nDrawable, nGC, nX, nY,

			}

			   pTextItem[nCurItem].chars,

		}

			   pTextItem[nCurItem].nchars);

	}

	    }

	else

	}

	{

    }

		XDrawText( pDisplay, nDrawable, nGC, nX, nY, pTextItem, nItem );

  else

	}

    {

      XDrawText (pDisplay, nDrawable, nGC, nX, nY, pTextItem, nItem);

    }

DrawVerticalString ( Display *pDisplay, Drawable nDrawable, GC nGC,

DrawVerticalString (Display * pDisplay, Drawable nDrawable, GC nGC,

                     int nX, int nY, const sal_Unicode *pStr, int nLength,

		    int nX, int nY, const sal_Unicode * pStr, int nLength,

                     ExtendedFontStruct *pFont )

		    ExtendedFontStruct * pFont)

{

{

	VerticalTextItem** pTextItems;

  VerticalTextItem **pTextItems;

	int nNumItem = pFont->GetVerticalTextItems( pStr, nLength, RTL_TEXTENCODING_UNICODE,

  int nNumItem =

						    pStr, pTextItems );

    pFont->GetVerticalTextItems (pStr, nLength, RTL_TEXTENCODING_UNICODE,

				 pStr, pTextItems);

	for ( int nIdx = 0; nIdx < nNumItem; nIdx++ )

	{

  for (int nIdx = 0; nIdx < nNumItem; nIdx++)

		if ( pTextItems[nIdx]->mpXFontStruct == NULL )

    {

			continue;

      if (pTextItems[nIdx]->mpXFontStruct == NULL)

	continue;

		XSetFont( pDisplay, nGC, pTextItems[nIdx]->mpXFontStruct->fid );

		for ( int nChar = 0; nChar < pTextItems[nIdx]->mnLength; nChar++ )

      XSetFont (pDisplay, nGC, pTextItems[nIdx]->mpXFontStruct->fid);

		{

      for (int nChar = 0; nChar < pTextItems[nIdx]->mnLength; nChar++)

			XDrawString16( pDisplay, nDrawable, nGC,

	{

				       nX + pTextItems[nIdx]->mnTransX,

	  XDrawString16 (pDisplay, nDrawable, nGC,

				       nY + pTextItems[nIdx]->mnTransY,

			 nX + pTextItems[nIdx]->mnTransX,

				       (XChar2b*)(pTextItems[nIdx]->mpString + nChar), 1 );

			 nY + pTextItems[nIdx]->mnTransY,

			nY += (pTextItems[nIdx]->mbFixed ?

			 (XChar2b *) (pTextItems[nIdx]->mpString + nChar), 1);

			       pTextItems[nIdx]->mnFixedAdvance : pTextItems[nIdx]->mpAdvanceAry[nChar]);

	  nY += (pTextItems[nIdx]->mbFixed ?

		}

		 pTextItems[nIdx]->mnFixedAdvance : pTextItems[nIdx]->

	}

		 mpAdvanceAry[nChar]);

	}

	for (int nIdx2 = 0; nIdx2 < nNumItem; nIdx2++)

    }

	{

		delete( pTextItems[nIdx2] );

  for (int nIdx2 = 0; nIdx2 < nNumItem; nIdx2++)

	}

    {

	free( pTextItems );

      delete (pTextItems[nIdx2]);

    }

  free (pTextItems);

	rtl_TextEncoding mnEncoding;

  rtl_TextEncoding mnEncoding;

	const sal_Unicode* mpString; 

  const sal_Unicode *mpString;

DrawVerticalTextItem( Display *pDisplay, Drawable nDrawable, GC nGC,

DrawVerticalTextItem (Display * pDisplay, Drawable nDrawable, GC nGC,

		      int nX, int nY, XTextItem16* pTextItem, int nItem,

		      int nX, int nY, XTextItem16 * pTextItem, int nItem,

		      VTextItemExt* pVTextItemExt, ExtendedFontStruct* pFont )

		      VTextItemExt * pVTextItemExt,

{

		      ExtendedFontStruct * pFont)

	for ( int nItemIdx = 0; nItemIdx < nItem; nItemIdx++ )

{

	{

  for (int nItemIdx = 0; nItemIdx < nItem; nItemIdx++)

		VerticalTextItem** pVTextItems;

    {

		int nNumItem = pFont->GetVerticalTextItems( pVTextItemExt[nItemIdx].mpString,

      VerticalTextItem **pVTextItems;

							    pTextItem[nItemIdx].nchars,

      int nNumItem =

							    pVTextItemExt[nItemIdx].mnEncoding,

	pFont->GetVerticalTextItems (pVTextItemExt[nItemIdx].mpString,

							    (sal_Unicode *)pTextItem[nItemIdx].chars,

				     pTextItem[nItemIdx].nchars,

							    pVTextItems );

				     pVTextItemExt[nItemIdx].mnEncoding,

		for ( int nIdx = 0; nIdx < nNumItem; nIdx++ )

				     (sal_Unicode *) pTextItem[nItemIdx].chars,

		{

				     pVTextItems);

			if ( pVTextItems[nIdx]->mpXFontStruct == NULL )

      for (int nIdx = 0; nIdx < nNumItem; nIdx++)

				continue;

	{

	  if (pVTextItems[nIdx]->mpXFontStruct == NULL)

			XSetFont( pDisplay, nGC, pVTextItems[nIdx]->mpXFontStruct->fid );

	    continue;

			for (int nChar = 0; nChar < pVTextItems[nIdx]->mnLength; nChar++ )

			{

	  XSetFont (pDisplay, nGC, pVTextItems[nIdx]->mpXFontStruct->fid);

				XDrawString16( pDisplay, nDrawable, nGC,

	  for (int nChar = 0; nChar < pVTextItems[nIdx]->mnLength; nChar++)

					       nX + pVTextItems[nIdx]->mnTransX,

	    {

					       nY + pVTextItems[nIdx]->mnTransY,

	      XDrawString16 (pDisplay, nDrawable, nGC,

					       (XChar2b*)(pVTextItems[nIdx]->mpString + nChar), 1 );

			     nX + pVTextItems[nIdx]->mnTransX,

				nY += (pVTextItems[nIdx]->mbFixed ?

			     nY + pVTextItems[nIdx]->mnTransY,

				       pVTextItems[nIdx]->mnFixedAdvance : pVTextItems[nIdx]->mpAdvanceAry[nChar]);

			     (XChar2b *) (pVTextItems[nIdx]->mpString +

			}

					  nChar), 1);

		}

	      nY +=

		for ( int nIdx2 = 0; nIdx2 < nNumItem; nIdx2++ )

		(pVTextItems[nIdx]->mbFixed ? pVTextItems[nIdx]->

		{

		 mnFixedAdvance : pVTextItems[nIdx]->mpAdvanceAry[nChar]);

			delete( pVTextItems[nIdx2] );

	    }

		}

		free( pVTextItems ); 

DrawString( Display *pDisplay, Drawable nDrawable, GC nGC,

DrawString (Display * pDisplay, Drawable nDrawable, GC nGC,

		int nX, int nY, const sal_Unicode *pStr, int nLength, int nAngle, BOOL bVertical,

	    int nX, int nY, const sal_Unicode * pStr, int nLength, int nAngle,

		SalConverterCache *pCvt, ExtendedFontStruct *pFont )

	    BOOL bVertical, SalConverterCache * pCvt,

{

	    ExtendedFontStruct * pFont)

	// sanity check

{

	if ( pFont == NULL || nLength == 0 )

  // sanity check

		return;

  if (pFont == NULL || nLength == 0)

    return;

  rtl_TextEncoding nAsciiEnc = pFont->GetAsciiEncoding ();

  if (nAsciiEnc == RTL_TEXTENCODING_UNICODE)

    {

      if (bVertical)

	DrawVerticalString (pDisplay, nDrawable, nGC, nX, nY, pStr, nLength,

			    pFont);

      else

	{

	  // plain Unicode, can handle all chars and can be handled straight forward

	  XFontStruct *pFontStruct = pFont->GetFontStruct (nAsciiEnc);

	  if (pFontStruct == NULL)

	    return;

	  XSetFont (pDisplay, nGC, pFontStruct->fid);

#ifdef OSL_LITENDIAN

	  sal_Unicode *pBuffer =

	    (sal_Unicode *) alloca (nLength * sizeof (sal_Unicode));

	  for (int i = 0; i < nLength; i++)

	    pBuffer[i] = SwapBytes (pStr[i]);

#else

	  sal_Unicode *pBuffer = const_cast < sal_Unicode * >(pStr);

#endif

	rtl_TextEncoding nAsciiEnc = pFont->GetAsciiEncoding();

	  XDrawString16 (pDisplay, nDrawable, nGC, nX, nY,

			 (XChar2b *) pBuffer, nLength);

	}

    }

  else

    {

      // convert the string to a XTextItem16 with each item chars having the 

      // encoding matching the font of fontid

      XTextItem16 *pTextItem =

	(XTextItem16 *) alloca (nLength * sizeof (XTextItem16));

      XChar2b *pMBChar = (XChar2b *) alloca (nLength * sizeof (XChar2b));

      memcpy (pMBChar, pStr, nLength * sizeof (XChar2b));

	if ( nAsciiEnc == RTL_TEXTENCODING_UNICODE )

      rtl_TextEncoding nEncoding = nAsciiEnc;

	{

      XFontStruct *pFontStruct = pFont->GetFontStruct (nEncoding);

		if ( bVertical )

			DrawVerticalString( pDisplay, nDrawable, nGC, nX, nY, pStr, nLength, pFont );

		else

		{

			// plain Unicode, can handle all chars and can be handled straight forward

      if (pFontStruct == NULL)

			XFontStruct* pFontStruct = pFont->GetFontStruct( nAsciiEnc );

	return;

			if ( pFontStruct == NULL )

      VTextItemExt *pVTextItemExt;

				return;

      if (bVertical)

	pVTextItemExt =

			XSetFont( pDisplay, nGC, pFontStruct->fid );

	  (VTextItemExt *) alloca (nLength * sizeof (VTextItemExt));

			#ifdef OSL_LITENDIAN

			sal_Unicode *pBuffer = (sal_Unicode*)alloca( nLength * sizeof(sal_Unicode) );

			for ( int i = 0; i < nLength; i++ )

				pBuffer[ i ] = SwapBytes(pStr[ i ]) ;

			#else

			sal_Unicode *pBuffer = const_cast<sal_Unicode*>(pStr);

			#endif

			XDrawString16( pDisplay, nDrawable, nGC, nX, nY, (XChar2b*)pBuffer, nLength );

      for (int nChar = 0, nItem = -1; nChar < nLength; nChar++)

		}

	}

	else

		// convert the string to a XTextItem16 with each item chars having the 

	  rtl_TextEncoding nOldEnc = nEncoding;

		// encoding matching the font of fontid

	  pFont->GetFontStruct (pStr[nChar], &nEncoding, &pFontStruct, pCvt);

		XTextItem16 *pTextItem = (XTextItem16*)alloca( nLength * sizeof(XTextItem16) );

		XChar2b *pMBChar = (XChar2b*)alloca( nLength * sizeof(XChar2b) );

		memcpy( pMBChar, pStr, nLength * sizeof(XChar2b) );

		rtl_TextEncoding nEncoding   = nAsciiEnc;

		XFontStruct*	 pFontStruct = pFont->GetFontStruct( nEncoding );

		if ( pFontStruct == NULL )

			return;

		VTextItemExt* pVTextItemExt;

	  if (pFontStruct == NULL)

		if ( bVertical )

	    continue;

			pVTextItemExt = (VTextItemExt*)alloca( nLength * sizeof(VTextItemExt) );

		for ( int nChar = 0, nItem = -1; nChar < nLength; nChar++ )

	  if ((nItem != -1) && (pFontStruct->fid == pTextItem[nItem].font))

		{

	    {

			rtl_TextEncoding nOldEnc = nEncoding;

	      pTextItem[nItem].nchars += 1;

			pFont->GetFontStruct( pStr[nChar], &nEncoding, &pFontStruct, pCvt );

	    }

	  else

	    {

	      if (nItem != -1)

		ConvertTextItem16 (&pTextItem[nItem], pCvt, nOldEnc);

			if ( pFontStruct == NULL )

	      ++nItem;

				continue;    

			if ( (nItem != -1) && (pFontStruct->fid == pTextItem[ nItem ].font) )

	      pTextItem[nItem].chars = pMBChar + nChar;

			{

	      pTextItem[nItem].delta = 0;

				pTextItem[ nItem ].nchars += 1;

	      pTextItem[nItem].font = pFontStruct->fid;

			}

	      pTextItem[nItem].nchars = 1;

			else

			{

				if ( nItem != -1 )

					ConvertTextItem16( &pTextItem[ nItem ], pCvt, nOldEnc );

				++nItem;

				pTextItem[ nItem ].chars  = pMBChar + nChar;

				pTextItem[ nItem ].delta  = 0;

				pTextItem[ nItem ].font   = pFontStruct->fid;

				pTextItem[ nItem ].nchars = 1;

				if ( bVertical )

				{

					pVTextItemExt[ nItem ].mnEncoding = nEncoding;

					pVTextItemExt[ nItem ].mpString = pStr + nChar;

				}

			}

		}

		ConvertTextItem16( &pTextItem[ nItem ], pCvt, nEncoding );

		++nItem;

		if ( bVertical )

	      if (bVertical)

			pVTextItemExt[ nItem - 1 ].mnEncoding = nEncoding;

		  pVTextItemExt[nItem].mnEncoding = nEncoding;

			DrawVerticalTextItem( pDisplay, nDrawable, nGC, nX, nY,

		  pVTextItemExt[nItem].mpString = pStr + nChar;

					      pTextItem, nItem, pVTextItemExt, pFont );

			free( pVTextItemExt );

		else

	    }

		{

			if ( XSalIsDisplay( pDisplay ) )

				XDrawText16( pDisplay, nDrawable, nGC, nX, nY, pTextItem, nItem ); 

			else

				XPrinterDrawText16( pDisplay, nDrawable, nGC, nX, nY, nAngle, 

						pTextItem, nItem );

		}

void 

void

SalGraphicsData::DrawText( long nX, long nY, 

SalGraphicsData::DrawText (long nX, long nY,

		const sal_Unicode *pStr, USHORT nLen )

			   const sal_Unicode * pStr, USHORT nLen)

	if( bPrinter_ )

  if (bPrinter_)

		FaxPhoneComment( GetXDisplay(), pStr, nLen );

    FaxPhoneComment (GetXDisplay (), pStr, nLen);

	#ifdef __notdef__

  // Bug: #45670#

	// XXX Fix me this part is not unicode / multibyte aware

  // some monospace ISO8859-1 fonts have a hole between chars 128 and 159

  // some applications assume these characters have also the default width

  if (!bPrinter_ && PITCH_FIXED == xFont_->GetFont ()->mePitch && nLen > 1)

    {

      XFontStruct *pXFS = GetFontInfo ();

      long nWidth = xFont_->GetDim ()->GetWidth ();

	// Bug: #45670#

      if (xFont_->GetFixedWidth () != nWidth

	// some monospace ISO8859-1 fonts have a hole between chars 128 and 159

	  || xFont_->GetDefaultWidth () != nWidth)

	// some applications assume these characters have also the default width

	if( ! bPrinter_									&&

		PITCH_FIXED == xFont_->GetFont()->mePitch	&&

		nLen > 1 )

		XFontStruct *pXFS   = GetFontInfo();

	  unsigned int min_char = pXFS->min_char_or_byte2;

		long         nWidth = xFont_->GetDim()->GetWidth();

	  unsigned int max_char = pXFS->max_char_or_byte2;

	  XCharStruct *pXCS = pXFS->per_char - min_char;

	  for (USHORT i = 0; i < nLen - 1; i++)

	    {

	      unsigned int c = ((unsigned char *) pStr)[i];

	      long nW = c < min_char || c > max_char || !pXFS->per_char

		? xFont_->GetDefaultWidth () : pXCS[c].width;

		if( xFont_->GetFixedWidth() != nWidth

	      if (nW != nWidth)

			|| xFont_->GetDefaultWidth() != nWidth )

			unsigned int min_char	= pXFS->min_char_or_byte2;

		  long *pDXAry = new long[nLen];

			unsigned int max_char	= pXFS->max_char_or_byte2;

			XCharStruct *pXCS		= pXFS->per_char - min_char;

		  for (i = 0; i < nLen; i++)

		    pDXAry[i] = nWidth * (i + 1);

			for( USHORT i = 0; i < nLen-1; i++ )

			{

		  DrawText (nX, nY, pStr, nLen, pDXAry);

				unsigned int c = ((unsigned char*)pStr)[i];

		  delete pDXAry;

				long nW = c < min_char || c > max_char || ! pXFS->per_char

					? xFont_->GetDefaultWidth()

		  return;

					: pXCS[c].width;

				if( nW != nWidth )

				{

					long *pDXAry = new long[nLen];

					for( i = 0; i < nLen; i++ )

						pDXAry[i] = nWidth * (i+1);

					DrawText( nX, nY, pStr, nLen, pDXAry );

					delete pDXAry;

					return;

				}

			}

	#endif /* __notdef__ */

  Display *pDisplay = GetXDisplay ();

  SalConverterCache *pCvt = GetDisplay ()->GetConverter ();

	Display 			*pDisplay = GetXDisplay();

  GC pGC = SelectFont ();

	SalConverterCache 	*pCvt	  = GetDisplay()->GetConverter();

	GC       			pGC       = SelectFont();

  DrawString (pDisplay, hDrawable_, pGC, nX, nY,

	      pStr, nLen, nFontOrientation_ * 64 / 10, bFontVertical_, pCvt,

	DrawString( pDisplay, hDrawable_, pGC, nX, nY, 

	      xFont_);

			pStr, nLen, nFontOrientation_ * 64 / 10, bFontVertical_, pCvt, xFont_ );

void 

void

SalGraphics::DrawText( long nX, long nY, const xub_Unicode* pStr, USHORT nLen )

SalGraphics::DrawText (long nX, long nY, const xub_Unicode * pStr,

{ 

		       USHORT nLen)

	maGraphicsData.DrawText( nX, nY, pStr, nLen ); 

{

  maGraphicsData.DrawText (nX, nY, pStr, nLen);

static BOOL 

static BOOL

CheckNoNegativeCoordinateWorkaround()

CheckNoNegativeCoordinateWorkaround ()

	/* Motivation: one of our clients uses a Solaris 2.4 X86 system with an 

  /* Motivation: one of our clients uses a Solaris 2.4 X86 system with an 

	   XServer for the Matrox Mystique graphics card. This board/server

     XServer for the Matrox Mystique graphics card. This board/server

       sometimes does not draw Text with negative x-coordinates into a 

     sometimes does not draw Text with negative x-coordinates into a 

	   virtual device (for unknown reasons). A stock X-server just clips the

     virtual device (for unknown reasons). A stock X-server just clips the

	   part in the negative area. */

     part in the negative area. */

	static int nCheck = -2;

  static int nCheck = -2;

	if( nCheck == -2 )

  if (nCheck == -2)

	{

    {

		char* pCmp = getenv( "SAL_NO_NEGATIVE_TEXT_OFFSET" );

      char *pCmp = getenv ("SAL_NO_NEGATIVE_TEXT_OFFSET");

		if( pCmp && ! strncasecmp( pCmp, "true", 4 ) )

      if (pCmp && !strncasecmp (pCmp, "true", 4))

			nCheck = 1;

	nCheck = 1;

		else

      else

			nCheck = 0;

	nCheck = 0;

	}

    }

	return nCheck ? TRUE : FALSE;

  return nCheck ? TRUE : FALSE;

}

}

void 

SalGraphicsData::DrawText(

		long nX, long nY,

		const sal_Unicode* pStr, USHORT nLen, const long* pDXAry )

{

	#ifndef PRINTER_DUMMY

	if( bPrinter_ )

		FaxPhoneComment( GetXDisplay(), pStr, nLen );

	#endif

	GC pGC = SelectFont();

	// workaround for problems with negative coordinates

	long* pTmpAry = NULL;

	if( nX < 0 && CheckNoNegativeCoordinateWorkaround() )

	{

		long nOldX = nX;

		while( nX < 0 )

		{

			nX = nOldX + *pDXAry;

			pStr++, pDXAry++, nLen--;

			if( nLen < 1 )

				return;

		}

		pTmpAry = new long[ nLen ];

		for( int q = 0; q < nLen-1; q++ )

			pTmpAry[q] = pDXAry[q] - ( nX - nOldX );

		pDXAry = pTmpAry;

	}

	// draw every single character

	SalConverterCache *pCvt = GetDisplay()->GetConverter();

	int angle = nFontOrientation_ * 64 / 10;

	BOOL bVertical = bFontVertical_;

	Polygon aPolygon(1);

	Point   aOrigin( nX, nY );

	Point   aCharPos;

	DrawString( GetXDisplay(), hDrawable_, pGC, 

			aOrigin.X(), aOrigin.Y(), pStr, 1, angle, bVertical, pCvt, xFont_ );

	for( int i = 1; i < nLen ; i++ )

void

	{

SalGraphicsData::DrawText (long nX, long nY,

		aCharPos = Point( aOrigin.X() + pDXAry[ i - 1 ], aOrigin.Y() );

			   const sal_Unicode * pStr, USHORT nLen,

		aPolygon.SetPoint( aCharPos, 0 );

			   const long *pDXAry)

		aPolygon.Rotate( aOrigin, nFontOrientation_ );

{

		aCharPos = aPolygon.GetPoint( 0 );

#ifndef PRINTER_DUMMY

  if (bPrinter_)

    FaxPhoneComment (GetXDisplay (), pStr, nLen);

#endif

  GC pGC = SelectFont ();

		DrawString( GetXDisplay(), hDrawable_, pGC, 

  // workaround for problems with negative coordinates

				aCharPos.X(), aCharPos.Y(), pStr + i, 1, angle, bVertical, pCvt, xFont_ );

  long *pTmpAry = NULL;

	}

  if (nX < 0 && CheckNoNegativeCoordinateWorkaround ())

    {

      long nOldX = nX;

      while (nX < 0)

	{

	  nX = nOldX + *pDXAry;

	  pStr++, pDXAry++, nLen--;

	  if (nLen < 1)

	    return;

	}

      pTmpAry = new long[nLen];

      for (int q = 0; q < nLen - 1; q++)

	pTmpAry[q] = pDXAry[q] - (nX - nOldX);

      pDXAry = pTmpAry;

    }

  // draw every single character

  SalConverterCache *pCvt = GetDisplay ()->GetConverter ();

  int angle = nFontOrientation_ * 64 / 10;

  BOOL bVertical = bFontVertical_;

  Polygon aPolygon (1);

  Point aOrigin (nX, nY);

  Point aCharPos;

  DrawString (GetXDisplay (), hDrawable_, pGC,

	      aOrigin.X (), aOrigin.Y (), pStr, 1, angle, bVertical, pCvt,

	      xFont_);

  for (int i = 1; i < nLen; i++)

    {

      aCharPos = Point (aOrigin.X () + pDXAry[i - 1], aOrigin.Y ());

      aPolygon.SetPoint (aCharPos, 0);

      aPolygon.Rotate (aOrigin, nFontOrientation_);

      aCharPos = aPolygon.GetPoint (0);

      DrawString (GetXDisplay (), hDrawable_, pGC,

		  aCharPos.X (), aCharPos.Y (), pStr + i, 1, angle, bVertical,

		  pCvt, xFont_);

    }

	if( pTmpAry )

  if (pTmpAry)

		delete pTmpAry;

    delete pTmpAry;

USHORT 

USHORT SalGraphics::SetFont (ImplFontSelectData * pEntry)

SalGraphics::SetFont( ImplFontSelectData *pEntry )

{

{ 

  maGraphicsData.SetFont (pEntry);

	maGraphicsData.SetFont( pEntry );

  return _IsPrinter ()? SAL_SETFONT_USEDRAWTEXTARRAY : 0;

	return _IsPrinter() ? SAL_SETFONT_USEDRAWTEXTARRAY : 0;

void 

void

SalGraphics::DrawTextArray( long nX, long nY,

SalGraphics::DrawTextArray (long nX, long nY,

		const xub_Unicode *pStr, USHORT	nLen, const long *pDXAry )

			    const xub_Unicode * pStr, USHORT nLen,

{ 

			    const long *pDXAry)

	maGraphicsData.DrawText( nX, nY, pStr, nLen, pDXAry ); 

{

  maGraphicsData.DrawText (nX, nY, pStr, nLen, pDXAry);

void 

void

SalGraphics::SetTextColor( SalColor nSalColor )

SalGraphics::SetTextColor (SalColor nSalColor)

	if( _GetTextColor()	!= nSalColor )

  if (_GetTextColor () != nSalColor)

	{

    {

		_GetTextColor()		= nSalColor;

      _GetTextColor () = nSalColor;

		_GetTextPixel()		= _GetPixel( nSalColor );

      _GetTextPixel () = _GetPixel (nSalColor);

		_IsFontGC()			= FALSE;

      _IsFontGC () = FALSE;

	}

    }

void 

void

SalGraphics::GetDevFontList( ImplDevFontList *pList )

SalGraphics::GetDevFontList (ImplDevFontList * pList)

	XlfdStorage* pFonts = _GetDisplay()->GetXlfdList();

  XlfdStorage *pFonts = _GetDisplay ()->GetXlfdList ();

	for ( int nIdx = 0; nIdx < pFonts->GetCount(); nIdx++ )

  for (int nIdx = 0; nIdx < pFonts->GetCount (); nIdx++)

	{

    {

		ImplFontData *pFontData = new ImplFontData;

      ImplFontData *pFontData = new ImplFontData;

		pFonts->Get(nIdx)->ToImplFontData( pFontData );

      pFonts->Get (nIdx)->ToImplFontData (pFontData);

		pList->Add( pFontData );

      pList->Add (pFontData);

	}

    }

inline long 

inline long

sal_DivideNeg( long n1, long n2 )

sal_DivideNeg (long n1, long n2)

	return ( n1 < 0 ) ? (n1 - n2 / 2) / n2 : (n1 + n2 / 2) / n2;

  return (n1 < 0) ? (n1 - n2 / 2) / n2 : (n1 + n2 / 2) / n2;

void 

void

SalGraphics::GetFontMetric( ImplFontMetricData *pMetric )

SalGraphics::GetFontMetric (ImplFontMetricData * pMetric)

	ExtendedFontStruct* pFont = maGraphicsData.xFont_;

  ExtendedFontStruct *pFont = maGraphicsData.xFont_;

	if ( pFont != NULL )

  if (pFont != NULL)

	{

    {

		pFont->ToImplFontMetricData( pMetric );

      pFont->ToImplFontMetricData (pMetric);

		if( XSalCanDrawRotString( maGraphicsData.GetXDisplay(), None ) )

      if (XSalCanDrawRotString (maGraphicsData.GetXDisplay (), None))

			pMetric->mnOrientation = maGraphicsData.nFontOrientation_;

	pMetric->mnOrientation = maGraphicsData.nFontOrientation_;

        if ( maGraphicsData.bFontVertical_ )

      if (maGraphicsData.bFontVertical_)

		    pMetric->mnOrientation = 2700;

	pMetric->mnOrientation = 2700;

		long n;

      long n;

		n = maGraphicsData.aScale_.GetNumerator();

      n = maGraphicsData.aScale_.GetNumerator ();

		if( n != 1 )

      if (n != 1)

		{

	{

			pMetric->mnWidth	*= n;

	  pMetric->mnWidth *= n;

			pMetric->mnAscent	*= n;

	  pMetric->mnAscent *= n;

			pMetric->mnDescent	*= n;

	  pMetric->mnDescent *= n;

			pMetric->mnLeading	*= n;

	  pMetric->mnLeading *= n;

			pMetric->mnSlant	*= n;

	  pMetric->mnSlant *= n;

		}

		n = maGraphicsData.aScale_.GetDenominator();

		if( n != 1 )

		{

			pMetric->mnWidth	= Divide( pMetric->mnWidth,	n );

			pMetric->mnAscent	= sal_DivideNeg( pMetric->mnAscent,	 n );

			pMetric->mnDescent	= sal_DivideNeg( pMetric->mnDescent, n );

			pMetric->mnLeading	= sal_DivideNeg( pMetric->mnLeading, n );

			pMetric->mnSlant	= sal_DivideNeg( pMetric->mnSlant,	 n );

		}

InitializeWidthArray( long *pWidthArray, sal_Size nItems, int nValue = 0  )

InitializeWidthArray (long *pWidthArray, sal_Size nItems, int nValue = 0)

	const long nPrecision = 1;

  const long nPrecision = 1;

	for ( int i = 0; i < nItems; i++, pWidthArray++ )

  for (int i = 0; i < nItems; i++, pWidthArray++)

		*pWidthArray = nValue;

    *pWidthArray = nValue;

	return nPrecision;

  return nPrecision;

}

}

long 

long

SalGraphics::GetCharWidth( USHORT nChar1, USHORT nChar2, long  *pWidthAry )

SalGraphics::GetCharWidth (USHORT nChar1, USHORT nChar2, long *pWidthAry)

{

{

	// return the precision of the calculated charwidth, e.g. 1000 = 3 digits

  // return the precision of the calculated charwidth, e.g. 1000 = 3 digits

	// defaultet to 1 for now

  // defaultet to 1 for now

	const long nPrecision = 1;

  const long nPrecision = 1;

	int nRequestedWidth = nChar2 - nChar1 + 1;

  int nRequestedWidth = nChar2 - nChar1 + 1;

	int nCharWidth;

  int nCharWidth;

	// XXX sanity check, this may happen if no font at all is installed

  // XXX sanity check, this may happen if no font at all is installed

	// or no system font matches the requirements for the user interface

  // or no system font matches the requirements for the user interface

	if ( maGraphicsData.xFont_ == NULL )

  if (maGraphicsData.xFont_ == NULL)

		return InitializeWidthArray( pWidthAry, nRequestedWidth, 12 );

    return InitializeWidthArray (pWidthAry, nRequestedWidth, 12);

	// the font should know it's metrics best

  // the font should know it's metrics best

	SalDisplay *pSalDisplay = maGraphicsData.GetDisplay();

  SalDisplay *pSalDisplay = maGraphicsData.GetDisplay ();

	nCharWidth = maGraphicsData.xFont_->GetCharWidth(

  nCharWidth =

			pSalDisplay->GetConverter(), nChar1, nChar2, pWidthAry );

    maGraphicsData.xFont_->GetCharWidth (pSalDisplay->GetConverter (), nChar1,

					 nChar2, pWidthAry);

	// XXX sanity check, this may happen if the font cannot be loaded/queried

	// either because of a garbled fontpath or because of invalid fontfile

  // XXX sanity check, this may happen if the font cannot be loaded/queried

	if ( nCharWidth != nRequestedWidth )

  // either because of a garbled fontpath or because of invalid fontfile

		InitializeWidthArray( pWidthAry + nCharWidth, 

  if (nCharWidth != nRequestedWidth)

				nRequestedWidth - nCharWidth );	

    InitializeWidthArray (pWidthAry + nCharWidth,

			  nRequestedWidth - nCharWidth);

	// handle internal scaling

	const long nNumerator   = maGraphicsData.aScale_.GetNumerator();

  // handle internal scaling

	const long nDenominator = maGraphicsData.aScale_.GetDenominator();

  const long nNumerator = maGraphicsData.aScale_.GetNumerator ();

	long *pPtr;

  const long nDenominator = maGraphicsData.aScale_.GetDenominator ();

	sal_Unicode nChar;

  long *pPtr;

  sal_Unicode nChar;

	if ( nNumerator != 1 )

		for( pPtr = pWidthAry, nChar = nChar1; nChar <= nChar2; nChar++, pPtr++)

  if (nNumerator != 1)

			*pPtr *= nNumerator;

    for (pPtr = pWidthAry, nChar = nChar1; nChar <= nChar2; nChar++, pPtr++)

	if ( nDenominator != 1 )

      *pPtr *= nNumerator;

		for( pPtr = pWidthAry, nChar = nChar1; nChar <= nChar2; nChar++, pPtr++)

  if (nDenominator != 1)

			*pPtr = Divide( *pPtr, nDenominator );

    for (pPtr = pWidthAry, nChar = nChar1; nChar <= nChar2; nChar++, pPtr++)

      *pPtr = Divide (*pPtr, nDenominator);

	// return

  // return

	return nPrecision;

  return nPrecision;

extern unsigned char TranslateCharName( char* );

extern unsigned char TranslateCharName (char *);

ULONG 

ULONG SalGraphics::GetKernPairs (ULONG nPairs, ImplKernPairData * pKernPairs)

SalGraphics::GetKernPairs( ULONG nPairs, ImplKernPairData *pKernPairs )

	if( ! _IsPrinter() )

  if (!_IsPrinter ())

		return 0;

    return 0;

	// get pair kerning table ( internal data from xprinter )

  // get pair kerning table ( internal data from xprinter )

	int i, nCurPair=0;

  int

    i, nCurPair = 0;

	// XXX Fix me, improve this to be multi encoding aware: merge kern

	// pair list for all encodings available in the xfont

  // XXX Fix me, improve this to be multi encoding aware: merge kern

	rtl_TextEncoding nEncoding = maGraphicsData.xFont_->GetAsciiEncoding();

  // pair list for all encodings available in the xfont

	XFontStruct *pXFS = maGraphicsData.xFont_->GetFontStruct( nEncoding );

  rtl_TextEncoding

	XExtData    *pXES = pXFS->ext_data;

    nEncoding = maGraphicsData.xFont_->GetAsciiEncoding ();

  XFontStruct *

	for( i = 0; pXES && i < 2; i++, pXES = pXES->next );

    pXFS = maGraphicsData.xFont_->GetFontStruct (nEncoding);

	if( i < 2 )

  XExtData *

		return 0;

    pXES = pXFS->ext_data;

	XpPairKernData* pXpPKD = (XpPairKernData*)(pXES->private_data);

	PairKernData*   pPKD   = pXpPKD->pkd;

  for (i = 0; pXES && i < 2; i++, pXES = pXES->next);

  if (i < 2)

	for( i = 0, nCurPair=0; i < pXpPKD->numOfPairs; i++ )

    return 0;

	{

  XpPairKernData *

		unsigned char c1 = TranslateCharName( pPKD[i].name1 );

    pXpPKD = (XpPairKernData *) (pXES->private_data);

		unsigned char c2 = TranslateCharName( pPKD[i].name2 );

  PairKernData *

		if( c1 && c2 )

    pPKD = pXpPKD->pkd;

		{

			if( pKernPairs && nCurPair < nPairs )

  for (i = 0, nCurPair = 0; i < pXpPKD->numOfPairs; i++)

			{

    {

				pKernPairs[ nCurPair ].mnChar1 = c1;

      unsigned char

				pKernPairs[ nCurPair ].mnChar2 = c2;

	c1 = TranslateCharName (pPKD[i].name1);

				pKernPairs[ nCurPair ].mnKern = 

      unsigned char

						(long)(pPKD[i].xamt * pXpPKD->pointsize / 1000 );

	c2 = TranslateCharName (pPKD[i].name2);

			}

      if (c1 && c2)

			nCurPair++;

	{

		}

	  if (pKernPairs && nCurPair < nPairs)

	    {

	      pKernPairs[nCurPair].mnChar1 = c1;

	      pKernPairs[nCurPair].mnChar2 = c2;

	      pKernPairs[nCurPair].mnKern =

		(long) (pPKD[i].xamt * pXpPKD->pointsize / 1000);

	    }

	  nCurPair++;

	return nCurPair;

  return nCurPair;

BOOL 

BOOL

SalGraphics::GetGlyphBoundRect( xub_Unicode c,

  SalGraphics::GetGlyphBoundRect (xub_Unicode c,

		long *pX, long *pY, long *pDX, long *pDY )

				  long *pX, long *pY, long *pDX, long *pDY)

	return FALSE;

  return FALSE;

ULONG 

ULONG

SalGraphics::GetGlyphOutline( xub_Unicode c,

  SalGraphics::GetGlyphOutline (xub_Unicode c,

		USHORT **ppPolySizes, SalPoint **ppPoints, BYTE **ppFlags )

				USHORT ** ppPolySizes, SalPoint ** ppPoints,

				BYTE ** ppFlags)

	return 0;

  return 0;