/************************************************************** * * 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_sc.hxx" // INCLUDE --------------------------------------------------------------- #include #include "scitems.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "output.hxx" #include "document.hxx" #include "cell.hxx" #include "attrib.hxx" #include "patattr.hxx" #include "docpool.hxx" #include "tabvwsh.hxx" #include "progress.hxx" #include "pagedata.hxx" #include "chgtrack.hxx" #include "chgviset.hxx" #include "viewutil.hxx" #include "gridmerg.hxx" #include "invmerge.hxx" #include "fillinfo.hxx" #include "scmod.hxx" #include "appoptio.hxx" #include "postit.hxx" #include using namespace com::sun::star; // STATIC DATA ----------------------------------------------------------- // Farben fuer ChangeTracking "nach Autor" wie im Writer (swmodul1.cxx) #define SC_AUTHORCOLORCOUNT 9 static ColorData nAuthorColor[ SC_AUTHORCOLORCOUNT ] = { COL_LIGHTRED, COL_LIGHTBLUE, COL_LIGHTMAGENTA, COL_GREEN, COL_RED, COL_BLUE, COL_BROWN, COL_MAGENTA, COL_CYAN }; //------------------------------------------------------------------ ScActionColorChanger::ScActionColorChanger( const ScChangeTrack& rTrack ) : rOpt( SC_MOD()->GetAppOptions() ), rUsers( rTrack.GetUserCollection() ), nLastUserIndex( 0 ), nColor( COL_BLACK ) { } void ScActionColorChanger::Update( const ScChangeAction& rAction ) { ColorData nSetColor; switch (rAction.GetType()) { case SC_CAT_INSERT_COLS: case SC_CAT_INSERT_ROWS: case SC_CAT_INSERT_TABS: nSetColor = rOpt.GetTrackInsertColor(); break; case SC_CAT_DELETE_COLS: case SC_CAT_DELETE_ROWS: case SC_CAT_DELETE_TABS: nSetColor = rOpt.GetTrackDeleteColor(); break; case SC_CAT_MOVE: nSetColor = rOpt.GetTrackMoveColor(); break; default: nSetColor = rOpt.GetTrackContentColor(); break; } if ( nSetColor != COL_TRANSPARENT ) // Farbe eingestellt nColor = nSetColor; else // nach Autor { if ( rAction.GetUser() != aLastUserName ) { aLastUserName = rAction.GetUser(); StrData aData(aLastUserName); sal_uInt16 nIndex; if (!rUsers.Search(&aData, nIndex)) { // empty string is possible if a name wasn't found while saving a 5.0 file DBG_ASSERT( aLastUserName.Len() == 0, "Author not found" ); nIndex = 0; } nLastUserIndex = nIndex % SC_AUTHORCOLORCOUNT; } nColor = nAuthorColor[nLastUserIndex]; } } //================================================================== ScOutputData::ScOutputData( OutputDevice* pNewDev, ScOutputType eNewType, ScTableInfo& rTabInfo, ScDocument* pNewDoc, SCTAB nNewTab, long nNewScrX, long nNewScrY, SCCOL nNewX1, SCROW nNewY1, SCCOL nNewX2, SCROW nNewY2, double nPixelPerTwipsX, double nPixelPerTwipsY, const Fraction* pZoomX, const Fraction* pZoomY ) : pDev( pNewDev ), pRefDevice( pNewDev ), // default is output device pFmtDevice( pNewDev ), // default is output device mrTabInfo( rTabInfo ), pRowInfo( rTabInfo.mpRowInfo ), nArrCount( rTabInfo.mnArrCount ), pDoc( pNewDoc ), nTab( nNewTab ), nScrX( nNewScrX ), nScrY( nNewScrY ), nX1( nNewX1 ), nY1( nNewY1 ), nX2( nNewX2 ), nY2( nNewY2 ), eType( eNewType ), nPPTX( nPixelPerTwipsX ), nPPTY( nPixelPerTwipsY ), pEditObj( NULL ), pViewShell( NULL ), pDrawView( NULL ), // #114135# bEditMode( sal_False ), bMetaFile( sal_False ), bSingleGrid( sal_False ), bPagebreakMode( sal_False ), bSolidBackground( sal_False ), bUseStyleColor( sal_False ), bForceAutoColor( SC_MOD()->GetAccessOptions().GetIsAutomaticFontColor() ), bSyntaxMode( sal_False ), pValueColor( NULL ), pTextColor( NULL ), pFormulaColor( NULL ), aGridColor( COL_BLACK ), bShowNullValues( sal_True ), bShowFormulas( sal_False ), bShowSpellErrors( sal_False ), bMarkClipped( sal_False ), // sal_False fuer Drucker/Metafile etc. bSnapPixel( sal_False ), bAnyRotated( sal_False ), bAnyClipped( sal_False ), mpTargetPaintWindow(0) // #i74769# use SdrPaintWindow direct { if (pZoomX) aZoomX = *pZoomX; else aZoomX = Fraction(1,1); if (pZoomY) aZoomY = *pZoomY; else aZoomY = Fraction(1,1); nVisX1 = nX1; nVisY1 = nY1; nVisX2 = nX2; nVisY2 = nY2; pDoc->StripHidden( nVisX1, nVisY1, nVisX2, nVisY2, nTab ); nScrW = 0; for (SCCOL nX=nVisX1; nX<=nVisX2; nX++) nScrW += pRowInfo[0].pCellInfo[nX+1].nWidth; nMirrorW = nScrW; nScrH = 0; for (SCSIZE nArrY=1; nArrY+1IsTabProtected( nTab ); nTabTextDirection = pDoc->GetEditTextDirection( nTab ); bLayoutRTL = pDoc->IsLayoutRTL( nTab ); } ScOutputData::~ScOutputData() { delete pValueColor; delete pTextColor; delete pFormulaColor; } void ScOutputData::SetContentDevice( OutputDevice* pContentDev ) { // use pContentDev instead of pDev where used if ( pRefDevice == pDev ) pRefDevice = pContentDev; if ( pFmtDevice == pDev ) pFmtDevice = pContentDev; pDev = pContentDev; } void ScOutputData::SetMirrorWidth( long nNew ) { nMirrorW = nNew; } void ScOutputData::SetGridColor( const Color& rColor ) { aGridColor = rColor; } void ScOutputData::SetMarkClipped( sal_Bool bSet ) { bMarkClipped = bSet; } void ScOutputData::SetShowNullValues( sal_Bool bSet ) { bShowNullValues = bSet; } void ScOutputData::SetShowFormulas( sal_Bool bSet ) { bShowFormulas = bSet; } void ScOutputData::SetShowSpellErrors( sal_Bool bSet ) { bShowSpellErrors = bSet; } void ScOutputData::SetSnapPixel( sal_Bool bSet ) { bSnapPixel = bSet; } void ScOutputData::SetEditCell( SCCOL nCol, SCROW nRow ) { nEditCol = nCol; nEditRow = nRow; bEditMode = sal_True; } void ScOutputData::SetMetaFileMode( sal_Bool bNewMode ) { bMetaFile = bNewMode; } void ScOutputData::SetSingleGrid( sal_Bool bNewMode ) { bSingleGrid = bNewMode; } void ScOutputData::SetSyntaxMode( sal_Bool bNewMode ) { bSyntaxMode = bNewMode; if (bNewMode) if (!pValueColor) { pValueColor = new Color( COL_LIGHTBLUE ); pTextColor = new Color( COL_BLACK ); pFormulaColor = new Color( COL_GREEN ); } } void ScOutputData::DrawGrid( sal_Bool bGrid, sal_Bool bPage ) { SCCOL nX; SCROW nY; long nPosX; long nPosY; SCSIZE nArrY; ScBreakType nBreak = BREAK_NONE; ScBreakType nBreakOld = BREAK_NONE; sal_Bool bSingle; Color aPageColor; Color aManualColor; if (bPagebreakMode) bPage = sal_False; // keine "normalen" Umbrueche ueber volle Breite/Hoehe //! um den einen Pixel sieht das Metafile (oder die Druck-Ausgabe) anders aus //! als die Bildschirmdarstellung, aber wenigstens passen Druck und Metafile zusammen Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); long nOneY = aOnePixel.Height(); if (bMetaFile) nOneX = nOneY = 1; long nLayoutSign = bLayoutRTL ? -1 : 1; long nSignedOneX = nOneX * nLayoutSign; if ( eType == OUTTYPE_WINDOW ) { const svtools::ColorConfig& rColorCfg = SC_MOD()->GetColorConfig(); aPageColor.SetColor( rColorCfg.GetColorValue(svtools::CALCPAGEBREAKAUTOMATIC).nColor ); aManualColor.SetColor( rColorCfg.GetColorValue(svtools::CALCPAGEBREAKMANUAL).nColor ); } else { aPageColor = aGridColor; aManualColor = aGridColor; } pDev->SetLineColor( aGridColor ); ScGridMerger aGrid( pDev, nOneX, nOneY ); // // Vertikale Linien // nPosX = nScrX; if ( bLayoutRTL ) nPosX += nMirrorW - nOneX; for (nX=nX1; nX<=nX2; nX++) { SCCOL nXplus1 = nX+1; SCCOL nXplus2 = nX+2; sal_uInt16 nWidth = pRowInfo[0].pCellInfo[nXplus1].nWidth; if (nWidth) { nPosX += nWidth * nLayoutSign; if ( bPage ) { // Seitenumbrueche auch in ausgeblendeten suchen SCCOL nCol = nXplus1; while (nCol <= MAXCOL) { nBreak = pDoc->HasColBreak(nCol, nTab); bool bHidden = pDoc->ColHidden(nCol, nTab); if ( nBreak || !bHidden ) break; ++nCol; } if (nBreak != nBreakOld) { aGrid.Flush(); pDev->SetLineColor( (nBreak & BREAK_MANUAL) ? aManualColor : nBreak ? aPageColor : aGridColor ); nBreakOld = nBreak; } } sal_Bool bDraw = bGrid || nBreakOld; // einfaches Gitter nur wenn eingestellt //! Mit dieser Abfrage wird zuviel weggelassen, wenn ein automatischer //! Umbruch mitten in den Wiederholungsspalten liegt. //! Dann lieber den aeusseren Rahmen zweimal ausgeben... #if 0 // auf dem Drucker die Aussen-Linien weglassen (werden getrennt ausgegeben) if ( eType == OUTTYPE_PRINTER && !bMetaFile ) { if ( nX == MAXCOL ) bDraw = sal_False; else if (pDoc->HasColBreak(nXplus1, nTab)) bDraw = sal_False; } #endif sal_uInt16 nWidthXplus2 = pRowInfo[0].pCellInfo[nXplus2].nWidth; bSingle = bSingleGrid; //! in Fillinfo holen !!!!! if ( nXGetColWidth(nVisX,nTab) ) ++nVisX; nPosY = nScrY; long nNextY; for (nArrY=1; nArrY+1nHeight; sal_Bool bHOver = pThisRowInfo->pCellInfo[nXplus1].bHideGrid; if (!bHOver) { if (nWidthXplus2) bHOver = pThisRowInfo->pCellInfo[nXplus2].bHOverlapped; else { if (nVisX <= nX2) bHOver = pThisRowInfo->pCellInfo[nVisX+1].bHOverlapped; else bHOver = ((ScMergeFlagAttr*)pDoc->GetAttr( nVisX,pThisRowInfo->nRowNo,nTab,ATTR_MERGE_FLAG)) ->IsHorOverlapped(); if (bHOver) bHOver = ((ScMergeFlagAttr*)pDoc->GetAttr( nXplus1,pThisRowInfo->nRowNo,nTab,ATTR_MERGE_FLAG)) ->IsHorOverlapped(); } } if (pThisRowInfo->bChanged && !bHOver) { //Point aStart( nPosX-nSignedOneX, nPosY ); //Point aEnd( nPosX-nSignedOneX, nNextY-nOneY ); //pDev->DrawLine( aStart, aEnd ); aGrid.AddVerLine( nPosX-nSignedOneX, nPosY, nNextY-nOneY ); } nPosY = nNextY; } } else { //Point aStart( nPosX-nSignedOneX, nScrY ); //Point aEnd( nPosX-nSignedOneX, nScrY+nScrH-nOneY ); //pDev->DrawLine( aStart, aEnd ); aGrid.AddVerLine( nPosX-nSignedOneX, nScrY, nScrY+nScrH-nOneY ); } } } } // // Horizontale Linien // bool bHiddenRow = true; SCROW nHiddenEndRow = -1; nPosY = nScrY; for (nArrY=1; nArrY+1 nHiddenEndRow) bHiddenRow = pDoc->RowHidden(i, nTab, nHiddenEndRow); /* TODO: optimize the row break thing for large hidden * segments where HasRowBreak() has to be called * nevertheless for each row, as a row break is drawn also * for hidden rows, above them. This needed to be done only * once per hidden segment, maybe giving manual breaks * priority. Something like GetNextRowBreak() and * GetNextManualRowBreak(). */ nBreak = pDoc->HasRowBreak(i, nTab); if (!bHiddenRow || nBreak) break; } if (nBreakOld != nBreak) { aGrid.Flush(); pDev->SetLineColor( (nBreak & BREAK_MANUAL) ? aManualColor : (nBreak) ? aPageColor : aGridColor ); nBreakOld = nBreak; } } sal_Bool bDraw = bGrid || nBreakOld; // einfaches Gitter nur wenn eingestellt //! Mit dieser Abfrage wird zuviel weggelassen, wenn ein automatischer //! Umbruch mitten in den Wiederholungszeilen liegt. //! Dann lieber den aeusseren Rahmen zweimal ausgeben... #if 0 // auf dem Drucker die Aussen-Linien weglassen (werden getrennt ausgegeben) if ( eType == OUTTYPE_PRINTER && !bMetaFile ) { if ( nY == MAXROW ) bDraw = sal_False; else if (pDoc->HasRowBreak(nYplus1, nTab)) bDraw = sal_False; } #endif sal_Bool bNextYisNextRow = (pRowInfo[nArrYplus1].nRowNo == nYplus1); bSingle = !bNextYisNextRow; // Hidden for (SCCOL i=nX1; i<=nX2 && !bSingle; i++) { if (pRowInfo[nArrYplus1].pCellInfo[i+1].bVOverlapped) bSingle = sal_True; } if (bDraw) { if ( bSingle && nYGetAttr( i,nYplus1,nTab,ATTR_MERGE_FLAG)) ->IsVerOverlapped() && ((ScMergeFlagAttr*)pDoc->GetAttr( i,nVisY,nTab,ATTR_MERGE_FLAG)) ->IsVerOverlapped(); //! nVisY aus Array ?? } if (!bVOver) { //Point aStart( nPosX, nPosY-nOneY ); //Point aEnd( nNextX-nSignedOneX, nPosY-nOneY ); //pDev->DrawLine( aStart, aEnd ); aGrid.AddHorLine( nPosX, nNextX-nSignedOneX, nPosY-nOneY ); } } nPosX = nNextX; } } else { //Point aStart( nScrX, nPosY-nOneY ); //Point aEnd( nScrX+nScrW-nOneX, nPosY-nOneY ); //pDev->DrawLine( aStart, aEnd ); aGrid.AddHorLine( nScrX, nScrX+nScrW-nOneX, nPosY-nOneY ); } } } } } // ---------------------------------------------------------------------------- void ScOutputData::SetPagebreakMode( ScPageBreakData* pPageData ) { bPagebreakMode = sal_True; if (!pPageData) return; // noch nicht initialisiert -> alles "nicht gedruckt" // gedruckten Bereich markieren // (in FillInfo ist schon alles auf sal_False initialisiert) sal_uInt16 nRangeCount = sal::static_int_cast(pPageData->GetCount()); for (sal_uInt16 nPos=0; nPosGetData( nPos ).GetPrintRange(); SCCOL nStartX = Max( aRange.aStart.Col(), nX1 ); SCCOL nEndX = Min( aRange.aEnd.Col(), nX2 ); SCROW nStartY = Max( aRange.aStart.Row(), nY1 ); SCROW nEndY = Min( aRange.aEnd.Row(), nY2 ); for (SCSIZE nArrY=1; nArrY+1bChanged && pThisRowInfo->nRowNo >= nStartY && pThisRowInfo->nRowNo <= nEndY ) { for (SCCOL nX=nStartX; nX<=nEndX; nX++) pThisRowInfo->pCellInfo[nX+1].bPrinted = sal_True; } } } } void ScOutputData::FindRotated() { //! nRotMax speichern SCCOL nRotMax = nX2; for (SCSIZE nRotY=0; nRotY nRotMax) nRotMax = pRowInfo[nRotY].nRotMaxCol; for (SCSIZE nArrY=1; nArrYnRotMaxCol != SC_ROTMAX_NONE && ( pThisRowInfo->bChanged || pRowInfo[nArrY-1].bChanged || ( nArrY+1nRowNo; for (SCCOL nX=0; nX<=nRotMax; nX++) { CellInfo* pInfo = &pThisRowInfo->pCellInfo[nX+1]; const ScPatternAttr* pPattern = pInfo->pPatternAttr; const SfxItemSet* pCondSet = pInfo->pConditionSet; if ( !pPattern && !pDoc->ColHidden(nX, nTab) ) { pPattern = pDoc->GetPattern( nX, nY, nTab ); pCondSet = pDoc->GetCondResult( nX, nY, nTab ); } if ( pPattern ) // Spalte nicht ausgeblendet { sal_uInt8 nDir = pPattern->GetRotateDir( pCondSet ); if (nDir != SC_ROTDIR_NONE) { pInfo->nRotateDir = nDir; bAnyRotated = sal_True; } } } } } } // ---------------------------------------------------------------------------- sal_uInt16 lcl_GetRotateDir( ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab ) { const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab ); const SfxItemSet* pCondSet = pDoc->GetCondResult( nCol, nRow, nTab ); sal_uInt16 nRet = SC_ROTDIR_NONE; long nAttrRotate = pPattern->GetRotateVal( pCondSet ); if ( nAttrRotate ) { SvxRotateMode eRotMode = (SvxRotateMode)((const SvxRotateModeItem&) pPattern->GetItem(ATTR_ROTATE_MODE, pCondSet)).GetValue(); if ( eRotMode == SVX_ROTATE_MODE_STANDARD ) nRet = SC_ROTDIR_STANDARD; else if ( eRotMode == SVX_ROTATE_MODE_CENTER ) nRet = SC_ROTDIR_CENTER; else if ( eRotMode == SVX_ROTATE_MODE_TOP || eRotMode == SVX_ROTATE_MODE_BOTTOM ) { long nRot180 = nAttrRotate % 18000; // 1/100 Grad if ( nRot180 == 9000 ) nRet = SC_ROTDIR_CENTER; else if ( ( eRotMode == SVX_ROTATE_MODE_TOP && nRot180 < 9000 ) || ( eRotMode == SVX_ROTATE_MODE_BOTTOM && nRot180 > 9000 ) ) nRet = SC_ROTDIR_LEFT; else nRet = SC_ROTDIR_RIGHT; } } return nRet; } const SvxBrushItem* lcl_FindBackground( ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab ) { const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab ); const SfxItemSet* pCondSet = pDoc->GetCondResult( nCol, nRow, nTab ); const SvxBrushItem* pBackground = (const SvxBrushItem*) &pPattern->GetItem( ATTR_BACKGROUND, pCondSet ); sal_uInt16 nDir = lcl_GetRotateDir( pDoc, nCol, nRow, nTab ); // CENTER wird wie RIGHT behandelt... if ( nDir == SC_ROTDIR_RIGHT || nDir == SC_ROTDIR_CENTER ) { // Text geht nach rechts -> Hintergrund von links nehmen while ( nCol > 0 && lcl_GetRotateDir( pDoc, nCol, nRow, nTab ) == nDir && pBackground->GetColor().GetTransparency() != 255 ) { --nCol; pPattern = pDoc->GetPattern( nCol, nRow, nTab ); pCondSet = pDoc->GetCondResult( nCol, nRow, nTab ); pBackground = (const SvxBrushItem*)&pPattern->GetItem( ATTR_BACKGROUND, pCondSet ); } } else if ( nDir == SC_ROTDIR_LEFT ) { // Text geht nach links -> Hintergrund von rechts nehmen while ( nCol < MAXCOL && lcl_GetRotateDir( pDoc, nCol, nRow, nTab ) == nDir && pBackground->GetColor().GetTransparency() != 255 ) { ++nCol; pPattern = pDoc->GetPattern( nCol, nRow, nTab ); pCondSet = pDoc->GetCondResult( nCol, nRow, nTab ); pBackground = (const SvxBrushItem*)&pPattern->GetItem( ATTR_BACKGROUND, pCondSet ); } } return pBackground; } // ---------------------------------------------------------------------------- sal_Bool lcl_EqualBack( const RowInfo& rFirst, const RowInfo& rOther, SCCOL nX1, SCCOL nX2, sal_Bool bShowProt, sal_Bool bPagebreakMode ) { if ( rFirst.bChanged != rOther.bChanged || rFirst.bEmptyBack != rOther.bEmptyBack ) return sal_False; SCCOL nX; if ( bShowProt ) { for ( nX=nX1; nX<=nX2; nX++ ) { const ScPatternAttr* pPat1 = rFirst.pCellInfo[nX+1].pPatternAttr; const ScPatternAttr* pPat2 = rOther.pCellInfo[nX+1].pPatternAttr; if ( !pPat1 || !pPat2 || &pPat1->GetItem(ATTR_PROTECTION) != &pPat2->GetItem(ATTR_PROTECTION) ) return sal_False; } } else { for ( nX=nX1; nX<=nX2; nX++ ) if ( rFirst.pCellInfo[nX+1].pBackground != rOther.pCellInfo[nX+1].pBackground ) return sal_False; } if ( rFirst.nRotMaxCol != SC_ROTMAX_NONE || rOther.nRotMaxCol != SC_ROTMAX_NONE ) for ( nX=nX1; nX<=nX2; nX++ ) if ( rFirst.pCellInfo[nX+1].nRotateDir != rOther.pCellInfo[nX+1].nRotateDir ) return sal_False; if ( bPagebreakMode ) for ( nX=nX1; nX<=nX2; nX++ ) if ( rFirst.pCellInfo[nX+1].bPrinted != rOther.pCellInfo[nX+1].bPrinted ) return sal_False; return sal_True; } void ScOutputData::DrawBackground() { FindRotated(); //! von aussen ? ScModule* pScMod = SC_MOD(); // used only if bSolidBackground is set (only for ScGridWindow): Color aBgColor( pScMod->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor ); Rectangle aRect; Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); long nOneY = aOnePixel.Height(); if (bMetaFile) nOneX = nOneY = 0; long nLayoutSign = bLayoutRTL ? -1 : 1; long nSignedOneX = nOneX * nLayoutSign; pDev->SetLineColor(); sal_Bool bShowProt = bSyntaxMode && pDoc->IsTabProtected(nTab); sal_Bool bDoAll = bShowProt || bPagebreakMode || bSolidBackground; // #105733# SvtAccessibilityOptions::GetIsForBorders is no longer used (always assumed sal_True) sal_Bool bCellContrast = bUseStyleColor && Application::GetSettings().GetStyleSettings().GetHighContrastMode(); long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1nHeight; if ( pThisRowInfo->bChanged ) { if ( ( ( pThisRowInfo->bEmptyBack ) || bSyntaxMode ) && !bDoAll ) { // nichts } else { // scan for rows with the same background: SCSIZE nSkip = 0; while ( nArrY+nSkip+2pCellInfo[nX+1]; if (bCellContrast) { // high contrast for cell borders and backgrounds -> empty background pBackground = ScGlobal::GetEmptyBrushItem(); } else if (bShowProt) // show cell protection in syntax mode { const ScPatternAttr* pP = pInfo->pPatternAttr; if (pP) { const ScProtectionAttr& rProt = (const ScProtectionAttr&) pP->GetItem(ATTR_PROTECTION); if (rProt.GetProtection() || rProt.GetHideCell()) pBackground = ScGlobal::GetProtectedBrushItem(); else pBackground = ScGlobal::GetEmptyBrushItem(); } else pBackground = NULL; } else pBackground = pInfo->pBackground; if ( bPagebreakMode && !pInfo->bPrinted ) pBackground = ScGlobal::GetProtectedBrushItem(); if ( pInfo->nRotateDir > SC_ROTDIR_STANDARD && pBackground->GetColor().GetTransparency() != 255 && !bCellContrast ) { SCROW nY = pRowInfo[nArrY].nRowNo; pBackground = lcl_FindBackground( pDoc, nX, nY, nTab ); } if ( pBackground != pOldBackground ) { aRect.Right() = nPosX-nSignedOneX; if (pOldBackground) // ==0 if hidden { Color aBackCol = pOldBackground->GetColor(); if ( bSolidBackground && aBackCol.GetTransparency() ) aBackCol = aBgColor; if ( !aBackCol.GetTransparency() ) //! partial transparency? { pDev->SetFillColor( aBackCol ); pDev->DrawRect( aRect ); } } aRect.Left() = nPosX; pOldBackground = pBackground; } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } aRect.Right() = nPosX-nSignedOneX; if (pOldBackground) { Color aBackCol = pOldBackground->GetColor(); if ( bSolidBackground && aBackCol.GetTransparency() ) aBackCol = aBgColor; if ( !aBackCol.GetTransparency() ) //! partial transparency? { pDev->SetFillColor( aBackCol ); pDev->DrawRect( aRect ); } } nArrY += nSkip; } } nPosY += nRowHeight; } } void ScOutputData::DrawShadow() { DrawExtraShadow( sal_False, sal_False, sal_False, sal_False ); } void ScOutputData::DrawExtraShadow(sal_Bool bLeft, sal_Bool bTop, sal_Bool bRight, sal_Bool bBottom) { pDev->SetLineColor(); const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); // #105733# SvtAccessibilityOptions::GetIsForBorders is no longer used (always assumed sal_True) sal_Bool bCellContrast = bUseStyleColor && rStyleSettings.GetHighContrastMode(); Color aAutoTextColor; if ( bCellContrast ) aAutoTextColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor ); long nInitPosX = nScrX; if ( bLayoutRTL ) { Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); nInitPosX += nMirrorW - nOneX; } long nLayoutSign = bLayoutRTL ? -1 : 1; long nPosY = nScrY - pRowInfo[0].nHeight; for (SCSIZE nArrY=0; nArrYnHeight; if ( pThisRowInfo->bChanged && !bSkipY ) { long nPosX = nInitPosX - pRowInfo[0].pCellInfo[nX1].nWidth * nLayoutSign; for (SCCOL nArrX=nX1; nArrX<=nX2+2; nArrX++) { sal_Bool bCornerX = ( nArrX==nX1 || nArrX==nX2+2 ); sal_Bool bSkipX = ( nArrX==nX1 && !bLeft ) || ( nArrX==nX2+2 && !bRight ); for (sal_uInt16 nPass=0; nPass<2; nPass++) // horizontal / vertikal { const SvxShadowItem* pAttr = nPass ? pThisRowInfo->pCellInfo[nArrX].pVShadowOrigin : pThisRowInfo->pCellInfo[nArrX].pHShadowOrigin; if ( pAttr && !bSkipX ) { ScShadowPart ePart = nPass ? pThisRowInfo->pCellInfo[nArrX].eVShadowPart : pThisRowInfo->pCellInfo[nArrX].eHShadowPart; sal_Bool bDo = sal_True; if ( (nPass==0 && bCornerX) || (nPass==1 && bCornerY) ) if ( ePart != SC_SHADOW_CORNER ) bDo = sal_False; if (bDo) { long nThisWidth = pRowInfo[0].pCellInfo[nArrX].nWidth; long nMaxWidth = nThisWidth; if (!nMaxWidth) { //! direction must depend on shadow location SCCOL nWx = nArrX; // nX+1 while (nWxGetWidth(); long nSizeX = (long)(nSize*nPPTX); if (nSizeX >= nMaxWidth) nSizeX = nMaxWidth-1; long nSizeY = (long)(nSize*nPPTY); if (nSizeY >= nRowHeight) nSizeY = nRowHeight-1; nSizeX *= nLayoutSign; // used only to add to rectangle values SvxShadowLocation eLoc = pAttr->GetLocation(); if ( bLayoutRTL ) { // Shadow location is specified as "visual" (right is always right), // so the attribute's location value is mirrored here and in FillInfo. switch (eLoc) { case SVX_SHADOW_BOTTOMRIGHT: eLoc = SVX_SHADOW_BOTTOMLEFT; break; case SVX_SHADOW_BOTTOMLEFT: eLoc = SVX_SHADOW_BOTTOMRIGHT; break; case SVX_SHADOW_TOPRIGHT: eLoc = SVX_SHADOW_TOPLEFT; break; case SVX_SHADOW_TOPLEFT: eLoc = SVX_SHADOW_TOPRIGHT; break; default: { // added to avoid warnings } } } if (ePart == SC_SHADOW_HORIZ || ePart == SC_SHADOW_HSTART || ePart == SC_SHADOW_CORNER) { if (eLoc == SVX_SHADOW_TOPLEFT || eLoc == SVX_SHADOW_TOPRIGHT) aRect.Top() = aRect.Bottom() - nSizeY; else aRect.Bottom() = aRect.Top() + nSizeY; } if (ePart == SC_SHADOW_VERT || ePart == SC_SHADOW_VSTART || ePart == SC_SHADOW_CORNER) { if (eLoc == SVX_SHADOW_TOPLEFT || eLoc == SVX_SHADOW_BOTTOMLEFT) aRect.Left() = aRect.Right() - nSizeX; else aRect.Right() = aRect.Left() + nSizeX; } if (ePart == SC_SHADOW_HSTART) { if (eLoc == SVX_SHADOW_TOPLEFT || eLoc == SVX_SHADOW_BOTTOMLEFT) aRect.Right() -= nSizeX; else aRect.Left() += nSizeX; } if (ePart == SC_SHADOW_VSTART) { if (eLoc == SVX_SHADOW_TOPLEFT || eLoc == SVX_SHADOW_TOPRIGHT) aRect.Bottom() -= nSizeY; else aRect.Top() += nSizeY; } //! merge rectangles? pDev->SetFillColor( bCellContrast ? aAutoTextColor : pAttr->GetColor() ); pDev->DrawRect( aRect ); } } } nPosX += pRowInfo[0].pCellInfo[nArrX].nWidth * nLayoutSign; } } nPosY += nRowHeight; } } // // Loeschen // void ScOutputData::DrawClear() { Rectangle aRect; Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); long nOneY = aOnePixel.Height(); // (called only for ScGridWindow) Color aBgColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor ); if (bMetaFile) nOneX = nOneY = 0; pDev->SetLineColor(); pDev->SetFillColor( aBgColor ); long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1nHeight; if ( pThisRowInfo->bChanged ) { // scan for more rows which must be painted: SCSIZE nSkip = 0; while ( nArrY+nSkip+2DrawRect( aRect ); nArrY += nSkip; } nPosY += nRowHeight; } } // // Linien // long lclGetSnappedX( OutputDevice& rDev, long nPosX, bool bSnapPixel ) { return (bSnapPixel && nPosX) ? rDev.PixelToLogic( rDev.LogicToPixel( Size( nPosX, 0 ) ) ).Width() : nPosX; } long lclGetSnappedY( OutputDevice& rDev, long nPosY, bool bSnapPixel ) { return (bSnapPixel && nPosY) ? rDev.PixelToLogic( rDev.LogicToPixel( Size( 0, nPosY ) ) ).Height() : nPosY; } size_t lclGetArrayColFromCellInfoX( sal_uInt16 nCellInfoX, sal_uInt16 nCellInfoFirstX, sal_uInt16 nCellInfoLastX, bool bRTL ) { return static_cast< size_t >( bRTL ? (nCellInfoLastX + 2 - nCellInfoX) : (nCellInfoX - nCellInfoFirstX) ); } void ScOutputData::DrawFrame() { sal_uLong nOldDrawMode = pDev->GetDrawMode(); Color aSingleColor; sal_Bool bUseSingleColor = sal_False; const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); // #105733# SvtAccessibilityOptions::GetIsForBorders is no longer used (always assumed sal_True) sal_Bool bCellContrast = bUseStyleColor && rStyleSettings.GetHighContrastMode(); // #107519# if a Calc OLE object is embedded in Draw/Impress, the VCL DrawMode is used // for display mode / B&W printing. The VCL DrawMode handling doesn't work for lines // that are drawn with DrawRect, so if the line/background bits are set, the DrawMode // must be reset and the border colors handled here. if ( ( nOldDrawMode & DRAWMODE_WHITEFILL ) && ( nOldDrawMode & DRAWMODE_BLACKLINE ) ) { pDev->SetDrawMode( nOldDrawMode & (~DRAWMODE_WHITEFILL) ); aSingleColor.SetColor( COL_BLACK ); bUseSingleColor = sal_True; } else if ( ( nOldDrawMode & DRAWMODE_SETTINGSFILL ) && ( nOldDrawMode & DRAWMODE_SETTINGSLINE ) ) { pDev->SetDrawMode( nOldDrawMode & (~DRAWMODE_SETTINGSFILL) ); aSingleColor = rStyleSettings.GetWindowTextColor(); // same as used in VCL for DRAWMODE_SETTINGSLINE bUseSingleColor = sal_True; } else if ( bCellContrast ) { aSingleColor.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor ); bUseSingleColor = sal_True; } const Color* pForceColor = bUseSingleColor ? &aSingleColor : 0; if (bAnyRotated) DrawRotatedFrame( pForceColor ); // removes the lines that must not be painted here long nInitPosX = nScrX; if ( bLayoutRTL ) { Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); nInitPosX += nMirrorW - nOneX; } long nLayoutSign = bLayoutRTL ? -1 : 1; // *** set column and row sizes of the frame border array *** svx::frame::Array& rArray = mrTabInfo.maArray; size_t nColCount = rArray.GetColCount(); size_t nRowCount = rArray.GetRowCount(); // row heights // row 0 is not visible (dummy for borders from top) - subtract its height from initial position // subtract 1 unit more, because position 0 is first *in* cell, grid line is one unit before long nOldPosY = nScrY - 1 - pRowInfo[ 0 ].nHeight; long nOldSnapY = lclGetSnappedY( *pDev, nOldPosY, bSnapPixel ); rArray.SetYOffset( nOldSnapY ); for( size_t nRow = 0; nRow < nRowCount; ++nRow ) { long nNewPosY = nOldPosY + pRowInfo[ nRow ].nHeight; long nNewSnapY = lclGetSnappedY( *pDev, nNewPosY, bSnapPixel ); rArray.SetRowHeight( nRow, nNewSnapY - nOldSnapY ); nOldPosY = nNewPosY; nOldSnapY = nNewSnapY; } // column widths // column nX1 is not visible (dummy for borders from left) - subtract its width from initial position // subtract 1 unit more, because position 0 is first *in* cell, grid line is one unit above long nOldPosX = nInitPosX - nLayoutSign * (1 + pRowInfo[ 0 ].pCellInfo[ nX1 ].nWidth); long nOldSnapX = lclGetSnappedX( *pDev, nOldPosX, bSnapPixel ); // set X offset for left-to-right sheets; for right-to-left sheets this is done after for() loop if( !bLayoutRTL ) rArray.SetXOffset( nOldSnapX ); for( sal_uInt16 nInfoIdx = nX1; nInfoIdx <= nX2 + 2; ++nInfoIdx ) { size_t nCol = lclGetArrayColFromCellInfoX( nInfoIdx, nX1, nX2, bLayoutRTL ); long nNewPosX = nOldPosX + pRowInfo[ 0 ].pCellInfo[ nInfoIdx ].nWidth * nLayoutSign; long nNewSnapX = lclGetSnappedX( *pDev, nNewPosX, bSnapPixel ); rArray.SetColWidth( nCol, Abs( nNewSnapX - nOldSnapX ) ); nOldPosX = nNewPosX; nOldSnapX = nNewSnapX; } if( bLayoutRTL ) rArray.SetXOffset( nOldSnapX ); // *** draw the array *** size_t nFirstCol = 1; size_t nFirstRow = 1; size_t nLastCol = nColCount - 2; size_t nLastRow = nRowCount - 2; if( mrTabInfo.mbPageMode ) rArray.SetClipRange( nFirstCol, nFirstRow, nLastCol, nLastRow ); // draw only rows with set RowInfo::bChanged flag size_t nRow1 = nFirstRow; while( nRow1 <= nLastRow ) { while( (nRow1 <= nLastRow) && !pRowInfo[ nRow1 ].bChanged ) ++nRow1; if( nRow1 <= nLastRow ) { size_t nRow2 = nRow1; while( (nRow2 + 1 <= nLastRow) && pRowInfo[ nRow2 + 1 ].bChanged ) ++nRow2; rArray.DrawRange( *pDev, nFirstCol, nRow1, nLastCol, nRow2, pForceColor ); nRow1 = nRow2 + 1; } } pDev->SetDrawMode(nOldDrawMode); } // ------------------------------------------------------------------------- // Linie unter der Zelle const SvxBorderLine* lcl_FindHorLine( ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, sal_uInt16 nRotDir, sal_Bool bTopLine ) { if ( nRotDir != SC_ROTDIR_LEFT && nRotDir != SC_ROTDIR_RIGHT ) return NULL; sal_Bool bFound = sal_False; while (!bFound) { if ( nRotDir == SC_ROTDIR_LEFT ) { // Text nach links -> Linie von rechts if ( nCol < MAXCOL ) ++nCol; else return NULL; // war nix } else { // Text nach rechts -> Linie von links if ( nCol > 0 ) --nCol; else return NULL; // war nix } const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, nTab ); const SfxItemSet* pCondSet = pDoc->GetCondResult( nCol, nRow, nTab ); if ( !pPattern->GetRotateVal( pCondSet ) || ((const SvxRotateModeItem&)pPattern->GetItem( ATTR_ROTATE_MODE, pCondSet)).GetValue() == SVX_ROTATE_MODE_STANDARD ) bFound = sal_True; } if (bTopLine) --nRow; const SvxBorderLine* pThisBottom; if ( ValidRow(nRow) ) pThisBottom = ((const SvxBoxItem*)pDoc->GetAttr( nCol, nRow, nTab, ATTR_BORDER ))->GetBottom(); else pThisBottom = NULL; const SvxBorderLine* pNextTop; if ( nRow < MAXROW ) pNextTop = ((const SvxBoxItem*)pDoc->GetAttr( nCol, nRow+1, nTab, ATTR_BORDER ))->GetTop(); else pNextTop = NULL; if ( ScHasPriority( pThisBottom, pNextTop ) ) return pThisBottom; else return pNextTop; } // lcl_HorizLine muss genau zu normal ausgegebenen Linien passen! void lcl_HorizLine( OutputDevice& rDev, const Point& rLeft, const Point& rRight, const svx::frame::Style& rLine, const Color* pForceColor ) { svx::frame::DrawHorFrameBorder( rDev, rLeft, rRight, rLine, pForceColor ); } void lcl_VertLineEnds( OutputDevice& rDev, const Point& rTop, const Point& rBottom, const Color& rColor, long nXOffs, long nWidth, const svx::frame::Style& rTopLine, const svx::frame::Style& rBottomLine ) { rDev.SetLineColor(rColor); // PEN_NULL ??? rDev.SetFillColor(rColor); // Position oben/unten muss unabhaengig von der Liniendicke sein, // damit der Winkel stimmt (oder X-Position auch anpassen) long nTopPos = rTop.Y(); long nBotPos = rBottom.Y(); long nTopLeft = rTop.X() + nXOffs; long nTopRight = nTopLeft + nWidth - 1; long nBotLeft = rBottom.X() + nXOffs; long nBotRight = nBotLeft + nWidth - 1; // oben abschliessen if ( rTopLine.Prim() ) { long nLineW = rTopLine.GetWidth(); if (nLineW >= 2) { Point aTriangle[3]; aTriangle[0] = Point( nTopLeft, nTopPos ); // wie aPoints[0] aTriangle[1] = Point( nTopRight, nTopPos ); // wie aPoints[1] aTriangle[2] = Point( rTop.X(), nTopPos - (nLineW - 1) / 2 ); Polygon aTriPoly( 3, aTriangle ); rDev.DrawPolygon( aTriPoly ); } } // unten abschliessen if ( rBottomLine.Prim() ) { long nLineW = rBottomLine.GetWidth(); if (nLineW >= 2) { Point aTriangle[3]; aTriangle[0] = Point( nBotLeft, nBotPos ); // wie aPoints[3] aTriangle[1] = Point( nBotRight, nBotPos ); // wie aPoints[2] aTriangle[2] = Point( rBottom.X(), nBotPos - (nLineW - 1) / 2 + nLineW - 1 ); Polygon aTriPoly( 3, aTriangle ); rDev.DrawPolygon( aTriPoly ); } } } void lcl_VertLine( OutputDevice& rDev, const Point& rTop, const Point& rBottom, const svx::frame::Style& rLine, const svx::frame::Style& rTopLine, const svx::frame::Style& rBottomLine, const Color* pForceColor ) { if( rLine.Prim() ) { svx::frame::DrawVerFrameBorderSlanted( rDev, rTop, rBottom, rLine, pForceColor ); svx::frame::Style aScaled( rLine ); aScaled.ScaleSelf( 1.0 / cos( svx::frame::GetVerDiagAngle( rTop, rBottom ) ) ); if( pForceColor ) aScaled.SetColor( *pForceColor ); long nXOffs = (aScaled.GetWidth() - 1) / -2L; lcl_VertLineEnds( rDev, rTop, rBottom, aScaled.GetColor(), nXOffs, aScaled.Prim(), rTopLine, rBottomLine ); if( aScaled.Secn() ) lcl_VertLineEnds( rDev, rTop, rBottom, aScaled.GetColor(), nXOffs + aScaled.Prim() + aScaled.Dist(), aScaled.Secn(), rTopLine, rBottomLine ); } } void ScOutputData::DrawRotatedFrame( const Color* pForceColor ) { //! nRotMax speichern SCCOL nRotMax = nX2; for (SCSIZE nRotY=0; nRotY nRotMax) nRotMax = pRowInfo[nRotY].nRotMaxCol; const ScPatternAttr* pPattern; const SfxItemSet* pCondSet; const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); // #105733# SvtAccessibilityOptions::GetIsForBorders is no longer used (always assumed sal_True) sal_Bool bCellContrast = bUseStyleColor && rStyleSettings.GetHighContrastMode(); // color (pForceColor) is determined externally, including DrawMode changes long nInitPosX = nScrX; if ( bLayoutRTL ) { Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); nInitPosX += nMirrorW - nOneX; } long nLayoutSign = bLayoutRTL ? -1 : 1; Rectangle aClipRect( Point(nScrX, nScrY), Size(nScrW, nScrH) ); if (bMetaFile) { pDev->Push(); pDev->IntersectClipRegion( aClipRect ); } else pDev->SetClipRegion( Region( aClipRect ) ); svx::frame::Array& rArray = mrTabInfo.maArray; long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY( nArrY ); long nRowHeight = rThisRowInfo.nHeight; if ( rThisRowInfo.nRotMaxCol != SC_ROTMAX_NONE && ( rThisRowInfo.bChanged || rPrevRowInfo.bChanged || ( nArrY+1nRotateDir > SC_ROTDIR_STANDARD && !pInfo->bHOverlapped && !pInfo->bVOverlapped ) { pPattern = pInfo->pPatternAttr; pCondSet = pInfo->pConditionSet; if (!pPattern) { pPattern = pDoc->GetPattern( nX, nY, nTab ); pInfo->pPatternAttr = pPattern; pCondSet = pDoc->GetCondResult( nX, nY, nTab ); pInfo->pConditionSet = pCondSet; } //! LastPattern etc. long nAttrRotate = pPattern->GetRotateVal( pCondSet ); SvxRotateMode eRotMode = (SvxRotateMode)((const SvxRotateModeItem&) pPattern->GetItem(ATTR_ROTATE_MODE, pCondSet)).GetValue(); if ( nAttrRotate ) { if (nX nX) { --nCol; nPosX -= nLayoutSign * (long) pRowInfo[0].pCellInfo[nCol+1].nWidth; } } // Startposition minus 1, damit auch schraege Hintergruende // zur Umrandung passen (Umrandung ist auf dem Gitter) long nTop = nPosY - 1; long nBottom = nPosY + nRowHeight - 1; long nTopLeft = nPosX - nLayoutSign; long nTopRight = nPosX + ( nColWidth - 1 ) * nLayoutSign; long nBotLeft = nTopLeft; long nBotRight = nTopRight; // inclusion of the sign here hasn't been decided yet // (if not, the extension of the non-rotated background must also be changed) double nRealOrient = nLayoutSign * nAttrRotate * F_PI18000; // 1/100th degrees double nCos = cos( nRealOrient ); double nSin = sin( nRealOrient ); //! begrenzen !!! long nSkew = (long) ( nRowHeight * nCos / nSin ); switch (eRotMode) { case SVX_ROTATE_MODE_BOTTOM: nTopLeft += nSkew; nTopRight += nSkew; break; case SVX_ROTATE_MODE_CENTER: nSkew /= 2; nTopLeft += nSkew; nTopRight += nSkew; nBotLeft -= nSkew; nBotRight -= nSkew; break; case SVX_ROTATE_MODE_TOP: nBotLeft -= nSkew; nBotRight -= nSkew; break; default: { // added to avoid warnings } } Point aPoints[4]; aPoints[0] = Point( nTopLeft, nTop ); aPoints[1] = Point( nTopRight, nTop ); aPoints[2] = Point( nBotRight, nBottom ); aPoints[3] = Point( nBotLeft, nBottom ); const SvxBrushItem* pBackground = pInfo->pBackground; if (!pBackground) pBackground = (const SvxBrushItem*) &pPattern->GetItem( ATTR_BACKGROUND, pCondSet ); if (bCellContrast) { // high contrast for cell borders and backgrounds -> empty background pBackground = ScGlobal::GetEmptyBrushItem(); } const Color& rColor = pBackground->GetColor(); if ( rColor.GetTransparency() != 255 ) { // #95879# draw background only for the changed row itself // (background doesn't extend into other cells). // For the borders (rotated and normal), clipping should be // set if the row isn't changed, but at least the borders // don't cover the cell contents. if ( rThisRowInfo.bChanged ) { Polygon aPoly( 4, aPoints ); // ohne Pen wird bei DrawPolygon rechts und unten // ein Pixel weggelassen... if ( rColor.GetTransparency() == 0 ) pDev->SetLineColor(rColor); else pDev->SetLineColor(); pDev->SetFillColor(rColor); pDev->DrawPolygon( aPoly ); } } svx::frame::Style aTopLine, aBottomLine, aLeftLine, aRightLine; if ( nX < nX1 || nX > nX2 ) // Attribute in FillInfo nicht gesetzt { //! Seitengrenzen fuer Druck beruecksichtigen !!!!! const SvxBorderLine* pLeftLine; const SvxBorderLine* pTopLine; const SvxBorderLine* pRightLine; const SvxBorderLine* pBottomLine; pDoc->GetBorderLines( nX, nY, nTab, &pLeftLine, &pTopLine, &pRightLine, &pBottomLine ); aTopLine.Set( pTopLine, nPPTY ); aBottomLine.Set( pBottomLine, nPPTY ); aLeftLine.Set( pLeftLine, nPPTX ); aRightLine.Set( pRightLine, nPPTX ); } else { size_t nCol = lclGetArrayColFromCellInfoX( nArrX, nX1, nX2, bLayoutRTL ); aTopLine = rArray.GetCellStyleTop( nCol, nRow ); aBottomLine = rArray.GetCellStyleBottom( nCol, nRow ); aLeftLine = rArray.GetCellStyleLeft( nCol, nRow ); aRightLine = rArray.GetCellStyleRight( nCol, nRow ); // in RTL mode the array is already mirrored -> swap back left/right borders if( bLayoutRTL ) std::swap( aLeftLine, aRightLine ); } lcl_HorizLine( *pDev, aPoints[bLayoutRTL?1:0], aPoints[bLayoutRTL?0:1], aTopLine, pForceColor ); lcl_HorizLine( *pDev, aPoints[bLayoutRTL?2:3], aPoints[bLayoutRTL?3:2], aBottomLine, pForceColor ); lcl_VertLine( *pDev, aPoints[0], aPoints[3], aLeftLine, aTopLine, aBottomLine, pForceColor ); lcl_VertLine( *pDev, aPoints[1], aPoints[2], aRightLine, aTopLine, aBottomLine, pForceColor ); } } nPosX += nColWidth * nLayoutSign; } // erst hinterher im zweiten Schritt die Linien fuer normale Ausgabe loeschen nX = nX1 > 0 ? (nX1-1) : static_cast(0); for (; nX<=nX2+1; nX++) // sichtbarer Teil +- 1 { sal_uInt16 nArrX = nX + 1; CellInfo& rInfo = rThisRowInfo.pCellInfo[nArrX]; if ( rInfo.nRotateDir > SC_ROTDIR_STANDARD && !rInfo.bHOverlapped && !rInfo.bVOverlapped ) { pPattern = rInfo.pPatternAttr; pCondSet = rInfo.pConditionSet; SvxRotateMode eRotMode = (SvxRotateMode)((const SvxRotateModeItem&) pPattern->GetItem(ATTR_ROTATE_MODE, pCondSet)).GetValue(); size_t nCol = lclGetArrayColFromCellInfoX( nArrX, nX1, nX2, bLayoutRTL ); // horizontal: angrenzende Linie verlaengern // (nur, wenn die gedrehte Zelle eine Umrandung hat) sal_uInt16 nDir = rInfo.nRotateDir; if ( rArray.GetCellStyleTop( nCol, nRow ).Prim() && eRotMode != SVX_ROTATE_MODE_TOP ) { svx::frame::Style aStyle( lcl_FindHorLine( pDoc, nX, nY, nTab, nDir, sal_True ), nPPTY ); rArray.SetCellStyleTop( nCol, nRow, aStyle ); if( nRow > 0 ) rArray.SetCellStyleBottom( nCol, nRow - 1, aStyle ); } if ( rArray.GetCellStyleBottom( nCol, nRow ).Prim() && eRotMode != SVX_ROTATE_MODE_BOTTOM ) { svx::frame::Style aStyle( lcl_FindHorLine( pDoc, nX, nY, nTab, nDir, sal_False ), nPPTY ); rArray.SetCellStyleBottom( nCol, nRow, aStyle ); if( nRow + 1 < rArray.GetRowCount() ) rArray.SetCellStyleTop( nCol, nRow + 1, aStyle ); } // always remove vertical borders if( !rArray.IsMergedOverlappedLeft( nCol, nRow ) ) { rArray.SetCellStyleLeft( nCol, nRow, svx::frame::Style() ); if( nCol > 0 ) rArray.SetCellStyleRight( nCol - 1, nRow, svx::frame::Style() ); } if( !rArray.IsMergedOverlappedRight( nCol, nRow ) ) { rArray.SetCellStyleRight( nCol, nRow, svx::frame::Style() ); if( nCol + 1 < rArray.GetColCount() ) rArray.SetCellStyleLeft( nCol + 1, nRow, svx::frame::Style() ); } // remove diagonal borders rArray.SetCellStyleTLBR( nCol, nRow, svx::frame::Style() ); rArray.SetCellStyleBLTR( nCol, nRow, svx::frame::Style() ); } } } nPosY += nRowHeight; } if (bMetaFile) pDev->Pop(); else pDev->SetClipRegion(); } // Drucker Region ScOutputData::GetChangedAreaRegion() { Region aRegion; Rectangle aDrawingRect; bool bHad(false); long nPosY = nScrY; SCSIZE nArrY; aDrawingRect.Left() = nScrX; aDrawingRect.Right() = nScrX+nScrW-1; for(nArrY=1; nArrY+1bChanged) { if(!bHad) { aDrawingRect.Top() = nPosY; bHad = true; } aDrawingRect.Bottom() = nPosY + pRowInfo[nArrY].nHeight - 1; } else if(bHad) { aRegion.Union(pDev->PixelToLogic(aDrawingRect)); bHad = false; } nPosY += pRowInfo[nArrY].nHeight; } if(bHad) { aRegion.Union(pDev->PixelToLogic(aDrawingRect)); } return aRegion; } sal_Bool ScOutputData::SetChangedClip() { PolyPolygon aPoly; Rectangle aDrawingRect; aDrawingRect.Left() = nScrX; aDrawingRect.Right() = nScrX+nScrW-1; sal_Bool bHad = sal_False; long nPosY = nScrY; SCSIZE nArrY; for (nArrY=1; nArrY+1bChanged ) { if (!bHad) { aDrawingRect.Top() = nPosY; bHad = sal_True; } aDrawingRect.Bottom() = nPosY + pRowInfo[nArrY].nHeight - 1; } else if (bHad) { aPoly.Insert( Polygon( pDev->PixelToLogic(aDrawingRect) ) ); bHad = sal_False; } nPosY += pRowInfo[nArrY].nHeight; } if (bHad) aPoly.Insert( Polygon( pDev->PixelToLogic(aDrawingRect) ) ); sal_Bool bRet = (aPoly.Count() != 0); if (bRet) pDev->SetClipRegion(Region(aPoly)); return bRet; } void ScOutputData::FindChanged() { SCCOL nX; SCSIZE nArrY; sal_Bool bWasIdleDisabled = pDoc->IsIdleDisabled(); pDoc->DisableIdle( sal_True ); for (nArrY=0; nArrYpCellInfo[nX+1].pCell; if (pCell) if (pCell->GetCellType() == CELLTYPE_FORMULA) { ScFormulaCell* pFCell = (ScFormulaCell*)pCell; if ( !bProgress && pFCell->GetDirty() ) { ScProgress::CreateInterpretProgress( pDoc, sal_True ); bProgress = sal_True; } if (!pFCell->IsRunning()) { (void)pFCell->GetValue(); if (pFCell->IsChanged()) { pThisRowInfo->bChanged = sal_True; if ( pThisRowInfo->pCellInfo[nX+1].bMerged ) { SCSIZE nOverY = nArrY + 1; while ( nOverYDisableIdle( bWasIdleDisabled ); } #ifdef OLD_SELECTION_PAINT void ScOutputData::DrawMark( Window* pWin ) { Rectangle aRect; ScInvertMerger aInvert( pWin ); //! additional method AddLineRect for ScInvertMerger? long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1bChanged) { long nPosX = nScrX; if (bLayoutRTL) nPosX += nMirrorW - 1; // always in pixels aRect = Rectangle( Point( nPosX,nPosY ), Size(1, pThisRowInfo->nHeight) ); if (bLayoutRTL) aRect.Left() = aRect.Right() + 1; else aRect.Right() = aRect.Left() - 1; sal_Bool bOldMarked = sal_False; for (SCCOL nX=nX1; nX<=nX2; nX++) { if (pThisRowInfo->pCellInfo[nX+1].bMarked != bOldMarked) { if (bOldMarked && aRect.Right() >= aRect.Left()) aInvert.AddRect( aRect ); if (bLayoutRTL) aRect.Right() = nPosX; else aRect.Left() = nPosX; bOldMarked = pThisRowInfo->pCellInfo[nX+1].bMarked; } if (bLayoutRTL) { nPosX -= pRowInfo[0].pCellInfo[nX+1].nWidth; aRect.Left() = nPosX+1; } else { nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth; aRect.Right() = nPosX-1; } } if (bOldMarked && aRect.Right() >= aRect.Left()) aInvert.AddRect( aRect ); } nPosY += pThisRowInfo->nHeight; } } #endif void ScOutputData::DrawRefMark( SCCOL nRefStartX, SCROW nRefStartY, SCCOL nRefEndX, SCROW nRefEndY, const Color& rColor, sal_Bool bHandle ) { PutInOrder( nRefStartX, nRefEndX ); PutInOrder( nRefStartY, nRefEndY ); if ( nRefStartX == nRefEndX && nRefStartY == nRefEndY ) pDoc->ExtendMerge( nRefStartX, nRefStartY, nRefEndX, nRefEndY, nTab ); if ( nRefStartX <= nVisX2 && nRefEndX >= nVisX1 && nRefStartY <= nVisY2 && nRefEndY >= nVisY1 ) { long nMinX = nScrX; long nMinY = nScrY; long nMaxX = nScrX+nScrW-1; long nMaxY = nScrY+nScrH-1; if ( bLayoutRTL ) { long nTemp = nMinX; nMinX = nMaxX; nMaxX = nTemp; } long nLayoutSign = bLayoutRTL ? -1 : 1; sal_Bool bTop = sal_False; sal_Bool bBottom = sal_False; sal_Bool bLeft = sal_False; sal_Bool bRight = sal_False; long nPosY = nScrY; sal_Bool bNoStartY = ( nY1 < nRefStartY ); sal_Bool bNoEndY = sal_False; for (SCSIZE nArrY=1; nArrYnRefStartY && bNoStartY) ) { nMinY = nPosY; bTop = sal_True; } if ( nY==nRefEndY ) { nMaxY = nPosY + pRowInfo[nArrY].nHeight - 2; bBottom = sal_True; } if ( nY>nRefEndY && bNoEndY ) { nMaxY = nPosY-2; bBottom = sal_True; } bNoStartY = ( nY < nRefStartY ); bNoEndY = ( nY < nRefEndY ); nPosY += pRowInfo[nArrY].nHeight; } long nPosX = nScrX; if ( bLayoutRTL ) nPosX += nMirrorW - 1; // always in pixels for (SCCOL nX=nX1; nX<=nX2; nX++) { if ( nX==nRefStartX ) { nMinX = nPosX; bLeft = sal_True; } if ( nX==nRefEndX ) { nMaxX = nPosX + ( pRowInfo[0].pCellInfo[nX+1].nWidth - 2 ) * nLayoutSign; bRight = sal_True; } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } if ( nMaxX * nLayoutSign >= nMinX * nLayoutSign && nMaxY >= nMinY ) { pDev->SetLineColor( rColor ); if (bTop && bBottom && bLeft && bRight) { pDev->SetFillColor(); pDev->DrawRect( Rectangle( nMinX, nMinY, nMaxX, nMaxY ) ); } else { if (bTop) pDev->DrawLine( Point( nMinX,nMinY ), Point( nMaxX,nMinY ) ); if (bBottom) pDev->DrawLine( Point( nMinX,nMaxY ), Point( nMaxX,nMaxY ) ); if (bLeft) pDev->DrawLine( Point( nMinX,nMinY ), Point( nMinX,nMaxY ) ); if (bRight) pDev->DrawLine( Point( nMaxX,nMinY ), Point( nMaxX,nMaxY ) ); } if ( bHandle && bRight && bBottom ) { pDev->SetLineColor(); pDev->SetFillColor( rColor ); pDev->DrawRect( Rectangle( nMaxX-3*nLayoutSign, nMaxY-3, nMaxX+nLayoutSign, nMaxY+1 ) ); } } } } void ScOutputData::DrawOneChange( SCCOL nRefStartX, SCROW nRefStartY, SCCOL nRefEndX, SCROW nRefEndY, const Color& rColor, sal_uInt16 nType ) { PutInOrder( nRefStartX, nRefEndX ); PutInOrder( nRefStartY, nRefEndY ); if ( nRefStartX == nRefEndX && nRefStartY == nRefEndY ) pDoc->ExtendMerge( nRefStartX, nRefStartY, nRefEndX, nRefEndY, nTab ); if ( nRefStartX <= nVisX2 + 1 && nRefEndX >= nVisX1 && nRefStartY <= nVisY2 + 1 && nRefEndY >= nVisY1 ) // +1 because it touches next cells left/top { long nMinX = nScrX; long nMinY = nScrY; long nMaxX = nScrX+nScrW-1; long nMaxY = nScrY+nScrH-1; if ( bLayoutRTL ) { long nTemp = nMinX; nMinX = nMaxX; nMaxX = nTemp; } long nLayoutSign = bLayoutRTL ? -1 : 1; sal_Bool bTop = sal_False; sal_Bool bBottom = sal_False; sal_Bool bLeft = sal_False; sal_Bool bRight = sal_False; long nPosY = nScrY; sal_Bool bNoStartY = ( nY1 < nRefStartY ); sal_Bool bNoEndY = sal_False; for (SCSIZE nArrY=1; nArrYnRefStartY && bNoStartY) ) { nMinY = nPosY - 1; bTop = sal_True; } if ( nY==nRefEndY ) { nMaxY = nPosY + pRowInfo[nArrY].nHeight - 1; bBottom = sal_True; } if ( nY>nRefEndY && bNoEndY ) { nMaxY = nPosY - 1; bBottom = sal_True; } bNoStartY = ( nY < nRefStartY ); bNoEndY = ( nY < nRefEndY ); nPosY += pRowInfo[nArrY].nHeight; } long nPosX = nScrX; if ( bLayoutRTL ) nPosX += nMirrorW - 1; // always in pixels for (SCCOL nX=nX1; nX<=nX2+1; nX++) { if ( nX==nRefStartX ) { nMinX = nPosX - nLayoutSign; bLeft = sal_True; } if ( nX==nRefEndX ) { nMaxX = nPosX + ( pRowInfo[0].pCellInfo[nX+1].nWidth - 1 ) * nLayoutSign; bRight = sal_True; } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } if ( nMaxX * nLayoutSign >= nMinX * nLayoutSign && nMaxY >= nMinY ) { if ( nType == SC_CAT_DELETE_ROWS ) bLeft = bRight = bBottom = sal_False; //! dicke Linie ??? else if ( nType == SC_CAT_DELETE_COLS ) bTop = bBottom = bRight = sal_False; //! dicke Linie ??? pDev->SetLineColor( rColor ); if (bTop && bBottom && bLeft && bRight) { pDev->SetFillColor(); pDev->DrawRect( Rectangle( nMinX, nMinY, nMaxX, nMaxY ) ); } else { if (bTop) { pDev->DrawLine( Point( nMinX,nMinY ), Point( nMaxX,nMinY ) ); if ( nType == SC_CAT_DELETE_ROWS ) pDev->DrawLine( Point( nMinX,nMinY+1 ), Point( nMaxX,nMinY+1 ) ); } if (bBottom) pDev->DrawLine( Point( nMinX,nMaxY ), Point( nMaxX,nMaxY ) ); if (bLeft) { pDev->DrawLine( Point( nMinX,nMinY ), Point( nMinX,nMaxY ) ); if ( nType == SC_CAT_DELETE_COLS ) pDev->DrawLine( Point( nMinX+nLayoutSign,nMinY ), Point( nMinX+nLayoutSign,nMaxY ) ); } if (bRight) pDev->DrawLine( Point( nMaxX,nMinY ), Point( nMaxX,nMaxY ) ); } if ( bLeft && bTop ) { pDev->SetLineColor(); pDev->SetFillColor( rColor ); pDev->DrawRect( Rectangle( nMinX+nLayoutSign, nMinY+1, nMinX+3*nLayoutSign, nMinY+3 ) ); } } } } void ScOutputData::DrawChangeTrack() { ScChangeTrack* pTrack = pDoc->GetChangeTrack(); ScChangeViewSettings* pSettings = pDoc->GetChangeViewSettings(); if ( !pTrack || !pTrack->GetFirst() || !pSettings || !pSettings->ShowChanges() ) return; // nix da oder abgeschaltet ScActionColorChanger aColorChanger(*pTrack); // Clipping passiert von aussen //! ohne Clipping, nur betroffene Zeilen painten ??!??!? SCCOL nEndX = nX2; SCROW nEndY = nY2; if ( nEndX < MAXCOL ) ++nEndX; // auch noch von der naechsten Zelle, weil die Markierung if ( nEndY < MAXROW ) ++nEndY; // in die jeweils vorhergehende Zelle hineinragt ScRange aViewRange( nX1, nY1, nTab, nEndX, nEndY, nTab ); const ScChangeAction* pAction = pTrack->GetFirst(); while (pAction) { ScChangeActionType eActionType; if ( pAction->IsVisible() ) { eActionType = pAction->GetType(); const ScBigRange& rBig = pAction->GetBigRange(); if ( rBig.aStart.Tab() == nTab ) { ScRange aRange = rBig.MakeRange(); if ( eActionType == SC_CAT_DELETE_ROWS ) aRange.aEnd.SetRow( aRange.aStart.Row() ); else if ( eActionType == SC_CAT_DELETE_COLS ) aRange.aEnd.SetCol( aRange.aStart.Col() ); if ( aRange.Intersects( aViewRange ) && ScViewUtil::IsActionShown( *pAction, *pSettings, *pDoc ) ) { aColorChanger.Update( *pAction ); Color aColor( aColorChanger.GetColor() ); DrawOneChange( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aColor, sal::static_int_cast(eActionType) ); } } if ( eActionType == SC_CAT_MOVE && ((const ScChangeActionMove*)pAction)-> GetFromRange().aStart.Tab() == nTab ) { ScRange aRange = ((const ScChangeActionMove*)pAction)-> GetFromRange().MakeRange(); if ( aRange.Intersects( aViewRange ) && ScViewUtil::IsActionShown( *pAction, *pSettings, *pDoc ) ) { aColorChanger.Update( *pAction ); Color aColor( aColorChanger.GetColor() ); DrawOneChange( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aColor, sal::static_int_cast(eActionType) ); } } } pAction = pAction->GetNext(); } } void ScOutputData::DrawNoteMarks() { sal_Bool bFirst = sal_True; long nInitPosX = nScrX; if ( bLayoutRTL ) nInitPosX += nMirrorW - 1; // always in pixels long nLayoutSign = bLayoutRTL ? -1 : 1; long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1bChanged ) { long nPosX = nInitPosX; for (SCCOL nX=nX1; nX<=nX2; nX++) { CellInfo* pInfo = &pThisRowInfo->pCellInfo[nX+1]; ScBaseCell* pCell = pInfo->pCell; sal_Bool bIsMerged = sal_False; if ( nX==nX1 && pInfo->bHOverlapped && !pInfo->bVOverlapped ) { // find start of merged cell bIsMerged = sal_True; SCROW nY = pRowInfo[nArrY].nRowNo; SCCOL nMergeX = nX; SCROW nMergeY = nY; pDoc->ExtendOverlapped( nMergeX, nMergeY, nX, nY, nTab ); pCell = pDoc->GetCell( ScAddress(nMergeX,nMergeY,nTab) ); // use origin's pCell for NotePtr test below } if ( pCell && pCell->HasNote() && ( bIsMerged || ( !pInfo->bHOverlapped && !pInfo->bVOverlapped ) ) ) { if (bFirst) { pDev->SetLineColor(); const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); if ( bUseStyleColor && rStyleSettings.GetHighContrastMode() ) pDev->SetFillColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor ); else pDev->SetFillColor(COL_LIGHTRED); bFirst = sal_False; } long nMarkX = nPosX + ( pRowInfo[0].pCellInfo[nX+1].nWidth - 4 ) * nLayoutSign; if ( bIsMerged || pInfo->bMerged ) { // if merged, add widths of all cells SCCOL nNextX = nX + 1; while ( nNextX <= nX2 + 1 && pThisRowInfo->pCellInfo[nNextX+1].bHOverlapped ) { nMarkX += pRowInfo[0].pCellInfo[nNextX+1].nWidth * nLayoutSign; ++nNextX; } } if ( bLayoutRTL ? ( nMarkX >= 0 ) : ( nMarkX < nScrX+nScrW ) ) pDev->DrawRect( Rectangle( nMarkX,nPosY,nMarkX+2*nLayoutSign,nPosY+2 ) ); } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } } nPosY += pThisRowInfo->nHeight; } } void ScOutputData::AddPDFNotes() { vcl::PDFExtOutDevData* pPDFData = PTR_CAST( vcl::PDFExtOutDevData, pDev->GetExtOutDevData() ); if ( !pPDFData || !pPDFData->GetIsExportNotes() ) return; long nInitPosX = nScrX; if ( bLayoutRTL ) { Size aOnePixel = pDev->PixelToLogic(Size(1,1)); long nOneX = aOnePixel.Width(); nInitPosX += nMirrorW - nOneX; } long nLayoutSign = bLayoutRTL ? -1 : 1; long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1bChanged ) { long nPosX = nInitPosX; for (SCCOL nX=nX1; nX<=nX2; nX++) { CellInfo* pInfo = &pThisRowInfo->pCellInfo[nX+1]; ScBaseCell* pCell = pInfo->pCell; sal_Bool bIsMerged = sal_False; SCROW nY = pRowInfo[nArrY].nRowNo; SCCOL nMergeX = nX; SCROW nMergeY = nY; if ( nX==nX1 && pInfo->bHOverlapped && !pInfo->bVOverlapped ) { // find start of merged cell bIsMerged = sal_True; pDoc->ExtendOverlapped( nMergeX, nMergeY, nX, nY, nTab ); pCell = pDoc->GetCell( ScAddress(nMergeX,nMergeY,nTab) ); // use origin's pCell for NotePtr test below } if ( pCell && pCell->HasNote() && ( bIsMerged || ( !pInfo->bHOverlapped && !pInfo->bVOverlapped ) ) ) { long nNoteWidth = (long)( SC_CLIPMARK_SIZE * nPPTX ); long nNoteHeight = (long)( SC_CLIPMARK_SIZE * nPPTY ); long nMarkX = nPosX + ( pRowInfo[0].pCellInfo[nX+1].nWidth - nNoteWidth ) * nLayoutSign; if ( bIsMerged || pInfo->bMerged ) { // if merged, add widths of all cells SCCOL nNextX = nX + 1; while ( nNextX <= nX2 + 1 && pThisRowInfo->pCellInfo[nNextX+1].bHOverlapped ) { nMarkX += pRowInfo[0].pCellInfo[nNextX+1].nWidth * nLayoutSign; ++nNextX; } } if ( bLayoutRTL ? ( nMarkX >= 0 ) : ( nMarkX < nScrX+nScrW ) ) { Rectangle aNoteRect( nMarkX, nPosY, nMarkX+nNoteWidth*nLayoutSign, nPosY+nNoteHeight ); const ScPostIt* pNote = pCell->GetNote(); // Note title is the cell address (as on printed note pages) String aTitle; ScAddress aAddress( nMergeX, nMergeY, nTab ); aAddress.Format( aTitle, SCA_VALID, pDoc, pDoc->GetAddressConvention() ); // Content has to be a simple string without line breaks String aContent = pNote->GetText(); xub_StrLen nPos; while ( (nPos=aContent.Search('\n')) != STRING_NOTFOUND ) aContent.SetChar( nPos, ' ' ); vcl::PDFNote aNote; aNote.Title = aTitle; aNote.Contents = aContent; pPDFData->CreateNote( aNoteRect, aNote ); } } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } } nPosY += pThisRowInfo->nHeight; } } void ScOutputData::DrawClipMarks() { if (!bAnyClipped) return; Color aArrowFillCol( COL_LIGHTRED ); sal_uLong nOldDrawMode = pDev->GetDrawMode(); const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); if ( bUseStyleColor && rStyleSettings.GetHighContrastMode() ) { // use DrawMode to change the arrow's outline color pDev->SetDrawMode( nOldDrawMode | DRAWMODE_SETTINGSLINE ); // use text color also for the fill color aArrowFillCol.SetColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor ); } long nInitPosX = nScrX; if ( bLayoutRTL ) nInitPosX += nMirrorW - 1; // always in pixels long nLayoutSign = bLayoutRTL ? -1 : 1; Rectangle aCellRect; long nPosY = nScrY; for (SCSIZE nArrY=1; nArrY+1bChanged ) { SCROW nY = pThisRowInfo->nRowNo; long nPosX = nInitPosX; for (SCCOL nX=nX1; nX<=nX2; nX++) { CellInfo* pInfo = &pThisRowInfo->pCellInfo[nX+1]; if (pInfo->nClipMark) { if (pInfo->bHOverlapped || pInfo->bVOverlapped) { // merge origin may be outside of visible area - use document functions SCCOL nOverX = nX; SCROW nOverY = nY; long nStartPosX = nPosX; long nStartPosY = nPosY; while ( nOverX > 0 && ( ((const ScMergeFlagAttr*)pDoc->GetAttr( nOverX, nOverY, nTab, ATTR_MERGE_FLAG ))->GetValue() & SC_MF_HOR ) ) { --nOverX; nStartPosX -= nLayoutSign * (long) ( pDoc->GetColWidth(nOverX,nTab) * nPPTX ); } while ( nOverY > 0 && ( ((const ScMergeFlagAttr*)pDoc->GetAttr( nOverX, nOverY, nTab, ATTR_MERGE_FLAG ))->GetValue() & SC_MF_VER ) ) { --nOverY; nStartPosY -= nLayoutSign * (long) ( pDoc->GetRowHeight(nOverY,nTab) * nPPTY ); } long nOutWidth = (long) ( pDoc->GetColWidth(nOverX,nTab) * nPPTX ); long nOutHeight = (long) ( pDoc->GetRowHeight(nOverY,nTab) * nPPTY ); const ScMergeAttr* pMerge = (const ScMergeAttr*) pDoc->GetAttr( nOverX, nOverY, nTab, ATTR_MERGE ); SCCOL nCountX = pMerge->GetColMerge(); for (SCCOL i=1; iGetColWidth(nOverX+i,nTab) * nPPTX ); SCROW nCountY = pMerge->GetRowMerge(); nOutHeight += (long) pDoc->GetScaledRowHeight( nOverY+1, nOverY+nCountY-1, nTab, nPPTY); if ( bLayoutRTL ) nStartPosX -= nOutWidth - 1; aCellRect = Rectangle( Point( nStartPosX, nStartPosY ), Size( nOutWidth, nOutHeight ) ); } else { long nOutWidth = pRowInfo[0].pCellInfo[nX+1].nWidth; long nOutHeight = pThisRowInfo->nHeight; if ( pInfo->bMerged && pInfo->pPatternAttr ) { SCCOL nOverX = nX; SCROW nOverY = nY; const ScMergeAttr* pMerge = (ScMergeAttr*)&pInfo->pPatternAttr->GetItem(ATTR_MERGE); SCCOL nCountX = pMerge->GetColMerge(); for (SCCOL i=1; iGetColWidth(nOverX+i,nTab) * nPPTX ); SCROW nCountY = pMerge->GetRowMerge(); nOutHeight += (long) pDoc->GetScaledRowHeight( nOverY+1, nOverY+nCountY-1, nTab, nPPTY); } long nStartPosX = nPosX; if ( bLayoutRTL ) nStartPosX -= nOutWidth - 1; // #i80447# create aCellRect from two points in case nOutWidth is 0 aCellRect = Rectangle( Point( nStartPosX, nPosY ), Point( nStartPosX+nOutWidth-1, nPosY+nOutHeight-1 ) ); } aCellRect.Bottom() -= 1; // don't paint over the cell grid if ( bLayoutRTL ) aCellRect.Left() += 1; else aCellRect.Right() -= 1; long nMarkPixel = (long)( SC_CLIPMARK_SIZE * nPPTX ); Size aMarkSize( nMarkPixel, (nMarkPixel-1)*2 ); if ( pInfo->nClipMark & ( bLayoutRTL ? SC_CLIPMARK_RIGHT : SC_CLIPMARK_LEFT ) ) { // visually left Rectangle aMarkRect = aCellRect; aMarkRect.Right() = aCellRect.Left()+nMarkPixel-1; #if 0 //! Test pDev->SetLineColor(); pDev->SetFillColor(COL_YELLOW); pDev->DrawRect(aMarkRect); //! Test #endif SvxFont::DrawArrow( *pDev, aMarkRect, aMarkSize, aArrowFillCol, sal_True ); } if ( pInfo->nClipMark & ( bLayoutRTL ? SC_CLIPMARK_LEFT : SC_CLIPMARK_RIGHT ) ) { // visually right Rectangle aMarkRect = aCellRect; aMarkRect.Left() = aCellRect.Right()-nMarkPixel+1; #if 0 //! Test pDev->SetLineColor(); pDev->SetFillColor(COL_LIGHTGREEN); pDev->DrawRect(aMarkRect); //! Test #endif SvxFont::DrawArrow( *pDev, aMarkRect, aMarkSize, aArrowFillCol, sal_False ); } } nPosX += pRowInfo[0].pCellInfo[nX+1].nWidth * nLayoutSign; } } nPosY += pThisRowInfo->nHeight; } pDev->SetDrawMode(nOldDrawMode); }