| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| |
| #include <stdlib.h> |
| |
| #ifndef _SVX_SVXIDS_HRC |
| #include <svx/svxids.hrc> |
| #endif |
| #include <i18npool/mslangid.hxx> |
| #include <svtools/ctrltool.hxx> |
| #include <svl/urihelper.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/adjitem.hxx> |
| #include <editeng/blnkitem.hxx> |
| #include <editeng/crsditem.hxx> |
| #include <editeng/kernitem.hxx> |
| #include <editeng/lspcitem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <editeng/postitem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <editeng/cmapitem.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <editeng/wghtitem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/langitem.hxx> |
| #include <svl/itempool.hxx> |
| #include <editeng/spltitem.hxx> |
| #include <editeng/widwitem.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <editeng/orphitem.hxx> |
| #include <svtools/svparser.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/wrkwin.hxx> |
| |
| #include "css1kywd.hxx" |
| #include "svxcss1.hxx" |
| |
| // die Funktionen zum Parsen einer CSS1-Property sind von folgendem Typ: |
| typedef void (*FnParseCSS1Prop)( const CSS1Expression *pExpr, |
| SfxItemSet& rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ); |
| |
| SV_IMPL_PTRARR( CSS1Selectors, CSS1Selector* ) |
| |
| |
| /* */ |
| |
| static CSS1PropertyEnum __READONLY_DATA aFontSizeTable[] = |
| { |
| { sCSS1_PV_xx_small, 0 }, |
| { sCSS1_PV_x_small, 1 }, |
| { sCSS1_PV_small, 2 }, |
| { sCSS1_PV_medium, 3 }, |
| { sCSS1_PV_large, 4 }, |
| { sCSS1_PV_x_large, 5 }, |
| { sCSS1_PV_xx_large, 6 }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aFontFamilyTable[] = |
| { |
| { sCSS1_PV_serif, FAMILY_ROMAN }, |
| { sCSS1_PV_sans_serif, FAMILY_SWISS }, |
| { sCSS1_PV_cursive, FAMILY_SCRIPT }, |
| { sCSS1_PV_fantasy, FAMILY_DECORATIVE }, |
| { sCSS1_PV_monospace, FAMILY_MODERN }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aFontWeightTable[] = |
| { |
| { sCSS1_PV_extra_light, WEIGHT_NORMAL }, // WEIGHT_ULTRALIGHT (OBS) |
| { sCSS1_PV_light, WEIGHT_NORMAL }, // WEIGHT_LIGHT (OBSOLETE) |
| { sCSS1_PV_demi_light, WEIGHT_NORMAL }, // WEIGHT_SEMILIGHT (OBS) |
| { sCSS1_PV_medium, WEIGHT_NORMAL }, // WEIGHT_MEDIUM (OBS) |
| { sCSS1_PV_normal, WEIGHT_NORMAL }, // WEIGHT_MEDIUM |
| { sCSS1_PV_demi_bold, WEIGHT_NORMAL }, // WEIGHT_SEMIBOLD (OBS) |
| { sCSS1_PV_bold, WEIGHT_BOLD }, // WEIGHT_BOLD (OBSOLETE) |
| { sCSS1_PV_extra_bold, WEIGHT_BOLD }, // WEIGHT_ULTRABOLD (OBS) |
| { sCSS1_PV_bolder, WEIGHT_BOLD }, |
| { sCSS1_PV_lighter, WEIGHT_NORMAL }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aFontStyleTable[] = |
| { |
| { sCSS1_PV_normal, ITALIC_NONE }, |
| { sCSS1_PV_italic, ITALIC_NORMAL }, |
| { sCSS1_PV_oblique, ITALIC_NORMAL }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aFontVariantTable[] = |
| { |
| { sCSS1_PV_normal, SVX_CASEMAP_NOT_MAPPED }, |
| { sCSS1_PV_small_caps, SVX_CASEMAP_KAPITAELCHEN }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aDirectionTable[] = |
| { |
| { sCSS1_PV_ltr, FRMDIR_HORI_LEFT_TOP }, |
| { sCSS1_PV_rtl, FRMDIR_HORI_RIGHT_TOP }, |
| { sCSS1_PV_inherit, FRMDIR_ENVIRONMENT }, |
| { 0, 0 } |
| }; |
| |
| /* */ |
| |
| static CSS1PropertyEnum __READONLY_DATA aBGRepeatTable[] = |
| { |
| { sCSS1_PV_repeat, GPOS_TILED }, |
| { sCSS1_PV_repeat_x, GPOS_TILED }, |
| { sCSS1_PV_repeat_y, GPOS_TILED }, |
| { sCSS1_PV_no_repeat, GPOS_NONE }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aBGHoriPosTable[] = |
| { |
| { sCSS1_PV_left, GPOS_LT }, |
| { sCSS1_PV_center, GPOS_MT }, |
| { sCSS1_PV_right, GPOS_RT }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aBGVertPosTable[] = |
| { |
| { sCSS1_PV_top, GPOS_LT }, |
| { sCSS1_PV_middle, GPOS_LM }, |
| { sCSS1_PV_bottom, GPOS_LB }, |
| { 0, 0 } |
| }; |
| |
| /* */ |
| |
| static CSS1PropertyEnum __READONLY_DATA aTextAlignTable[] = |
| { |
| { sCSS1_PV_left, SVX_ADJUST_LEFT }, |
| { sCSS1_PV_center, SVX_ADJUST_CENTER }, |
| { sCSS1_PV_right, SVX_ADJUST_RIGHT }, |
| { sCSS1_PV_justify, SVX_ADJUST_BLOCK }, |
| { 0, 0 } |
| }; |
| |
| /* */ |
| |
| static CSS1PropertyEnum __READONLY_DATA aBorderWidthTable[] = |
| { |
| { sCSS1_PV_thin, 0 }, // DEF_LINE_WIDTH_0 / DEF_DOUBLE_LINE0 |
| { sCSS1_PV_medium, 1 }, // DEF_LINE_WIDTH_1 / DEF_DOUBLE_LINE1 |
| { sCSS1_PV_thick, 2 }, // DEF_LINE_WIDTH_2 / DEF_DOUBLE_LINE2 |
| { 0, 0 } |
| }; |
| |
| enum CSS1BorderStyle { CSS1_BS_NONE, CSS1_BS_SINGLE, CSS1_BS_DOUBLE }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aBorderStyleTable[] = |
| { |
| { sCSS1_PV_none, CSS1_BS_NONE }, |
| { sCSS1_PV_dotted, CSS1_BS_SINGLE }, |
| { sCSS1_PV_dashed, CSS1_BS_SINGLE }, |
| { sCSS1_PV_solid, CSS1_BS_SINGLE }, |
| { sCSS1_PV_double, CSS1_BS_DOUBLE }, |
| { sCSS1_PV_groove, CSS1_BS_SINGLE }, |
| { sCSS1_PV_ridge, CSS1_BS_SINGLE }, |
| { sCSS1_PV_inset, CSS1_BS_SINGLE }, |
| { sCSS1_PV_outset, CSS1_BS_SINGLE }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aFloatTable[] = |
| { |
| { sCSS1_PV_left, SVX_ADJUST_LEFT }, |
| { sCSS1_PV_right, SVX_ADJUST_RIGHT }, |
| { sCSS1_PV_none, SVX_ADJUST_END }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aPositionTable[] = |
| { |
| { sCSS1_PV_absolute, SVX_CSS1_POS_ABSOLUTE }, |
| { sCSS1_PV_relative, SVX_CSS1_POS_RELATIVE }, |
| { sCSS1_PV_static, SVX_CSS1_POS_STATIC }, |
| { 0, 0 } |
| }; |
| |
| // Feature: PrintExt |
| static CSS1PropertyEnum __READONLY_DATA aSizeTable[] = |
| { |
| { sCSS1_PV_auto, SVX_CSS1_STYPE_AUTO }, |
| { sCSS1_PV_landscape, SVX_CSS1_STYPE_LANDSCAPE }, |
| { sCSS1_PV_portrait, SVX_CSS1_STYPE_PORTRAIT }, |
| { 0, 0 } |
| }; |
| |
| static CSS1PropertyEnum __READONLY_DATA aPageBreakTable[] = |
| { |
| { sCSS1_PV_auto, SVX_CSS1_PBREAK_AUTO }, |
| { sCSS1_PV_always, SVX_CSS1_PBREAK_ALWAYS }, |
| { sCSS1_PV_avoid, SVX_CSS1_PBREAK_AVOID }, |
| { sCSS1_PV_left, SVX_CSS1_PBREAK_LEFT }, |
| { sCSS1_PV_right, SVX_CSS1_PBREAK_RIGHT }, |
| { 0, 0 } |
| }; |
| |
| // /Feature: PrintExt |
| |
| /* */ |
| |
| // Ein Eintrag besteht aus vier USHORTs. Der erste ist die Gesamtbreite, |
| // die anderen sind die 3 Einzelbreiten |
| |
| #define SBORDER_ENTRY( n ) \ |
| DEF_LINE_WIDTH_##n, DEF_LINE_WIDTH_##n, 0, 0 |
| |
| #define DBORDER_ENTRY( n ) \ |
| DEF_DOUBLE_LINE##n##_OUT + DEF_DOUBLE_LINE##n##_IN + \ |
| DEF_DOUBLE_LINE##n##_DIST, \ |
| DEF_DOUBLE_LINE##n##_OUT, \ |
| DEF_DOUBLE_LINE##n##_IN, \ |
| DEF_DOUBLE_LINE##n##_DIST |
| |
| #define TDBORDER_ENTRY( n ) \ |
| DEF_DOUBLE_LINE##n##_OUT, \ |
| DEF_DOUBLE_LINE##n##_OUT, \ |
| DEF_DOUBLE_LINE##n##_IN, \ |
| DEF_DOUBLE_LINE##n##_DIST |
| |
| |
| static sal_uInt16 __READONLY_DATA aSBorderWidths[] = |
| { |
| SBORDER_ENTRY( 0 ), SBORDER_ENTRY( 1 ), SBORDER_ENTRY( 2 ), |
| SBORDER_ENTRY( 3 ), SBORDER_ENTRY( 4 ) |
| }; |
| |
| static sal_uInt16 __READONLY_DATA aDBorderWidths[] = |
| { |
| DBORDER_ENTRY( 0 ), |
| DBORDER_ENTRY( 7 ), |
| DBORDER_ENTRY( 1 ), |
| DBORDER_ENTRY( 8 ), |
| DBORDER_ENTRY( 4 ), |
| DBORDER_ENTRY( 9 ), |
| DBORDER_ENTRY( 3 ), |
| DBORDER_ENTRY( 10 ), |
| DBORDER_ENTRY( 2 ), |
| DBORDER_ENTRY( 5 ) |
| }; |
| |
| static sal_uInt16 __READONLY_DATA aTDBorderWidths[] = |
| { |
| TDBORDER_ENTRY( 7 ), TDBORDER_ENTRY( 8 ), TDBORDER_ENTRY( 9 ), |
| TDBORDER_ENTRY( 10 ) |
| }; |
| |
| #undef SBORDER_ENTRY |
| #undef DBORDER_ENTRY |
| |
| /* */ |
| |
| struct SvxCSS1ItemIds |
| { |
| sal_uInt16 nFont; |
| sal_uInt16 nFontCJK; |
| sal_uInt16 nFontCTL; |
| sal_uInt16 nPosture; |
| sal_uInt16 nPostureCJK; |
| sal_uInt16 nPostureCTL; |
| sal_uInt16 nWeight; |
| sal_uInt16 nWeightCJK; |
| sal_uInt16 nWeightCTL; |
| sal_uInt16 nFontHeight; |
| sal_uInt16 nFontHeightCJK; |
| sal_uInt16 nFontHeightCTL; |
| sal_uInt16 nUnderline; |
| sal_uInt16 nOverline; |
| sal_uInt16 nCrossedOut; |
| sal_uInt16 nColor; |
| sal_uInt16 nKerning; |
| sal_uInt16 nCaseMap; |
| sal_uInt16 nBlink; |
| |
| sal_uInt16 nLineSpacing; |
| sal_uInt16 nAdjust; |
| sal_uInt16 nWidows; |
| sal_uInt16 nOrphans; |
| sal_uInt16 nFmtSplit; |
| |
| sal_uInt16 nLRSpace; |
| sal_uInt16 nULSpace; |
| sal_uInt16 nBox; |
| sal_uInt16 nBrush; |
| |
| sal_uInt16 nLanguage; |
| sal_uInt16 nLanguageCJK; |
| sal_uInt16 nLanguageCTL; |
| sal_uInt16 nDirection; |
| }; |
| |
| |
| static SvxCSS1ItemIds aItemIds; |
| |
| |
| /* */ |
| |
| struct SvxCSS1BorderInfo |
| { |
| Color aColor; |
| sal_uInt16 nAbsWidth; |
| sal_uInt16 nNamedWidth; |
| CSS1BorderStyle eStyle; |
| |
| SvxCSS1BorderInfo() : |
| aColor( COL_BLACK ), nAbsWidth( USHRT_MAX ), |
| nNamedWidth( USHRT_MAX ), eStyle( CSS1_BS_NONE ) |
| {} |
| |
| SvxCSS1BorderInfo( const SvxCSS1BorderInfo& rInfo ) : |
| aColor( rInfo.aColor ), nAbsWidth( rInfo.nAbsWidth ), |
| nNamedWidth( rInfo.nNamedWidth ), eStyle( rInfo.eStyle ) |
| {} |
| |
| void SetBorderLine( sal_uInt16 nLine, SvxBoxItem &rBoxItem ) const; |
| }; |
| |
| void SvxCSS1BorderInfo::SetBorderLine( sal_uInt16 nLine, SvxBoxItem &rBoxItem ) const |
| { |
| if( CSS1_BS_NONE==eStyle || nAbsWidth==0 || |
| (nAbsWidth==USHRT_MAX && nNamedWidth==USHRT_MAX) ) |
| { |
| rBoxItem.SetLine( 0, nLine ); |
| return; |
| } |
| |
| SvxBorderLine aBorderLine( &aColor ); |
| |
| // Linien-Stil doppelt oder einfach? |
| sal_Bool bDouble = eStyle == CSS1_BS_DOUBLE; |
| |
| // benannte Breite umrechnenen, wenn keine absolute gegeben ist |
| if( nAbsWidth==USHRT_MAX ) |
| { |
| const sal_uInt16 *aWidths = bDouble ? aDBorderWidths : aSBorderWidths; |
| sal_uInt16 nNWidth = nNamedWidth * 4; |
| aBorderLine.SetOutWidth( aWidths[nNWidth+1] ); |
| aBorderLine.SetInWidth( aWidths[nNWidth+2] ); |
| aBorderLine.SetDistance( aWidths[nNWidth+3] ); |
| } |
| else |
| { |
| SvxCSS1Parser::SetBorderWidth( aBorderLine, nAbsWidth, bDouble ); |
| } |
| |
| rBoxItem.SetLine( &aBorderLine, nLine ); |
| } |
| |
| |
| /* */ |
| |
| SvxCSS1PropertyInfo::SvxCSS1PropertyInfo() |
| { |
| for( sal_uInt16 i=0; i<4; i++ ) |
| aBorderInfos[i] = 0; |
| |
| Clear(); |
| } |
| |
| SvxCSS1PropertyInfo::SvxCSS1PropertyInfo( const SvxCSS1PropertyInfo& rProp ) : |
| aId( rProp.aId ), |
| bTopMargin( rProp.bTopMargin ), |
| bBottomMargin( rProp.bBottomMargin ), |
| bLeftMargin( rProp.bLeftMargin ), |
| bRightMargin( rProp.bRightMargin ), |
| bTextIndent( rProp.bTextIndent ), |
| eFloat( rProp.eFloat ), |
| ePosition( rProp.ePosition ), |
| nTopBorderDistance( rProp.nTopBorderDistance ), |
| nBottomBorderDistance( rProp.nBottomBorderDistance ), |
| nLeftBorderDistance( rProp.nLeftBorderDistance ), |
| nRightBorderDistance( rProp.nRightBorderDistance ), |
| nLeft( rProp.nLeft ), |
| nTop( rProp.nTop ), |
| nWidth( rProp.nWidth ), |
| nHeight( rProp.nHeight ), |
| nLeftMargin( rProp.nLeftMargin ), |
| nRightMargin( rProp.nRightMargin ), |
| eLeftType( rProp.eLeftType ), |
| eTopType( rProp.eTopType ), |
| eWidthType( rProp.eWidthType ), |
| eHeightType( rProp.eHeightType ), |
| // Feature: PrintExt |
| eSizeType( rProp.eSizeType ), |
| ePageBreakBefore( rProp.ePageBreakBefore ), |
| ePageBreakAfter( rProp.ePageBreakAfter ) |
| // /Feature: PrintExt |
| { |
| for( sal_uInt16 i=0; i<4; i++ ) |
| aBorderInfos[i] = rProp.aBorderInfos[i] |
| ? new SvxCSS1BorderInfo( *rProp.aBorderInfos[i] ) |
| : 0; |
| } |
| |
| SvxCSS1PropertyInfo::~SvxCSS1PropertyInfo() |
| { |
| DestroyBorderInfos(); |
| } |
| |
| void SvxCSS1PropertyInfo::DestroyBorderInfos() |
| { |
| for( sal_uInt16 i=0; i<4; i++ ) |
| { |
| delete aBorderInfos[i]; |
| aBorderInfos[i] = 0; |
| } |
| } |
| |
| void SvxCSS1PropertyInfo::Clear() |
| { |
| aId.Erase(); |
| bTopMargin = bBottomMargin = sal_False; |
| bLeftMargin = bRightMargin = bTextIndent = sal_False; |
| nLeftMargin = nRightMargin = 0; |
| eFloat = SVX_ADJUST_END; |
| |
| ePosition = SVX_CSS1_POS_NONE; |
| nTopBorderDistance = nBottomBorderDistance = |
| nLeftBorderDistance = nRightBorderDistance = USHRT_MAX; |
| nLeft = nTop = nWidth = nHeight = 0; |
| eLeftType = eTopType = eWidthType = eHeightType = SVX_CSS1_LTYPE_NONE; |
| |
| // Feature: PrintExt |
| eSizeType = SVX_CSS1_STYPE_NONE; |
| ePageBreakBefore = SVX_CSS1_PBREAK_NONE; |
| ePageBreakAfter = SVX_CSS1_PBREAK_NONE; |
| |
| DestroyBorderInfos(); |
| } |
| |
| void SvxCSS1PropertyInfo::Merge( const SvxCSS1PropertyInfo& rProp ) |
| { |
| if( rProp.bTopMargin ) |
| bTopMargin = sal_True; |
| if( rProp.bBottomMargin ) |
| bBottomMargin = sal_True; |
| |
| if( rProp.bLeftMargin ) |
| { |
| bLeftMargin = sal_True; |
| nLeftMargin = rProp.nLeftMargin; |
| } |
| if( rProp.bRightMargin ) |
| { |
| bRightMargin = sal_True; |
| nRightMargin = rProp.nRightMargin; |
| } |
| if( rProp.bTextIndent ) |
| bTextIndent = sal_True; |
| |
| for( sal_uInt16 i=0; i<4; i++ ) |
| { |
| if( rProp.aBorderInfos[i] ) |
| { |
| if( aBorderInfos[i] ) |
| delete aBorderInfos[i]; |
| |
| aBorderInfos[i] = new SvxCSS1BorderInfo( *rProp.aBorderInfos[i] ); |
| } |
| } |
| |
| if( USHRT_MAX != rProp.nTopBorderDistance ) |
| nTopBorderDistance = rProp.nTopBorderDistance; |
| if( USHRT_MAX != rProp.nBottomBorderDistance ) |
| nBottomBorderDistance = rProp.nBottomBorderDistance; |
| if( USHRT_MAX != rProp.nLeftBorderDistance ) |
| nLeftBorderDistance = rProp.nLeftBorderDistance; |
| if( USHRT_MAX != rProp.nRightBorderDistance ) |
| nRightBorderDistance = rProp.nRightBorderDistance; |
| |
| if( rProp.eFloat != SVX_ADJUST_END ) |
| eFloat = rProp.eFloat; |
| |
| if( rProp.ePosition != SVX_CSS1_POS_NONE ) |
| ePosition = rProp.ePosition; |
| |
| // Feature: PrintExt |
| if( rProp.eSizeType != SVX_CSS1_STYPE_NONE ) |
| { |
| eSizeType = rProp.eSizeType; |
| nWidth = rProp.nWidth; |
| nHeight = rProp.nHeight; |
| } |
| |
| if( rProp.ePageBreakBefore != SVX_CSS1_PBREAK_NONE ) |
| ePageBreakBefore = rProp.ePageBreakBefore; |
| |
| if( rProp.ePageBreakAfter != SVX_CSS1_PBREAK_NONE ) |
| ePageBreakAfter = rProp.ePageBreakAfter; |
| |
| // /Feature: PrintExt |
| |
| if( rProp.eLeftType != SVX_CSS1_LTYPE_NONE ) |
| { |
| eLeftType = rProp.eLeftType; |
| nLeft = rProp.nLeft; |
| } |
| |
| if( rProp.eTopType != SVX_CSS1_LTYPE_NONE ) |
| { |
| eTopType = rProp.eTopType; |
| nTop = rProp.nTop; |
| } |
| |
| if( rProp.eWidthType != SVX_CSS1_LTYPE_NONE ) |
| { |
| eWidthType = rProp.eWidthType; |
| nWidth = rProp.nWidth; |
| } |
| |
| if( rProp.eHeightType != SVX_CSS1_LTYPE_NONE ) |
| { |
| eHeightType = rProp.eHeightType; |
| nHeight = rProp.nHeight; |
| } |
| } |
| |
| SvxCSS1BorderInfo *SvxCSS1PropertyInfo::GetBorderInfo( sal_uInt16 nLine, sal_Bool bCreate ) |
| { |
| sal_uInt16 nPos = 0; |
| switch( nLine ) |
| { |
| case BOX_LINE_TOP: nPos = 0; break; |
| case BOX_LINE_BOTTOM: nPos = 1; break; |
| case BOX_LINE_LEFT: nPos = 2; break; |
| case BOX_LINE_RIGHT: nPos = 3; break; |
| } |
| |
| if( !aBorderInfos[nPos] && bCreate ) |
| aBorderInfos[nPos] = new SvxCSS1BorderInfo; |
| |
| return aBorderInfos[nPos]; |
| } |
| |
| void SvxCSS1PropertyInfo::CopyBorderInfo( sal_uInt16 nSrcLine, sal_uInt16 nDstLine, |
| sal_uInt16 nWhat ) |
| { |
| SvxCSS1BorderInfo *pSrcInfo = GetBorderInfo( nSrcLine, sal_False ); |
| if( !pSrcInfo ) |
| return; |
| |
| SvxCSS1BorderInfo *pDstInfo = GetBorderInfo( nDstLine ); |
| if( (nWhat & SVX_CSS1_BORDERINFO_WIDTH) != 0 ) |
| { |
| pDstInfo->nAbsWidth = pSrcInfo->nAbsWidth; |
| pDstInfo->nNamedWidth = pSrcInfo->nNamedWidth; |
| } |
| |
| if( (nWhat & SVX_CSS1_BORDERINFO_COLOR) != 0 ) |
| pDstInfo->aColor = pSrcInfo->aColor; |
| |
| if( (nWhat & SVX_CSS1_BORDERINFO_STYLE) != 0 ) |
| pDstInfo->eStyle = pSrcInfo->eStyle; |
| } |
| |
| void SvxCSS1PropertyInfo::CopyBorderInfo( sal_uInt16 nCount, sal_uInt16 nWhat ) |
| { |
| if( nCount==0 ) |
| { |
| CopyBorderInfo( BOX_LINE_BOTTOM, BOX_LINE_TOP, nWhat ); |
| CopyBorderInfo( BOX_LINE_TOP, BOX_LINE_LEFT, nWhat ); |
| } |
| if( nCount<=1 ) |
| { |
| CopyBorderInfo( BOX_LINE_LEFT, BOX_LINE_RIGHT, nWhat ); |
| } |
| } |
| |
| void SvxCSS1PropertyInfo::SetBoxItem( SfxItemSet& rItemSet, |
| sal_uInt16 nMinBorderDist, |
| const SvxBoxItem *pDfltItem, |
| sal_Bool bTable ) |
| { |
| sal_Bool bChg = nTopBorderDistance != USHRT_MAX || |
| nBottomBorderDistance != USHRT_MAX || |
| nLeftBorderDistance != USHRT_MAX || |
| nRightBorderDistance != USHRT_MAX; |
| sal_uInt16 i; |
| |
| for( i = 0; !bChg && i < 4; i++ ) |
| bChg = aBorderInfos[i]!=0; |
| |
| if( !bChg ) |
| return; |
| |
| SvxBoxItem aBoxItem( aItemIds.nBox ); |
| if( pDfltItem ) |
| aBoxItem = *pDfltItem; |
| |
| SvxCSS1BorderInfo *pInfo = GetBorderInfo( BOX_LINE_TOP, sal_False ); |
| if( pInfo ) |
| pInfo->SetBorderLine( BOX_LINE_TOP, aBoxItem ); |
| |
| pInfo = GetBorderInfo( BOX_LINE_BOTTOM, sal_False ); |
| if( pInfo ) |
| pInfo->SetBorderLine( BOX_LINE_BOTTOM, aBoxItem ); |
| |
| pInfo = GetBorderInfo( BOX_LINE_LEFT, sal_False ); |
| if( pInfo ) |
| pInfo->SetBorderLine( BOX_LINE_LEFT, aBoxItem ); |
| |
| pInfo = GetBorderInfo( BOX_LINE_RIGHT, sal_False ); |
| if( pInfo ) |
| pInfo->SetBorderLine( BOX_LINE_RIGHT, aBoxItem ); |
| |
| for( i=0; i<4; i++ ) |
| { |
| sal_uInt16 nLine = BOX_LINE_TOP, nDist = 0; |
| switch( i ) |
| { |
| case 0: nLine = BOX_LINE_TOP; |
| nDist = nTopBorderDistance; |
| nTopBorderDistance = USHRT_MAX; |
| break; |
| case 1: nLine = BOX_LINE_BOTTOM; |
| nDist = nBottomBorderDistance; |
| nBottomBorderDistance = USHRT_MAX; |
| break; |
| case 2: nLine = BOX_LINE_LEFT; |
| nDist = nLeftBorderDistance; |
| nLeftBorderDistance = USHRT_MAX; |
| break; |
| case 3: nLine = BOX_LINE_RIGHT; |
| nDist = nRightBorderDistance; |
| nRightBorderDistance = USHRT_MAX; |
| break; |
| } |
| |
| if( aBoxItem.GetLine( nLine ) ) |
| { |
| if( USHRT_MAX == nDist ) |
| nDist = aBoxItem.GetDistance( nLine ); |
| |
| if( nDist < nMinBorderDist ) |
| nDist = nMinBorderDist; |
| } |
| else |
| { |
| if( USHRT_MAX == nDist ) |
| nDist = aBoxItem.GetDistance( nLine ); |
| |
| if( !bTable ) |
| nDist = 0U; |
| else if( nDist && nDist < nMinBorderDist ) |
| nDist = nMinBorderDist; |
| } |
| |
| aBoxItem.SetDistance( nDist, nLine ); |
| } |
| |
| rItemSet.Put( aBoxItem ); |
| |
| DestroyBorderInfos(); |
| } |
| |
| |
| /* */ |
| |
| SvxCSS1MapEntry::SvxCSS1MapEntry( const String& rKey, const SfxItemSet& rItemSet, |
| const SvxCSS1PropertyInfo& rProp ) : |
| aKey( rKey ), |
| aItemSet( rItemSet ), |
| aPropInfo( rProp ) |
| { |
| // TODO: ToUpperAscii |
| aKey.ToUpperAscii(); |
| } |
| |
| #if defined( ICC ) || defined( BLC ) |
| sal_Bool operator==( const SvxCSS1MapEntry& rE1, const SvxCSS1MapEntry& rE2 ) |
| { |
| return rE1.aKey==rE2.aKey; |
| } |
| |
| sal_Bool operator<( const SvxCSS1MapEntry& rE1, const SvxCSS1MapEntry& rE2 ) |
| { |
| return rE1.aKey<rE2.aKey; |
| } |
| #endif |
| |
| SV_IMPL_OP_PTRARR_SORT( SvxCSS1Map, SvxCSS1MapEntryPtr ) |
| |
| /* */ |
| |
| sal_Bool SvxCSS1Parser::StyleParsed( const CSS1Selector * /*pSelector*/, |
| SfxItemSet& /*rItemSet*/, |
| SvxCSS1PropertyInfo& /*rPropInfo*/ ) |
| { |
| // wie man sieht passiert hier gar nichts |
| return sal_True; |
| } |
| |
| sal_Bool SvxCSS1Parser::SelectorParsed( const CSS1Selector *pSelector, |
| sal_Bool bFirst ) |
| { |
| if( bFirst ) |
| { |
| DBG_ASSERT( pSheetItemSet, "Wo ist der Item-Set fuer Style-Sheets?" ); |
| |
| // Dieses ist der erste Selektor einer Rule, also muessen |
| // die bisher geparsten Items auf die Styles verteilt werden |
| // pSheetPropInfo->CreateBoxItem( *pSheetItemSet, GetDfltBorderDist() ); |
| for( sal_uInt16 i=0; i<aSelectors.Count(); i++ ) |
| { |
| StyleParsed( aSelectors[i], *pSheetItemSet, *pSheetPropInfo ); |
| } |
| pSheetItemSet->ClearItem(); |
| pSheetPropInfo->Clear(); |
| |
| // und die naechste Rule vorbereiten |
| if( aSelectors.Count() ) |
| aSelectors.DeleteAndDestroy( 0, aSelectors.Count() ); |
| } |
| |
| aSelectors.C40_INSERT( CSS1Selector, pSelector, aSelectors.Count() ); |
| |
| return sal_False; // den Selektor haben wir gespeichert. Loeschen toedlich! |
| } |
| |
| |
| sal_Bool SvxCSS1Parser::DeclarationParsed( const String& rProperty, |
| const CSS1Expression *pExpr ) |
| { |
| DBG_ASSERT( pExpr, "DeclarationParsed() ohne Expression" ); |
| |
| if( !pExpr ) |
| return sal_True; |
| |
| ParseProperty( rProperty, pExpr ); |
| |
| return sal_True; // die Deklaration brauchen wir nicht mehr. Loeschen! |
| } |
| |
| /* */ |
| |
| SvxCSS1Parser::SvxCSS1Parser( SfxItemPool& rPool, const String& rBaseURL, sal_uInt16 nMinFixLineSp, |
| sal_uInt16 *pWhichIds, sal_uInt16 nWhichIds ) : |
| CSS1Parser(), |
| sBaseURL( rBaseURL ), |
| pSheetItemSet(0), |
| pItemSet(0), |
| pSearchEntry( 0 ), |
| nMinFixLineSpace( nMinFixLineSp ), |
| eDfltEnc( RTL_TEXTENCODING_DONTKNOW ), |
| nScriptFlags( CSS1_SCRIPT_ALL ), |
| bIgnoreFontFamily( sal_False ) |
| { |
| // Item-Ids auch initialisieren |
| aItemIds.nFont = rPool.GetTrueWhich( SID_ATTR_CHAR_FONT, sal_False ); |
| aItemIds.nFontCJK = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_FONT, sal_False ); |
| aItemIds.nFontCTL = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_FONT, sal_False ); |
| aItemIds.nPosture = rPool.GetTrueWhich( SID_ATTR_CHAR_POSTURE, sal_False ); |
| aItemIds.nPostureCJK = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_POSTURE, sal_False ); |
| aItemIds.nPostureCTL = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_POSTURE, sal_False ); |
| aItemIds.nWeight = rPool.GetTrueWhich( SID_ATTR_CHAR_WEIGHT, sal_False ); |
| aItemIds.nWeightCJK = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_WEIGHT, sal_False ); |
| aItemIds.nWeightCTL = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_WEIGHT, sal_False ); |
| aItemIds.nFontHeight = rPool.GetTrueWhich( SID_ATTR_CHAR_FONTHEIGHT, sal_False ); |
| aItemIds.nFontHeightCJK = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT, sal_False ); |
| aItemIds.nFontHeightCTL = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT, sal_False ); |
| aItemIds.nUnderline = rPool.GetTrueWhich( SID_ATTR_CHAR_UNDERLINE, sal_False ); |
| aItemIds.nOverline = rPool.GetTrueWhich( SID_ATTR_CHAR_OVERLINE, sal_False ); |
| aItemIds.nCrossedOut = rPool.GetTrueWhich( SID_ATTR_CHAR_STRIKEOUT, sal_False ); |
| aItemIds.nColor = rPool.GetTrueWhich( SID_ATTR_CHAR_COLOR, sal_False ); |
| aItemIds.nKerning = rPool.GetTrueWhich( SID_ATTR_CHAR_KERNING, sal_False ); |
| aItemIds.nCaseMap = rPool.GetTrueWhich( SID_ATTR_CHAR_CASEMAP, sal_False ); |
| aItemIds.nBlink = rPool.GetTrueWhich( SID_ATTR_FLASH, sal_False ); |
| |
| aItemIds.nLineSpacing = rPool.GetTrueWhich( SID_ATTR_PARA_LINESPACE, sal_False ); |
| aItemIds.nAdjust = rPool.GetTrueWhich( SID_ATTR_PARA_ADJUST, sal_False ); |
| aItemIds.nWidows = rPool.GetTrueWhich( SID_ATTR_PARA_WIDOWS, sal_False ); |
| aItemIds.nOrphans = rPool.GetTrueWhich( SID_ATTR_PARA_ORPHANS, sal_False ); |
| aItemIds.nFmtSplit = rPool.GetTrueWhich( SID_ATTR_PARA_SPLIT, sal_False ); |
| |
| aItemIds.nLRSpace = rPool.GetTrueWhich( SID_ATTR_LRSPACE, sal_False ); |
| aItemIds.nULSpace = rPool.GetTrueWhich( SID_ATTR_ULSPACE, sal_False ); |
| aItemIds.nBox = rPool.GetTrueWhich( SID_ATTR_BORDER_OUTER, sal_False ); |
| aItemIds.nBrush = rPool.GetTrueWhich( SID_ATTR_BRUSH, sal_False ); |
| |
| aItemIds.nLanguage = rPool.GetTrueWhich( SID_ATTR_CHAR_LANGUAGE, sal_False ); |
| aItemIds.nLanguageCJK = rPool.GetTrueWhich( SID_ATTR_CHAR_CJK_LANGUAGE, sal_False ); |
| aItemIds.nLanguageCTL = rPool.GetTrueWhich( SID_ATTR_CHAR_CTL_LANGUAGE, sal_False ); |
| aItemIds.nDirection = rPool.GetTrueWhich( SID_ATTR_FRAMEDIRECTION, sal_False ); |
| |
| aWhichMap.Insert( (sal_uInt16)0, (sal_uInt16)0 ); |
| SvParser::BuildWhichTbl( aWhichMap, (sal_uInt16 *)&aItemIds, |
| sizeof(aItemIds) / sizeof(sal_uInt16) ); |
| if( pWhichIds && nWhichIds ) |
| SvParser::BuildWhichTbl( aWhichMap, pWhichIds, nWhichIds ); |
| |
| pSheetItemSet = new SfxItemSet( rPool, aWhichMap.GetData() ); |
| pSheetPropInfo = new SvxCSS1PropertyInfo; |
| pSearchEntry = new SvxCSS1MapEntry( rPool, aWhichMap.GetData() ); |
| } |
| |
| SvxCSS1Parser::~SvxCSS1Parser() |
| { |
| delete pSheetItemSet; |
| delete pSheetPropInfo; |
| delete pSearchEntry; |
| } |
| |
| |
| /* */ |
| |
| sal_Bool SvxCSS1Parser::ParseStyleSheet( const String& rIn ) |
| { |
| pItemSet = pSheetItemSet; |
| pPropInfo = pSheetPropInfo; |
| |
| sal_Bool bSuccess = CSS1Parser::ParseStyleSheet( rIn ); |
| |
| // die bisher geparsten Items auf die Styles verteilt werden |
| // pSheetPropInfo->CreateBoxItem( *pSheetItemSet, GetDfltBorderDist() ); |
| for( sal_uInt16 i=0; i<aSelectors.Count(); i++ ) |
| { |
| StyleParsed( aSelectors[i], *pSheetItemSet, *pSheetPropInfo ); |
| } |
| |
| // und etwas aufrauemen |
| if( aSelectors.Count() ) |
| aSelectors.DeleteAndDestroy( 0, aSelectors.Count() ); |
| pSheetItemSet->ClearItem(); |
| pSheetPropInfo->Clear(); |
| |
| pItemSet = 0; |
| pPropInfo = 0; |
| |
| return bSuccess; |
| } |
| |
| sal_Bool SvxCSS1Parser::ParseStyleOption( const String& rIn, |
| SfxItemSet& rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo ) |
| { |
| pItemSet = &rItemSet; |
| pPropInfo = &rPropInfo; |
| |
| sal_Bool bSuccess = CSS1Parser::ParseStyleOption( rIn ); |
| rItemSet.ClearItem( aItemIds.nDirection ); |
| // pPropInfo->CreateBoxItem( *pItemSet, GetDfltBorderDist() ); |
| |
| pItemSet = 0; |
| pPropInfo = 0; |
| |
| return bSuccess; |
| } |
| |
| /* */ |
| |
| sal_Bool SvxCSS1Parser::GetEnum( const CSS1PropertyEnum *pPropTable, |
| const String &rValue, sal_uInt16& rEnum ) |
| { |
| String aValue( rValue ); |
| aValue.ToLowerAscii(); |
| while( pPropTable->pName ) |
| { |
| if( !rValue.EqualsIgnoreCaseAscii( pPropTable->pName ) ) |
| pPropTable++; |
| else |
| break; |
| } |
| |
| if( pPropTable->pName ) |
| rEnum = pPropTable->nEnum; |
| |
| return (pPropTable->pName != 0); |
| } |
| |
| void SvxCSS1Parser::PixelToTwip( long &rWidth, long &rHeight ) |
| { |
| if( Application::GetDefaultDevice() ) |
| { |
| Size aTwipSz( rWidth, rHeight ); |
| aTwipSz = Application::GetDefaultDevice()->PixelToLogic( aTwipSz, |
| MapMode(MAP_TWIP) ); |
| |
| rWidth = aTwipSz.Width(); |
| rHeight = aTwipSz.Height(); |
| } |
| } |
| |
| void SvxCSS1Parser::SetBorderWidth( SvxBorderLine& aBorderLine, sal_uInt16 nWidth, |
| sal_Bool bDouble, sal_Bool bTable ) |
| { |
| const sal_uInt16 *aWidths; |
| sal_uInt16 nSize; |
| if( !bDouble ) |
| { |
| aWidths = aSBorderWidths; |
| nSize = sizeof( aSBorderWidths ); |
| } |
| else if( bTable ) |
| { |
| aWidths = aTDBorderWidths; |
| nSize = sizeof( aTDBorderWidths ); |
| } |
| else |
| { |
| aWidths = aDBorderWidths; |
| nSize = sizeof( aDBorderWidths ); |
| } |
| |
| sal_uInt16 i = (nSize / sizeof(sal_uInt16)) - 4; |
| while( i>0 && |
| nWidth <= ((aWidths[i] + aWidths[i-4]) / 2) ) |
| { |
| DBG_ASSERT( aWidths[i] > aWidths[i-4], |
| "Linienbreiten sind nicht sortiert!" ); |
| i -= 4; |
| } |
| |
| aBorderLine.SetOutWidth( aWidths[i+1] ); |
| aBorderLine.SetInWidth( aWidths[i+2] ); |
| aBorderLine.SetDistance( aWidths[i+3] ); |
| } |
| |
| sal_uInt32 SvxCSS1Parser::GetFontHeight( sal_uInt16 nSize ) const |
| { |
| sal_uInt16 nHeight; |
| |
| switch( nSize ) |
| { |
| case 0: nHeight = 8*20; break; |
| case 1: nHeight = 10*20; break; |
| case 2: nHeight = 11*20; break; |
| case 3: nHeight = 12*20; break; |
| case 4: nHeight = 17*20; break; |
| case 5: nHeight = 20*20; break; |
| case 6: |
| default: nHeight = 32*20; break; |
| } |
| |
| return nHeight; |
| } |
| |
| const FontList *SvxCSS1Parser::GetFontList() const |
| { |
| return 0; |
| } |
| |
| SvxCSS1MapEntry *SvxCSS1Parser::GetMapEntry( const String& rKey, |
| const SvxCSS1Map& rMap ) const |
| { |
| pSearchEntry->SetKey( rKey ); |
| |
| SvxCSS1MapEntry *pRet = 0; |
| sal_uInt16 nPos; |
| if( rMap.Seek_Entry( pSearchEntry, &nPos ) ) |
| pRet = rMap[nPos]; |
| |
| return pRet; |
| } |
| |
| void SvxCSS1Parser::InsertMapEntry( const String& rKey, |
| const SfxItemSet& rItemSet, |
| const SvxCSS1PropertyInfo& rProp, |
| SvxCSS1Map& rMap ) |
| { |
| SvxCSS1MapEntry *pEntry = GetMapEntry( rKey, rMap ); |
| if( pEntry ) |
| { |
| MergeStyles( rItemSet, rProp, |
| pEntry->GetItemSet(), pEntry->GetPropertyInfo(), sal_True ); |
| } |
| else |
| { |
| rMap.Insert( new SvxCSS1MapEntry( rKey, rItemSet, rProp ) ); |
| } |
| } |
| |
| |
| void SvxCSS1Parser::MergeStyles( const SfxItemSet& rSrcSet, |
| const SvxCSS1PropertyInfo& rSrcInfo, |
| SfxItemSet& rTargetSet, |
| SvxCSS1PropertyInfo& rTargetInfo, |
| sal_Bool bSmart ) |
| { |
| if( !bSmart ) |
| { |
| rTargetSet.Put( rSrcSet ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRSpace( (const SvxLRSpaceItem&)rTargetSet.Get(aItemIds.nLRSpace) ); |
| SvxULSpaceItem aULSpace( (const SvxULSpaceItem&)rTargetSet.Get(aItemIds.nULSpace) ); |
| SvxBoxItem aBox( (const SvxBoxItem&)rTargetSet.Get(aItemIds.nBox) ); |
| |
| rTargetSet.Put( rSrcSet ); |
| |
| if( rSrcInfo.bLeftMargin || rSrcInfo.bRightMargin || |
| rSrcInfo.bTextIndent ) |
| { |
| const SvxLRSpaceItem& rNewLRSpace = |
| (const SvxLRSpaceItem&)rSrcSet.Get( aItemIds.nLRSpace ); |
| |
| if( rSrcInfo.bLeftMargin ) |
| aLRSpace.SetLeft( rNewLRSpace.GetLeft() ); |
| if( rSrcInfo.bRightMargin ) |
| aLRSpace.SetRight( rNewLRSpace.GetRight() ); |
| if( rSrcInfo.bTextIndent ) |
| aLRSpace.SetTxtFirstLineOfst( rNewLRSpace.GetTxtFirstLineOfst() ); |
| |
| rTargetSet.Put( aLRSpace ); |
| } |
| |
| if( rSrcInfo.bTopMargin || rSrcInfo.bBottomMargin ) |
| { |
| const SvxULSpaceItem& rNewULSpace = |
| (const SvxULSpaceItem&)rSrcSet.Get( aItemIds.nULSpace ); |
| |
| if( rSrcInfo.bTopMargin ) |
| aULSpace.SetUpper( rNewULSpace.GetUpper() ); |
| if( rSrcInfo.bBottomMargin ) |
| aULSpace.SetLower( rNewULSpace.GetLower() ); |
| |
| rTargetSet.Put( aULSpace ); |
| } |
| } |
| |
| rTargetInfo.Merge( rSrcInfo ); |
| } |
| |
| void SvxCSS1Parser::SetDfltEncoding( rtl_TextEncoding eEnc ) |
| { |
| eDfltEnc = eEnc; |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_font_size( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uLong nHeight = 0; |
| sal_uInt16 nPropHeight = 100; |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| nHeight = pExpr->GetULength(); |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = 0; |
| long nPHeight = (long)pExpr->GetNumber(); |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nHeight = (sal_uLong)nPHeight; |
| } |
| break; |
| //#ifdef PERCENTAGE_POSSIBLE |
| case CSS1_PERCENTAGE: |
| // nur fuer Drop-Caps! |
| nPropHeight = (sal_uInt16)pExpr->GetNumber(); |
| break; |
| //#endif |
| case CSS1_IDENT: |
| { |
| sal_uInt16 nSize; |
| #ifdef PERCENTAGE_POSSIBLE |
| const String& rValue = pExpr->GetString(); |
| #endif |
| if( SvxCSS1Parser::GetEnum( aFontSizeTable, pExpr->GetString(), |
| nSize ) ) |
| { |
| nHeight = rParser.GetFontHeight( nSize ); |
| } |
| #ifdef PERCENTAGE_POSSIBLE |
| else if( rValue.EqualsIgnoreCaseAscii( sCSS1_PV_larger ) ) |
| { |
| nPropHeight = 150; |
| } |
| else if( rValue.EqualsIgnoreCaseAscii( sCSS1_PV_smaller ) ) |
| { |
| nPropHeight = 67; |
| } |
| #endif |
| } |
| break; |
| |
| default: |
| ; |
| } |
| |
| if( nHeight || nPropHeight!=100 ) |
| { |
| SvxFontHeightItem aFontHeight( nHeight, nPropHeight, |
| aItemIds.nFontHeight ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aFontHeight ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aFontHeight.SetWhich( aItemIds.nFontHeightCJK ); |
| rItemSet.Put( aFontHeight ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aFontHeight.SetWhich( aItemIds.nFontHeightCTL ); |
| rItemSet.Put( aFontHeight ); |
| } |
| } |
| } |
| |
| /* */ |
| |
| |
| static void ParseCSS1_font_family( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| String aName, aStyleName, aDfltName; |
| FontFamily eFamily = FAMILY_DONTKNOW; |
| FontPitch ePitch = PITCH_DONTKNOW; |
| rtl_TextEncoding eEnc = rParser.GetDfltEncoding(); |
| const FontList *pFList = rParser.GetFontList(); |
| sal_Bool bFirst = sal_True; |
| sal_Bool bFound = sal_False; |
| while( pExpr && (bFirst || ','==pExpr->GetOp() || !pExpr->GetOp()) ) |
| { |
| CSS1Token eType = pExpr->GetType(); |
| if( CSS1_IDENT==eType || CSS1_STRING==eType ) |
| { |
| String aIdent( pExpr->GetString() ); |
| |
| if( CSS1_IDENT==eType ) |
| { |
| // Alle nachfolgenden id's sammeln und mit einem |
| // Space getrennt hintendranhaengen |
| const CSS1Expression *pNext = pExpr->GetNext(); |
| while( pNext && !pNext->GetOp() && |
| CSS1_IDENT==pNext->GetType() ) |
| { |
| (aIdent += ' ') += pNext->GetString(); |
| pExpr = pNext; |
| pNext = pExpr->GetNext(); |
| } |
| } |
| if( aIdent.Len() ) |
| { |
| if( !bFound && pFList ) |
| { |
| sal_Handle hFont = pFList->GetFirstFontInfo( aIdent ); |
| if( 0 != hFont ) |
| { |
| const FontInfo& rFInfo = pFList->GetFontInfo( hFont ); |
| if( RTL_TEXTENCODING_DONTKNOW != rFInfo.GetCharSet() ) |
| { |
| bFound = sal_True; |
| if( RTL_TEXTENCODING_SYMBOL == rFInfo.GetCharSet() ) |
| eEnc = RTL_TEXTENCODING_SYMBOL; |
| } |
| } |
| } |
| if( !bFirst ) |
| aName += ';'; |
| aName += aIdent; |
| } |
| } |
| |
| pExpr = pExpr->GetNext(); |
| bFirst = sal_False; |
| } |
| |
| if( aName.Len() && !rParser.IsIgnoreFontFamily() ) |
| { |
| SvxFontItem aFont( eFamily, aName, aStyleName, ePitch, |
| eEnc, aItemIds.nFont ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aFont ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aFont.SetWhich( aItemIds.nFontCJK ); |
| rItemSet.Put( aFont ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aFont.SetWhich( aItemIds.nFontCTL ); |
| rItemSet.Put( aFont ); |
| } |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_font_weight( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| case CSS1_STRING: // MS-IE, was sonst |
| { |
| sal_uInt16 nWeight; |
| if( SvxCSS1Parser::GetEnum( aFontWeightTable, pExpr->GetString(), |
| nWeight ) ) |
| { |
| SvxWeightItem aWeight( (FontWeight)nWeight, aItemIds.nWeight ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aWeight ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCJK ); |
| rItemSet.Put( aWeight ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCTL ); |
| rItemSet.Put( aWeight ); |
| } |
| } |
| } |
| break; |
| case CSS1_NUMBER: |
| { |
| sal_uInt16 nWeight = (sal_uInt16)pExpr->GetNumber(); |
| SvxWeightItem aWeight( nWeight>400 ? WEIGHT_BOLD : WEIGHT_NORMAL, |
| aItemIds.nWeight ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aWeight ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCJK ); |
| rItemSet.Put( aWeight ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCTL ); |
| rItemSet.Put( aWeight ); |
| } |
| } |
| break; |
| |
| default: |
| ; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_font_style( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_Bool bPosture = sal_False; |
| sal_Bool bCaseMap = sal_False; |
| FontItalic eItalic = ITALIC_NONE; |
| SvxCaseMap eCaseMap = SVX_CASEMAP_NOT_MAPPED; |
| |
| // normal | italic || small-caps | oblique || small-caps | small-caps |
| // (wobei nor noch normal | italic und oblique zulaessig sind |
| |
| // der Wert kann zwei Werte enthalten! |
| for( sal_uInt16 i=0; pExpr && i<2; i++ ) |
| { |
| // Auch hier hinterlaesst MS-IEs Parser seine Spuren |
| if( (CSS1_IDENT==pExpr->GetType() || CSS1_STRING==pExpr->GetType()) && |
| !pExpr->GetOp() ) |
| { |
| const String& rValue = pExpr->GetString(); |
| // erstmal pruefen, ob es ein Italic-Wert oder 'normal' ist |
| sal_uInt16 nItalic; |
| if( SvxCSS1Parser::GetEnum( aFontStyleTable, rValue, nItalic ) ) |
| { |
| eItalic = (FontItalic)nItalic; |
| if( !bCaseMap && ITALIC_NONE==eItalic ) |
| { |
| // fuer 'normal' muessen wir auch die case-map aussch. |
| eCaseMap = SVX_CASEMAP_NOT_MAPPED; |
| bCaseMap = sal_True; |
| } |
| bPosture = sal_True; |
| } |
| else if( !bCaseMap && |
| rValue.EqualsIgnoreCaseAscii(sCSS1_PV_small_caps) ) |
| { |
| eCaseMap = SVX_CASEMAP_KAPITAELCHEN; |
| bCaseMap = sal_True; |
| } |
| } |
| |
| // den naechsten Ausdruck holen |
| pExpr = pExpr->GetNext(); |
| } |
| |
| if( bPosture ) |
| { |
| SvxPostureItem aPosture( eItalic, aItemIds.nPosture ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aPosture ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aPosture.SetWhich( aItemIds.nPostureCJK ); |
| rItemSet.Put( aPosture ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aPosture.SetWhich( aItemIds.nPostureCTL ); |
| rItemSet.Put( aPosture ); |
| } |
| } |
| |
| if( bCaseMap ) |
| rItemSet.Put( SvxCaseMapItem( eCaseMap, aItemIds.nCaseMap ) ); |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_font_variant( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| // normal | small-caps |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| { |
| sal_uInt16 nCaseMap; |
| if( SvxCSS1Parser::GetEnum( aFontVariantTable, pExpr->GetString(), |
| nCaseMap ) ) |
| { |
| rItemSet.Put( SvxCaseMapItem( (SvxCaseMap)nCaseMap, |
| aItemIds.nCaseMap ) ); |
| } |
| } |
| default: |
| ; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_color( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| case CSS1_RGB: |
| case CSS1_HEXCOLOR: |
| case CSS1_STRING: // Wegen MS-IE |
| { |
| Color aColor; |
| if( pExpr->GetColor( aColor ) ) |
| rItemSet.Put( SvxColorItem( aColor, aItemIds.nColor ) ); |
| } |
| break; |
| default: |
| ; |
| } |
| } |
| |
| static void ParseCSS1_direction( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nDir; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| case CSS1_STRING: |
| if( SvxCSS1Parser::GetEnum( aDirectionTable, pExpr->GetString(), |
| nDir ) ) |
| { |
| rItemSet.Put( SvxFrameDirectionItem( |
| static_cast < SvxFrameDirection >( nDir ), |
| aItemIds.nDirection ) ); |
| } |
| break; |
| default: |
| ; |
| } |
| } |
| |
| /* */ |
| |
| static void MergeHori( SvxGraphicPosition& ePos, SvxGraphicPosition eHori ) |
| { |
| DBG_ASSERT( GPOS_LT==eHori || GPOS_MT==eHori || GPOS_RT==eHori, |
| "vertikale Position nicht oben" ); |
| |
| switch( ePos ) |
| { |
| case GPOS_LT: |
| case GPOS_MT: |
| case GPOS_RT: |
| ePos = eHori; |
| break; |
| |
| case GPOS_LM: |
| case GPOS_MM: |
| case GPOS_RM: |
| ePos = GPOS_LT==eHori ? GPOS_LM : (GPOS_MT==eHori ? GPOS_MM : GPOS_RM); |
| break; |
| |
| case GPOS_LB: |
| case GPOS_MB: |
| case GPOS_RB: |
| ePos = GPOS_LT==eHori ? GPOS_LB : (GPOS_MT==eHori ? GPOS_MB : GPOS_RB); |
| break; |
| |
| default: |
| ; |
| } |
| } |
| |
| static void MergeVert( SvxGraphicPosition& ePos, SvxGraphicPosition eVert ) |
| { |
| DBG_ASSERT( GPOS_LT==eVert || GPOS_LM==eVert || GPOS_LB==eVert, |
| "horizontale Position nicht links" ); |
| |
| switch( ePos ) |
| { |
| case GPOS_LT: |
| case GPOS_LM: |
| case GPOS_LB: |
| ePos = eVert; |
| break; |
| |
| case GPOS_MT: |
| case GPOS_MM: |
| case GPOS_MB: |
| ePos = GPOS_LT==eVert ? GPOS_MT : (GPOS_LM==eVert ? GPOS_MM : GPOS_MB); |
| break; |
| |
| case GPOS_RT: |
| case GPOS_RM: |
| case GPOS_RB: |
| ePos = GPOS_LT==eVert ? GPOS_RT : (GPOS_LM==eVert ? GPOS_RM : GPOS_RB); |
| break; |
| |
| default: |
| ; |
| } |
| } |
| |
| static void ParseCSS1_background( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| Color aColor; |
| String aURL; |
| |
| sal_Bool bColor = sal_False, bTransparent = sal_False; |
| SvxGraphicPosition eRepeat = GPOS_TILED; |
| SvxGraphicPosition ePos = GPOS_LT; |
| sal_Bool bHori = sal_False, bVert = sal_False; |
| |
| while( pExpr && !pExpr->GetOp() ) |
| { |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_URL: |
| pExpr->GetURL( aURL ); |
| break; |
| |
| case CSS1_RGB: |
| bColor = pExpr->GetColor( aColor ); |
| break; |
| |
| case CSS1_LENGTH: |
| case CSS1_PIXLENGTH: |
| { |
| // da wir keine absolute Positionierung koennen, |
| // unterscheiden wir nur zwischen 0 und !0. Deshalb |
| // koennen Pixel auch wie alle anderen Einheiten behandelt |
| // werden. |
| |
| sal_uLong nLength = (sal_uLong)pExpr->GetNumber(); |
| if( !bHori ) |
| { |
| ePos = nLength ? GPOS_MM : GPOS_LT; |
| bHori = sal_True; |
| } |
| else if( !bVert ) |
| { |
| MergeVert( ePos, (nLength ? GPOS_LM : GPOS_LT) ); |
| bVert = sal_True; |
| } |
| } |
| break; |
| |
| case CSS1_PERCENTAGE: |
| { |
| // die %-Angabe wird auf den enum abgebildet |
| |
| sal_uInt16 nPerc = (sal_uInt16)pExpr->GetNumber(); |
| if( !bHori ) |
| { |
| ePos = nPerc < 25 ? GPOS_LT |
| : (nPerc < 75 ? GPOS_MM |
| : GPOS_RB); |
| } |
| else if( !bVert ) |
| { |
| SvxGraphicPosition eVert = |
| nPerc < 25 ? GPOS_LT: (nPerc < 75 ? GPOS_LM |
| : GPOS_LB); |
| MergeVert( ePos, eVert ); |
| } |
| } |
| break; |
| |
| case CSS1_IDENT: |
| case CSS1_HEXCOLOR: |
| case CSS1_STRING: // Wegen MS-IE |
| { |
| sal_uInt16 nEnum; |
| const String &rValue = pExpr->GetString(); |
| if( rValue.EqualsIgnoreCaseAscii( sCSS1_PV_transparent ) ) |
| { |
| bTransparent = sal_True; |
| } |
| if( SvxCSS1Parser::GetEnum( aBGRepeatTable, rValue, nEnum ) ) |
| { |
| eRepeat = (SvxGraphicPosition)nEnum; |
| } |
| else if( SvxCSS1Parser::GetEnum( aBGHoriPosTable, rValue, nEnum ) ) |
| { |
| // <position>, horizontal |
| MergeHori( ePos, (SvxGraphicPosition)nEnum ); |
| } |
| else if( SvxCSS1Parser::GetEnum( aBGVertPosTable, rValue, nEnum ) ) |
| { |
| // <position>, vertikal |
| MergeVert( ePos, (SvxGraphicPosition)nEnum ); |
| } |
| else if( !bColor ) |
| { |
| // <color> |
| bColor = pExpr->GetColor( aColor ); |
| } |
| // <scroll> kennen wir nicht |
| } |
| break; |
| |
| default: |
| ; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| } |
| |
| // transparent schlaegt alles |
| if( bTransparent ) |
| { |
| bColor = sal_False; |
| aURL.Erase(); |
| } |
| |
| // repeat hat prio gegenueber einer Position |
| if( GPOS_NONE == eRepeat ) |
| eRepeat = ePos; |
| |
| if( bTransparent || bColor || aURL.Len() ) |
| { |
| SvxBrushItem aBrushItem( aItemIds.nBrush ); |
| |
| if( bTransparent ) |
| aBrushItem.SetColor( Color(COL_TRANSPARENT)); |
| else if( bColor ) |
| aBrushItem.SetColor( aColor ); |
| |
| if( aURL.Len() ) |
| { |
| aBrushItem.SetGraphicLink( URIHelper::SmartRel2Abs( INetURLObject( rParser.GetBaseURL()), aURL, Link(), false ) ); |
| aBrushItem.SetGraphicPos( eRepeat ); |
| } |
| |
| rItemSet.Put( aBrushItem ); |
| } |
| } |
| |
| static void ParseCSS1_background_color( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| Color aColor; |
| |
| sal_Bool bColor = sal_False, bTransparent = sal_False; |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_RGB: |
| bColor = pExpr->GetColor( aColor ); |
| break; |
| case CSS1_IDENT: |
| case CSS1_HEXCOLOR: |
| case CSS1_STRING: // Wegen MS-IE |
| if( pExpr->GetString().EqualsIgnoreCaseAscii( sCSS1_PV_transparent ) ) |
| { |
| bTransparent = sal_True; |
| } |
| else |
| { |
| // <color> |
| bColor = pExpr->GetColor( aColor ); |
| } |
| break; |
| default: |
| ; |
| } |
| |
| if( bTransparent || bColor ) |
| { |
| SvxBrushItem aBrushItem( aItemIds.nBrush ); |
| |
| if( bTransparent ) |
| aBrushItem.SetColor( Color(COL_TRANSPARENT) ); |
| else if( bColor ) |
| aBrushItem.SetColor( aColor); |
| |
| rItemSet.Put( aBrushItem ); |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_line_height( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nHeight = 0; |
| sal_uInt8 nPropHeight = 0; |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| nHeight = (sal_uInt16)pExpr->GetULength(); |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = 0; |
| long nPHeight = (long)pExpr->GetNumber(); |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nHeight = (sal_uInt16)nPHeight; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| { |
| sal_uInt16 nPHeight = (sal_uInt16)pExpr->GetNumber(); |
| nPropHeight = nPHeight <= 200 ? (sal_uInt8)nPHeight : 200; |
| } |
| break; |
| case CSS1_NUMBER: |
| { |
| sal_uInt16 nPHeight = (sal_uInt16)(pExpr->GetNumber() * 100); |
| nPropHeight = nPHeight <= 200 ? (sal_uInt8)nPHeight : 200; |
| } |
| break; |
| default: |
| ; |
| } |
| |
| if( nHeight ) |
| { |
| if( nHeight < rParser.GetMinFixLineSpace() ) |
| nHeight = rParser.GetMinFixLineSpace(); |
| SvxLineSpacingItem aLSItem( nHeight, aItemIds.nLineSpacing ); |
| aLSItem.SetLineHeight( nHeight ); |
| // --> OD 2006-07-26 #138463# |
| // interpret <line-height> attribute as minimum line height |
| aLSItem.GetLineSpaceRule() = SVX_LINE_SPACE_MIN; |
| // <-- |
| aLSItem.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF; |
| rItemSet.Put( aLSItem ); |
| } |
| else if( nPropHeight ) |
| { |
| SvxLineSpacingItem aLSItem( nPropHeight, aItemIds.nLineSpacing ); |
| aLSItem.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO; |
| if( 100 == nPropHeight ) |
| aLSItem.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF; |
| else |
| aLSItem.SetPropLineSpace( nPropHeight ); |
| rItemSet.Put( aLSItem ); |
| } |
| |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_font( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| FontItalic eItalic = ITALIC_NONE; |
| SvxCaseMap eCaseMap = SVX_CASEMAP_NOT_MAPPED; |
| FontWeight eWeight = WEIGHT_NORMAL; |
| |
| // [ <font-style> || <font-variant> || <font-weight> ] ? |
| while( pExpr && !pExpr->GetOp() && |
| (CSS1_IDENT==pExpr->GetType() || |
| CSS1_STRING==pExpr->GetType() || |
| CSS1_NUMBER==pExpr->GetType()) ) |
| { |
| if( CSS1_IDENT==pExpr->GetType() || |
| CSS1_STRING==pExpr->GetType() ) |
| { |
| const String& rValue = pExpr->GetString(); |
| |
| sal_uInt16 nEnum; |
| |
| if( SvxCSS1Parser::GetEnum( aFontStyleTable, rValue, nEnum ) ) |
| { |
| eItalic = (FontItalic)nEnum; |
| } |
| else if( SvxCSS1Parser::GetEnum( aFontVariantTable, rValue, nEnum ) ) |
| { |
| eCaseMap = (SvxCaseMap)nEnum; |
| } |
| else if( SvxCSS1Parser::GetEnum( aFontWeightTable, rValue, nEnum ) ) |
| { |
| eWeight = (FontWeight)nEnum; |
| } |
| } |
| else |
| { |
| eWeight = (sal_uInt16)pExpr->GetNumber() > 400 ? WEIGHT_BOLD |
| : WEIGHT_NORMAL; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| } |
| |
| if( !pExpr || pExpr->GetOp() ) |
| return; |
| |
| // Da "font" alle Werte zurecksetzt, fuer die nichts angegeben ist, |
| // tun wir das hier. |
| SvxPostureItem aPosture( eItalic, aItemIds.nPosture ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aPosture ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aPosture.SetWhich( aItemIds.nPostureCJK ); |
| rItemSet.Put( aPosture ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aPosture.SetWhich( aItemIds.nPostureCTL ); |
| rItemSet.Put( aPosture ); |
| } |
| |
| rItemSet.Put( SvxCaseMapItem( eCaseMap, aItemIds.nCaseMap ) ); |
| |
| SvxWeightItem aWeight( eWeight, aItemIds.nWeight ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aWeight ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCJK ); |
| rItemSet.Put( aWeight ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aWeight.SetWhich( aItemIds.nWeightCTL ); |
| rItemSet.Put( aWeight ); |
| } |
| |
| |
| // font-size |
| CSS1Expression aExpr( pExpr->GetType(), pExpr->GetString(), |
| pExpr->GetNumber() ); |
| ParseCSS1_font_size( &aExpr, rItemSet, rPropInfo, rParser ); |
| pExpr = pExpr->GetNext(); |
| |
| if( !pExpr ) |
| return; |
| |
| // [ '/' line-height ]? |
| if( '/' == pExpr->GetOp() ) |
| { |
| // '/' line-height |
| aExpr.Set( pExpr->GetType(), pExpr->GetString(), pExpr->GetNumber() ); |
| ParseCSS1_line_height( &aExpr, rItemSet, rPropInfo, rParser ); |
| |
| pExpr = pExpr->GetNext(); |
| } |
| |
| if( !pExpr || pExpr->GetOp() ) |
| return; |
| |
| // font-family |
| ParseCSS1_font_family( pExpr, rItemSet, rPropInfo, rParser ); |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_letter_spacing( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| rItemSet.Put( SvxKerningItem( (short)pExpr->GetSLength(), |
| aItemIds.nKerning ) ); |
| break; |
| |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = (long)pExpr->GetNumber(); |
| long nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| rItemSet.Put( SvxKerningItem( (short)nPWidth, aItemIds.nKerning ) ); |
| } |
| break; |
| |
| case CSS1_NUMBER: |
| if( pExpr->GetNumber() == 0 ) |
| { |
| // eigentlich unnoetig, aber wir sind ja tollerant |
| rItemSet.Put( SvxKerningItem( (short)0, aItemIds.nKerning ) ); |
| } |
| break; |
| |
| case CSS1_IDENT: |
| case CSS1_STRING: // Vorschtshalber auch MS-IE |
| if( pExpr->GetString().EqualsIgnoreCaseAscii(sCSS1_PV_normal) ) |
| { |
| rItemSet.Put( SvxKerningItem( (short)0, aItemIds.nKerning ) ); |
| } |
| break; |
| default: |
| ; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_text_decoration( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_Bool bUnderline = sal_False; |
| sal_Bool bOverline = sal_False; |
| sal_Bool bCrossedOut = sal_False; |
| sal_Bool bBlink = sal_False; |
| sal_Bool bBlinkOn = sal_False; |
| FontUnderline eUnderline = UNDERLINE_NONE; |
| FontUnderline eOverline = UNDERLINE_NONE; |
| FontStrikeout eCrossedOut = STRIKEOUT_NONE; |
| |
| // der Wert kann zwei Werte enthalten! Und MS-IE auch Strings |
| while( pExpr && (pExpr->GetType() == CSS1_IDENT || |
| pExpr->GetType() == CSS1_STRING) && !pExpr->GetOp() ) |
| { |
| String aValue = pExpr->GetString(); |
| aValue.ToLowerAscii(); |
| sal_Bool bKnown = sal_False; |
| |
| switch( aValue.GetChar( 0 ) ) |
| { |
| case 'n': |
| if( aValue.EqualsAscii( sCSS1_PV_none ) ) |
| { |
| bUnderline = sal_True; |
| eUnderline = UNDERLINE_NONE; |
| |
| bOverline = sal_True; |
| eOverline = UNDERLINE_NONE; |
| |
| bCrossedOut = sal_True; |
| eCrossedOut = STRIKEOUT_NONE; |
| |
| bBlink = sal_True; |
| bBlinkOn = sal_False; |
| |
| bKnown = sal_True; |
| } |
| break; |
| |
| case 'u': |
| if( aValue.EqualsAscii( sCSS1_PV_underline ) ) |
| { |
| bUnderline = sal_True; |
| eUnderline = UNDERLINE_SINGLE; |
| |
| bKnown = sal_True; |
| } |
| break; |
| |
| case 'o': |
| if( aValue.EqualsAscii( sCSS1_PV_overline ) ) |
| { |
| bOverline = sal_True; |
| eOverline = UNDERLINE_SINGLE; |
| |
| bKnown = sal_True; |
| } |
| break; |
| |
| case 'l': |
| if( aValue.EqualsAscii( sCSS1_PV_line_through ) ) |
| { |
| bCrossedOut = sal_True; |
| eCrossedOut = STRIKEOUT_SINGLE; |
| |
| bKnown = sal_True; |
| } |
| break; |
| |
| case 'b': |
| if( aValue.EqualsAscii( sCSS1_PV_blink ) ) |
| { |
| bBlink = sal_True; |
| bBlinkOn = sal_True; |
| |
| bKnown = sal_True; |
| } |
| break; |
| } |
| |
| if( !bKnown ) |
| { |
| bUnderline = sal_True; |
| eUnderline = UNDERLINE_SINGLE; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| } |
| |
| if( bUnderline ) |
| rItemSet.Put( SvxUnderlineItem( eUnderline, aItemIds.nUnderline ) ); |
| |
| if( bOverline ) |
| rItemSet.Put( SvxOverlineItem( eOverline, aItemIds.nOverline ) ); |
| |
| if( bCrossedOut ) |
| rItemSet.Put( SvxCrossedOutItem( eCrossedOut, aItemIds.nCrossedOut ) ); |
| |
| if( bBlink ) |
| rItemSet.Put( SvxBlinkItem( bBlinkOn, aItemIds.nBlink ) ); |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_text_align( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| if( CSS1_IDENT==pExpr->GetType() || |
| CSS1_STRING==pExpr->GetType() ) // MS-IE, mal wieder |
| { |
| sal_uInt16 nAdjust; |
| if( SvxCSS1Parser::GetEnum( aTextAlignTable, pExpr->GetString(), |
| nAdjust ) ) |
| { |
| rItemSet.Put( SvxAdjustItem( (SvxAdjust)nAdjust, |
| aItemIds.nAdjust ) ); |
| } |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_text_indent( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| short nIndent = 0; |
| sal_Bool bSet = sal_False; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| nIndent = (short)pExpr->GetSLength(); |
| bSet = sal_True; |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = (long)pExpr->GetNumber(); |
| long nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nIndent = (short)nPWidth; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nLRSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxLRSpaceItem aLRItem( *((const SvxLRSpaceItem*)pItem) ); |
| aLRItem.SetTxtFirstLineOfst( nIndent ); |
| rItemSet.Put( aLRItem ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRItem( aItemIds.nLRSpace ); |
| aLRItem.SetTxtFirstLineOfst( nIndent ); |
| rItemSet.Put( aLRItem ); |
| } |
| rPropInfo.bTextIndent = sal_True; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_margin_left( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| long nLeft = 0; |
| sal_Bool bSet = sal_False; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| nLeft = pExpr->GetSLength(); |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| nLeft = (long)pExpr->GetNumber(); |
| long nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nLeft, nPHeight ); |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| rPropInfo.nLeftMargin = nLeft; |
| if( nLeft < 0 ) |
| nLeft = 0; |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nLRSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxLRSpaceItem aLRItem( *((const SvxLRSpaceItem*)pItem) ); |
| aLRItem.SetTxtLeft( (sal_uInt16)nLeft ); |
| rItemSet.Put( aLRItem ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRItem( aItemIds.nLRSpace ); |
| aLRItem.SetTxtLeft( (sal_uInt16)nLeft ); |
| rItemSet.Put( aLRItem ); |
| } |
| rPropInfo.bLeftMargin = sal_True; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_margin_right( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| long nRight = 0; |
| sal_Bool bSet = sal_False; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| nRight = pExpr->GetSLength(); |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| nRight = (long)pExpr->GetNumber(); |
| long nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nRight, nPHeight ); |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| rPropInfo.nRightMargin = nRight; |
| if( nRight < 0 ) |
| nRight = 0; |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nLRSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxLRSpaceItem aLRItem( *((const SvxLRSpaceItem*)pItem) ); |
| aLRItem.SetRight( (sal_uInt16)nRight ); |
| rItemSet.Put( aLRItem ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRItem( aItemIds.nLRSpace ); |
| aLRItem.SetRight( (sal_uInt16)nRight ); |
| rItemSet.Put( aLRItem ); |
| } |
| rPropInfo.bRightMargin = sal_True; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_margin_top( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nUpper = 0; |
| sal_Bool bSet = sal_False; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| long nTmp = pExpr->GetSLength(); |
| if( nTmp < 0 ) |
| nTmp = 0; |
| nUpper = (sal_uInt16)nTmp; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = 0; |
| long nPHeight = (long)pExpr->GetNumber(); |
| if( nPHeight < 0 ) |
| nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nUpper = (sal_uInt16)nPHeight; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nULSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxULSpaceItem aULItem( *((const SvxULSpaceItem*)pItem) ); |
| aULItem.SetUpper( nUpper ); |
| rItemSet.Put( aULItem ); |
| } |
| else |
| { |
| SvxULSpaceItem aULItem( aItemIds.nULSpace ); |
| aULItem.SetUpper( nUpper ); |
| rItemSet.Put( aULItem ); |
| } |
| rPropInfo.bTopMargin = sal_True; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_margin_bottom( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nLower = 0; |
| sal_Bool bSet = sal_False; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| long nTmp = pExpr->GetSLength(); |
| if( nTmp < 0 ) |
| nTmp = 0; |
| nLower = (sal_uInt16)nTmp; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = 0; |
| long nPHeight = (long)pExpr->GetNumber(); |
| if( nPHeight < 0 ) |
| nPHeight = 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nLower = (sal_uInt16)nPHeight; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nULSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxULSpaceItem aULItem( *((const SvxULSpaceItem*)pItem) ); |
| aULItem.SetLower( nLower ); |
| rItemSet.Put( aULItem ); |
| } |
| else |
| { |
| SvxULSpaceItem aULItem( aItemIds.nULSpace ); |
| aULItem.SetLower( nLower ); |
| rItemSet.Put( aULItem ); |
| } |
| rPropInfo.bBottomMargin = sal_True; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_margin( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| long nMargins[4] = { 0, 0, 0, 0 }; |
| sal_Bool bSetMargins[4] = { sal_False, sal_False, sal_False, sal_False }; |
| |
| for( sal_uInt16 i=0; pExpr && i<4 && !pExpr->GetOp(); i++ ) |
| { |
| sal_Bool bSetThis = sal_False; |
| long nMargin = 0; |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| nMargin = pExpr->GetSLength(); |
| bSetThis = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = 0; |
| nMargin = (long)pExpr->GetNumber(); |
| SvxCSS1Parser::PixelToTwip( nPWidth, nMargin ); |
| bSetThis = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSetThis ) |
| { |
| // 0 = top |
| // 1 = right |
| // 2 = bottom |
| // 3 = left |
| switch( i ) |
| { |
| case 0: |
| nMargins[0] = nMargins[1] =nMargins[2] = nMargins[3] = nMargin; |
| bSetMargins[0] = bSetMargins[1] = |
| bSetMargins[2] = bSetMargins[3] = sal_True; |
| break; |
| case 1: |
| nMargins[1] = nMargins[3] = nMargin; // right + left |
| bSetMargins[1] = bSetMargins[3] = sal_True; |
| break; |
| case 2: |
| nMargins[2] = nMargin; // bottom |
| bSetMargins[2] = sal_True; |
| break; |
| case 3: |
| nMargins[3] = nMargin; // left |
| bSetMargins[3] = sal_True; |
| break; |
| } |
| } |
| pExpr = pExpr->GetNext(); |
| } |
| |
| if( bSetMargins[3] || bSetMargins[1] ) |
| { |
| if( bSetMargins[3] ) |
| { |
| rPropInfo.bLeftMargin = sal_True; |
| rPropInfo.nLeftMargin = nMargins[3]; |
| if( nMargins[3] < 0 ) |
| nMargins[3] = 0; |
| } |
| if( bSetMargins[1] ) |
| { |
| rPropInfo.bRightMargin = sal_True; |
| rPropInfo.nRightMargin = nMargins[1]; |
| if( nMargins[1] < 0 ) |
| nMargins[1] = 0; |
| } |
| |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nLRSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxLRSpaceItem aLRItem( *((const SvxLRSpaceItem*)pItem) ); |
| if( bSetMargins[3] ) |
| aLRItem.SetLeft( (sal_uInt16)nMargins[3] ); |
| if( bSetMargins[1] ) |
| aLRItem.SetRight( (sal_uInt16)nMargins[1] ); |
| rItemSet.Put( aLRItem ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRItem( aItemIds.nLRSpace ); |
| if( bSetMargins[3] ) |
| aLRItem.SetLeft( (sal_uInt16)nMargins[3] ); |
| if( bSetMargins[1] ) |
| aLRItem.SetRight( (sal_uInt16)nMargins[1] ); |
| rItemSet.Put( aLRItem ); |
| } |
| } |
| |
| if( bSetMargins[0] || bSetMargins[2] ) |
| { |
| if( nMargins[0] < 0 ) |
| nMargins[0] = 0; |
| if( nMargins[2] < 0 ) |
| nMargins[2] = 0; |
| |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( aItemIds.nULSpace, sal_False, |
| &pItem ) ) |
| { |
| SvxULSpaceItem aULItem( *((const SvxULSpaceItem*)pItem) ); |
| if( bSetMargins[0] ) |
| aULItem.SetUpper( (sal_uInt16)nMargins[0] ); |
| if( bSetMargins[2] ) |
| aULItem.SetLower( (sal_uInt16)nMargins[2] ); |
| rItemSet.Put( aULItem ); |
| } |
| else |
| { |
| SvxULSpaceItem aULItem( aItemIds.nULSpace ); |
| if( bSetMargins[0] ) |
| aULItem.SetUpper( (sal_uInt16)nMargins[0] ); |
| if( bSetMargins[2] ) |
| aULItem.SetLower( (sal_uInt16)nMargins[2] ); |
| rItemSet.Put( aULItem ); |
| } |
| |
| rPropInfo.bTopMargin |= bSetMargins[0]; |
| rPropInfo.bBottomMargin |= bSetMargins[2]; |
| } |
| } |
| |
| /* */ |
| |
| static sal_Bool ParseCSS1_padding_xxx( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/, |
| sal_uInt16 nWhichLine ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_Bool bSet = sal_False; |
| sal_uInt16 nDist = 0; |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_LENGTH: |
| { |
| long nTmp = pExpr->GetSLength(); |
| if( nTmp < 0 ) |
| nTmp = 0; |
| else if( nTmp > USHRT_MAX-1 ) |
| nTmp = USHRT_MAX-1; |
| nDist = (sal_uInt16)nTmp; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PIXLENGTH: |
| { |
| long nPWidth = (long)pExpr->GetNumber(); |
| long nPHeight = 0; |
| if( nPWidth < 0 ) |
| nPWidth = 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| if( nPWidth > USHRT_MAX-1 ) |
| nPWidth = USHRT_MAX-1; |
| nDist = (sal_uInt16)nPWidth; |
| bSet = sal_True; |
| } |
| break; |
| case CSS1_PERCENTAGE: |
| // koennen wir nicht |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| { |
| switch( nWhichLine ) |
| { |
| case BOX_LINE_TOP: rPropInfo.nTopBorderDistance = nDist; break; |
| case BOX_LINE_BOTTOM: rPropInfo.nBottomBorderDistance = nDist;break; |
| case BOX_LINE_LEFT: rPropInfo.nLeftBorderDistance = nDist; break; |
| case BOX_LINE_RIGHT: rPropInfo.nRightBorderDistance = nDist; break; |
| } |
| } |
| |
| return bSet; |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_padding_top( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_padding_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_TOP ); |
| } |
| |
| static void ParseCSS1_padding_bottom( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_padding_xxx( pExpr, rItemSet, rPropInfo, rParser, |
| BOX_LINE_BOTTOM ); |
| } |
| |
| static void ParseCSS1_padding_left( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_padding_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_LEFT ); |
| } |
| |
| static void ParseCSS1_padding_right( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_padding_xxx( pExpr, rItemSet, rPropInfo, rParser, |
| BOX_LINE_RIGHT ); |
| } |
| |
| static void ParseCSS1_padding( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| sal_uInt16 n=0; |
| while( n<4 && pExpr && !pExpr->GetOp() ) |
| { |
| sal_uInt16 nLine = n==0 || n==2 ? BOX_LINE_BOTTOM : BOX_LINE_LEFT; |
| if( ParseCSS1_padding_xxx( pExpr, rItemSet, rPropInfo, rParser, |
| nLine ) ) |
| { |
| if( n==0 ) |
| { |
| rPropInfo.nTopBorderDistance = rPropInfo.nBottomBorderDistance; |
| rPropInfo.nLeftBorderDistance = rPropInfo.nTopBorderDistance; |
| } |
| if( n <= 1 ) |
| rPropInfo.nRightBorderDistance = rPropInfo.nLeftBorderDistance; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| n++; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_border_xxx( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/, |
| sal_uInt16 nWhichLine, sal_Bool bAll ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nWidth = USHRT_MAX; // die Linien-Dicke |
| sal_uInt16 nNWidth = 1; // benannte Linien-Dicke (und default) |
| CSS1BorderStyle eStyle = CSS1_BS_NONE; // Linien-Style |
| Color aColor; |
| sal_Bool bColor = sal_False; |
| |
| while( pExpr && !pExpr->GetOp() ) |
| { |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_RGB: |
| case CSS1_HEXCOLOR: |
| if( pExpr->GetColor( aColor ) ) |
| bColor = sal_True; |
| break; |
| |
| case CSS1_IDENT: |
| { |
| const String& rValue = pExpr->GetString(); |
| sal_uInt16 nValue; |
| if( SvxCSS1Parser::GetEnum( aBorderWidthTable, rValue, nValue ) ) |
| { |
| nNWidth = nValue; |
| } |
| else if( SvxCSS1Parser::GetEnum( aBorderStyleTable, rValue, nValue ) ) |
| { |
| eStyle = (CSS1BorderStyle)nValue; |
| } |
| else if( pExpr->GetColor( aColor ) ) |
| { |
| bColor = sal_True; |
| } |
| } |
| break; |
| |
| case CSS1_LENGTH: |
| nWidth = (sal_uInt16)pExpr->GetULength(); |
| break; |
| |
| case CSS1_PIXLENGTH: |
| { |
| sal_Bool bHori = nWhichLine == BOX_LINE_TOP || |
| nWhichLine == BOX_LINE_BOTTOM; |
| // Ein Pixel wird zur Haarlinie (ist huebscher) |
| long nWidthL = (long)pExpr->GetNumber(); |
| if( nWidthL > 1 ) |
| { |
| long nPWidth = bHori ? 0 : nWidthL; |
| long nPHeight = bHori ? nWidthL : 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nWidth = (sal_uInt16)(bHori ? nPHeight : nPWidth); |
| } |
| else |
| nWidth = 1; |
| } |
| break; |
| |
| default: |
| ; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| } |
| |
| for( sal_uInt16 i=0; i<4; i++ ) |
| { |
| sal_uInt16 nLine = 0; |
| switch( i ) |
| { |
| case 0: nLine = BOX_LINE_TOP; break; |
| case 1: nLine = BOX_LINE_BOTTOM; break; |
| case 2: nLine = BOX_LINE_LEFT; break; |
| case 3: nLine = BOX_LINE_RIGHT; break; |
| } |
| |
| if( bAll || nLine == nWhichLine ) |
| { |
| SvxCSS1BorderInfo *pInfo = rPropInfo.GetBorderInfo( nLine ); |
| pInfo->eStyle = eStyle; |
| pInfo->nAbsWidth = nWidth; |
| pInfo->nNamedWidth = nNWidth; |
| if( bColor ) |
| pInfo->aColor = aColor; |
| } |
| } |
| } |
| |
| static void ParseCSS1_border_xxx_width( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/, |
| sal_uInt16 nWhichLine ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| sal_uInt16 nWidth = USHRT_MAX; // die Linien-Dicke |
| sal_uInt16 nNWidth = 1; // benannte Linien-Dicke (und default) |
| |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| { |
| sal_uInt16 nValue; |
| if( SvxCSS1Parser::GetEnum( aBorderWidthTable, pExpr->GetString(), nValue ) ) |
| { |
| nNWidth = nValue; |
| } |
| } |
| break; |
| |
| case CSS1_LENGTH: |
| nWidth = (sal_uInt16)pExpr->GetULength(); |
| break; |
| |
| case CSS1_PIXLENGTH: |
| { |
| sal_Bool bHori = nWhichLine == BOX_LINE_TOP || |
| nWhichLine == BOX_LINE_BOTTOM; |
| long nWidthL = (long)pExpr->GetNumber(); |
| long nPWidth = bHori ? 0 : nWidthL; |
| long nPHeight = bHori ? nWidthL : 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| nWidth = (sal_uInt16)(bHori ? nPHeight : nPWidth); |
| } |
| break; |
| |
| default: |
| ; |
| } |
| |
| SvxCSS1BorderInfo *pInfo = rPropInfo.GetBorderInfo( nWhichLine ); |
| pInfo->nAbsWidth = nWidth; |
| pInfo->nNamedWidth = nNWidth; |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_border_top_width( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx_width( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_TOP ); |
| } |
| |
| static void ParseCSS1_border_right_width( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx_width( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_RIGHT ); |
| } |
| |
| static void ParseCSS1_border_bottom_width( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx_width( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_BOTTOM ); |
| } |
| |
| static void ParseCSS1_border_left_width( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx_width( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_LEFT ); |
| } |
| |
| static void ParseCSS1_border_width( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| sal_uInt16 n=0; |
| while( n<4 && pExpr && !pExpr->GetOp() ) |
| { |
| sal_uInt16 nLine = n==0 || n==2 ? BOX_LINE_BOTTOM : BOX_LINE_LEFT; |
| ParseCSS1_border_xxx_width( pExpr, rItemSet, rPropInfo, rParser, nLine ); |
| rPropInfo.CopyBorderInfo( n, SVX_CSS1_BORDERINFO_WIDTH ); |
| |
| pExpr = pExpr->GetNext(); |
| n++; |
| } |
| } |
| |
| static void ParseCSS1_border_color( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| sal_uInt16 n=0; |
| while( n<4 && pExpr && !pExpr->GetOp() ) |
| { |
| sal_uInt16 nLine = n==0 || n==2 ? BOX_LINE_BOTTOM : BOX_LINE_LEFT; |
| Color aColor; |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_RGB: |
| case CSS1_HEXCOLOR: |
| case CSS1_IDENT: |
| if( pExpr->GetColor( aColor ) ) |
| rPropInfo.GetBorderInfo( nLine )->aColor = aColor; |
| break; |
| default: |
| ; |
| } |
| rPropInfo.CopyBorderInfo( n, SVX_CSS1_BORDERINFO_COLOR ); |
| |
| pExpr = pExpr->GetNext(); |
| n++; |
| } |
| } |
| |
| static void ParseCSS1_border_style( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| sal_uInt16 n=0; |
| while( n<4 && pExpr && !pExpr->GetOp() ) |
| { |
| sal_uInt16 nLine = n==0 || n==2 ? BOX_LINE_BOTTOM : BOX_LINE_LEFT; |
| sal_uInt16 nValue; |
| if( CSS1_IDENT==pExpr->GetType() && |
| SvxCSS1Parser::GetEnum( aBorderStyleTable, pExpr->GetString(), |
| nValue ) ) |
| { |
| rPropInfo.GetBorderInfo( nLine )->eStyle = (CSS1BorderStyle)nValue; |
| } |
| rPropInfo.CopyBorderInfo( n, SVX_CSS1_BORDERINFO_STYLE ); |
| |
| pExpr = pExpr->GetNext(); |
| n++; |
| } |
| } |
| |
| |
| static void ParseCSS1_border_top( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_TOP, sal_False ); |
| } |
| |
| static void ParseCSS1_border_right( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_RIGHT, sal_False ); |
| } |
| |
| static void ParseCSS1_border_bottom( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_BOTTOM, sal_False ); |
| } |
| |
| static void ParseCSS1_border_left( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx( pExpr, rItemSet, rPropInfo, rParser, BOX_LINE_LEFT, sal_False ); |
| } |
| |
| static void ParseCSS1_border( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& rParser ) |
| { |
| ParseCSS1_border_xxx( pExpr, rItemSet, rPropInfo, rParser, 0, sal_True ); |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_float( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| if( CSS1_IDENT==pExpr->GetType() ) |
| { |
| sal_uInt16 nFloat; |
| if( SvxCSS1Parser::GetEnum( aFloatTable, pExpr->GetString(), nFloat ) ) |
| rPropInfo.eFloat = (SvxAdjust)nFloat; |
| } |
| } |
| |
| |
| /* */ |
| |
| static void ParseCSS1_position( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| DBG_ASSERT( pExpr, "kein Ausdruck" ); |
| |
| if( CSS1_IDENT==pExpr->GetType() ) |
| { |
| sal_uInt16 nPos; |
| if( SvxCSS1Parser::GetEnum( aPositionTable, pExpr->GetString(), nPos ) ) |
| rPropInfo.ePosition = (SvxCSS1Position)nPos; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_length( const CSS1Expression *pExpr, |
| long& rLength, |
| SvxCSS1LengthType& rLengthType, |
| sal_Bool bHori ) |
| { |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| if( pExpr->GetString().EqualsIgnoreCaseAscii( sCSS1_PV_auto ) ) |
| { |
| rLength = 0; |
| rLengthType = SVX_CSS1_LTYPE_AUTO; |
| } |
| break; |
| |
| case CSS1_LENGTH: |
| rLength = pExpr->GetSLength(); |
| rLengthType = SVX_CSS1_LTYPE_TWIP; |
| break; |
| |
| case CSS1_PIXLENGTH: |
| case CSS1_NUMBER: // wegen Netscape und IE |
| { |
| long nWidthL = (long)pExpr->GetNumber(); |
| long nPWidth = bHori ? 0 : nWidthL; |
| long nPHeight = bHori ? nWidthL : 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| rLength = (bHori ? nPHeight : nPWidth); |
| rLengthType = SVX_CSS1_LTYPE_TWIP; |
| } |
| break; |
| |
| case CSS1_PERCENTAGE: |
| rLength = (long)pExpr->GetNumber(); |
| if( rLength > 100 ) |
| rLength = 100; |
| rLengthType = SVX_CSS1_LTYPE_PERCENTAGE; |
| break; |
| |
| default: |
| ; |
| } |
| } |
| |
| /* */ |
| |
| static void ParseCSS1_width( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_length( pExpr, rPropInfo.nWidth, rPropInfo.eWidthType, sal_True ); |
| } |
| |
| static void ParseCSS1_height( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_length( pExpr, rPropInfo.nHeight, rPropInfo.eHeightType, sal_False ); |
| } |
| |
| static void ParseCSS1_left( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_length( pExpr, rPropInfo.nLeft, rPropInfo.eLeftType, sal_True ); |
| } |
| |
| static void ParseCSS1_top( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_length( pExpr, rPropInfo.nTop, rPropInfo.eTopType, sal_False ); |
| } |
| |
| /* */ |
| |
| // Feature: PrintExt |
| static void ParseCSS1_size( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| sal_uInt16 n=0; |
| while( n<2 && pExpr && !pExpr->GetOp() ) |
| { |
| switch( pExpr->GetType() ) |
| { |
| case CSS1_IDENT: |
| { |
| sal_uInt16 nValue; |
| if( SvxCSS1Parser::GetEnum( aSizeTable, pExpr->GetString(), |
| nValue ) ) |
| { |
| rPropInfo.eSizeType = (SvxCSS1SizeType)nValue; |
| } |
| } |
| break; |
| |
| case CSS1_LENGTH: |
| rPropInfo.nHeight = pExpr->GetSLength(); |
| if( n==0 ) |
| rPropInfo.nWidth = rPropInfo.nHeight; |
| rPropInfo.eSizeType = SVX_CSS1_STYPE_TWIP; |
| break; |
| |
| case CSS1_PIXLENGTH: |
| { |
| long nPHeight = (long)pExpr->GetNumber(); |
| long nPWidth = n==0 ? nPHeight : 0; |
| SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight ); |
| rPropInfo.nHeight = nPHeight; |
| if( n==0 ) |
| rPropInfo.nWidth = nPWidth; |
| rPropInfo.eSizeType = SVX_CSS1_STYPE_TWIP; |
| } |
| break; |
| |
| default: |
| ; |
| } |
| |
| pExpr = pExpr->GetNext(); |
| n++; |
| } |
| } |
| |
| // /Feature: PrintExt |
| |
| /* */ |
| |
| // Feature: PrintExt |
| |
| static void ParseCSS1_page_break_xxx( const CSS1Expression *pExpr, |
| SvxCSS1PageBreak& rPBreak ) |
| { |
| if( CSS1_IDENT == pExpr->GetType() ) |
| { |
| sal_uInt16 nValue; |
| if( SvxCSS1Parser::GetEnum( aPageBreakTable, pExpr->GetString(), |
| nValue ) ) |
| { |
| rPBreak = (SvxCSS1PageBreak)nValue; |
| } |
| } |
| } |
| |
| static void ParseCSS1_page_break_before( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_page_break_xxx( pExpr, rPropInfo.ePageBreakBefore ); |
| } |
| |
| static void ParseCSS1_page_break_after( const CSS1Expression *pExpr, |
| SfxItemSet & /*rItemSet*/, |
| SvxCSS1PropertyInfo& rPropInfo, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| ParseCSS1_page_break_xxx( pExpr, rPropInfo.ePageBreakAfter ); |
| } |
| |
| static void ParseCSS1_page_break_inside( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| SvxCSS1PageBreak eBreak(SVX_CSS1_PBREAK_NONE); |
| ParseCSS1_page_break_xxx( pExpr, eBreak ); |
| |
| sal_Bool bSetSplit = sal_False, bSplit = sal_True; |
| switch( eBreak ) |
| { |
| case SVX_CSS1_PBREAK_AUTO: |
| bSetSplit = sal_True; |
| break; |
| case SVX_CSS1_PBREAK_AVOID: |
| bSplit = sal_False; |
| bSetSplit = sal_True; |
| break; |
| default: |
| ; |
| } |
| |
| if( bSetSplit ) |
| rItemSet.Put( SvxFmtSplitItem( bSplit, aItemIds.nFmtSplit ) ); |
| } |
| |
| static void ParseCSS1_widows( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| if( CSS1_NUMBER == pExpr->GetType() ) |
| { |
| sal_uInt8 nVal = pExpr->GetNumber() <= 255 |
| ? (sal_uInt8)pExpr->GetNumber() |
| : 255; |
| SvxWidowsItem aWidowsItem( nVal, aItemIds.nWidows ); |
| rItemSet.Put( aWidowsItem ); |
| } |
| } |
| |
| static void ParseCSS1_orphans( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& /*rParser*/ ) |
| { |
| if( CSS1_NUMBER == pExpr->GetType() ) |
| { |
| sal_uInt8 nVal = pExpr->GetNumber() <= 255 |
| ? (sal_uInt8)pExpr->GetNumber() |
| : 255; |
| SvxOrphansItem aOrphansItem( nVal, aItemIds.nOrphans ); |
| rItemSet.Put( aOrphansItem ); |
| } |
| } |
| // /Feature: PrintExt |
| |
| static void ParseCSS1_so_language( const CSS1Expression *pExpr, |
| SfxItemSet &rItemSet, |
| SvxCSS1PropertyInfo& /*rPropInfo*/, |
| const SvxCSS1Parser& rParser ) |
| { |
| if( CSS1_IDENT == pExpr->GetType() || |
| CSS1_STRING == pExpr->GetType() ) |
| { |
| LanguageType eLang = MsLangId::convertIsoStringToLanguage( pExpr->GetString() ); |
| if( LANGUAGE_DONTKNOW != eLang ) |
| { |
| SvxLanguageItem aLang( eLang, aItemIds.nLanguage ); |
| if( rParser.IsSetWesternProps() ) |
| rItemSet.Put( aLang ); |
| if( rParser.IsSetCJKProps() ) |
| { |
| aLang.SetWhich( aItemIds.nLanguageCJK ); |
| rItemSet.Put( aLang ); |
| } |
| if( rParser.IsSetCTLProps() ) |
| { |
| aLang.SetWhich( aItemIds.nLanguageCTL ); |
| rItemSet.Put( aLang ); |
| } |
| } |
| } |
| } |
| |
| /* */ |
| |
| // die Zuordung Property zu parsender Funktion |
| struct CSS1PropEntry |
| { |
| union |
| { |
| const sal_Char *sName; |
| String *pName; |
| }; |
| FnParseCSS1Prop pFunc; |
| }; |
| |
| #define CSS1_PROP_ENTRY(p) \ |
| { { sCSS1_P_##p }, ParseCSS1_##p } |
| |
| |
| // die Tabelle mit den Zuordnungen |
| static CSS1PropEntry __FAR_DATA aCSS1PropFnTab[] = |
| { |
| CSS1_PROP_ENTRY(background), |
| CSS1_PROP_ENTRY(background_color), |
| CSS1_PROP_ENTRY(border_top_width), |
| CSS1_PROP_ENTRY(border_right_width), |
| CSS1_PROP_ENTRY(border_bottom_width), |
| CSS1_PROP_ENTRY(border_left_width), |
| CSS1_PROP_ENTRY(border_width), |
| CSS1_PROP_ENTRY(border_color), |
| CSS1_PROP_ENTRY(border_style), |
| CSS1_PROP_ENTRY(border_top), |
| CSS1_PROP_ENTRY(border_right), |
| CSS1_PROP_ENTRY(border_bottom), |
| CSS1_PROP_ENTRY(border_left), |
| CSS1_PROP_ENTRY(border), |
| CSS1_PROP_ENTRY(color), |
| CSS1_PROP_ENTRY(direction), |
| CSS1_PROP_ENTRY(float), |
| CSS1_PROP_ENTRY(font_size), |
| CSS1_PROP_ENTRY(font_family), |
| CSS1_PROP_ENTRY(font_style), |
| CSS1_PROP_ENTRY(font_variant), |
| CSS1_PROP_ENTRY(font_weight), |
| CSS1_PROP_ENTRY(letter_spacing), |
| CSS1_PROP_ENTRY(line_height), |
| CSS1_PROP_ENTRY(font), |
| CSS1_PROP_ENTRY(text_align), |
| CSS1_PROP_ENTRY(text_decoration), |
| CSS1_PROP_ENTRY(text_indent), |
| CSS1_PROP_ENTRY(margin_left), |
| CSS1_PROP_ENTRY(margin_right), |
| CSS1_PROP_ENTRY(margin_top), |
| CSS1_PROP_ENTRY(margin_bottom), |
| CSS1_PROP_ENTRY(margin), |
| CSS1_PROP_ENTRY(padding_top), |
| CSS1_PROP_ENTRY(padding_bottom), |
| CSS1_PROP_ENTRY(padding_left), |
| CSS1_PROP_ENTRY(padding_right), |
| CSS1_PROP_ENTRY(padding), |
| CSS1_PROP_ENTRY(position), |
| CSS1_PROP_ENTRY(left), |
| CSS1_PROP_ENTRY(top), |
| CSS1_PROP_ENTRY(width), |
| CSS1_PROP_ENTRY(height), |
| // Feature: PrintExt |
| CSS1_PROP_ENTRY(size), |
| CSS1_PROP_ENTRY(page_break_before), |
| CSS1_PROP_ENTRY(page_break_after), |
| CSS1_PROP_ENTRY(page_break_inside), |
| CSS1_PROP_ENTRY(widows), |
| CSS1_PROP_ENTRY(orphans), |
| // /Feature: PrintExt |
| CSS1_PROP_ENTRY(so_language) |
| }; |
| |
| /* */ |
| |
| static int __FAR_DATA bSortedPropFns = sal_False; |
| |
| extern "C" |
| { |
| static int |
| #if defined( WNT ) |
| __cdecl |
| #endif |
| #if defined( ICC ) |
| _Optlink |
| #endif |
| CSS1PropEntryCompare( const void *pFirst, const void *pSecond) |
| { |
| int nRet; |
| if( ((CSS1PropEntry*)pFirst)->pFunc ) |
| { |
| if( ((CSS1PropEntry*)pSecond)->pFunc ) |
| nRet = strcmp( ((CSS1PropEntry*)pFirst)->sName , |
| ((CSS1PropEntry*)pSecond)->sName ); |
| else |
| nRet = -1 * ((CSS1PropEntry*)pSecond)->pName->CompareToAscii( |
| ((CSS1PropEntry*)pFirst)->sName ); |
| } |
| else |
| { |
| if( ((CSS1PropEntry*)pSecond)->pFunc ) |
| nRet = ((CSS1PropEntry*)pFirst)->pName->CompareToAscii( |
| ((CSS1PropEntry*)pSecond)->sName ); |
| else |
| nRet = ((CSS1PropEntry*)pFirst)->pName->CompareTo( |
| *((CSS1PropEntry*)pSecond)->pName ); |
| } |
| |
| return nRet; |
| } |
| } |
| |
| void SvxCSS1Parser::ParseProperty( const String& rProperty, |
| const CSS1Expression *pExpr ) |
| { |
| DBG_ASSERT( pItemSet, "DeclarationParsed() ohne ItemSet" ); |
| |
| if( !bSortedPropFns ) |
| { |
| qsort( (void*) aCSS1PropFnTab, |
| sizeof( aCSS1PropFnTab ) / sizeof( CSS1PropEntry ), |
| sizeof( CSS1PropEntry ), |
| CSS1PropEntryCompare ); |
| bSortedPropFns = sal_True; |
| } |
| |
| String aTmp( rProperty ); |
| aTmp.ToLowerAscii(); |
| |
| CSS1PropEntry aSrch; |
| aSrch.pName = &aTmp; |
| aSrch.pFunc = 0; |
| |
| void* pFound; |
| if( 0 != ( pFound = bsearch( (char *) &aSrch, |
| (void*) aCSS1PropFnTab, |
| sizeof( aCSS1PropFnTab ) / sizeof( CSS1PropEntry ), |
| sizeof( CSS1PropEntry ), |
| CSS1PropEntryCompare ))) |
| { |
| (((CSS1PropEntry*)pFound)->pFunc)( pExpr, *pItemSet, *pPropInfo, *this ); |
| } |
| } |