Removed psp::pitch::type/psp::family::type/psp::italic::type

12 files changed, 138 insertions, 328 deletions

diff --git a/vcl/inc/vcl/fontmanager.hxx b/vcl/inc/vcl/fontmanager.hxx
index 0318e4cbdeb0..145c4d0a2169 100644
--- a/vcl/inc/vcl/fontmanager.hxx
+++ b/vcl/inc/vcl/fontmanager.hxx
@@ -57,38 +57,6 @@ class ImplFontOptions;
 namespace psp {
 class PPDParser; // see ppdparser.hxx
 
-namespace italic
-{
-enum type {
-    Upright = 0,
-    Oblique = 1,
-    Italic = 2,
-    Unknown = 3
-};
-}
-
-namespace pitch
-{
-enum type {
-    Unknown = 0,
-    Fixed = 1,
-    Variable = 2
-};
-}
-
-namespace family
-{
-enum type {
-    Unknown = 0,
-    Decorative = 1,
-    Modern = 2,
-    Roman = 3,
-    Script = 4,
-    Swiss = 5,
-    System = 6
-};
-}
-
 namespace fonttype
 {
 enum type {
@@ -99,15 +67,6 @@ enum type {
 };
 }
 
-namespace fcstatus
-{
-enum type {
-    istrue,
-    isunset,
-    isfalse
-};
-}
-
 /*
  *  the difference between FastPrintFontInfo and PrintFontInfo
  *  is that the information in FastPrintFontInfo can usually
@@ -127,11 +86,11 @@ struct FastPrintFontInfo
     rtl::OUString                       m_aFamilyName;
     rtl::OUString                       m_aStyleName;
     std::list< rtl::OUString >          m_aAliases;
-    family::type                        m_eFamilyStyle;
-    italic::type                        m_eItalic;
+    FontFamily                          m_eFamilyStyle;
+    FontItalic                          m_eItalic;
     FontWidth                           m_eWidth;
     FontWeight                          m_eWeight;
-    pitch::type                         m_ePitch;
+    FontPitch                           m_ePitch;
     rtl_TextEncoding                    m_aEncoding;
     bool                                m_bSubsettable;
     bool                                m_bEmbeddable;
@@ -139,11 +98,11 @@ struct FastPrintFontInfo
     FastPrintFontInfo() :
             m_nID( 0 ),
             m_eType( fonttype::Unknown ),
-            m_eFamilyStyle( family::Unknown ),
-            m_eItalic( italic::Unknown ),
+            m_eFamilyStyle( FAMILY_DONTKNOW ),
+            m_eItalic( ITALIC_DONTKNOW ),
             m_eWidth( WIDTH_DONTKNOW ),
             m_eWeight( WEIGHT_DONTKNOW ),
-            m_ePitch( pitch::Unknown ),
+            m_ePitch( PITCH_DONTKNOW ),
             m_aEncoding( RTL_TEXTENCODING_DONTKNOW )
     {}
 };
@@ -242,10 +201,10 @@ class VCL_PLUGIN_PUBLIC PrintFontManager
         std::list< int >                            m_aAliases;
         int                                         m_nPSName;      // atom
         rtl::OUString                               m_aStyleName;
-        italic::type                                m_eItalic;
+        FontItalic                                  m_eItalic;
         FontWidth                                   m_eWidth;
         FontWeight                                  m_eWeight;
-        pitch::type                                 m_ePitch;
+        FontPitch                                   m_ePitch;
         rtl_TextEncoding                            m_aEncoding;
         bool                                        m_bFontEncodingOnly; // set if font should be only accessed by builtin encoding
         CharacterMetric                             m_aGlobalMetricX;
@@ -325,10 +284,10 @@ class VCL_PLUGIN_PUBLIC PrintFontManager
         rtl::OString        aFoundry;
         rtl::OString        aFamily;
         rtl::OString        aAddStyle;
-        italic::type        eItalic;
+        FontItalic          eItalic;
         FontWeight          eWeight;
         FontWidth           eWidth;
-        pitch::type         ePitch;
+        FontPitch           ePitch;
         rtl_TextEncoding    aEncoding;
 
         XLFDEntry() { nMask = 0; }
@@ -341,7 +300,7 @@ class VCL_PLUGIN_PUBLIC PrintFontManager
 
     fontID                                      m_nNextFontID;
     boost::unordered_map< fontID, PrintFont* >       m_aFonts;
-    boost::unordered_map< int, family::type >        m_aFamilyTypes;
+    boost::unordered_map< int, FontFamily >        m_aFamilyTypes;
     std::list< rtl::OUString >              m_aPrinterDrivers;
     std::list< rtl::OString >               m_aFontDirectories;
     std::list< int >                            m_aPrivateFontDirectories;
@@ -383,7 +342,7 @@ class VCL_PLUGIN_PUBLIC PrintFontManager
     fontID findFontFileID( int nDirID, const rtl::OString& rFile ) const;
     fontID findFontBuiltinID( int nPSNameAtom ) const;
 
-    family::type matchFamilyName( const rtl::OUString& rFamily ) const;
+    FontFamily matchFamilyName( const rtl::OUString& rFamily ) const;
 
     PrintFont* getFont( fontID nID ) const
     {
@@ -468,7 +427,7 @@ public:
     const rtl::OUString& getPSName( fontID nFontID ) const;
 
     // get a specific fonts style family
-    family::type getFontFamilyType( fontID nFontID ) const;
+    FontFamily getFontFamilyType( fontID nFontID ) const;
 
     // get a specific fonts family name aliases
     void getFontFamilyAliases( fontID nFontID ) const;
@@ -481,10 +440,10 @@ public:
     }
 
     // get a specific fonts italic type
-    italic::type getFontItalic( fontID nFontID ) const
+    FontItalic getFontItalic( fontID nFontID ) const
     {
         PrintFont* pFont = getFont( nFontID );
-        return pFont ? pFont->m_eItalic : italic::Unknown;
+        return pFont ? pFont->m_eItalic : ITALIC_DONTKNOW;
     }
 
     // get a specific fonts width type
@@ -502,10 +461,10 @@ public:
     }
 
     // get a specific fonts pitch type
-    pitch::type getFontPitch( fontID nFontID ) const
+    FontPitch getFontPitch( fontID nFontID ) const
     {
         PrintFont* pFont = getFont( nFontID );
-        return pFont ? pFont->m_ePitch : pitch::Unknown;
+        return pFont ? pFont->m_ePitch : PITCH_DONTKNOW;
     }
 
     // get a specific fonts encoding
@@ -703,8 +662,8 @@ public:
     ImplFontOptions* getFontOptions( const FastPrintFontInfo&, int nSize, void (*subcallback)(void*)) const;
 
     rtl::OUString Substitute( const rtl::OUString& rFontName, rtl::OUString& rMissingCodes,
-        const rtl::OString& rLangAttrib, italic::type& rItalic, FontWeight& rWeight,
-        FontWidth& rWidth, pitch::type& rPitch) const;
+        const rtl::OString& rLangAttrib, FontItalic& rItalic, FontWeight& rWeight,
+        FontWidth& rWidth, FontPitch& rPitch) const;
     bool hasFontconfig() const { return m_bFontconfigSuccess; }
 
     int FreeTypeCharIndex( void *pFace, sal_uInt32 aChar );
diff --git a/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx b/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
index eb2ec34d7162..fd46be07678f 100644
--- a/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
+++ b/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
@@ -3399,9 +3399,9 @@ void GtkSalGraphics::updateSettings( AllSettings& rSettings )
     // set italic
     switch( eStyle )
     {
-        case PANGO_STYLE_NORMAL:    aInfo.m_eItalic = psp::italic::Upright;break;
-        case PANGO_STYLE_ITALIC:    aInfo.m_eItalic = psp::italic::Italic;break;
-        case PANGO_STYLE_OBLIQUE:   aInfo.m_eItalic = psp::italic::Oblique;break;
+        case PANGO_STYLE_NORMAL:    aInfo.m_eItalic = ITALIC_NONE;break;
+        case PANGO_STYLE_ITALIC:    aInfo.m_eItalic = ITALIC_NORMAL;break;
+        case PANGO_STYLE_OBLIQUE:   aInfo.m_eItalic = ITALIC_OBLIQUE;break;
     }
     // set weight
     if( eWeight <= PANGO_WEIGHT_ULTRALIGHT )
@@ -3456,10 +3456,10 @@ void GtkSalGraphics::updateSettings( AllSettings& rSettings )
         aFont.SetWeight( aInfo.m_eWeight );
     if( aInfo.m_eWidth != WIDTH_DONTKNOW )
         aFont.SetWidthType( aInfo.m_eWidth );
-    if( aInfo.m_eItalic != psp::italic::Unknown )
-        aFont.SetItalic( PspGraphics::ToFontItalic( aInfo.m_eItalic ) );
-    if( aInfo.m_ePitch != psp::pitch::Unknown )
-        aFont.SetPitch( PspGraphics::ToFontPitch( aInfo.m_ePitch ) );
+    if( aInfo.m_eItalic != ITALIC_DONTKNOW )
+        aFont.SetItalic( aInfo.m_eItalic );
+    if( aInfo.m_ePitch != PITCH_DONTKNOW )
+        aFont.SetPitch( aInfo.m_ePitch );
 
     aStyleSet.SetAppFont( aFont );
     aStyleSet.SetHelpFont( aFont );
diff --git a/vcl/unx/headless/svppspgraphics.cxx b/vcl/unx/headless/svppspgraphics.cxx
index 253c5c8832d9..071c5b09f9c9 100644
--- a/vcl/unx/headless/svppspgraphics.cxx
+++ b/vcl/unx/headless/svppspgraphics.cxx
@@ -724,8 +724,8 @@ sal_uInt16 PspGraphics::SetFont( ImplFontSelectData *pEntry, int nFallbackLevel
     bool bArtBold = false;
     if( pEntry->meItalic == ITALIC_OBLIQUE || pEntry->meItalic == ITALIC_NORMAL )
     {
-        psp::italic::type eItalic = m_pPrinterGfx->GetFontMgr().getFontItalic( nID );
-        if( eItalic != psp::italic::Italic && eItalic != psp::italic::Oblique )
+        FontItalic eItalic = m_pPrinterGfx->GetFontMgr().getFontItalic( nID );
+        if( eItalic != ITALIC_NORMAL && eItalic != ITALIC_OBLIQUE )
             bArtItalic = true;
     }
     int nWeight = (int)pEntry->meWeight;
@@ -1078,54 +1078,16 @@ void PspGraphics::DoGetGlyphWidths( psp::fontID aFont,
 
 // ----------------------------------------------------------------------------
 
-FontPitch PspGraphics::ToFontPitch (psp::pitch::type ePitch)
-{
-    switch (ePitch)
-    {
-        case psp::pitch::Fixed:     return PITCH_FIXED;
-        case psp::pitch::Variable:  return PITCH_VARIABLE;
-        default: break;
-    }
-    return PITCH_DONTKNOW;
-}
-
-FontItalic PspGraphics::ToFontItalic (psp::italic::type eItalic)
-{
-    switch (eItalic)
-    {
-        case psp::italic::Upright:  return ITALIC_NONE;
-        case psp::italic::Oblique:  return ITALIC_OBLIQUE;
-        case psp::italic::Italic:   return ITALIC_NORMAL;
-        default: break;
-    }
-    return ITALIC_DONTKNOW;
-}
-
-FontFamily PspGraphics::ToFontFamily (psp::family::type eFamily)
-{
-    switch (eFamily)
-    {
-        case psp::family::Decorative: return FAMILY_DECORATIVE;
-        case psp::family::Modern:     return FAMILY_MODERN;
-        case psp::family::Roman:      return FAMILY_ROMAN;
-        case psp::family::Script:     return FAMILY_SCRIPT;
-        case psp::family::Swiss:      return FAMILY_SWISS;
-        case psp::family::System:     return FAMILY_SYSTEM;
-        default: break;
-    }
-    return FAMILY_DONTKNOW;
-}
-
 ImplDevFontAttributes PspGraphics::Info2DevFontAttributes( const psp::FastPrintFontInfo& rInfo )
 {
     ImplDevFontAttributes aDFA;
     aDFA.maName         = rInfo.m_aFamilyName;
     aDFA.maStyleName    = rInfo.m_aStyleName;
-    aDFA.meFamily       = ToFontFamily (rInfo.m_eFamilyStyle);
+    aDFA.meFamily       = rInfo.m_eFamilyStyle;
     aDFA.meWeight       = rInfo.m_eWeight;
-    aDFA.meItalic       = ToFontItalic (rInfo.m_eItalic);
+    aDFA.meItalic       = rInfo.m_eItalic;
     aDFA.meWidthType    = rInfo.m_eWidth;
-    aDFA.mePitch        = ToFontPitch (rInfo.m_ePitch);
+    aDFA.mePitch        = rInfo.m_ePitch;
     aDFA.mbSymbolFlag   = (rInfo.m_aEncoding == RTL_TEXTENCODING_SYMBOL);
 
     switch( rInfo.m_eType )
diff --git a/vcl/unx/headless/svppspgraphics.hxx b/vcl/unx/headless/svppspgraphics.hxx
index eadc04129632..5fdab151003c 100644
--- a/vcl/unx/headless/svppspgraphics.hxx
+++ b/vcl/unx/headless/svppspgraphics.hxx
@@ -79,9 +79,6 @@ public:
                                   Ucs2UIntMap& rUnicodeEnc );
     static ImplDevFontAttributes Info2DevFontAttributes( const psp::FastPrintFontInfo& );
     static void AnnounceFonts( ImplDevFontList*, const psp::FastPrintFontInfo& );
-    static FontPitch    ToFontPitch (psp::pitch::type ePitch);
-    static FontItalic   ToFontItalic (psp::italic::type eItalic);
-    static FontFamily   ToFontFamily (psp::family::type eFamily);
 
     // overload all pure virtual methods
     virtual void            GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY );
diff --git a/vcl/unx/inc/pspgraphics.h b/vcl/unx/inc/pspgraphics.h
index ec227c3eabc8..2c41297d3162 100644
--- a/vcl/unx/inc/pspgraphics.h
+++ b/vcl/unx/inc/pspgraphics.h
@@ -77,9 +77,6 @@ public:
 
     static ImplDevFontAttributes Info2DevFontAttributes( const psp::FastPrintFontInfo& );
     static void AnnounceFonts( ImplDevFontList*, const psp::FastPrintFontInfo& );
-    static FontPitch    ToFontPitch (psp::pitch::type ePitch);
-    static FontItalic   ToFontItalic (psp::italic::type eItalic);
-    static FontFamily   ToFontFamily (psp::family::type eFamily);
 
     // overload all pure virtual methods
     virtual void            GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY );
diff --git a/vcl/unx/kde/salnativewidgets-kde.cxx b/vcl/unx/kde/salnativewidgets-kde.cxx
index 99b998d99266..252cb0b77331 100644
--- a/vcl/unx/kde/salnativewidgets-kde.cxx
+++ b/vcl/unx/kde/salnativewidgets-kde.cxx
@@ -1761,7 +1761,7 @@ static Font toFont( const QFont &rQFont, const ::com::sun::star::lang::Locale& r
     aInfo.m_aFamilyName = String( rQFont.family().utf8(), RTL_TEXTENCODING_UTF8 );
 
     // set italic
-    aInfo.m_eItalic = ( qFontInfo.italic()? psp::italic::Italic: psp::italic::Upright );
+    aInfo.m_eItalic = ( qFontInfo.italic()? ITALIC_NORMAL: ITALIC_NONE );
 
     // set weight
     int nWeight = qFontInfo.weight();
@@ -1821,10 +1821,10 @@ static Font toFont( const QFont &rQFont, const ::com::sun::star::lang::Locale& r
         aFont.SetWeight( aInfo.m_eWeight );
     if( aInfo.m_eWidth != WIDTH_DONTKNOW )
         aFont.SetWidthType( aInfo.m_eWidth );
-    if( aInfo.m_eItalic != psp::italic::Unknown )
-        aFont.SetItalic( PspGraphics::ToFontItalic( aInfo.m_eItalic ) );
-    if( aInfo.m_ePitch != psp::pitch::Unknown )
-        aFont.SetPitch( PspGraphics::ToFontPitch( aInfo.m_ePitch ) );
+    if( aInfo.m_eItalic != ITALIC_DONTKNOW )
+        aFont.SetItalic( aInfo.m_eItalic );
+    if( aInfo.m_ePitch != PITCH_DONTKNOW )
+        aFont.SetPitch( aInfo.m_ePitch );
 
     return aFont;
 }
diff --git a/vcl/unx/kde4/KDESalFrame.cxx b/vcl/unx/kde4/KDESalFrame.cxx
index 64a8bac2c22c..220859bc7e01 100644
--- a/vcl/unx/kde4/KDESalFrame.cxx
+++ b/vcl/unx/kde4/KDESalFrame.cxx
@@ -102,7 +102,7 @@ static Font toFont( const QFont &rQFont, const ::com::sun::star::lang::Locale& r
     aInfo.m_aFamilyName = String( (const char *) rQFont.family().toUtf8(), RTL_TEXTENCODING_UTF8 );
 
     // set italic
-    aInfo.m_eItalic = ( qFontInfo.italic()? psp::italic::Italic: psp::italic::Upright );
+    aInfo.m_eItalic = ( qFontInfo.italic()? ITALIC_NORMAL: ITALIC_NONE );
 
     // set weight
     int nWeight = qFontInfo.weight();
@@ -162,10 +162,10 @@ static Font toFont( const QFont &rQFont, const ::com::sun::star::lang::Locale& r
         aFont.SetWeight( aInfo.m_eWeight );
     if( aInfo.m_eWidth != WIDTH_DONTKNOW )
         aFont.SetWidthType( aInfo.m_eWidth );
-    if( aInfo.m_eItalic != psp::italic::Unknown )
-        aFont.SetItalic( PspGraphics::ToFontItalic( aInfo.m_eItalic ) );
-    if( aInfo.m_ePitch != psp::pitch::Unknown )
-        aFont.SetPitch( PspGraphics::ToFontPitch( aInfo.m_ePitch ) );
+    if( aInfo.m_eItalic != ITALIC_DONTKNOW )
+        aFont.SetItalic( aInfo.m_eItalic );
+    if( aInfo.m_ePitch != PITCH_DONTKNOW )
+        aFont.SetPitch( aInfo.m_ePitch );
 
     return aFont;
 }
diff --git a/vcl/unx/source/fontmanager/fontcache.cxx b/vcl/unx/source/fontmanager/fontcache.cxx
index a4a88745e98d..f1c07afed1c9 100644
--- a/vcl/unx/source/fontmanager/fontcache.cxx
+++ b/vcl/unx/source/fontmanager/fontcache.cxx
@@ -408,10 +408,10 @@ void FontCache::read()
                 }
                 int nCollEntry      = atoi( pLine );
                 pFont->m_nPSName    = pAtoms->getAtom( ATOM_PSNAME, OUString( pLine + nTokenPos[1], nTokenPos[2]-nTokenPos[1]-1, RTL_TEXTENCODING_UTF8 ), sal_True );
-                pFont->m_eItalic    = (italic::type)atoi( pLine+nTokenPos[2] );
+                pFont->m_eItalic    = (FontItalic)atoi( pLine+nTokenPos[2] );
                 pFont->m_eWeight    = (FontWeight)atoi( pLine+nTokenPos[3] );
                 pFont->m_eWidth     = (FontWidth)atoi( pLine+nTokenPos[4] );
-                pFont->m_ePitch     = (pitch::type)atoi( pLine+nTokenPos[5] );
+                pFont->m_ePitch     = (FontPitch)atoi( pLine+nTokenPos[5] );
                 pFont->m_aEncoding  = (rtl_TextEncoding)atoi( pLine+nTokenPos[6] );
                 pFont->m_nAscend    = atoi( pLine + nTokenPos[7] );
                 pFont->m_nDescend   = atoi( pLine + nTokenPos[8] );
diff --git a/vcl/unx/source/fontmanager/fontconfig.cxx b/vcl/unx/source/fontmanager/fontconfig.cxx
index b755bf0b8e41..53731ea1ee2d 100644
--- a/vcl/unx/source/fontmanager/fontconfig.cxx
+++ b/vcl/unx/source/fontmanager/fontconfig.cxx
@@ -775,22 +775,22 @@ namespace
         return WEIGHT_BLACK;
     }
 
-    italic::type convertSlant(int slant)
+    FontItalic convertSlant(int slant)
     {
         // set italic
         if( slant == FC_SLANT_ITALIC )
-            return italic::Italic;
+            return ITALIC_NORMAL;
         else if( slant == FC_SLANT_OBLIQUE )
-            return italic::Oblique;
-        return italic::Upright;
+            return ITALIC_OBLIQUE;
+        return ITALIC_NONE;
     }
 
-    pitch::type convertSpacing(int spacing)
+    FontPitch convertSpacing(int spacing)
     {
         // set pitch
         if( spacing == FC_MONO || spacing == FC_CHARCELL )
-            return pitch::Fixed;
-        return pitch::Variable;
+            return PITCH_FIXED;
+        return PITCH_VARIABLE;
     }
 
     // translation: fontconfig enum -> vcl enum
@@ -1041,15 +1041,15 @@ bool PrintFontManager::addFontconfigDir( const rtl::OString& rDirName )
 }
 
 static void addtopattern(FontCfgWrapper& rWrapper, FcPattern *pPattern,
-    italic::type eItalic, FontWeight eWeight, FontWidth eWidth, pitch::type ePitch)
+    FontItalic eItalic, FontWeight eWeight, FontWidth eWidth, FontPitch ePitch)
 {
-    if( eItalic != italic::Unknown )
+    if( eItalic != ITALIC_DONTKNOW )
     {
         int nSlant = FC_SLANT_ROMAN;
         switch( eItalic )
         {
-            case italic::Italic:        nSlant = FC_SLANT_ITALIC;break;
-            case italic::Oblique:       nSlant = FC_SLANT_OBLIQUE;break;
+            case ITALIC_NORMAL:     nSlant = FC_SLANT_ITALIC;break;
+            case ITALIC_OBLIQUE:        nSlant = FC_SLANT_OBLIQUE;break;
             default:
                 break;
         }
@@ -1094,13 +1094,13 @@ static void addtopattern(FontCfgWrapper& rWrapper, FcPattern *pPattern,
         }
         rWrapper.FcPatternAddInteger( pPattern, FC_WIDTH, nWidth );
     }
-    if( ePitch != pitch::Unknown )
+    if( ePitch != PITCH_DONTKNOW )
     {
         int nSpacing = FC_PROPORTIONAL;
         switch( ePitch )
         {
-            case pitch::Fixed:          nSpacing = FC_MONO;break;
-            case pitch::Variable:       nSpacing = FC_PROPORTIONAL;break;
+            case PITCH_FIXED:           nSpacing = FC_MONO;break;
+            case PITCH_VARIABLE:        nSpacing = FC_PROPORTIONAL;break;
             default:
                 break;
         }
@@ -1112,8 +1112,8 @@ static void addtopattern(FontCfgWrapper& rWrapper, FcPattern *pPattern,
 
 rtl::OUString PrintFontManager::Substitute(const rtl::OUString& rFontName,
     rtl::OUString& rMissingCodes, const rtl::OString &rLangAttrib,
-    italic::type &rItalic, FontWeight &rWeight,
-    FontWidth &rWidth, pitch::type &rPitch) const
+    FontItalic &rItalic, FontWeight &rWeight,
+    FontWidth &rWidth, FontPitch &rPitch) const
 {
     rtl::OUString aName;
     FontCfgWrapper& rWrapper = FontCfgWrapper::get();
@@ -1429,7 +1429,7 @@ int PrintFontManager::FreeTypeCharIndex( void*, sal_uInt32 )
 }
 
 rtl::OUString PrintFontManager::Substitute( const rtl::OUString&,
-    rtl::OUString&, const rtl::OString&, italic::type, FontWeight, FontWidth, pitch::type) const
+    rtl::OUString&, const rtl::OString&, FontItalic, FontWeight, FontWidth, FontPitch) const
 {
     rtl::OUString aName;
     return aName;
diff --git a/vcl/unx/source/fontmanager/fontmanager.cxx b/vcl/unx/source/fontmanager/fontmanager.cxx
index d22a19a2a78f..c4a962ae9e62 100644
--- a/vcl/unx/source/fontmanager/fontmanager.cxx
+++ b/vcl/unx/source/fontmanager/fontmanager.cxx
@@ -135,15 +135,15 @@ inline sal_uInt32 getUInt32BE( const sal_uInt8*& pBuffer )
     return nRet;
 }
 
-static italic::type parseItalic( const ByteString& rItalic )
+static FontItalic parseItalic( const ByteString& rItalic )
 {
-    italic::type eItalic = italic::Unknown;
+    FontItalic eItalic = ITALIC_DONTKNOW;
     if( rItalic.EqualsIgnoreCaseAscii( "i" ) )
-        eItalic = italic::Italic;
+        eItalic = ITALIC_NORMAL;
     else if( rItalic.EqualsIgnoreCaseAscii( "o" ) )
-        eItalic = italic::Oblique;
+        eItalic = ITALIC_OBLIQUE;
     else
-        eItalic = italic::Upright;
+        eItalic = ITALIC_NONE;
     return eItalic;
 }
 
@@ -356,10 +356,10 @@ PrintFontManager::PrintFont::PrintFont( fonttype::type eType ) :
         m_eType( eType ),
         m_nFamilyName( 0 ),
         m_nPSName( 0 ),
-        m_eItalic( italic::Unknown ),
+        m_eItalic( ITALIC_DONTKNOW ),
         m_eWidth( WIDTH_DONTKNOW ),
         m_eWeight( WEIGHT_DONTKNOW ),
-        m_ePitch( pitch::Unknown ),
+        m_ePitch( PITCH_DONTKNOW ),
         m_aEncoding( RTL_TEXTENCODING_DONTKNOW ),
         m_bFontEncodingOnly( false ),
         m_pMetrics( NULL ),
@@ -813,11 +813,11 @@ bool PrintFontManager::PrintFont::readAfmMetrics( const OString& rFileName, Mult
 
     // italic
     if( pInfo->gfi->italicAngle > 0 )
-        m_eItalic = italic::Oblique;
+        m_eItalic = ITALIC_OBLIQUE;
     else if( pInfo->gfi->italicAngle < 0 )
-        m_eItalic = italic::Italic;
+        m_eItalic = ITALIC_NORMAL;
     else
-        m_eItalic = italic::Upright;
+        m_eItalic = ITALIC_NONE;
 
     // weight
     ByteString aLowerWeight( pInfo->gfi->weight );
@@ -825,7 +825,7 @@ bool PrintFontManager::PrintFont::readAfmMetrics( const OString& rFileName, Mult
     m_eWeight = parseWeight( aLowerWeight );
 
     // pitch
-    m_ePitch = pInfo->gfi->isFixedPitch ? pitch::Fixed : pitch::Variable;
+    m_ePitch = pInfo->gfi->isFixedPitch ? PITCH_FIXED : PITCH_VARIABLE;
 
     // encoding - only set if unknown
     int nAdobeEncoding = 0;
@@ -1533,9 +1533,9 @@ bool PrintFontManager::parseXLFD( const OString& rXLFD, XLFDEntry& rEntry )
 
     // evaluate pitch
     if( aPitch.toChar() == 'c' || aPitch.toChar() == 'm' )
-        rEntry.ePitch = pitch::Fixed;
+        rEntry.ePitch = PITCH_FIXED;
     else
-        rEntry.ePitch = pitch::Variable;
+        rEntry.ePitch = PITCH_VARIABLE;
 
     OString aToken = aEnc.toAsciiLowerCase();
     // get encoding
@@ -1710,9 +1710,9 @@ OString PrintFontManager::getXLFD( PrintFont* pFont ) const
     aXLFD.append('-');
     switch( pFont->m_eItalic )
     {
-        case italic::Upright:       aXLFD.append('r');break;
-        case italic::Oblique:       aXLFD.append('o');break;
-        case italic::Italic:        aXLFD.append('i');break;
+        case ITALIC_NONE:       aXLFD.append('r');break;
+        case ITALIC_OBLIQUE:       aXLFD.append('o');break;
+        case ITALIC_NORMAL:        aXLFD.append('i');break;
         default: break;
     }
     aXLFD.append('-');
@@ -1730,7 +1730,7 @@ OString PrintFontManager::getXLFD( PrintFont* pFont ) const
         default: break;
     }
     aXLFD.append("-utf8-0-0-0-0-");
-    aXLFD.append( pFont->m_ePitch == pitch::Fixed ? "m" : "p" );
+    aXLFD.append( pFont->m_ePitch == PITCH_FIXED ? "m" : "p" );
     aXLFD.append("-0-");
     const char* pEnc = rtl_getBestUnixCharsetFromTextEncoding( pFont->m_aEncoding );
     if( ! pEnc )
@@ -1975,12 +1975,12 @@ bool PrintFontManager::analyzeTrueTypeFile( PrintFont* pFont ) const
             default:                        pFont->m_eWidth = WIDTH_NORMAL; break;
         }
 
-        pFont->m_ePitch = aInfo.pitch ? pitch::Fixed : pitch::Variable;
-        pFont->m_eItalic = aInfo.italicAngle == 0 ? italic::Upright : ( aInfo.italicAngle < 0 ? italic::Italic : italic::Oblique );
+        pFont->m_ePitch = aInfo.pitch ? PITCH_FIXED : PITCH_VARIABLE;
+        pFont->m_eItalic = aInfo.italicAngle == 0 ? ITALIC_NONE : ( aInfo.italicAngle < 0 ? ITALIC_NORMAL : ITALIC_OBLIQUE );
         // #104264# there are fonts that set italic angle 0 although they are
         // italic; use macstyle bit here
         if( aInfo.italicAngle == 0 && (aInfo.macStyle & 2) )
-            pFont->m_eItalic = italic::Italic;
+            pFont->m_eItalic = ITALIC_NORMAL;
 
         pFont->m_aEncoding = aInfo.symbolEncoded ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UCS2;
 
@@ -2431,13 +2431,13 @@ void PrintFontManager::initialize()
     ::boost::unordered_map< fontID, PrintFont* >::iterator font_it;
     for (font_it = m_aFonts.begin(); font_it != m_aFonts.end(); ++font_it)
     {
-        ::boost::unordered_map< int, family::type >::const_iterator it =
+        ::boost::unordered_map< int, FontFamily >::const_iterator it =
               m_aFamilyTypes.find( font_it->second->m_nFamilyName );
         if (it != m_aFamilyTypes.end())
             continue;
         const ::rtl::OUString& rFamily =
             m_pAtoms->getString( ATOM_FAMILYNAME, font_it->second->m_nFamilyName);
-        family::type eType = matchFamilyName( rFamily );
+        FontFamily eType = matchFamilyName( rFamily );
         m_aFamilyTypes[ font_it->second->m_nFamilyName ] = eType;
     }
 
@@ -2460,7 +2460,7 @@ void PrintFontManager::initialize()
 
 // -------------------------------------------------------------------------
 inline bool
-equalPitch (psp::pitch::type from, psp::pitch::type to)
+equalPitch (FontPitch from, FontPitch to)
 {
     return from == to;
 }
@@ -2472,10 +2472,10 @@ equalWeight (FontWeight from, FontWeight to)
 }
 
 inline bool
-equalItalic (psp::italic::type from, psp::italic::type to)
+equalItalic (FontItalic from, FontItalic to)
 {
-    if ( (from == psp::italic::Italic) || (from == psp::italic::Oblique) )
-        return (to == psp::italic::Italic) || (to == psp::italic::Oblique);
+    if ( (from == ITALIC_NORMAL) || (from == ITALIC_OBLIQUE) )
+        return (to == ITALIC_NORMAL) || (to == ITALIC_OBLIQUE);
     return to == from;
 }
 inline bool
@@ -2490,15 +2490,15 @@ namespace {
     struct BuiltinFontIdentifier
     {
         OUString            aFamily;
-        italic::type        eItalic;
+        FontItalic          eItalic;
         FontWeight          eWeight;
-        pitch::type         ePitch;
+        FontPitch           ePitch;
         rtl_TextEncoding    aEncoding;
 
         BuiltinFontIdentifier( const OUString& rFam,
-                               italic::type eIt,
+                               FontItalic eIt,
                                FontWeight eWg,
-                               pitch::type ePt,
+                               FontPitch ePt,
                                rtl_TextEncoding enc ) :
             aFamily( rFam ),
             eItalic( eIt ),
@@ -2652,12 +2652,12 @@ void PrintFontManager::getFontList( ::std::list< fontID >& rFontIDs, const PPDPa
 
 void PrintFontManager::fillPrintFontInfo( PrintFont* pFont, FastPrintFontInfo& rInfo ) const
 {
-    ::boost::unordered_map< int, family::type >::const_iterator style_it =
+    ::boost::unordered_map< int, FontFamily >::const_iterator style_it =
           m_aFamilyTypes.find( pFont->m_nFamilyName );
     rInfo.m_eType           = pFont->m_eType;
     rInfo.m_aFamilyName     = m_pAtoms->getString( ATOM_FAMILYNAME, pFont->m_nFamilyName );
     rInfo.m_aStyleName      = pFont->m_aStyleName;
-    rInfo.m_eFamilyStyle    = style_it != m_aFamilyTypes.end() ? style_it->second : family::Unknown;
+    rInfo.m_eFamilyStyle    = style_it != m_aFamilyTypes.end() ? style_it->second : FAMILY_DONTKNOW;
     rInfo.m_eItalic         = pFont->m_eItalic;
     rInfo.m_eWidth          = pFont->m_eWidth;
     rInfo.m_eWeight         = pFont->m_eWeight;
@@ -2796,42 +2796,42 @@ int PrintFontManager::getFontFaceNumber( fontID nFontID ) const
 // -------------------------------------------------------------------------
 
 
-family::type PrintFontManager::matchFamilyName( const ::rtl::OUString& rFamily ) const
+FontFamily PrintFontManager::matchFamilyName( const ::rtl::OUString& rFamily ) const
 {
     typedef struct {
         const char*  mpName;
         sal_uInt16   mnLength;
-        family::type meType;
+        FontFamily   meType;
     } family_t;
 
 #define InitializeClass( p, a ) p, sizeof(p) - 1, a
     const family_t pFamilyMatch[] =  {
-        { InitializeClass( "arial",                  family::Swiss )  },
-        { InitializeClass( "arioso",                 family::Script ) },
-        { InitializeClass( "avant garde",            family::Swiss )  },
-        { InitializeClass( "avantgarde",             family::Swiss )  },
-        { InitializeClass( "bembo",                  family::Roman )  },
-        { InitializeClass( "bookman",                family::Roman )  },
-        { InitializeClass( "conga",                  family::Roman )  },
-        { InitializeClass( "courier",                family::Modern ) },
-        { InitializeClass( "curl",                   family::Script ) },
-        { InitializeClass( "fixed",                  family::Modern ) },
-        { InitializeClass( "gill",                   family::Swiss )  },
-        { InitializeClass( "helmet",                 family::Modern ) },
-        { InitializeClass( "helvetica",              family::Swiss )  },
-        { InitializeClass( "international",          family::Modern ) },
-        { InitializeClass( "lucida",                 family::Swiss )  },
-        { InitializeClass( "new century schoolbook", family::Roman )  },
-        { InitializeClass( "palatino",               family::Roman )  },
-        { InitializeClass( "roman",                  family::Roman )  },
-        { InitializeClass( "sans serif",             family::Swiss )  },
-        { InitializeClass( "sansserif",              family::Swiss )  },
-        { InitializeClass( "serf",                   family::Roman )  },
-        { InitializeClass( "serif",                  family::Roman )  },
-        { InitializeClass( "times",                  family::Roman )  },
-        { InitializeClass( "utopia",                 family::Roman )  },
-        { InitializeClass( "zapf chancery",          family::Script ) },
-        { InitializeClass( "zapfchancery",           family::Script ) }
+        { InitializeClass( "arial",                  FAMILY_SWISS )  },
+        { InitializeClass( "arioso",                 FAMILY_SCRIPT ) },
+        { InitializeClass( "avant garde",            FAMILY_SWISS )  },
+        { InitializeClass( "avantgarde",             FAMILY_SWISS )  },
+        { InitializeClass( "bembo",                  FAMILY_ROMAN )  },
+        { InitializeClass( "bookman",                FAMILY_ROMAN )  },
+        { InitializeClass( "conga",                  FAMILY_ROMAN )  },
+        { InitializeClass( "courier",                FAMILY_MODERN ) },
+        { InitializeClass( "curl",                   FAMILY_SCRIPT ) },
+        { InitializeClass( "fixed",                  FAMILY_MODERN ) },
+        { InitializeClass( "gill",                   FAMILY_SWISS )  },
+        { InitializeClass( "helmet",                 FAMILY_MODERN ) },
+        { InitializeClass( "helvetica",              FAMILY_SWISS )  },
+        { InitializeClass( "international",          FAMILY_MODERN ) },
+        { InitializeClass( "lucida",                 FAMILY_SWISS )  },
+        { InitializeClass( "new century schoolbook", FAMILY_ROMAN )  },
+        { InitializeClass( "palatino",               FAMILY_ROMAN )  },
+        { InitializeClass( "roman",                  FAMILY_ROMAN )  },
+        { InitializeClass( "sans serif",             FAMILY_SWISS )  },
+        { InitializeClass( "sansserif",              FAMILY_SWISS )  },
+        { InitializeClass( "serf",                   FAMILY_ROMAN )  },
+        { InitializeClass( "serif",                  FAMILY_ROMAN )  },
+        { InitializeClass( "times",                  FAMILY_ROMAN )  },
+        { InitializeClass( "utopia",                 FAMILY_ROMAN )  },
+        { InitializeClass( "zapf chancery",          FAMILY_SCRIPT ) },
+        { InitializeClass( "zapfchancery",           FAMILY_SCRIPT ) }
     };
 
     rtl::OString aFamily = rtl::OUStringToOString( rFamily, RTL_TEXTENCODING_ASCII_US );
@@ -2858,20 +2858,20 @@ family::type PrintFontManager::matchFamilyName( const ::rtl::OUString& rFamily )
                 return pHaystack->meType;
     }
 
-    return family::Unknown;
+    return FAMILY_DONTKNOW;
 }
 
 // -------------------------------------------------------------------------
 
-family::type PrintFontManager::getFontFamilyType( fontID nFontID ) const
+FontFamily PrintFontManager::getFontFamilyType( fontID nFontID ) const
 {
     PrintFont* pFont = getFont( nFontID );
     if( !pFont )
-        return family::Unknown;
+        return FAMILY_DONTKNOW;
 
-    ::boost::unordered_map< int, family::type >::const_iterator it =
+    ::boost::unordered_map< int, FontFamily >::const_iterator it =
           m_aFamilyTypes.find( pFont->m_nFamilyName );
-    return (it != m_aFamilyTypes.end()) ? it->second : family::Unknown;
+    return (it != m_aFamilyTypes.end()) ? it->second : FAMILY_DONTKNOW;
 }
 
 
@@ -4014,13 +4014,13 @@ bool PrintFontManager::readOverrideMetrics()
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StyleName" ) ) )
                 pFont->m_aStyleName = getString(pProps[n].Value);
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Italic" ) ) )
-                pFont->m_eItalic = static_cast<italic::type>(getInt(pProps[n].Value));
+                pFont->m_eItalic = static_cast<FontItalic>(getInt(pProps[n].Value));
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Width" ) ) )
                 pFont->m_eWidth = static_cast<FontWidth>(getInt(pProps[n].Value));
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Weight" ) ) )
                 pFont->m_eWeight = static_cast<FontWeight>(getInt(pProps[n].Value));
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Pitch" ) ) )
-                pFont->m_ePitch = static_cast<pitch::type>(getInt(pProps[n].Value));
+                pFont->m_ePitch = static_cast<FontPitch>(getInt(pProps[n].Value));
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Encoding" ) ) )
                 pFont->m_aEncoding = static_cast<rtl_TextEncoding>(getInt(pProps[n].Value));
             else if( pProps[n].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FontEncodingOnly" ) ) )
diff --git a/vcl/unx/source/gdi/pspgraphics.cxx b/vcl/unx/source/gdi/pspgraphics.cxx
index 1717d9857120..4b4a4d9ebfa4 100644
--- a/vcl/unx/source/gdi/pspgraphics.cxx
+++ b/vcl/unx/source/gdi/pspgraphics.cxx
@@ -810,8 +810,8 @@ sal_uInt16 PspGraphics::SetFont( ImplFontSelectData *pEntry, int nFallbackLevel
     bool bArtBold = false;
     if( pEntry->meItalic == ITALIC_OBLIQUE || pEntry->meItalic == ITALIC_NORMAL )
     {
-        psp::italic::type eItalic = m_pPrinterGfx->GetFontMgr().getFontItalic( nID );
-        if( eItalic != psp::italic::Italic && eItalic != psp::italic::Oblique )
+        FontItalic eItalic = m_pPrinterGfx->GetFontMgr().getFontItalic( nID );
+        if( eItalic != ITALIC_NORMAL && eItalic != ITALIC_OBLIQUE )
             bArtItalic = true;
     }
     int nWeight = (int)pEntry->meWeight;
@@ -1180,63 +1180,16 @@ void PspGraphics::DoGetGlyphWidths( psp::fontID aFont,
 }
 // ----------------------------------------------------------------------------
 
-FontPitch PspGraphics::ToFontPitch (psp::pitch::type ePitch)
-{
-    switch (ePitch)
-    {
-        case psp::pitch::Fixed:     return PITCH_FIXED;
-        case psp::pitch::Variable:  return PITCH_VARIABLE;
-        case psp::pitch::Unknown:   return PITCH_DONTKNOW;
-        default:
-            OSL_FAIL( "unknown pitch mapping" );
-            break;
-    }
-    return PITCH_DONTKNOW;
-}
-
-FontItalic PspGraphics::ToFontItalic (psp::italic::type eItalic)
-{
-    switch (eItalic)
-    {
-        case psp::italic::Upright:  return ITALIC_NONE;
-        case psp::italic::Oblique:  return ITALIC_OBLIQUE;
-        case psp::italic::Italic:   return ITALIC_NORMAL;
-        case psp::italic::Unknown:  return ITALIC_DONTKNOW;
-        default:
-            OSL_FAIL( "unknown italic mapping" );
-            break;
-    }
-    return ITALIC_DONTKNOW;
-}
-
-FontFamily PspGraphics::ToFontFamily (psp::family::type eFamily)
-{
-    switch (eFamily)
-    {
-        case psp::family::Decorative: return FAMILY_DECORATIVE;
-        case psp::family::Modern:     return FAMILY_MODERN;
-        case psp::family::Roman:      return FAMILY_ROMAN;
-        case psp::family::Script:     return FAMILY_SCRIPT;
-        case psp::family::Swiss:      return FAMILY_SWISS;
-        case psp::family::System:     return FAMILY_SYSTEM;
-        case psp::family::Unknown:    return FAMILY_DONTKNOW;
-        default:
-            OSL_FAIL( "unknown family mapping" );
-            break;
-    }
-    return FAMILY_DONTKNOW;
-}
-
 ImplDevFontAttributes PspGraphics::Info2DevFontAttributes( const psp::FastPrintFontInfo& rInfo )
 {
     ImplDevFontAttributes aDFA;
     aDFA.maName         = rInfo.m_aFamilyName;
     aDFA.maStyleName    = rInfo.m_aStyleName;
-    aDFA.meFamily       = ToFontFamily (rInfo.m_eFamilyStyle);
+    aDFA.meFamily       = rInfo.m_eFamilyStyle;
     aDFA.meWeight       = rInfo.m_eWeight;
-    aDFA.meItalic       = ToFontItalic (rInfo.m_eItalic);
+    aDFA.meItalic       = rInfo.m_eItalic;
     aDFA.meWidthType    = rInfo.m_eWidth;
-    aDFA.mePitch        = ToFontPitch (rInfo.m_ePitch);
+    aDFA.mePitch        = rInfo.m_ePitch;
     aDFA.mbSymbolFlag   = (rInfo.m_aEncoding == RTL_TEXTENCODING_SYMBOL);
     aDFA.mbSubsettable  = rInfo.m_bSubsettable;
     aDFA.mbEmbeddable   = rInfo.m_bEmbeddable;
diff --git a/vcl/unx/source/gdi/salgdi3.cxx b/vcl/unx/source/gdi/salgdi3.cxx
index 7b46858e67eb..df65d8cc64da 100644
--- a/vcl/unx/source/gdi/salgdi3.cxx
+++ b/vcl/unx/source/gdi/salgdi3.cxx
@@ -1100,31 +1100,11 @@ void cairosubcallback( void* pPattern )
 
 ImplFontOptions* GetFCFontOptions( const ImplFontAttributes& rFontAttributes, int nSize)
 {
-    // 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
+    aInfo.m_eItalic = rFontAttributes.GetSlant();
     aInfo.m_eWeight = rFontAttributes.GetWeight();
-    // set width
     aInfo.m_eWidth = rFontAttributes.GetWidthType();
 
     const psp::PrintFontManager& rPFM = psp::PrintFontManager::get();
@@ -1395,56 +1375,18 @@ static ImplFontSelectData GetFcSubstitute(const ImplFontSelectData &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;
-        }
-    }
-
+    FontItalic eItalic = rFontSelData.GetSlant();
     FontWeight eWeight = rFontSelData.GetWeight();
     FontWidth eWidth = rFontSelData.GetWidthType();
-
-    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;
-        }
-    }
+    FontPitch ePitch = rFontSelData.GetPitch();
 
     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;
-    }
-
+    aRet.meItalic    = eItalic;
     aRet.meWeight    = eWeight;
     aRet.meWidthType = eWidth;
-
-    switch (ePitch)
-    {
-        case psp::pitch::Fixed: aRet.mePitch = PITCH_FIXED; break;
-        case psp::pitch::Variable: aRet.mePitch = PITCH_VARIABLE; break;
-        default:
-            break;
-    }
+    aRet.mePitch     = ePitch;
 
     return aRet;
 }