/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the Collabora Office project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * 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 . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace com::sun::star; #define SC_GROWY_SMALL_EXTRA 100 #define SC_GROWY_BIG_EXTRA 200 constexpr OUString TAG_TABBARWIDTH = u"tw:"_ustr; namespace { void lcl_KitRemoveWindow(ScTabViewShell* pTabViewShell, ScSplitPos eWhich) { if (comphelper::COKit::isActive()) { auto lRemoveWindows = [pTabViewShell, eWhich] (ScTabViewShell* pOtherViewShell) { pOtherViewShell->RemoveWindowFromForeignEditView(pTabViewShell, eWhich); }; KitHelper::forEachOtherView(pTabViewShell, lRemoveWindows); } } } // anonymous namespace namespace { void collectUIInformation(std::map&& aParameters, const OUString& rAction) { EventDescription aDescription; aDescription.aID = u"grid_window"_ustr; aDescription.aAction = rAction; aDescription.aParameters = std::move(aParameters); aDescription.aParent = u"MainWindow"_ustr; aDescription.aKeyWord = u"ScGridWinUIObject"_ustr; UITestLogger::getInstance().logEvent(aDescription); } } const ScPositionHelper::index_type ScPositionHelper::null; // definition bool ScPositionHelper::Comp::operator() (const value_type& rValue1, const value_type& rValue2) const { if (rValue1.first == null || rValue2.first == null) { return rValue1.second < rValue2.second; } else { return rValue1.first < rValue2.first; } } ScPositionHelper::ScPositionHelper(const ScDocument& rDoc, bool bColumn) : MAX_INDEX(bColumn ? rDoc.MaxCol() : MAXTILEDROW) { mData.insert(std::make_pair(-1, 0)); } void ScPositionHelper::insert(index_type nIndex, tools::Long nPos) { if (nIndex < 0) return; SAL_INFO("sc.kit.poshelper", "ScPositionHelper::insert: nIndex: " << nIndex << ", nPos: " << nPos << ", size: " << mData.size()); value_type aValue = std::make_pair(nIndex, nPos); mData.erase(aValue); mData.insert(aValue); SAL_INFO("sc.kit.poshelper", "ScPositionHelper::insert: after insert: size: " << mData.size()); } void ScPositionHelper::removeByIndex(index_type nIndex) { if (nIndex < 0) return; SAL_INFO("sc.kit.poshelper", "ScPositionHelper::remove: nIndex: " << nIndex << ", size: " << mData.size()); auto it = mData.find(std::make_pair(nIndex, 0)); if (it == mData.end()) return; mData.erase(it); SAL_INFO("sc.kit.poshelper", "ScPositionHelper::remove: after erase: size: " << mData.size()); } void ScPositionHelper::invalidateByIndex(index_type nIndex) { SAL_INFO("sc.kit.poshelper", "ScPositionHelper::invalidate: nIndex: " << nIndex); if (nIndex < 0) { mData.clear(); mData.insert(std::make_pair(-1, 0)); } else { auto it = mData.lower_bound(std::make_pair(nIndex, 0)); mData.erase(it, mData.end()); } } void ScPositionHelper::invalidateByPosition(tools::Long nPos) { SAL_INFO("sc.kit.poshelper", "ScPositionHelper::invalidate: nPos: " << nPos); if (nPos <= 0) { mData.clear(); mData.insert(std::make_pair(-1, 0)); } else { auto it = mData.lower_bound(std::make_pair(null, nPos)); mData.erase(it, mData.end()); } } const ScPositionHelper::value_type& ScPositionHelper::getNearestByIndex(index_type nIndex) const { SAL_INFO("sc.kit.poshelper", "ScPositionHelper::getNearest: nIndex: " << nIndex << ", size: " << mData.size()); auto posUB = mData.upper_bound(std::make_pair(nIndex, 0)); if (posUB == mData.begin()) { return *posUB; } auto posLB = std::prev(posUB); // coverity[copy_paste_error : FALSE] - posUB is correct if (posUB == mData.end()) { return *posLB; } tools::Long nDiffUB = posUB->first - nIndex; tools::Long nDiffLB = posLB->first - nIndex; if (nDiffUB < -nDiffLB) { return *posUB; } else { return *posLB; } } const ScPositionHelper::value_type& ScPositionHelper::getNearestByPosition(tools::Long nPos) const { SAL_INFO("sc.kit.poshelper", "ScPositionHelper::getNearest: nPos: " << nPos << ", size: " << mData.size()); auto posUB = mData.upper_bound(std::make_pair(null, nPos)); if (posUB == mData.begin()) { return *posUB; } auto posLB = std::prev(posUB); // coverity[copy_paste_error : FALSE] - posUB is correct if (posUB == mData.end()) { return *posLB; } tools::Long nDiffUB = posUB->second - nPos; tools::Long nDiffLB = posLB->second - nPos; if (nDiffUB < -nDiffLB) { return *posUB; } else { return *posLB; } } tools::Long ScPositionHelper::getPosition(index_type nIndex) const { auto it = mData.find(std::make_pair(nIndex, 0)); if (it == mData.end()) return -1; return it->second; } tools::Long ScPositionHelper::computePosition(index_type nIndex, const std::function& getSizePx) { assert(MAX_INDEX > 0); if (nIndex < 0) nIndex = 0; if (nIndex > MAX_INDEX) nIndex = MAX_INDEX; const auto& rNearest = getNearestByIndex(nIndex); index_type nStartIndex = rNearest.first; tools::Long nTotalPixels = rNearest.second; if (nStartIndex < nIndex) { for (index_type nIdx = nStartIndex + 1; nIdx <= nIndex; ++nIdx) { nTotalPixels += getSizePx(nIdx); } } else { for (index_type nIdx = nStartIndex; nIdx > nIndex; --nIdx) { nTotalPixels -= getSizePx(nIdx); } } return nTotalPixels; } ScBoundsProvider::ScBoundsProvider(const ScViewData &rView, SCTAB nT, bool bColHeader) : rDoc(rView.GetDocument()) , nTab(nT) , bColumnHeader(bColHeader) , MAX_INDEX(bColHeader ? rDoc.MaxCol() : MAXTILEDROW) , mfPPTX(rView.GetPPTX()) , mfPPTY(rView.GetPPTY()) , nFirstIndex(-1) , nSecondIndex(-1) , nFirstPositionPx(-1) , nSecondPositionPx(-1) {} void ScBoundsProvider::GetStartIndexAndPosition(SCCOL& nIndex, tools::Long& nPosition) const { assert(bColumnHeader); nIndex = nFirstIndex; nPosition = nFirstPositionPx; } void ScBoundsProvider::GetEndIndexAndPosition(SCCOL& nIndex, tools::Long& nPosition) const { assert(bColumnHeader); nIndex = nSecondIndex; nPosition = nSecondPositionPx; } void ScBoundsProvider::GetStartIndexAndPosition(SCROW& nIndex, tools::Long& nPosition) const { assert(!bColumnHeader); nIndex = nFirstIndex; nPosition = nFirstPositionPx; } void ScBoundsProvider::GetEndIndexAndPosition(SCROW& nIndex, tools::Long& nPosition) const { assert(!bColumnHeader); nIndex = nSecondIndex; nPosition = nSecondPositionPx; } tools::Long ScBoundsProvider::GetSize(index_type nIndex) const { const sal_uInt16 nSize = bColumnHeader ? rDoc.GetColWidth(nIndex, nTab) : rDoc.GetRowHeight(nIndex, nTab); return ScViewData::ToPixel(nSize, bColumnHeader ? mfPPTX : mfPPTY); } void ScBoundsProvider::GetIndexAndPos(index_type nNearestIndex, tools::Long nNearestPosition, tools::Long nBound, index_type& nFoundIndex, tools::Long& nPosition, bool bTowards, tools::Long nDiff) { if (nDiff > 0) // nBound < nNearestPosition GeIndexBackwards(nNearestIndex, nNearestPosition, nBound, nFoundIndex, nPosition, bTowards); else GetIndexTowards(nNearestIndex, nNearestPosition, nBound, nFoundIndex, nPosition, bTowards); } void ScBoundsProvider::Compute( value_type aFirstNearest, value_type aSecondNearest, tools::Long nFirstBound, tools::Long nSecondBound) { SAL_INFO("sc.kit.header", "BoundsProvider: nFirstBound: " << nFirstBound << ", nSecondBound: " << nSecondBound); tools::Long nFirstDiff = aFirstNearest.second - nFirstBound; tools::Long nSecondDiff = aSecondNearest.second - nSecondBound; SAL_INFO("sc.kit.header", "BoundsProvider: rTopNearest: index: " << aFirstNearest.first << ", pos: " << aFirstNearest.second << ", diff: " << nFirstDiff); SAL_INFO("sc.kit.header", "BoundsProvider: rBottomNearest: index: " << aSecondNearest.first << ", pos: " << aSecondNearest.second << ", diff: " << nSecondDiff); bool bReverse = (std::abs(nFirstDiff) >= std::abs(nSecondDiff)); if(bReverse) { std::swap(aFirstNearest, aSecondNearest); std::swap(nFirstBound, nSecondBound); std::swap(nFirstDiff, nSecondDiff); } index_type nNearestIndex = aFirstNearest.first; tools::Long nNearestPosition = aFirstNearest.second; SAL_INFO("sc.kit.header", "BoundsProvider: nearest to first bound: nNearestIndex: " << nNearestIndex << ", nNearestPosition: " << nNearestPosition); GetIndexAndPos(nNearestIndex, nNearestPosition, nFirstBound, nFirstIndex, nFirstPositionPx, !bReverse, nFirstDiff); SAL_INFO("sc.kit.header", "BoundsProvider: nFirstIndex: " << nFirstIndex << ", nFirstPositionPx: " << nFirstPositionPx); if (std::abs(nSecondDiff) < std::abs(nSecondBound - nFirstPositionPx)) { nNearestIndex = aSecondNearest.first; nNearestPosition = aSecondNearest.second; } else { nNearestPosition = nFirstPositionPx; nNearestIndex = nFirstIndex; nSecondDiff = !bReverse ? -1 : 1; } SAL_INFO("sc.kit.header", "BoundsProvider: nearest to second bound: nNearestIndex: " << nNearestIndex << ", nNearestPosition: " << nNearestPosition << ", diff: " << nSecondDiff); GetIndexAndPos(nNearestIndex, nNearestPosition, nSecondBound, nSecondIndex, nSecondPositionPx, bReverse, nSecondDiff); SAL_INFO("sc.kit.header", "BoundsProvider: nSecondIndex: " << nSecondIndex << ", nSecondPositionPx: " << nSecondPositionPx); if (bReverse) { std::swap(nFirstIndex, nSecondIndex); std::swap(nFirstPositionPx, nSecondPositionPx); } } void ScBoundsProvider::EnlargeStartBy(tools::Long nOffset) { const index_type nNewFirstIndex = std::max(static_cast(-1), static_cast(nFirstIndex - nOffset)); for (index_type nIndex = nFirstIndex; nIndex > nNewFirstIndex; --nIndex) { const tools::Long nSizePx = GetSize(nIndex); nFirstPositionPx -= nSizePx; } nFirstIndex = nNewFirstIndex; SAL_INFO("sc.kit.header", "BoundsProvider: added offset: nFirstIndex: " << nFirstIndex << ", nFirstPositionPx: " << nFirstPositionPx); } void ScBoundsProvider::EnlargeEndBy(tools::Long nOffset) { const index_type nNewSecondIndex = std::min(MAX_INDEX, static_cast(nSecondIndex + nOffset)); for (index_type nIndex = nSecondIndex + 1; nIndex <= nNewSecondIndex; ++nIndex) { const tools::Long nSizePx = GetSize(nIndex); nSecondPositionPx += nSizePx; } nSecondIndex = nNewSecondIndex; SAL_INFO("sc.kit.header", "BoundsProvider: added offset: nSecondIndex: " << nSecondIndex << ", nSecondPositionPx: " << nSecondPositionPx); } void ScBoundsProvider::GeIndexBackwards( index_type nNearestIndex, tools::Long nNearestPosition, tools::Long nBound, index_type& nFoundIndex, tools::Long& nPosition, bool bTowards) { nFoundIndex = -1; for (index_type nIndex = nNearestIndex; nIndex >= 0; --nIndex) { if (nBound >= nNearestPosition) { nFoundIndex = nIndex; // last index whose nPosition is less than nBound nPosition = nNearestPosition; break; } const tools::Long nSizePx = GetSize(nIndex); nNearestPosition -= nSizePx; } if (!bTowards && nFoundIndex != -1) { nFoundIndex += 1; nPosition += GetSize(nFoundIndex); } } void ScBoundsProvider::GetIndexTowards( index_type nNearestIndex, tools::Long nNearestPositionPx, tools::Long nBoundPx, index_type& nFoundIndex, tools::Long& nPosition, bool bTowards) { nFoundIndex = -2; if (bColumnHeader) { for (index_type nIndex = nNearestIndex + 1; nIndex <= MAX_INDEX; ++nIndex) { const sal_uInt16 nSize = rDoc.GetColWidth(nIndex, nTab); const tools::Long nSizePx = ScViewData::ToPixel(nSize, mfPPTX); nNearestPositionPx += nSizePx; if (nNearestPositionPx > nBoundPx) { nFoundIndex = nIndex; // first index whose nPosition is greater than nBoundPx nPosition = nNearestPositionPx; break; } } } else { SCROW nFoundRow = rDoc.GetRowForHeightPixels(nTab, nNearestIndex, nNearestPositionPx, nBoundPx, mfPPTY); if (nFoundRow != -1) { nFoundIndex = nFoundRow; // first index whose nPosition is greater than nBound nPosition = nNearestPositionPx; } } if (nFoundIndex == -2) { nFoundIndex = MAX_INDEX; nPosition = nNearestPositionPx; } else if (bTowards) { nPosition -= GetSize(nFoundIndex); nFoundIndex -= 1; } } ScViewDataTable::ScViewDataTable(const ScDocument& rDoc) : eZoomType( SvxZoomType::PERCENT ), fZoomX( 1.0 ), fZoomY( 1.0 ), fPageZoomX( 3.0 / 5 ), // Page-Default: 60% fPageZoomY( 3.0 / 5 ), nHSplitPos( 0 ), nVSplitPos( 0 ), eHSplitMode( SC_SPLIT_NONE ), eVSplitMode( SC_SPLIT_NONE ), eWhichActive( SC_SPLIT_BOTTOMLEFT ), nFixPosX( 0 ), nFixPosY( 0 ), nCurX( 0 ), nCurY( 0 ), nOldCurX( 0 ), nOldCurY( 0 ), aWidthHelper(rDoc, true), aHeightHelper(rDoc, false), nMaxTiledCol( 20 ), nMaxTiledRow( 50 ), nLastSheetViewTab(sc::DefaultSheetViewID), bShowGrid( true ), mbOldCursorValid( false ) { nPosX[0]=nPosX[1]=0; nPosY[0]=nPosY[1]=0; nTPosX[0]=nTPosX[1]=0; nTPosY[0]=nTPosY[1]=0; nMPosX[0]=nMPosX[1]=0; nMPosY[0]=nMPosY[1]=0; nPixPosX[0]=nPixPosX[1]=0; nPixPosY[0]=nPixPosY[1]=0; } void ScViewDataTable::WriteUserDataSequence(cpo::uno::Sequence & rSettings, const ScViewData& rViewData, SCTAB nTab) const { rSettings.realloc(SC_TABLE_VIEWSETTINGS_COUNT); beans::PropertyValue* pSettings = rSettings.getArray(); ScSplitMode eExHSplitMode = eHSplitMode; ScSplitMode eExVSplitMode = eVSplitMode; SCCOL nExFixPosX = nFixPosX; SCROW nExFixPosY = nFixPosY; tools::Long nExHSplitPos = nHSplitPos; tools::Long nExVSplitPos = nVSplitPos; if (comphelper::COKit::isActive()) { rViewData.OverrideWithKitFreeze(eExHSplitMode, eExVSplitMode, nExFixPosX, nExFixPosY, nExHSplitPos, nExVSplitPos, nTab); } pSettings[SC_CURSOR_X].Name = SC_CURSORPOSITIONX; pSettings[SC_CURSOR_X].Value <<= sal_Int32(nCurX); pSettings[SC_CURSOR_Y].Name = SC_CURSORPOSITIONY; pSettings[SC_CURSOR_Y].Value <<= sal_Int32(nCurY); // Write freezepan data only when freeze pans are set if(nExFixPosX != 0 || nExFixPosY != 0 || nExHSplitPos != 0 || nExVSplitPos != 0) { pSettings[SC_HORIZONTAL_SPLIT_MODE].Name = SC_HORIZONTALSPLITMODE; pSettings[SC_HORIZONTAL_SPLIT_MODE].Value <<= sal_Int16(eExHSplitMode); pSettings[SC_VERTICAL_SPLIT_MODE].Name = SC_VERTICALSPLITMODE; pSettings[SC_VERTICAL_SPLIT_MODE].Value <<= sal_Int16(eExVSplitMode); pSettings[SC_HORIZONTAL_SPLIT_POSITION].Name = SC_HORIZONTALSPLITPOSITION; if (eExHSplitMode == SC_SPLIT_FIX) pSettings[SC_HORIZONTAL_SPLIT_POSITION].Value <<= sal_Int32(nExFixPosX); else pSettings[SC_HORIZONTAL_SPLIT_POSITION].Value <<= sal_Int32(nExHSplitPos); pSettings[SC_VERTICAL_SPLIT_POSITION].Name = SC_VERTICALSPLITPOSITION; if (eExVSplitMode == SC_SPLIT_FIX) pSettings[SC_VERTICAL_SPLIT_POSITION].Value <<= sal_Int32(nExFixPosY); else pSettings[SC_VERTICAL_SPLIT_POSITION].Value <<= sal_Int32(nExVSplitPos); } // Prevent writing odd settings that would make crash versions that // don't apply SanitizeWhichActive() when reading the settings. // See tdf#117093 const ScSplitPos eActiveSplitRange = SanitizeWhichActive(); // And point out to give us a chance to inspect weird things (if anyone // remembers what s/he did). assert(eWhichActive == eActiveSplitRange); pSettings[SC_ACTIVE_SPLIT_RANGE].Name = SC_ACTIVESPLITRANGE; pSettings[SC_ACTIVE_SPLIT_RANGE].Value <<= sal_Int16(eActiveSplitRange); pSettings[SC_POSITION_LEFT].Name = SC_POSITIONLEFT; pSettings[SC_POSITION_LEFT].Value <<= sal_Int32(nPosX[SC_SPLIT_LEFT]); pSettings[SC_POSITION_RIGHT].Name = SC_POSITIONRIGHT; pSettings[SC_POSITION_RIGHT].Value <<= sal_Int32(nPosX[SC_SPLIT_RIGHT]); pSettings[SC_POSITION_TOP].Name = SC_POSITIONTOP; pSettings[SC_POSITION_TOP].Value <<= sal_Int32(nPosY[SC_SPLIT_TOP]); pSettings[SC_POSITION_BOTTOM].Name = SC_POSITIONBOTTOM; pSettings[SC_POSITION_BOTTOM].Value <<= sal_Int32(nPosY[SC_SPLIT_BOTTOM]); sal_Int32 nZoomValue = tools::Long(fZoomY * 100); sal_Int32 nPageZoomValue = tools::Long(fPageZoomY * 100); pSettings[SC_TABLE_ZOOM_TYPE].Name = SC_ZOOMTYPE; pSettings[SC_TABLE_ZOOM_TYPE].Value <<= sal_Int16(eZoomType); const std::optional& oExportZoom = rViewData.GetExportZoom(); if (oExportZoom && comphelper::IsContextFlagActive(u"IsKitExport"_ustr)) nZoomValue = *oExportZoom; pSettings[SC_TABLE_ZOOM_VALUE].Name = SC_ZOOMVALUE; pSettings[SC_TABLE_ZOOM_VALUE].Value <<= nZoomValue; pSettings[SC_TABLE_PAGE_VIEW_ZOOM_VALUE].Name = SC_PAGEVIEWZOOMVALUE; pSettings[SC_TABLE_PAGE_VIEW_ZOOM_VALUE].Value <<= nPageZoomValue; pSettings[SC_TABLE_SHOWGRID].Name = SC_UNO_SHOWGRID; pSettings[SC_TABLE_SHOWGRID].Value <<= bShowGrid; // Common SdrModel processing rViewData.GetDocument().GetDrawLayer()->WriteUserDataSequence(rSettings); } void ScViewDataTable::ReadUserDataSequence(const cpo::uno::Sequence & aSettings, ScViewData& rViewData, SCTAB nTab, bool& rHasZoom ) { rHasZoom = false; sal_Int32 nTemp32(0); sal_Int16 nTemp16(0); sal_Int32 nTempPosV(0); sal_Int32 nTempPosH(0); sal_Int32 nTempPosVTw(0); sal_Int32 nTempPosHTw(0); bool bHasVSplitInTwips = false; bool bHasHSplitInTwips = false; for (const auto& rSetting : aSettings) { OUString sName(rSetting.Name); if (sName == SC_CURSORPOSITIONX) { rSetting.Value >>= nTemp32; nCurX = rViewData.GetDocument().SanitizeCol( static_cast(nTemp32)); } else if (sName == SC_CURSORPOSITIONY) { rSetting.Value >>= nTemp32; nCurY = rViewData.GetDocument().SanitizeRow( static_cast(nTemp32)); } else if (sName == SC_HORIZONTALSPLITMODE) { if ((rSetting.Value >>= nTemp16) && nTemp16 <= ScSplitMode::SC_SPLIT_MODE_MAX_ENUM) eHSplitMode = static_cast(nTemp16); } else if (sName == SC_VERTICALSPLITMODE) { if ((rSetting.Value >>= nTemp16) && nTemp16 <= ScSplitMode::SC_SPLIT_MODE_MAX_ENUM) eVSplitMode = static_cast(nTemp16); } else if (sName == SC_HORIZONTALSPLITPOSITION) { rSetting.Value >>= nTempPosH; bHasHSplitInTwips = false; } else if (sName == SC_VERTICALSPLITPOSITION) { rSetting.Value >>= nTempPosV; bHasVSplitInTwips = false; } else if (sName == SC_HORIZONTALSPLITPOSITION_TWIPS) { rSetting.Value >>= nTempPosHTw; bHasHSplitInTwips = true; } else if (sName == SC_VERTICALSPLITPOSITION_TWIPS) { rSetting.Value >>= nTempPosVTw; bHasVSplitInTwips = true; } else if (sName == SC_ACTIVESPLITRANGE) { if ((rSetting.Value >>= nTemp16) && nTemp16 <= ScSplitPos::SC_SPLIT_POS_MAX_ENUM) eWhichActive = static_cast(nTemp16); } else if (sName == SC_POSITIONLEFT) { rSetting.Value >>= nTemp32; nPosX[SC_SPLIT_LEFT] = rViewData.GetDocument().SanitizeCol( static_cast(nTemp32)); } else if (sName == SC_POSITIONRIGHT) { rSetting.Value >>= nTemp32; nPosX[SC_SPLIT_RIGHT] = rViewData.GetDocument().SanitizeCol( static_cast(nTemp32)); } else if (sName == SC_POSITIONTOP) { rSetting.Value >>= nTemp32; nPosY[SC_SPLIT_TOP] = rViewData.GetDocument().SanitizeRow( static_cast(nTemp32)); } else if (sName == SC_POSITIONBOTTOM) { rSetting.Value >>= nTemp32; nPosY[SC_SPLIT_BOTTOM] = rViewData.GetDocument().SanitizeRow( static_cast(nTemp32)); } else if (sName == SC_ZOOMTYPE) { rSetting.Value >>= nTemp16; eZoomType = SvxZoomType(nTemp16); rHasZoom = true; // set if there is any zoom information } else if (sName == SC_ZOOMVALUE) { rSetting.Value >>= nTemp32; double fZoom = double(nTemp32) / 100; fZoomX = fZoomY = fZoom; rHasZoom = true; } else if (sName == SC_PAGEVIEWZOOMVALUE) { rSetting.Value >>= nTemp32; double fZoom = double(nTemp32) / 100; fPageZoomX = fPageZoomY = fZoom; rHasZoom = true; } else if (sName == SC_UNO_SHOWGRID) { rSetting.Value >>= bShowGrid; } else if (sName == SC_TABLESELECTED) { bool bSelected = false; rSetting.Value >>= bSelected; rViewData.GetMarkData().SelectTable( nTab, bSelected ); } else if (sName == SC_UNONAME_TABCOLOR) { // There are documents out there that have their tab color defined as a view setting. Color aColor = COL_AUTO; rSetting.Value >>= aColor; if (aColor != COL_AUTO) { ScDocument& rDoc = rViewData.GetDocument(); rDoc.SetTabBgColor(nTab, aColor); } } // Fallback to common SdrModel processing else rViewData.GetDocument().GetDrawLayer()->ReadUserDataSequenceValue(&rSetting); } if (eHSplitMode == SC_SPLIT_FIX) nFixPosX = rViewData.GetDocument().SanitizeCol( static_cast( bHasHSplitInTwips ? nTempPosHTw : nTempPosH )); else nHSplitPos = bHasHSplitInTwips ? static_cast< tools::Long >( nTempPosHTw * rViewData.GetPPTX() ) : nTempPosH; if (eVSplitMode == SC_SPLIT_FIX) nFixPosY = rViewData.GetDocument().SanitizeRow( static_cast( bHasVSplitInTwips ? nTempPosVTw : nTempPosV )); else nVSplitPos = bHasVSplitInTwips ? static_cast< tools::Long >( nTempPosVTw * rViewData.GetPPTY() ) : nTempPosV; eWhichActive = SanitizeWhichActive(); } ScSplitPos ScViewDataTable::SanitizeWhichActive() const { if ((WhichH(eWhichActive) == SC_SPLIT_RIGHT && eHSplitMode == SC_SPLIT_NONE) || (WhichV(eWhichActive) == SC_SPLIT_TOP && eVSplitMode == SC_SPLIT_NONE)) { SAL_WARN("sc.ui","ScViewDataTable::SanitizeWhichActive - bad eWhichActive " << eWhichActive); // The default always initialized grid window is SC_SPLIT_BOTTOMLEFT. return SC_SPLIT_BOTTOMLEFT; } return eWhichActive; } ScViewData::ScViewData(ScDocShell& rDocSh, ScTabViewShell* pViewSh) : ScViewData(nullptr, &rDocSh, pViewSh) { } ScViewData::ScViewData(ScDocument& rDoc) : ScViewData(&rDoc, nullptr, nullptr) { } static ScViewOptions DefaultOptions() { ScViewOptions aOptions; aOptions.SetOption(sc::ViewOption::GRID, true); aOptions.SetOption(sc::ViewOption::SYNTAX, false); aOptions.SetOption(sc::ViewOption::HEADER, true); aOptions.SetOption(sc::ViewOption::TABCONTROLS, true); aOptions.SetOption(sc::ViewOption::VSCROLL, true); aOptions.SetOption(sc::ViewOption::HSCROLL, true); aOptions.SetOption(sc::ViewOption::OUTLINER, true); return aOptions; } // Either pDoc or pDocSh must be valid ScViewData::ScViewData(ScDocument* pDoc, ScDocShell* pDocSh, ScTabViewShell* pViewSh) : nPPTX(0.0), nPPTY(0.0), maMarkData (pDocSh ? pDocSh->GetDocument().GetSheetLimits() : pDoc->GetSheetLimits()), maHighlightData (pDocSh ? pDocSh->GetDocument().GetSheetLimits() : pDoc->GetSheetLimits()), pDocShell ( pDocSh ), mrDoc (pDocSh ? pDocSh->GetDocument() : *pDoc), pView ( pViewSh ), maOptions (pDocSh ? pDocSh->GetDocument().GetViewOptions() : DefaultOptions()), pSpellingView ( nullptr ), aLogicMode ( MapUnit::Map100thMM ), eDefZoomType( SvxZoomType::PERCENT ), fDefZoomX ( 1.0 ), fDefZoomY ( 1.0 ), fDefPageZoomX( 3.0 / 5 ), fDefPageZoomY( 3.0 / 5 ), eRefType ( SC_REFTYPE_NONE ), mnTabNumber(0), nRefTabNo ( 0 ), nRefStartX(0), nRefStartY(0), nRefStartZ(0), nRefEndX(0), nRefEndY(0), nRefEndZ(0), nFillStartX(0), nFillStartY(0), nFillEndX(0), nFillEndY(0), nPasteFlags ( ScPasteFlags::NONE ), eEditActivePart( SC_SPLIT_BOTTOMLEFT ), nFillMode ( ScFillMode::NONE ), eEditAdjust ( SvxAdjust::Left ), bActive ( true ), // how to initialize? bIsRefMode ( false ), bDelMarkValid( false ), bPagebreak ( false ), bSelCtrlMouseClick( false ), bMoveArea ( false ), bEditHighlight ( false ), bGrowing (false), nFormulaBarLines(1), m_nKitPageUpDownOffset( 0 ) { assert(bool(pDoc) != bool(pDocSh)); // either one or the other, not both maMarkData.SelectOneTable(0); // Sync with nTabNo aScrSize = Size( o3tl::convert(STD_COL_WIDTH * OLE_STD_CELLS_X, o3tl::Length::twip, o3tl::Length::px), o3tl::convert(mrDoc.GetSheetOptimalMinRowHeight(mnTabNumber) * OLE_STD_CELLS_Y, o3tl::Length::twip, o3tl::Length::px)); maTabData.emplace_back( new ScViewDataTable(mrDoc) ); pThisTab = maTabData[mnTabNumber].get(); nEditEndCol = nEditStartCol = nEditCol = 0; nEditEndRow = nEditRow = 0; nTabStartCol = SC_TABSTART_NONE; // don't show hidden tables if (!mrDoc.IsVisible(mnTabNumber)) { while (!mrDoc.IsVisible(mnTabNumber) && mrDoc.HasTable(mnTabNumber + 1)) { ++mnTabNumber; maTabData.emplace_back(nullptr); maTabData[mnTabNumber].reset( new ScViewDataTable(mrDoc) ); } pThisTab = maTabData[mnTabNumber].get(); } SCTAB nTableCount = mrDoc.GetTableCount(); EnsureTabDataSize(nTableCount); CalcPPT(); } ScViewData::~ScViewData() { KillEditView(); } ScDBFunc* ScViewData::GetView() const { return pView; } bool ScViewData::IsValidTabNumber(SCTAB nTabNumber) const { return nTabNumber >= 0 && o3tl::make_unsigned(nTabNumber) < maTabData.size(); } void ScViewData::UpdateCurrentTab() { assert(IsValidTabNumber(GetTabNumber())); pThisTab = maTabData[mnTabNumber].get(); while (!pThisTab) { if (mnTabNumber > 0) pThisTab = maTabData[--mnTabNumber].get(); else { maTabData[0].reset(new ScViewDataTable(mrDoc)); pThisTab = maTabData[0].get(); } } } void ScViewData::InsertTab( SCTAB nTab ) { if( nTab >= static_cast(maTabData.size())) maTabData.resize(nTab+1); else maTabData.insert( maTabData.begin() + nTab, nullptr ); CreateTabData( nTab ); UpdateCurrentTab(); maMarkData.InsertTab(nTab); collectUIInformation({{}}, u"InsertTab"_ustr); } void ScViewData::InsertTabs( SCTAB nTab, SCTAB nNewSheets ) { if (nTab >= static_cast(maTabData.size())) maTabData.resize(nTab+nNewSheets); else { // insert nNewSheets new tables at position nTab auto prevSize = maTabData.size(); maTabData.resize(prevSize + nNewSheets); std::move_backward(maTabData.begin() + nTab, maTabData.begin() + prevSize, maTabData.end()); } for (SCTAB i = nTab; i < nTab + nNewSheets; ++i) { CreateTabData( i ); maMarkData.InsertTab(i); } UpdateCurrentTab(); } void ScViewData::DeleteTab( SCTAB nTab ) { assert(IsValidTabNumber(nTab)); maTabData.erase(maTabData.begin() + nTab); if (o3tl::make_unsigned(GetTabNumber()) >= maTabData.size()) { EnsureTabDataSize(1); mnTabNumber = maTabData.size() - 1; } UpdateCurrentTab(); maMarkData.DeleteTab(nTab); } void ScViewData::DeleteTabs( SCTAB nTab, SCTAB nSheets ) { for (SCTAB i = 0; i < nSheets; ++i) { maMarkData.DeleteTab(nTab + i); } maTabData.erase(maTabData.begin() + nTab, maTabData.begin()+ nTab+nSheets); if (o3tl::make_unsigned(GetTabNumber()) >= maTabData.size()) { EnsureTabDataSize(1); mnTabNumber = maTabData.size() - 1; } UpdateCurrentTab(); } void ScViewData::CopyTab( SCTAB nSrcTab, SCTAB nDestTab ) { if (nDestTab==SC_TAB_APPEND) nDestTab = mrDoc.GetTableCount() - 1; // something had to have been copied if (nDestTab > MAXTAB) { OSL_FAIL("too many sheets"); return; } if (nSrcTab >= static_cast(maTabData.size())) OSL_FAIL("pTabData out of bounds, FIX IT"); EnsureTabDataSize(nDestTab + 1); if ( maTabData[nSrcTab] ) maTabData.emplace(maTabData.begin() + nDestTab, new ScViewDataTable( *maTabData[nSrcTab] )); else maTabData.insert(maTabData.begin() + nDestTab, nullptr); UpdateCurrentTab(); maMarkData.InsertTab(nDestTab); } void ScViewData::MoveTab( SCTAB nSrcTab, SCTAB nDestTab ) { if (nDestTab==SC_TAB_APPEND) nDestTab = mrDoc.GetTableCount() - 1; std::unique_ptr pTab; if (nSrcTab < static_cast(maTabData.size())) { pTab = std::move(maTabData[nSrcTab]); maTabData.erase( maTabData.begin() + nSrcTab ); } if (nDestTab < static_cast(maTabData.size())) maTabData.insert( maTabData.begin() + nDestTab, std::move(pTab) ); else { EnsureTabDataSize(nDestTab + 1); maTabData[nDestTab] = std::move(pTab); } UpdateCurrentTab(); maMarkData.DeleteTab(nSrcTab); maMarkData.InsertTab(nDestTab); // adapted if needed } void ScViewData::CreateTabData( std::vector< SCTAB >& rvTabs ) { for ( const auto& rTab : rvTabs ) CreateTabData(rTab); } void ScViewData::SetZoomType( SvxZoomType eNew, std::vector< SCTAB >& tabs ) { bool bAll = tabs.empty(); if ( !bAll ) // create associated table data CreateTabData( tabs ); if ( bAll ) { for ( auto & i: maTabData ) { if ( i ) i->eZoomType = eNew; } eDefZoomType = eNew; } else { for ( const SCTAB& i : tabs ) { if ( i < static_cast(maTabData.size()) && maTabData[i] ) maTabData[i]->eZoomType = eNew; } } } void ScViewData::SetZoomType( SvxZoomType eNew, bool bAll ) { std::vector< SCTAB > vTabs; // Empty for all tabs if ( !bAll ) // get selected tabs { ScMarkData::const_iterator itr = maMarkData.begin(), itrEnd = maMarkData.end(); vTabs.insert(vTabs.begin(), itr, itrEnd); } SetZoomType( eNew, vTabs ); } void ScViewData::SetZoom( double fNewX, double fNewY, std::vector< SCTAB >& tabs ) { bool bAll = tabs.empty(); if ( !bAll ) // create associated table data CreateTabData( tabs ); // sanity check - we shouldn't need something this low / big SAL_WARN_IF(fNewX < 0.01 || fNewX > 100.0, "sc.viewdata", "fraction rNewX not sensible: " << fNewX); SAL_WARN_IF(fNewY < 0.01 || fNewY > 100.0, "sc.viewdata", "fraction rNewY not sensible: " << fNewY); if ( bAll ) { for ( auto & i: maTabData ) { if ( i ) { if ( bPagebreak ) { i->fPageZoomX = fNewX; i->fPageZoomY = fNewY; } else { i->fZoomX = fNewX; i->fZoomY = fNewY; } } } if ( bPagebreak ) { fDefPageZoomX = fNewX; fDefPageZoomY = fNewY; } else { fDefZoomX = fNewX; fDefZoomY = fNewY; } } else { for ( const SCTAB& i : tabs ) { if ( i < static_cast(maTabData.size()) && maTabData[i] ) { if ( bPagebreak ) { maTabData[i]->fPageZoomX = fNewX; maTabData[i]->fPageZoomY = fNewY; } else { maTabData[i]->fZoomX = fNewX; maTabData[i]->fZoomY = fNewY; } } } } RefreshZoom(); } void ScViewData::SetZoom( double fNewX, double fNewY, bool bAll ) { std::vector< SCTAB > vTabs; if ( !bAll ) // get selected tabs { ScMarkData::const_iterator itr = maMarkData.begin(), itrEnd = maMarkData.end(); vTabs.insert(vTabs.begin(), itr, itrEnd); } SetZoom( fNewX, fNewY, vTabs ); } void ScViewData::SetShowGrid( bool bShow ) { CreateSelectedTabData(); maTabData[GetTabNumber()]->bShowGrid = bShow; } bool ScViewData::GetPrintGrid() const { bool bPrintGrid; ScStyleSheetPool* pStylePool = mrDoc.GetStyleSheetPool(); SfxStyleSheetBase* pStyleSheet = pStylePool->Find( mrDoc.GetPageStyle( GetTabNumber() ), SfxStyleFamily::Page ); if (pStyleSheet) { SfxItemSet& rSet = pStyleSheet->GetItemSet(); bPrintGrid = rSet.Get(ATTR_PAGE_GRID).GetValue(); } else { const ScViewOptions& rOpt = mrDoc.GetViewOptions(); bPrintGrid = rOpt.GetOption(sc::ViewOption::GRID); } return bPrintGrid; } void ScViewData::SetPrintGrid( bool bPrintGrid ) { ScStyleSheetPool* pStylePool = mrDoc.GetStyleSheetPool(); SfxStyleSheetBase* pStyleSheet = pStylePool->Find( mrDoc.GetPageStyle( GetTabNumber() ), SfxStyleFamily::Page ); if (pStyleSheet) { SfxItemSet& rSet = pStyleSheet->GetItemSet(); SfxItemState eState = rSet.GetItemState(ATTR_PAGE_GRID, true); bool bOld = rSet.Get(ATTR_PAGE_GRID).GetValue(); if (bOld == bPrintGrid && eState == SfxItemState::DEFAULT) rSet.ClearItem(ATTR_PAGE_GRID); else rSet.Put(SfxBoolItem(ATTR_PAGE_GRID, bPrintGrid)); mrDoc.PageStyleModified(GetTabNumber(), pStyleSheet->GetName()); } else { // If no style sheet exists, modify the view options directly ScViewOptions aNewOptions = mrDoc.GetViewOptions(); aNewOptions.SetOption(sc::ViewOption::GRID, bPrintGrid); mrDoc.SetViewOptions(aNewOptions); } } void ScViewData::RefreshZoom() { // recalculate zoom-dependent values (only for current sheet) CalcPPT(); RecalcPixPos(); aScenButSize = Size(0,0); aLogicMode.SetScaleX( GetZoomX() ); aLogicMode.SetScaleY( GetZoomY() ); } void ScViewData::SetPagebreakMode( bool bSet ) { bPagebreak = bSet; RefreshZoom(); } ScMarkType ScViewData::GetSimpleArea( ScRange & rRange, ScMarkData & rNewMark ) const { ScMarkType eMarkType = SC_MARK_NONE; if ( rNewMark.IsMarked() || rNewMark.IsMultiMarked() ) { if ( rNewMark.IsMultiMarked() ) rNewMark.MarkToSimple(); if ( rNewMark.IsMarked() && !rNewMark.IsMultiMarked() ) { rRange = rNewMark.GetMarkArea(); if (ScViewUtil::HasFiltered(rRange, GetDocument())) eMarkType = SC_MARK_SIMPLE_FILTERED; else eMarkType = SC_MARK_SIMPLE; } else eMarkType = SC_MARK_MULTI; } if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED) { if (eMarkType == SC_MARK_NONE) eMarkType = SC_MARK_SIMPLE; const ScPatternAttr* pMarkPattern = mrDoc.GetPattern(GetCurX(), GetCurY(), CurrentTabForData()); const ScMergeAttr* pMergeItem = nullptr; if (pMarkPattern && pMarkPattern->GetItemSet().GetItemState(ATTR_MERGE, false, &pMergeItem) == SfxItemState::SET) { SCROW nRow = pMergeItem->GetRowMerge(); SCCOL nCol = pMergeItem->GetColMerge(); if ( nRow < 1 || nCol < 1 ) { // This kind of cells do exist. Not sure if that is intended or a bug. rRange = ScRange(GetCurX(), GetCurY(), GetTabNumber()); } else { rRange = ScRange(GetCurX(), GetCurY(), GetTabNumber(), GetCurX() + nCol - 1, GetCurY() + nRow - 1, GetTabNumber()); if ( ScViewUtil::HasFiltered(rRange, GetDocument()) ) eMarkType = SC_MARK_SIMPLE_FILTERED; } } else rRange = ScRange(GetCurX(), GetCurY(), GetTabNumber()); } return eMarkType; } ScMarkType ScViewData::GetSimpleArea( SCCOL& rStartCol, SCROW& rStartRow, SCTAB& rStartTab, SCCOL& rEndCol, SCROW& rEndRow, SCTAB& rEndTab ) const { // parameter bMergeMark is no longer needed: The view's selection is never modified // (a local copy is used), and a multi selection that adds to a single range can always // be treated like a single selection (GetSimpleArea isn't used in selection // handling itself) ScRange aRange; ScMarkData aNewMark(maMarkData); // use a local copy for MarkToSimple ScMarkType eMarkType = GetSimpleArea( aRange, aNewMark); aRange.GetVars( rStartCol, rStartRow, rStartTab, rEndCol, rEndRow, rEndTab); return eMarkType; } ScMarkType ScViewData::GetSimpleArea( ScRange& rRange ) const { // parameter bMergeMark is no longer needed, see above ScMarkData aNewMark(maMarkData); // use a local copy for MarkToSimple return GetSimpleArea( rRange, aNewMark); } void ScViewData::GetMultiArea( ScRangeListRef& rRange ) const { // parameter bMergeMark is no longer needed, see GetSimpleArea ScMarkData aNewMark(maMarkData); // use a local copy for MarkToSimple bool bMulti = aNewMark.IsMultiMarked(); if (bMulti) { aNewMark.MarkToSimple(); bMulti = aNewMark.IsMultiMarked(); } if (bMulti) { rRange = new ScRangeList; aNewMark.FillRangeListWithMarks( rRange.get(), false ); } else { ScRange aSimple; GetSimpleArea(aSimple); rRange = new ScRangeList(aSimple); } } bool ScViewData::SimpleColMarked() { SCCOL nStartCol; SCROW nStartRow; SCTAB nStartTab; SCCOL nEndCol; SCROW nEndRow; SCTAB nEndTab; if (GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE) if (nStartRow == 0 && nEndRow == mrDoc.MaxRow()) return true; return false; } bool ScViewData::SimpleRowMarked() { SCCOL nStartCol; SCROW nStartRow; SCTAB nStartTab; SCCOL nEndCol; SCROW nEndRow; SCTAB nEndTab; if (GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE) if (nStartCol == 0 && nEndCol == mrDoc.MaxCol()) return true; return false; } bool ScViewData::IsMultiMarked() const { // Test for "real" multi selection, calling MarkToSimple on a local copy, // and taking filtered in simple area marks into account. ScRange aDummy; ScMarkType eType = GetSimpleArea(aDummy); return (eType & SC_MARK_SIMPLE) != SC_MARK_SIMPLE; } bool ScViewData::SelectionForbidsPaste( ScDocument* pClipDoc ) { if (!pClipDoc) { // Same as checkDestRanges() in sc/source/ui/view/cellsh.cxx but // different return details. vcl::Window* pWin = GetActiveWin(); if (!pWin) // No window doesn't mean paste would be forbidden. return false; const ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard(ScTabViewShell::GetClipData(pWin)); if (!pOwnClip) // Foreign content does not get repeatedly replicated. return false; pClipDoc = pOwnClip->GetDocument(); if (!pClipDoc) // No clipdoc doesn't mean paste would be forbidden. return false; } const ScRange aSrcRange = pClipDoc->GetClipParam().getWholeRange(); const SCROW nRowSize = aSrcRange.aEnd.Row() - aSrcRange.aStart.Row() + 1; const SCCOL nColSize = aSrcRange.aEnd.Col() - aSrcRange.aStart.Col() + 1; return SelectionForbidsPaste( nColSize, nRowSize); } bool ScViewData::SelectionForbidsPaste( SCCOL nSrcCols, SCROW nSrcRows ) { ScRange aSelRange( ScAddress::UNINITIALIZED ); ScMarkType eMarkType = GetSimpleArea( aSelRange); if (eMarkType == SC_MARK_MULTI) // Not because of DOOM. return false; if (aSelRange.aEnd.Row() - aSelRange.aStart.Row() + 1 == nSrcRows) // This also covers entire col(s) copied to be pasted on entire cols. return false; if (aSelRange.aEnd.Col() - aSelRange.aStart.Col() + 1 == nSrcCols) // This also covers entire row(s) copied to be pasted on entire rows. return false; return SelectionFillDOOM( aSelRange); } bool ScViewData::SelectionForbidsCellFill() { ScRange aSelRange( ScAddress::UNINITIALIZED ); ScMarkType eMarkType = GetSimpleArea( aSelRange); return eMarkType != SC_MARK_MULTI && SelectionFillDOOM( aSelRange); } // static bool ScViewData::SelectionFillDOOM( const ScRange& rRange ) { // Assume that more than 23 full columns (23M cells) will not be // successful... Even with only 10 bytes per cell that would already be // 230MB, formula cells would be 100 bytes and more per cell. // rows * columns > 23m => rows > 23m / columns // to not overflow in case number of available columns or rows would be // arbitrarily increased. // We could refine this and take some actual cell size into account, // evaluate available memory and what not, but... const sal_Int32 kMax = 23 * 1024 * 1024; // current MAXROWCOUNT1 is 1024*1024=1048576 return (rRange.aEnd.Row() - rRange.aStart.Row() + 1) > (kMax / (rRange.aEnd.Col() - rRange.aStart.Col() + 1)); } void ScViewData::SetFillMode( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow ) { nFillMode = ScFillMode::FILL; nFillStartX = nStartCol; nFillStartY = nStartRow; nFillEndX = nEndCol; nFillEndY = nEndRow; } void ScViewData::SetDragMode( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScFillMode nMode ) { nFillMode = nMode; nFillStartX = nStartCol; nFillStartY = nStartRow; nFillEndX = nEndCol; nFillEndY = nEndRow; } void ScViewData::ResetFillMode() { nFillMode = ScFillMode::NONE; } void ScViewData::GetFillData( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, SCROW& rEndRow ) { rStartCol = nFillStartX; rStartRow = nFillStartY; rEndCol = nFillEndX; rEndRow = nFillEndY; } SCCOL ScViewData::GetOldCurX() const { if (pThisTab->mbOldCursorValid) return pThisTab->nOldCurX; else return pThisTab->nCurX; } SCROW ScViewData::GetOldCurY() const { if (pThisTab->mbOldCursorValid) return pThisTab->nOldCurY; else return pThisTab->nCurY; } void ScViewData::SetOldCursor( SCCOL nNewX, SCROW nNewY ) { pThisTab->nOldCurX = nNewX; pThisTab->nOldCurY = nNewY; pThisTab->mbOldCursorValid = true; } void ScViewData::ResetOldCursor() { pThisTab->mbOldCursorValid = false; } SCCOL ScViewData::GetPosX( ScHSplitPos eWhich, SCTAB nForTab ) const { if (comphelper::COKit::isActive()) return 0; if (nForTab == -1) return pThisTab->nPosX[eWhich]; if (!ValidTab(nForTab) || (nForTab >= static_cast(maTabData.size()))) return -1; return maTabData[nForTab]->nPosX[eWhich]; } SCROW ScViewData::GetPosY( ScVSplitPos eWhich, SCTAB nForTab ) const { if (comphelper::COKit::isActive()) return 0; if (nForTab == -1) return pThisTab->nPosY[eWhich]; if (!ValidTab(nForTab) || (nForTab >= static_cast(maTabData.size()))) return -1; return maTabData[nForTab]->nPosY[eWhich]; } ScViewDataTable* ScViewData::FetchTableData(SCTAB nTabIndex) const { if (!ValidTab(nTabIndex) || !IsValidTabNumber(nTabIndex)) return nullptr; ScViewDataTable* pRet = maTabData[nTabIndex].get(); SAL_WARN_IF(!pRet, "sc.viewdata", "ScViewData::FetchTableData: hidden sheet = " << nTabIndex); return pRet; } SCCOL ScViewData::GetCurXForTab( SCTAB nTabIndex ) const { ScViewDataTable* pTabData = FetchTableData(nTabIndex); return pTabData ? pTabData->nCurX : -1; } SCROW ScViewData::GetCurYForTab( SCTAB nTabIndex ) const { ScViewDataTable* pTabData = FetchTableData(nTabIndex); return pTabData ? pTabData->nCurY : -1; } void ScViewData::SetCurXForTab( SCCOL nNewCurX, SCTAB nTabIndex ) { if (ScViewDataTable* pTabData = FetchTableData(nTabIndex)) pTabData->nCurX = nNewCurX; } void ScViewData::SetCurYForTab( SCCOL nNewCurY, SCTAB nTabIndex ) { if (ScViewDataTable* pTabData = FetchTableData(nTabIndex)) pTabData->nCurY = nNewCurY; } void ScViewData::SetMaxTiledCol( SCCOL nNewMaxCol ) { nNewMaxCol = std::clamp(nNewMaxCol, SCCOL(0), mrDoc.MaxCol()); const SCTAB nTab = CurrentTabForData(); auto GetColWidthPx = [this, nTab](SCCOL nCol) { const sal_uInt16 nSize = this->mrDoc.GetColWidth(nCol, nTab); const tools::Long nSizePx = ScViewData::ToPixel(nSize, nPPTX); return nSizePx; }; tools::Long nTotalPixels = GetKitWidthHelper().computePosition(nNewMaxCol, GetColWidthPx); SAL_INFO("sc.kit.docsize", "ScViewData::SetMaxTiledCol: nNewMaxCol: " << nNewMaxCol << ", nTotalPixels: " << nTotalPixels); GetKitWidthHelper().removeByIndex(pThisTab->nMaxTiledCol); GetKitWidthHelper().insert(nNewMaxCol, nTotalPixels); pThisTab->nMaxTiledCol = nNewMaxCol; } void ScViewData::SetMaxTiledRow( SCROW nNewMaxRow ) { if (nNewMaxRow < 0) nNewMaxRow = 0; if (nNewMaxRow > MAXTILEDROW) nNewMaxRow = MAXTILEDROW; const SCTAB nTab = CurrentTabForData(); auto GetRowHeightPx = [this, nTab](SCROW nRow) { const sal_uInt16 nSize = this->mrDoc.GetRowHeight(nRow, nTab); const tools::Long nSizePx = ScViewData::ToPixel(nSize, nPPTY); return nSizePx; }; tools::Long nTotalPixels = GetKitHeightHelper().computePosition(nNewMaxRow, GetRowHeightPx); SAL_INFO("sc.kit.docsize", "ScViewData::SetMaxTiledRow: nNewMaxRow: " << nNewMaxRow << ", nTotalPixels: " << nTotalPixels); GetKitHeightHelper().removeByIndex(pThisTab->nMaxTiledRow); GetKitHeightHelper().insert(nNewMaxRow, nTotalPixels); pThisTab->nMaxTiledRow = nNewMaxRow; } tools::Rectangle ScViewData::GetEditArea( ScSplitPos eWhich, SCCOL nPosX, SCROW nPosY, vcl::Window* pWin, const ScPatternAttr* pPattern, bool bForceToTop, bool bInPrintTwips ) { Point aCellTopLeft = bInPrintTwips ? GetPrintTwipsPos(nPosX, nPosY) : GetScrPos(nPosX, nPosY, eWhich, true); return ScEditUtil(mrDoc, nPosX, nPosY, CurrentTabForData(), aCellTopLeft, pWin->GetOutDev(), nPPTX, nPPTY, GetZoomX(), GetZoomY(), bInPrintTwips ). GetEditArea( pPattern, bForceToTop ); } namespace { void notifyCellCursorAt(const ScTabViewShell* pViewShell, SCCOL nCol, SCROW nRow, const tools::Rectangle& rCursor) { OString msg = OString::number(rCursor.getX()) + ", " + OString::number(rCursor.getY()) + ", " + OString::number(rCursor.GetWidth()) + ", " + OString::number(rCursor.GetHeight()) + ", " + OString::number(nCol) + ", " + OString::number(nRow); pViewShell->viewCallback(COKitCallbackType::CELL_CURSOR, msg); KitHelper::notifyOtherViews(pViewShell, COKitCallbackType::CELL_VIEW_CURSOR, "rectangle", msg); } } void ScViewData::SetEditEngine( ScSplitPos eWhich, ScEditEngineDefaulter& rNewEngine, vcl::Window* pWin, SCCOL nNewX, SCROW nNewY ) { bool bLayoutRTL = mrDoc.IsLayoutRTL(CurrentTabForData()); ScHSplitPos eHWhich = WhichH(eWhich); ScVSplitPos eVWhich = WhichV(eWhich); bool bLOKActive = comphelper::COKit::isActive(); bool bLOKPrintTwips = bLOKActive && comphelper::COKit::isCompatFlagSet( comphelper::COKit::Compat::scPrintTwipsMsgs); bool bLOKLayoutRTL = bLOKActive && bLayoutRTL; bool bWasThere = false; if (pEditView[eWhich]) { // if the view is already there don't call anything that changes the cursor position if (bEditActive[eWhich]) { bWasThere = true; } else { lcl_KitRemoveWindow(GetViewShell(), eWhich); pEditView[eWhich]->setEditEngine(rNewEngine); } if (pEditView[eWhich]->GetWindow() != pWin) { lcl_KitRemoveWindow(GetViewShell(), eWhich); pEditView[eWhich]->SetWindow(pWin); OSL_FAIL("EditView Window has changed"); } } else { pEditView[eWhich].reset(new EditView(rNewEngine, pWin)); if (bLOKActive) { // We can broadcast the view-cursor message in print-twips for all views. pEditView[eWhich]->SetBroadcastKitViewCursor(bLOKPrintTwips); pEditView[eWhich]->RegisterViewShell(pView); } } // add windows from other views if (!bWasThere && bLOKActive) { ScTabViewShell* pThisViewShell = GetViewShell(); SCTAB nThisTabNo = CurrentTabForData(); auto lAddWindows = [pThisViewShell, nThisTabNo, eWhich] (ScTabViewShell* pOtherViewShell) { ScViewData& rOtherViewData = pOtherViewShell->GetViewData(); SCTAB nOtherTabNo = rOtherViewData.CurrentTabForData(); if (nThisTabNo == nOtherTabNo) pOtherViewShell->AddWindowToForeignEditView(pThisViewShell, eWhich); }; KitHelper::forEachOtherView(pThisViewShell, lAddWindows); } // if view is gone then during IdleFormat sometimes a cursor is drawn EEControlBits nEC = rNewEngine.GetControlWord(); rNewEngine.SetControlWord(nEC & ~EEControlBits::DOIDLEFORMAT); EVControlBits nVC = pEditView[eWhich]->GetControlWord(); pEditView[eWhich]->SetControlWord(nVC & ~EVControlBits::AUTOSCROLL); bEditActive[eWhich] = true; const ScPatternAttr* pPattern = mrDoc.GetPattern(nNewX, nNewY, CurrentTabForData()); if (!pPattern) { SAL_WARN("sc.viewdata", "No Pattern Found for: Col: " << nNewX << ", Row: " << nNewY << ", Tab: " << CurrentTabForData()); pPattern = &mrDoc.getCellAttributeHelper().getDefaultCellAttribute(); } SvxCellHorJustify eJust = pPattern->GetItem( ATTR_HOR_JUSTIFY ).GetValue(); bool bBreak = ( eJust == SvxCellHorJustify::Block ) || pPattern->GetItem(ATTR_LINEBREAK).GetValue(); bool bAsianVertical = rNewEngine.IsEffectivelyVertical(); // set by InputHandler tools::Rectangle aPixRect = ScEditUtil(mrDoc, nNewX, nNewY, CurrentTabForData(), GetScrPos(nNewX, nNewY, eWhich), pWin->GetOutDev(), nPPTX,nPPTY,GetZoomX(),GetZoomY() ). GetEditArea( pPattern, true ); tools::Rectangle aPTwipsRect; if (bLOKPrintTwips) { aPTwipsRect = ScEditUtil(mrDoc, nNewX, nNewY, CurrentTabForData(), GetPrintTwipsPos(nNewX, nNewY), pWin->GetOutDev(), nPPTX, nPPTY, GetZoomX(), GetZoomY(), true /* bInPrintTwips */). GetEditArea(pPattern, true); } // when right-aligned, leave space for the cursor // in vertical mode, editing is always right-aligned if ( GetEditAdjust() == SvxAdjust::Right || bAsianVertical ) { aPixRect.AdjustRight(1 ); if (bLOKPrintTwips) aPTwipsRect.AdjustRight(o3tl::convert(1, o3tl::Length::px, o3tl::Length::twip)); } if (bLOKPrintTwips) { if (!pEditView[eWhich]->HasKitSpecialPositioning()) pEditView[eWhich]->InitKitSpecialPositioning(MapUnit::MapTwip, aPTwipsRect, Point()); else pEditView[eWhich]->SetKitSpecialOutputArea(aPTwipsRect); } if (bLOKActive && pEditView[eWhich]->HasKitSpecialPositioning()) pEditView[eWhich]->SetKitSpecialFlags(bLOKLayoutRTL ? KitSpecialFlags::LayoutRTL : KitSpecialFlags::NONE); tools::Rectangle aOutputArea = pWin->PixelToLogic( aPixRect, GetLogicMode() ); pEditView[eWhich]->SetOutputArea( aOutputArea ); if (bLOKPrintTwips) notifyCellCursorAt(GetViewShell(), nNewX, nNewY, aPTwipsRect); ScModule* pScMod = ScModule::get(); if ( bActive && eWhich == GetActivePart() ) { // keep the part that has the active edit view available after // switching sheets or reference input on a different part eEditActivePart = eWhich; // modify members nEditCol etc. only if also extending for needed area nEditCol = nNewX; nEditRow = nNewY; const ScMergeAttr* pMergeAttr = &pPattern->GetItem(ATTR_MERGE); nEditEndCol = nEditCol; if (pMergeAttr->GetColMerge() > 1) nEditEndCol += pMergeAttr->GetColMerge() - 1; nEditEndRow = nEditRow; if (pMergeAttr->GetRowMerge() > 1) nEditEndRow += pMergeAttr->GetRowMerge() - 1; nEditStartCol = nEditCol; // For growing use only the alignment value from the attribute, numbers // (existing or started) with default alignment extend to the right. bool bGrowCentered = ( eJust == SvxCellHorJustify::Center ); bool bGrowToLeft = ( eJust == SvxCellHorJustify::Right ); // visual left bool bLOKRTLInvert = (bLOKActive && bLayoutRTL); if ( bAsianVertical ) bGrowCentered = bGrowToLeft = false; // keep old behavior for asian mode tools::Long nSizeXPix, nSizeXPTwips = 0; const tools::Long nGridWidthPx = pView->GetGridWidth(eHWhich); const tools::Long nGridHeightPx = pView->GetGridHeight(eVWhich); tools::Long nGridWidthTwips = 0, nGridHeightTwips = 0; if (bLOKPrintTwips) { Size aGridSize(nGridWidthPx, nGridHeightPx); const MapMode& rWinMapMode = GetLogicMode(); aGridSize = OutputDevice::LogicToLogic( pWin->PixelToLogic(aGridSize, rWinMapMode), rWinMapMode, MapMode(MapUnit::MapTwip)); nGridWidthTwips = aGridSize.Width(); nGridHeightTwips = aGridSize.Height(); } if (bBreak && !bAsianVertical) { nSizeXPix = aPixRect.GetWidth(); // papersize -> no horizontal scrolling if (bLOKPrintTwips) nSizeXPTwips = aPTwipsRect.GetWidth(); } else { OSL_ENSURE(pView,"no View for EditView"); if ( bGrowCentered ) { // growing into both directions until one edge is reached //! should be limited to whole cells in both directions tools::Long nLeft = aPixRect.Left(); tools::Long nRight = nGridWidthPx - aPixRect.Right(); nSizeXPix = aPixRect.GetWidth() + 2 * std::min( nLeft, nRight ); if (bLOKPrintTwips) { tools::Long nLeftPTwips = aPTwipsRect.Left(); tools::Long nRightPTwips = nGridWidthTwips - aPTwipsRect.Right(); nSizeXPTwips = aPTwipsRect.GetWidth() + 2 * std::min(nLeftPTwips, nRightPTwips); } } else if ( (bGrowToLeft && !bLOKRTLInvert) || (!bGrowToLeft && bLOKRTLInvert) ) { nSizeXPix = aPixRect.Right(); // space that's available in the window when growing to the left if (bLOKPrintTwips) nSizeXPTwips = aPTwipsRect.Right(); } else { nSizeXPix = nGridWidthPx - aPixRect.Left(); if (bLOKPrintTwips) nSizeXPTwips = nGridWidthTwips - aPTwipsRect.Left(); } if ( nSizeXPix <= 0 ) { nSizeXPix = aPixRect.GetWidth(); // editing outside to the right of the window -> keep cell width if (bLOKPrintTwips) nSizeXPTwips = aPTwipsRect.GetWidth(); } } OSL_ENSURE(pView,"no View for EditView"); tools::Long nSizeYPix = nGridHeightPx - aPixRect.Top(); tools::Long nSizeYPTwips = bLOKPrintTwips ? (nGridHeightTwips - aPTwipsRect.Top()) : 0; if ( nSizeYPix <= 0 ) { nSizeYPix = aPixRect.GetHeight(); // editing outside below the window -> keep cell height if (bLOKPrintTwips) nSizeYPTwips = aPTwipsRect.GetHeight(); } Size aPaperSize = pView->GetActiveWin()->PixelToLogic( Size( nSizeXPix, nSizeYPix ), GetLogicMode() ); Size aPaperSizePTwips(nSizeXPTwips, nSizeYPTwips); // In the COKit case the following code can make the cell background and visible area larger // than needed which makes selecting the adjacent right cell impossible in some cases. if (bBreak && !bAsianVertical && pScMod->GetInputOptions().GetTextWysiwyg() && !bLOKActive) { // if text is formatted for printer, use the exact same paper width // (and same line breaks) as for output. double fFract(1.0); constexpr auto HMM_PER_TWIPS = o3tl::convert(1.0, o3tl::Length::twip, o3tl::Length::mm100); tools::Rectangle aUtilRect = ScEditUtil(mrDoc, nNewX, nNewY, CurrentTabForData(), Point(0, 0), pWin->GetOutDev(), HMM_PER_TWIPS, HMM_PER_TWIPS, fFract, fFract ).GetEditArea( pPattern, false ); aPaperSize.setWidth( aUtilRect.GetWidth() ); if (bLOKPrintTwips) { aPaperSizePTwips.setWidth(o3tl::convert(aUtilRect.GetWidth(), o3tl::Length::mm100, o3tl::Length::twip)); } } rNewEngine.SetPaperSize( aPaperSize ); if (bLOKPrintTwips) rNewEngine.SetKitSpecialPaperSize(aPaperSizePTwips); // sichtbarer Ausschnitt Size aPaper = rNewEngine.GetPaperSize(); tools::Rectangle aVis = pEditView[eWhich]->GetVisArea(); tools::Rectangle aVisPTwips; if (bLOKPrintTwips) aVisPTwips = pEditView[eWhich]->GetKitSpecialVisArea(); tools::Long nDiff = aVis.Right() - aVis.Left(); tools::Long nDiffPTwips = bLOKPrintTwips ? (aVisPTwips.Right() - aVisPTwips.Left()) : 0; // On re-entry take the alignment from the engine's current paragraph // adjustment rather than the cell's committed one. EditGrowX may have // originally re-anchored the in-edit text (a typed number shows left // aligned but commits right aligned), and the visible area must follow it. SvxAdjust eVisAdjust = GetEditAdjust(); if (bWasThere) { eVisAdjust = rNewEngine.GetDefaults().Get(EE_PARA_JUST).GetAdjust(); } if ( eVisAdjust == SvxAdjust::Right ) { aVis.SetRight( aPaper.Width() - 1 ); if (bLOKPrintTwips) aVisPTwips.SetRight( aPaperSizePTwips.Width() - 1 ); bMoveArea = !bLayoutRTL; } else if ( eVisAdjust == SvxAdjust::Center ) { aVis.SetRight( ( aPaper.Width() - 1 + nDiff ) / 2 ); if (bLOKPrintTwips) aVisPTwips.SetRight( ( aPaperSizePTwips.Width() - 1 + nDiffPTwips ) / 2 ); bMoveArea = true; // always } else { aVis.SetRight( nDiff ); if (bLOKPrintTwips) aVisPTwips.SetRight(nDiffPTwips); bMoveArea = bLayoutRTL; } aVis.SetLeft( aVis.Right() - nDiff ); if (bLOKPrintTwips) aVisPTwips.SetLeft(aVisPTwips.Right() - nDiffPTwips); // #i49561# Important note: // The set offset of the visible area of the EditView for centered and // right alignment in horizontal layout is consider by instances of // class in its methods // and . This is needed for the correct visibility // of paragraphs in edit mode at the accessibility API. pEditView[eWhich]->SetVisArea(aVis); if (bLOKPrintTwips) pEditView[eWhich]->SetKitSpecialVisArea(aVisPTwips); // UpdateMode has been disabled in ScInputHandler::StartTable // must be enabled before EditGrowY (GetTextHeight) rNewEngine.SetUpdateLayout( true ); rNewEngine.SetStatusEventHdl( LINK( this, ScViewData, EditEngineHdl ) ); EditGrowY( true ); // adjust to existing text content EditGrowX(); Point aDocPos = pEditView[eWhich]->GetWindowPosTopLeft(0); if (aDocPos.Y() < aOutputArea.Top()) pEditView[eWhich]->Scroll( 0, aOutputArea.Top() - aDocPos.Y() ); } // here bEditActive needs to be set already // (due to Map-Mode during Paint) if (!bWasThere) rNewEngine.InsertView(pEditView[eWhich].get()); // background color of the cell Color aBackCol = pPattern->GetItem(ATTR_BACKGROUND).GetColor(); if ( aBackCol.IsTransparent() ) { aBackCol = pScMod->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor; } pEditView[eWhich]->SetBackgroundColor( aBackCol ); if (comphelper::COKit::isActive()) { // now only needed when not CEOO (CellEditOnOverlay) // needed? // needed, if position changed pEditView[eWhich]->Invalidate(); } } IMPL_LINK( ScViewData, EditEngineHdl, EditStatus&, rStatus, void ) { EditStatusFlags nStatus = rStatus.GetStatusWord(); if (nStatus & (EditStatusFlags::HSCROLL | EditStatusFlags::TextHeightChanged | EditStatusFlags::TEXTWIDTHCHANGED | EditStatusFlags::CURSOROUT)) { EditGrowY(); EditGrowX(); if (nStatus & EditStatusFlags::CURSOROUT) { ScSplitPos eWhich = GetActivePart(); if (pEditView[eWhich]) pEditView[eWhich]->ShowCursor(false); } } } void ScViewData::EditGrowX() { // It is insane to call EditGrowX while the output area is already growing. // That could occur because of the call to SetDefaultItem later. // We end up with wrong start/end edit columns and the changes // to the output area performed by the inner call to this method are // useless since they are discarded by the outer call. if (bGrowing) return; comphelper::FlagRestorationGuard aFlagGuard(bGrowing, true); bool bLOKActive = comphelper::COKit::isActive(); bool bLOKPrintTwips = bLOKActive && comphelper::COKit::isCompatFlagSet( comphelper::COKit::Compat::scPrintTwipsMsgs); ScDocument& rLocalDoc = GetDocument(); ScSplitPos eWhich = GetActivePart(); ScHSplitPos eHWhich = WhichH(eWhich); EditView* pCurView = pEditView[eWhich].get(); if ( !pCurView || !bEditActive[eWhich]) return; SCTAB nCurrentTab = CurrentTabForData(); bool bLayoutRTL = rLocalDoc.IsLayoutRTL(nCurrentTab); ScEditEngineDefaulter* pEngine = static_cast(&pCurView->getEditEngine()); vcl::Window* pWin = pCurView->GetWindow(); // Get the left- and right-most column positions. SCCOL nLeft = GetPosX(eHWhich); SCCOL nRight = nLeft + VisibleCellsX(eHWhich); Size aSize = pEngine->GetPaperSize(); Size aSizePTwips; if (bLOKPrintTwips) aSizePTwips = pEngine->GetKitSpecialPaperSize(); tools::Rectangle aArea = pCurView->GetOutputArea(); tools::Rectangle aAreaPTwips; if (bLOKPrintTwips) aAreaPTwips = pCurView->GetKitSpecialOutputArea(); tools::Long nOldRight = aArea.Right(); // Margin is already included in the original width. tools::Long nTextWidth = pEngine->CalcTextWidth(); bool bChanged = false; bool bAsianVertical = pEngine->IsEffectivelyVertical(); // get bGrow... variables the same way as in SetEditEngine const ScPatternAttr* pPattern = rLocalDoc.GetPattern( nEditCol, nEditRow, nCurrentTab); if (!pPattern) { SAL_WARN("sc.viewdata", "No Pattern Found for: Col: " << nEditCol << ", Row: " << nEditRow << ", Tab: " << nCurrentTab); pPattern = &rLocalDoc.getCellAttributeHelper().getDefaultCellAttribute(); } SvxCellHorJustify eJust = pPattern->GetItem( ATTR_HOR_JUSTIFY ).GetValue(); bool bGrowCentered = ( eJust == SvxCellHorJustify::Center ); bool bGrowToLeft = ( eJust == SvxCellHorJustify::Right ); // visual left bool bGrowBackwards = bGrowToLeft; // logical left if ( bLayoutRTL ) bGrowBackwards = !bGrowBackwards; // invert on RTL sheet if ( bAsianVertical ) bGrowCentered = bGrowToLeft = bGrowBackwards = false; // keep old behavior for asian mode bool bUnevenGrow = false; if ( bGrowCentered ) { while (aArea.GetWidth() + 0 < nTextWidth && ( nEditStartCol > nLeft || nEditEndCol < nRight ) ) { tools::Long nLogicLeft = 0; tools::Long nLogicLeftPTwips = 0; if ( nEditStartCol > nLeft ) { --nEditStartCol; tools::Long nColWidth = rLocalDoc.GetColWidth(nEditStartCol, nCurrentTab); tools::Long nLeftPix = ToPixel( nColWidth, nPPTX ); nLogicLeft = pWin->PixelToLogic(Size(nLeftPix,0)).Width(); if (bLOKPrintTwips) nLogicLeftPTwips = nColWidth; } tools::Long nLogicRight = 0; tools::Long nLogicRightPTwips = 0; if ( nEditEndCol < nRight ) { ++nEditEndCol; tools::Long nColWidth = rLocalDoc.GetColWidth(nEditEndCol, nCurrentTab); tools::Long nRightPix = ToPixel( nColWidth, nPPTX ); nLogicRight = pWin->PixelToLogic(Size(nRightPix,0)).Width(); if (bLOKPrintTwips) nLogicRightPTwips = nColWidth; } aArea.AdjustLeft( -((bLayoutRTL && !bLOKActive) ? nLogicRight : nLogicLeft) ); aArea.AdjustRight((bLayoutRTL && !bLOKActive) ? nLogicLeft : nLogicRight ); if (bLOKPrintTwips) { aAreaPTwips.AdjustLeft(-nLogicLeftPTwips); aAreaPTwips.AdjustRight(nLogicRightPTwips); } if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 ) { tools::Long nCenter = ( aArea.Left() + aArea.Right() ) / 2; tools::Long nHalf = aSize.Width() / 2; aArea.SetLeft( nCenter - nHalf + 1 ); aArea.SetRight( nCenter + aSize.Width() - nHalf - 1 ); if (bLOKPrintTwips) { tools::Long nCenterPTwips = ( aAreaPTwips.Left() + aAreaPTwips.Right() ) / 2; tools::Long nHalfPTwips = aSizePTwips.Width() / 2; aAreaPTwips.SetLeft( nCenterPTwips - nHalfPTwips + 1 ); aAreaPTwips.SetRight( nCenterPTwips + aSizePTwips.Width() - nHalfPTwips - 1 ); } } bChanged = true; if ( nLogicLeft != nLogicRight ) bUnevenGrow = true; } } else if ( bGrowBackwards ) { while (aArea.GetWidth() + 0 < nTextWidth && nEditStartCol > nLeft) { --nEditStartCol; tools::Long nColWidth = rLocalDoc.GetColWidth(nEditStartCol, nCurrentTab); tools::Long nPix = ToPixel( nColWidth, nPPTX ); tools::Long nLogicWidth = pWin->PixelToLogic(Size(nPix,0)).Width(); tools::Long& nLogicWidthPTwips = nColWidth; if ( !bLayoutRTL || bLOKActive ) { aArea.AdjustLeft( -nLogicWidth ); if (bLOKPrintTwips) aAreaPTwips.AdjustLeft( -nLogicWidthPTwips ); } else { aArea.AdjustRight(nLogicWidth ); if (bLOKPrintTwips) aAreaPTwips.AdjustRight(nLogicWidthPTwips); } if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 ) { if ( !bLayoutRTL || bLOKActive ) { aArea.SetLeft( aArea.Right() - aSize.Width() + 1 ); if (bLOKPrintTwips) aAreaPTwips.SetLeft( aAreaPTwips.Right() - aSizePTwips.Width() + 1 ); } else { aArea.SetRight( aArea.Left() + aSize.Width() - 1 ); if (bLOKPrintTwips) aAreaPTwips.SetRight( aAreaPTwips.Left() + aSizePTwips.Width() - 1 ); } } bChanged = true; } } else { while (aArea.GetWidth() + 0 < nTextWidth && nEditEndCol < nRight) { ++nEditEndCol; tools::Long nColWidth = rLocalDoc.GetColWidth(nEditEndCol, nCurrentTab); tools::Long nPix = ToPixel( nColWidth, nPPTX ); tools::Long nLogicWidth = pWin->PixelToLogic(Size(nPix,0)).Width(); tools::Long& nLogicWidthPTwips = nColWidth; if ( bLayoutRTL && !bLOKActive ) { aArea.AdjustLeft( -nLogicWidth ); } else { aArea.AdjustRight(nLogicWidth ); if (bLOKPrintTwips) aAreaPTwips.AdjustRight(nLogicWidthPTwips); } if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 ) { if ( bLayoutRTL && !bLOKActive ) { aArea.SetLeft( aArea.Right() - aSize.Width() + 1 ); } else { aArea.SetRight( aArea.Left() + aSize.Width() - 1 ); if (bLOKPrintTwips) aAreaPTwips.SetRight( aAreaPTwips.Left() + aSizePTwips.Width() - 1 ); } } bChanged = true; } } if (!bChanged) return; if ( bMoveArea || bGrowCentered || bGrowBackwards || bLayoutRTL ) { tools::Rectangle aVis = pCurView->GetVisArea(); tools::Rectangle aVisPTwips; if (bLOKPrintTwips) aVisPTwips = pCurView->GetKitSpecialVisArea(); if ( bGrowCentered ) { // switch to center-aligned (undo?) and reset VisArea to center pEngine->SetDefaultItem( SvxAdjustItem( SvxAdjust::Center, EE_PARA_JUST ) ); tools::Long nCenter = aSize.Width() / 2; tools::Long nVisSize = aArea.GetWidth(); aVis.SetLeft( nCenter - nVisSize / 2 ); aVis.SetRight( aVis.Left() + nVisSize - 1 ); if (bLOKPrintTwips) { tools::Long nCenterPTwips = aSizePTwips.Width() / 2; tools::Long nVisSizePTwips = aAreaPTwips.GetWidth(); aVisPTwips.SetLeft( nCenterPTwips - nVisSizePTwips / 2 ); aVisPTwips.SetRight( aVisPTwips.Left() + nVisSizePTwips - 1 ); } } else if ( bGrowToLeft ) { // switch to right-aligned (undo?) and reset VisArea to the right pEngine->SetDefaultItem( SvxAdjustItem( SvxAdjust::Right, EE_PARA_JUST ) ); aVis.SetRight( aSize.Width() - 1 ); aVis.SetLeft( aSize.Width() - aArea.GetWidth() ); // with the new, increased area if (bLOKPrintTwips) { aVisPTwips.SetRight( aSizePTwips.Width() - 1 ); aVisPTwips.SetLeft( aSizePTwips.Width() - aAreaPTwips.GetWidth() ); // with the new, increased area } } else { // switch to left-aligned (undo?) and reset VisArea to the left pEngine->SetDefaultItem( SvxAdjustItem( SvxAdjust::Left, EE_PARA_JUST ) ); tools::Long nMove = aVis.Left(); aVis.SetLeft( 0 ); aVis.AdjustRight( -nMove ); if (bLOKPrintTwips) { tools::Long nMovePTwips = aVisPTwips.Left(); aVisPTwips.SetLeft( 0 ); aVisPTwips.AdjustRight( -nMovePTwips ); } } pCurView->SetVisArea( aVis ); if (bLOKPrintTwips) pCurView->SetKitSpecialVisArea( aVisPTwips ); bMoveArea = false; } if (bLOKPrintTwips) pCurView->SetKitSpecialOutputArea(aAreaPTwips); pCurView->SetOutputArea(aArea); if (bLOKPrintTwips) notifyCellCursorAt(GetViewShell(), nEditCol, nEditRow, aAreaPTwips); // In vertical mode, the whole text is moved to the next cell (right-aligned), // so everything must be repainted. Otherwise, paint only the new area. // If growing in centered alignment, if the cells left and right have different sizes, // the whole text will move, and may not even obscure all of the original display. if ( bUnevenGrow ) { aArea.SetLeft( pWin->PixelToLogic( Point(0,0) ).X() ); aArea.SetRight( pWin->PixelToLogic( aScrSize ).Width() ); } else if ( !bAsianVertical && !bGrowToLeft && !bGrowCentered ) aArea.SetLeft( nOldRight ); pWin->Invalidate(aArea); // invalidate other views pCurView->InvalidateOtherViewWindows(aArea); } void ScViewData::EditGrowY( bool bInitial ) { if (bGrowing) return; comphelper::FlagRestorationGuard aFlagGuard(bGrowing, true); bool bLOKActive = comphelper::COKit::isActive(); bool bLOKPrintTwips = bLOKActive && comphelper::COKit::isCompatFlagSet( comphelper::COKit::Compat::scPrintTwipsMsgs); ScSplitPos eWhich = GetActivePart(); ScVSplitPos eVWhich = WhichV(eWhich); EditView* pCurView = pEditView[eWhich].get(); if ( !pCurView || !bEditActive[eWhich]) return; EVControlBits nControl = pEditView[eWhich]->GetControlWord(); if ( nControl & EVControlBits::AUTOSCROLL ) { // if end of screen had already been reached and scrolling enabled, // don't further try to grow the edit area pCurView->SetOutputArea( pCurView->GetOutputArea() ); // re-align to pixels return; } EditEngine& rEngine = pCurView->getEditEngine(); vcl::Window* pWin = pCurView->GetWindow(); SCROW nBottom = GetPosY(eVWhich) + VisibleCellsY(eVWhich); Size aSize = rEngine.GetPaperSize(); Size aSizePTwips; tools::Rectangle aArea = pCurView->GetOutputArea(); tools::Rectangle aAreaPTwips; if (bLOKPrintTwips) { aSizePTwips = rEngine.GetKitSpecialPaperSize(); aAreaPTwips = pCurView->GetKitSpecialOutputArea(); } tools::Long nOldBottom = aArea.Bottom(); tools::Long nTextHeight = rEngine.GetTextHeight(); // When editing a formula in a cell with optimal height, allow a larger portion // to be clipped before extending to following rows, to avoid obscuring cells for // reference input (next row is likely to be useful in formulas). tools::Long nAllowedExtra = SC_GROWY_SMALL_EXTRA; if (nEditEndRow == nEditRow && !(mrDoc.GetRowFlags(nEditRow, CurrentTabForData()) & CRFlags::ManualSize) && rEngine.GetParagraphCount() <= 1 ) { // If the (only) paragraph starts with a '=', it's a formula. // If this is the initial call and the text is empty, allow the larger value, too, // because this occurs in the normal progress of editing a formula. // Subsequent calls with empty text might involve changed attributes (including // font height), so they are treated like normal text. OUString aText = rEngine.GetText( 0 ); if ( ( aText.isEmpty() && bInitial ) || aText.startsWith("=") ) nAllowedExtra = SC_GROWY_BIG_EXTRA; } bool bChanged = false; bool bMaxReached = false; while (aArea.GetHeight() + nAllowedExtra < nTextHeight && nEditEndRow < nBottom && !bMaxReached) { ++nEditEndRow; ScDocument& rLocalDoc = GetDocument(); tools::Long nRowHeight = rLocalDoc.GetRowHeight(nEditEndRow, CurrentTabForData()); tools::Long nPix = ToPixel( nRowHeight, nPPTY ); aArea.AdjustBottom(pWin->PixelToLogic(Size(0,nPix)).Height() ); if (bLOKPrintTwips) aAreaPTwips.AdjustBottom(nRowHeight); if ( aArea.Bottom() > aArea.Top() + aSize.Height() - 1 ) { aArea.SetBottom( aArea.Top() + aSize.Height() - 1 ); if (bLOKPrintTwips) aAreaPTwips.SetBottom( aAreaPTwips.Top() + aSizePTwips.Height() - 1 ); bMaxReached = true; // don't occupy more cells beyond paper size } bChanged = true; nAllowedExtra = SC_GROWY_SMALL_EXTRA; // larger value is only for first row } if (!bChanged) return; if (bLOKPrintTwips) pCurView->SetKitSpecialOutputArea(aAreaPTwips); pCurView->SetOutputArea(aArea); if (bLOKPrintTwips) notifyCellCursorAt(GetViewShell(), nEditCol, nEditRow, aAreaPTwips); if (nEditEndRow >= nBottom || bMaxReached) { if (!(nControl & EVControlBits::AUTOSCROLL)) pCurView->SetControlWord( nControl | EVControlBits::AUTOSCROLL ); } aArea.SetTop( nOldBottom ); pWin->Invalidate(aArea); // invalidate other views pCurView->InvalidateOtherViewWindows(aArea); } void ScViewData::ResetEditView() { KitEditViewHistory::Update(/*bRemove: */ true); EditEngine* pEngine = nullptr; for (sal_uInt16 i=0; i<4; i++) { if (pEditView[i]) { if (bEditActive[i]) { lcl_KitRemoveWindow(GetViewShell(), static_cast(i)); pEngine = &pEditView[i]->getEditEngine(); pEngine->RemoveView(pEditView[i].get()); pEditView[i]->SetOutputArea( tools::Rectangle() ); } bEditActive[i] = false; } } if (pEngine) pEngine->SetStatusEventHdl( Link() ); } void ScViewData::KillEditView() { KitEditViewHistory::Update(/*bRemove: */ true); for (sal_uInt16 i=0; i<4; i++) if (pEditView[i]) { if (bEditActive[i]) { EditEngine& rEngine = pEditView[i]->getEditEngine(); rEngine.RemoveView(pEditView[i].get()); } pEditView[i].reset(); } } void ScViewData::GetEditView( ScSplitPos eWhich, EditView*& rViewPtr, SCCOL& rCol, SCROW& rRow ) { rViewPtr = pEditView[eWhich].get(); rCol = nEditCol; rRow = nEditRow; } void ScViewData::CreateTabData( SCTAB nNewTab ) { EnsureTabDataSize(nNewTab + 1); if (!maTabData[nNewTab]) { maTabData[nNewTab].reset(new ScViewDataTable(mrDoc)); maTabData[nNewTab]->eZoomType = eDefZoomType; maTabData[nNewTab]->fZoomX = fDefZoomX; maTabData[nNewTab]->fZoomY = fDefZoomY; maTabData[nNewTab]->fPageZoomX = fDefPageZoomX; maTabData[nNewTab]->fPageZoomY = fDefPageZoomY; } } void ScViewData::CreateSelectedTabData() { for (const auto& rTab : maMarkData) CreateTabData(rTab); } void ScViewData::EnsureTabDataSize(size_t nSize) { if (nSize > maTabData.size()) maTabData.resize(nSize); } void ScViewData::SetTabNo( SCTAB nNewTab ) { if (!ValidTab(nNewTab)) { OSL_FAIL("wrong sheet number"); return; } // Remember the current sheet view tab on the default sheet's per-tab data if (ValidTab(mnTabNumber)) { SCTAB nDefaultOfOld = mrDoc.GetDefaultViewTableNumber(mnTabNumber); if (nDefaultOfOld != mnTabNumber && nDefaultOfOld < SCTAB(maTabData.size()) && maTabData[nDefaultOfOld]) { maTabData[nDefaultOfOld]->nLastSheetViewTab = mnTabNumber; } } mnTabNumber = nNewTab; CreateTabData(mnTabNumber); pThisTab = maTabData[mnTabNumber].get(); CalcPPT(); // for common column width correction RecalcPixPos(); //! not always needed! } ScPositionHelper* ScViewData::GetKitWidthHelper(SCTAB nTabIndex) { if (!ValidTab(nTabIndex) || (nTabIndex >= static_cast(maTabData.size())) || !maTabData[nTabIndex]) { return nullptr; } return &(maTabData[nTabIndex]->aWidthHelper); } ScPositionHelper* ScViewData::GetKitHeightHelper(SCTAB nTabIndex) { if (!ValidTab(nTabIndex) || (nTabIndex >= static_cast(maTabData.size())) || !maTabData[nTabIndex]) { return nullptr; } return &(maTabData[nTabIndex]->aHeightHelper); } void ScViewData::SetActivePart( ScSplitPos eNewActive ) { pThisTab->eWhichActive = eNewActive; // Let's hope we find the culprit for tdf#117093 // Don't sanitize the real value (yet?) because this function might be // called before setting the then corresponding split modes. For which in // fact then the order should be changed. assert(eNewActive == pThisTab->SanitizeWhichActive()); } Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScHSplitPos eWhich ) const { OSL_ENSURE( eWhich==SC_SPLIT_LEFT || eWhich==SC_SPLIT_RIGHT, "wrong position" ); ScSplitPos ePos = ( eWhich == SC_SPLIT_LEFT ) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT; return GetScrPos( nWhereX, nWhereY, ePos ); } Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScVSplitPos eWhich ) const { OSL_ENSURE( eWhich==SC_SPLIT_TOP || eWhich==SC_SPLIT_BOTTOM, "wrong position" ); ScSplitPos ePos = ( eWhich == SC_SPLIT_TOP ) ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT; return GetScrPos( nWhereX, nWhereY, ePos ); } Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScSplitPos eWhich, bool bAllowNeg, SCTAB nForTab ) const { ScHSplitPos eWhichX = SC_SPLIT_LEFT; ScVSplitPos eWhichY = SC_SPLIT_BOTTOM; switch( eWhich ) { case SC_SPLIT_TOPLEFT: eWhichX = SC_SPLIT_LEFT; eWhichY = SC_SPLIT_TOP; break; case SC_SPLIT_TOPRIGHT: eWhichX = SC_SPLIT_RIGHT; eWhichY = SC_SPLIT_TOP; break; case SC_SPLIT_BOTTOMLEFT: eWhichX = SC_SPLIT_LEFT; eWhichY = SC_SPLIT_BOTTOM; break; case SC_SPLIT_BOTTOMRIGHT: eWhichX = SC_SPLIT_RIGHT; eWhichY = SC_SPLIT_BOTTOM; break; } if (nForTab == -1) nForTab = CurrentTabForData(); bool bForCurTab = (nForTab == CurrentTabForData()); if (!bForCurTab && (!ValidTab(nForTab) || (nForTab >= static_cast(maTabData.size())))) { SAL_WARN("sc.viewdata", "ScViewData::GetScrPos : invalid nForTab = " << nForTab); nForTab = CurrentTabForData(); bForCurTab = true; } ScViewDataTable* pViewTable = bForCurTab ? pThisTab : maTabData[nForTab].get(); if (pView) { const_cast(this)->aScrSize.setWidth( pView->GetGridWidth(eWhichX) ); const_cast(this)->aScrSize.setHeight( pView->GetGridHeight(eWhichY) ); } bool bIsTiledRendering = comphelper::COKit::isActive(); SCCOL nPosX = GetPosX(eWhichX, nForTab); tools::Long nScrPosX = 0; if (bAllowNeg || nWhereX >= nPosX) { SCROW nStartPosX = nPosX; if (bIsTiledRendering) { OSL_ENSURE(nPosX == 0, "Unsupported case."); const auto& rNearest = pViewTable->aWidthHelper.getNearestByIndex(nWhereX - 1); nStartPosX = rNearest.first + 1; nScrPosX = rNearest.second; } if (nWhereX >= nStartPosX) { for (SCCOL nX = nStartPosX; nX < nWhereX && (bAllowNeg || bIsTiledRendering || nScrPosX <= aScrSize.Width()); nX++) { if (nX > mrDoc.MaxCol()) nScrPosX = 0x7FFFFFFF; else { sal_uInt16 nTSize = mrDoc.GetColWidth(nX, nForTab); if (nTSize) { tools::Long nSizeXPix = ToPixel( nTSize, nPPTX ); nScrPosX += nSizeXPix; } else { // If the width is zero, the column is possibly hidden, skips groups of such columns. SCCOL lastHidden = -1; if(mrDoc.ColHidden(nX, nForTab, nullptr, &lastHidden) && lastHidden > nX) nX = lastHidden - 1; } } } } else { for (SCCOL nX = nStartPosX; nX > nWhereX;) { --nX; sal_uInt16 nTSize = mrDoc.GetColWidth(nX, nForTab); if (nTSize) { tools::Long nSizeXPix = ToPixel( nTSize, nPPTX ); nScrPosX -= nSizeXPix; } else { // If the width is zero, the column is possibly hidden, skips groups of such columns. SCCOL firstHidden = -1; if(mrDoc.ColHidden(nX, nForTab, &firstHidden, nullptr) && firstHidden >= 0) nX = firstHidden; } } } } SCROW nPosY = GetPosY(eWhichY, nForTab); tools::Long nScrPosY = 0; if (bAllowNeg || nWhereY >= nPosY) { SCROW nStartPosY = nPosY; if (bIsTiledRendering) { OSL_ENSURE(nPosY == 0, "Unsupported case."); const auto& rNearest = pViewTable->aHeightHelper.getNearestByIndex(nWhereY - 1); nStartPosY = rNearest.first + 1; nScrPosY = rNearest.second; } if (nWhereY >= nStartPosY) { if (bAllowNeg) { // tdf#150623 If possible, use the faster range-based calculation functions. if ( nStartPosY > mrDoc.MaxRow() ) nScrPosY = 0x7FFFFFFF; else nScrPosY += mrDoc.GetScaledRowHeight(nStartPosY, nWhereY - 1, CurrentTabForData(), nPPTY); } else { for (SCROW nY = nStartPosY; nY < nWhereY && (bAllowNeg || bIsTiledRendering || nScrPosY <= aScrSize.Height()); nY++) { if ( nY > mrDoc.MaxRow() ) nScrPosY = 0x7FFFFFFF; else { sal_uInt16 nTSize = mrDoc.GetRowHeight(nY, CurrentTabForData()); if (nTSize) { tools::Long nSizeYPix = ToPixel( nTSize, nPPTY ); nScrPosY += nSizeYPix; } else if ( nY < mrDoc.MaxRow() ) { // skip multiple hidden rows (forward only for now) SCROW nNext = mrDoc.FirstVisibleRow(nY + 1, mrDoc.MaxRow(), CurrentTabForData()); if ( nNext > mrDoc.MaxRow() ) nY = mrDoc.MaxRow(); else nY = nNext - 1; // +=nDir advances to next visible row } } } } } else { for (SCROW nY = nStartPosY; nY > nWhereY;) { --nY; sal_uInt16 nTSize = mrDoc.GetRowHeight(nY, nForTab); if (nTSize) { tools::Long nSizeYPix = ToPixel( nTSize, nPPTY ); nScrPosY -= nSizeYPix; } else { // If the height is zero, the row is possibly hidden, skips groups of such rows. SCROW firstHidden = -1; if(mrDoc.RowHidden(nY, nForTab, &firstHidden, nullptr) && firstHidden >= 0) nY = firstHidden; } } } } if (mrDoc.IsLayoutRTL(nForTab) && !bIsTiledRendering) { // mirror horizontal position nScrPosX = aScrSize.Width() - 1 - nScrPosX; } return Point( nScrPosX, nScrPosY ); } Point ScViewData::GetPrintTwipsPos(SCCOL nCol, SCROW nRow) const { // hidden ones are given 0 sizes by these by default. // TODO: rewrite this to loop over spans (matters for jumbosheets). tools::Long nPosX = nCol ? mrDoc.GetColWidth(0, nCol - 1, CurrentTabForData()) : 0; // This is now fast as it loops over spans. tools::Long nPosY = nRow ? mrDoc.GetRowHeight(0, nRow - 1, CurrentTabForData()) : 0; // TODO: adjust for RTL layout case. return Point(nPosX, nPosY); } Point ScViewData::GetPrintTwipsPosFromTileTwips(const Point& rTileTwipsPos) const { const tools::Long nPixelX = static_cast(rTileTwipsPos.X() * nPPTX); const tools::Long nPixelY = static_cast(rTileTwipsPos.Y() * nPPTY); SCCOL nCol = 0; SCROW nRow = 0; // The following call (with bTestMerge = false) will not modify any members. const_cast(this)->GetPosFromPixel(nPixelX, nPixelY, SC_SPLIT_TOPLEFT, nCol, nRow, false /* bTestMerge */); const Point aPixCellPos = GetScrPos(nCol, nRow, SC_SPLIT_TOPLEFT, true /* bAllowNeg */); const Point aTileTwipsCellPos(aPixCellPos.X() / nPPTX, aPixCellPos.Y() / nPPTY); const Point aPrintTwipsCellPos = GetPrintTwipsPos(nCol, nRow); return aPrintTwipsCellPos + (rTileTwipsPos - aTileTwipsCellPos); } OString ScViewData::describeCellCursorAt(SCCOL nX, SCROW nY, bool bPixelAligned) const { const bool bPosSizeInPixels = bPixelAligned; Point aCellPos = bPosSizeInPixels ? GetScrPos( nX, nY, SC_SPLIT_BOTTOMRIGHT, true ) : GetPrintTwipsPos(nX, nY); tools::Long nSizeX; tools::Long nSizeY; if (bPosSizeInPixels) GetMergeSizePixel( nX, nY, nSizeX, nSizeY ); else GetMergeSizePrintTwips(nX, nY, nSizeX, nSizeY); std::stringstream ss; if (bPosSizeInPixels) { double fPPTX = GetPPTX(); double fPPTY = GetPPTY(); // make it a slim cell cursor, but not empty if (nSizeX == 0) nSizeX = 1; if (nSizeY == 0) nSizeY = 1; tools::Long nPosXTw = rtl::math::round(aCellPos.getX() / fPPTX); tools::Long nPosYTw = rtl::math::round(aCellPos.getY() / fPPTY); // look at Rectangle( const Point& rLT, const Size& rSize ) for the '- 1' tools::Long nSizeXTw = rtl::math::round(nSizeX / fPPTX) - 1; tools::Long nSizeYTw = rtl::math::round(nSizeY / fPPTY) - 1; ss << nPosXTw << ", " << nPosYTw << ", " << nSizeXTw << ", " << nSizeYTw << ", " << nX << ", " << nY; } else { // look at Rectangle( const Point& rLT, const Size& rSize ) for the decrement. if (nSizeX) --nSizeX; if (nSizeY) --nSizeY; ss << aCellPos.getX() << ", " << aCellPos.getY() << ", " << nSizeX << ", " << nSizeY << ", " << nX << ", " << nY; } return OString(ss.str()); } // Number of cells on a screen SCCOL ScViewData::CellsAtX( SCCOL nPosX, SCCOL nDir, ScHSplitPos eWhichX, tools::Long nScrSizeX ) const { OSL_ENSURE( nDir==1 || nDir==-1, "wrong CellsAt call" ); OSL_ENSURE(nScrSizeX >= 0, "ScViewData::CellsAtX: negative screen width"); if (pView) const_cast(this)->aScrSize.setWidth( pView->GetGridWidth(eWhichX) ); SCCOL nX; tools::Long nScrPosX = 0; if (nScrSizeX == SC_SIZE_NONE) nScrSizeX = aScrSize.Width(); if (nDir==1) nX = nPosX; // forwards else nX = nPosX-1; // backwards bool bOut = false; for ( ; nScrPosX<=nScrSizeX && !bOut; nX = sal::static_int_cast(nX + nDir) ) { SCCOL nColNo = nX; if (nColNo < 0 || nColNo > mrDoc.MaxCol()) bOut = true; else { sal_uInt16 nTSize = mrDoc.GetColWidth(nColNo, CurrentTabForData()); if (nTSize) { tools::Long nSizeXPix = ToPixel( nTSize, nPPTX ); nScrPosX = nScrPosX + nSizeXPix; } } } if (nDir==1) nX = sal::static_int_cast( nX - nPosX ); else nX = (nPosX-1)-nX; if (nX>0) --nX; return nX; } SCROW ScViewData::CellsAtY( SCROW nPosY, SCROW nDir, ScVSplitPos eWhichY, tools::Long nScrSizeY ) const { OSL_ENSURE( nDir==1 || nDir==-1, "wrong CellsAt call" ); OSL_ENSURE(nScrSizeY >= 0, "ScViewData::CellsAtY: negative screen height"); if (pView) const_cast(this)->aScrSize.setHeight( pView->GetGridHeight(eWhichY) ); if (nScrSizeY == SC_SIZE_NONE) nScrSizeY = aScrSize.Height(); SCROW nY; if (nDir==1) { // forward nY = nPosY; tools::Long nScrPosY = 0; AddPixelsWhile(nScrPosY, nScrSizeY, nY, mrDoc.MaxRow(), nPPTY, &mrDoc, CurrentTabForData()); // Original loop ended on last evaluated +1 or if that was MaxRow even on MaxRow+2. nY += (nY == mrDoc.MaxRow() ? 2 : 1); nY -= nPosY; } else { // backward nY = nPosY-1; tools::Long nScrPosY = 0; AddPixelsWhileBackward(nScrPosY, nScrSizeY, nY, 0, nPPTY, &mrDoc, CurrentTabForData()); // Original loop ended on last evaluated -1 or if that was 0 even on -2. nY -= (nY == 0 ? 2 : 1); nY = (nPosY-1)-nY; } if (nY>0) --nY; return nY; } SCCOL ScViewData::VisibleCellsX( ScHSplitPos eWhichX ) const { return CellsAtX( GetPosX( eWhichX ), 1, eWhichX ); } SCROW ScViewData::VisibleCellsY( ScVSplitPos eWhichY ) const { return CellsAtY( GetPosY( eWhichY ), 1, eWhichY ); } SCCOL ScViewData::PrevCellsX( ScHSplitPos eWhichX ) const { return CellsAtX( GetPosX( eWhichX ), -1, eWhichX ); } SCROW ScViewData::PrevCellsY( ScVSplitPos eWhichY ) const { return CellsAtY( GetPosY( eWhichY ), -1, eWhichY ); } bool ScViewData::GetMergeSizePixel( SCCOL nX, SCROW nY, tools::Long& rSizeXPix, tools::Long& rSizeYPix ) const { SCTAB nCurrentTab = CurrentTabForData(); const ScMergeAttr& rMerge = mrDoc.GetAttr(nX, nY, nCurrentTab, ATTR_MERGE); if ( rMerge.GetColMerge() > 1 || rMerge.GetRowMerge() > 1 ) { tools::Long nOutWidth = 0; tools::Long nOutHeight = 0; SCCOL nCountX = rMerge.GetColMerge(); for (SCCOL i=0; i 1 || nCountY > 1); } void ScViewData::GetPosFromPixel( tools::Long nClickX, tools::Long nClickY, ScSplitPos eWhich, SCCOL& rPosX, SCROW& rPosY, bool bTestMerge, bool bRepair, SCTAB nForTab ) { // special handling of 0 is now in ScViewFunctionSet::SetCursorAtPoint SCTAB nCurrentTab = CurrentTabForData(); if (nForTab == -1) nForTab = nCurrentTab; bool bForCurTab = (nForTab == nCurrentTab); if (!bForCurTab && (!ValidTab(nForTab) || (nForTab >= static_cast(maTabData.size())))) { SAL_WARN("sc.viewdata", "ScViewData::GetPosFromPixel : invalid nForTab = " << nForTab); nForTab = nCurrentTab; bForCurTab = true; } ScHSplitPos eHWhich = WhichH(eWhich); ScVSplitPos eVWhich = WhichV(eWhich); if (mrDoc.IsLayoutRTL(nForTab)) { if (!comphelper::COKit::isActive()) { // mirror horizontal position if (pView) aScrSize.setWidth( pView->GetGridWidth(eHWhich) ); nClickX = aScrSize.Width() - 1 - nClickX; } } SCCOL nStartPosX = GetPosX(eHWhich, nForTab); SCROW nStartPosY = GetPosY(eVWhich, nForTab); rPosX = nStartPosX; rPosY = nStartPosY; tools::Long nScrX = 0; tools::Long nScrY = 0; if (nClickX > 0) { while (rPosX <= mrDoc.MaxCol() && nClickX >= nScrX) { nScrX += ToPixel(mrDoc.GetColWidth(rPosX, nForTab), nPPTX); ++rPosX; } --rPosX; } else { while ( rPosX>0 && nClickX < nScrX ) { --rPosX; nScrX -= ToPixel(mrDoc.GetColWidth(rPosX, nForTab), nPPTX); } } if (nClickY > 0) AddPixelsWhile(nScrY, nClickY, rPosY, mrDoc.MaxRow(), nPPTY, &mrDoc, nForTab); else { /* TODO: could need some "SubPixelsWhileBackward" method */ while ( rPosY>0 && nClickY < nScrY ) { --rPosY; nScrY -= ToPixel(mrDoc.GetRowHeight(rPosY, nForTab), nPPTY); } } // cells too big? if (rPosX == nStartPosX && nClickX > 0) { if (pView) aScrSize.setWidth( pView->GetGridWidth(eHWhich) ); if ( nClickX > aScrSize.Width() ) ++rPosX; } if (rPosY == nStartPosY && nClickY > 0) { if (pView) aScrSize.setHeight( pView->GetGridHeight(eVWhich) ); if ( nClickY > aScrSize.Height() ) ++rPosY; } rPosX = std::clamp(rPosX, SCCOL(0), mrDoc.MaxCol()); rPosY = std::clamp(rPosY, SCROW(0), mrDoc.MaxRow()); if (!(bTestMerge && bForCurTab)) return; // public method to adapt position SCCOL nOrigX = rPosX; SCROW nOrigY = rPosY; mrDoc.SkipOverlapped(rPosX, rPosY, nCurrentTab); bool bHOver = (nOrigX != rPosX); bool bVOver = (nOrigY != rPosY); if ( !(bRepair && ( bHOver || bVOver )) ) return; const ScMergeAttr& rMerge = mrDoc.GetAttr(rPosX, rPosY, nCurrentTab, ATTR_MERGE); if ( ( bHOver && rMerge.GetColMerge() <= 1 ) || ( bVOver && rMerge.GetRowMerge() <= 1 ) ) { OSL_FAIL("merge error found"); mrDoc.RemoveFlagsTab(0, 0, mrDoc.MaxCol(), mrDoc.MaxRow(), nCurrentTab, ScMF::Hor | ScMF::Ver); SCCOL nEndCol = mrDoc.MaxCol(); SCROW nEndRow = mrDoc.MaxRow(); mrDoc.ExtendMerge(0, 0, nEndCol, nEndRow, nCurrentTab, true); if (pDocShell) pDocShell->PostPaint(ScRange(0, 0, nCurrentTab, mrDoc.MaxCol(), mrDoc.MaxRow(), nCurrentTab), PaintPartFlags::Grid); } } void ScViewData::GetMouseQuadrant( const Point& rClickPos, ScSplitPos eWhich, SCCOL nPosX, SCROW nPosY, bool& rLeft, bool& rTop ) { bool bLayoutRTL = mrDoc.IsLayoutRTL(CurrentTabForData()); tools::Long nLayoutSign = bLayoutRTL ? -1 : 1; Point aCellStart = GetScrPos( nPosX, nPosY, eWhich, true ); tools::Long nSizeX; tools::Long nSizeY; GetMergeSizePixel( nPosX, nPosY, nSizeX, nSizeY ); rLeft = ( rClickPos.X() - aCellStart.X() ) * nLayoutSign <= nSizeX / 2; rTop = rClickPos.Y() - aCellStart.Y() <= nSizeY / 2; } void ScViewData::SetPosX( ScHSplitPos eWhich, SCCOL nNewPosX ) { // in the tiled rendering case, nPosX [the leftmost visible column] must be 0 bool bIsTiledRendering = comphelper::COKit::isActive(); if (nNewPosX != 0 && !bIsTiledRendering) { SCCOL nOldPosX = pThisTab->nPosX[eWhich]; tools::Long nTPosX = pThisTab->nTPosX[eWhich]; tools::Long nPixPosX = pThisTab->nPixPosX[eWhich]; SCCOL i; if ( nNewPosX > nOldPosX ) for ( i=nOldPosX; i(nThis), nPPTX); } else for ( i=nNewPosX; i(nThis), nPPTX); } pThisTab->nPosX[eWhich] = nNewPosX; pThisTab->nTPosX[eWhich] = nTPosX; pThisTab->nMPosX[eWhich] = o3tl::convert(nTPosX, o3tl::Length::twip, o3tl::Length::mm100); pThisTab->nPixPosX[eWhich] = nPixPosX; } else { pThisTab->nPixPosX[eWhich] = pThisTab->nTPosX[eWhich] = pThisTab->nMPosX[eWhich] = pThisTab->nPosX[eWhich] = 0; } } void ScViewData::SetPosY( ScVSplitPos eWhich, SCROW nNewPosY ) { // in the tiled rendering case, nPosY [the topmost visible row] must be 0 bool bIsTiledRendering = comphelper::COKit::isActive(); if (nNewPosY != 0 && !bIsTiledRendering) { SCROW nOldPosY = pThisTab->nPosY[eWhich]; tools::Long nTPosY = pThisTab->nTPosY[eWhich]; tools::Long nPixPosY = pThisTab->nPixPosY[eWhich]; SCROW i, nHeightEndRow; if ( nNewPosY > nOldPosY ) for ( i=nOldPosY; i(nThis), nPPTY) * nRows; } else for ( i=nNewPosY; i(nThis), nPPTY) * nRows; } pThisTab->nPosY[eWhich] = nNewPosY; pThisTab->nTPosY[eWhich] = nTPosY; pThisTab->nMPosY[eWhich] = o3tl::convert(nTPosY, o3tl::Length::twip, o3tl::Length::mm100); pThisTab->nPixPosY[eWhich] = nPixPosY; } else { pThisTab->nPixPosY[eWhich] = pThisTab->nTPosY[eWhich] = pThisTab->nMPosY[eWhich] = pThisTab->nPosY[eWhich] = 0; } } void ScViewData::RecalcPixPos() // after zoom changes { for (sal_uInt16 eWhich=0; eWhich<2; eWhich++) { tools::Long nPixPosX = 0; SCCOL nPosX = pThisTab->nPosX[eWhich]; for (SCCOL i=0; inPixPosX[eWhich] = nPixPosX; tools::Long nPixPosY = 0; SCROW nPosY = pThisTab->nPosY[eWhich]; tools::Long nRowHeight = -1; SCROW nLastSameHeightRow = -1; for (SCROW j=0; jnPixPosY[eWhich] = nPixPosY; } } const MapMode& ScViewData::GetLogicMode( ScSplitPos eWhich ) { aLogicMode.SetOrigin( Point( pThisTab->nMPosX[WhichH(eWhich)], pThisTab->nMPosY[WhichV(eWhich)] ) ); return aLogicMode; } const MapMode& ScViewData::GetLogicMode() { aLogicMode.SetOrigin( Point() ); return aLogicMode; } void ScViewData::SetScreen( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 ) { SCCOL nCol; SCROW nRow; sal_uInt16 nTSize; tools::Long nSizePix; tools::Long nScrPosX = 0; tools::Long nScrPosY = 0; SetActivePart( SC_SPLIT_BOTTOMLEFT ); SetPosX( SC_SPLIT_LEFT, nCol1 ); SetPosY( SC_SPLIT_BOTTOM, nRow1 ); for (nCol=nCol1; nCol<=nCol2; nCol++) { nTSize = mrDoc.GetColWidth(nCol, CurrentTabForData()); if (nTSize) { nSizePix = ToPixel( nTSize, nPPTX ); nScrPosX += static_cast(nSizePix); } } for (nRow=nRow1; nRow<=nRow2; nRow++) { nTSize = mrDoc.GetRowHeight(nRow, CurrentTabForData()); if (nTSize) { nSizePix = ToPixel( nTSize, nPPTY ); nScrPosY += static_cast(nSizePix); } } aScrSize = Size( nScrPosX, nScrPosY ); } void ScViewData::SetScreenPos( const Point& rVisAreaStart ) { tools::Long nSize; tools::Long nTwips; tools::Long nAdd; bool bEnd; nSize = 0; nTwips = o3tl::convert(rVisAreaStart.X(), o3tl::Length::mm100, o3tl::Length::twip); if (mrDoc.IsLayoutRTL(CurrentTabForData())) nTwips = -nTwips; SCCOL nX1 = 0; bEnd = false; while (!bEnd) { nAdd = static_cast(mrDoc.GetColWidth(nX1, CurrentTabForData())); if (nSize + nAdd <= nTwips + 1 && nX1 < mrDoc.MaxCol()) { nSize += nAdd; ++nX1; } else bEnd = true; } nSize = 0; nTwips = o3tl::convert(rVisAreaStart.Y(), o3tl::Length::mm100, o3tl::Length::twip); SCROW nY1 = 0; bEnd = false; while (!bEnd) { nAdd = static_cast(mrDoc.GetRowHeight(nY1, CurrentTabForData())); if (nSize + nAdd <= nTwips + 1 && nY1 < mrDoc.MaxRow()) { nSize += nAdd; ++nY1; } else bEnd = true; } SetActivePart( SC_SPLIT_BOTTOMLEFT ); SetPosX( SC_SPLIT_LEFT, nX1 ); SetPosY( SC_SPLIT_BOTTOM, nY1 ); SetCurX( nX1 ); SetCurY( nY1 ); } void ScViewData::SetScreen( const tools::Rectangle& rVisArea ) { SetScreenPos( rVisArea.TopLeft() ); // here without GetOutputFactor(), since it's for the output into a Metafile aScrSize = rVisArea.GetSize(); aScrSize.setWidth(std::round(o3tl::convert( aScrSize.Width(), o3tl::Length::mm100, o3tl::Length::twip) * ScGlobal::nScreenPPTX)); aScrSize.setHeight(std::round(o3tl::convert( aScrSize.Height(), o3tl::Length::mm100, o3tl::Length::twip) * ScGlobal::nScreenPPTY)); } ScDocFunc& ScViewData::GetDocFunc() const { return pDocShell->GetDocFunc(); } SfxBindings& ScViewData::GetBindings() { assert(pView && "GetBindings() without ViewShell"); return pView->GetViewFrame().GetBindings(); } SfxDispatcher& ScViewData::GetDispatcher() { assert(pView && "GetDispatcher() without ViewShell"); return *pView->GetViewFrame().GetDispatcher(); } ScMarkData& ScViewData::GetMarkData() { return maMarkData; } ScMarkData& ScViewData::GetHighlightData() { return maHighlightData; } const ScMarkData& ScViewData::GetMarkData() const { return maMarkData; } weld::Window* ScViewData::GetDialogParent() { assert(pView && "GetDialogParent() without ViewShell"); return pView->GetDialogParent(); } ScGridWindow* ScViewData::GetActiveWin() { assert(pView && "GetActiveWin() without View"); return pView->GetActiveWin(); } const ScGridWindow* ScViewData::GetActiveWin() const { assert(pView && "GetActiveWin() without View"); return pView->GetActiveWin(); } ScDrawView* ScViewData::GetScDrawView() { assert(pView && "GetScDrawView() without View"); return pView->GetScDrawView(); } bool ScViewData::IsMinimized() const { assert(pView && "IsMinimized() without View"); return pView->IsMinimized(); } void ScViewData::UpdateScreenZoom( double fNewX, double fNewY ) { double fOldX = GetZoomX(); double fOldY = GetZoomY(); SetZoom( fNewX, fNewY, false ); double fWidth = GetZoomX(); fWidth *= aScrSize.Width(); fWidth /= fOldX; double fHeight = GetZoomY(); fHeight *= aScrSize.Height(); fHeight /= fOldY; aScrSize.setWidth( static_cast(fWidth) ); aScrSize.setHeight( static_cast(fHeight) ); } void ScViewData::CalcPPT() { double nOldPPTX = nPPTX; double nOldPPTY = nPPTY; nPPTX = ScGlobal::nScreenPPTX * GetZoomX(); if (pDocShell) nPPTX = nPPTX / pDocShell->GetOutputFactor(); // Factor is printer to screen nPPTY = ScGlobal::nScreenPPTY * GetZoomY(); // if detective objects are present, // try to adjust horizontal scale so the most common column width has minimal rounding errors, // to avoid differences between cell and drawing layer output SCTAB nCurrentTab = CurrentTabForData(); if (mrDoc.HasDetectiveObjects(nCurrentTab)) { SCCOL nEndCol = 0; SCROW nDummy = 0; mrDoc.GetTableArea(nCurrentTab, nEndCol, nDummy); if (nEndCol<20) nEndCol = 20; // same end position as when determining draw scale sal_uInt16 nTwips = mrDoc.GetCommonWidth(nEndCol, nCurrentTab); if (nTwips) { double fOriginal = nTwips * nPPTX; if ( fOriginal < static_cast(nEndCol) ) { // if one column is smaller than the column count, // rounding errors are likely to add up to a whole column. double fRounded = ::rtl::math::approxFloor( fOriginal + 0.5 ); if ( fRounded > 0.0 ) { double fScale = fRounded / fOriginal + 1E-6; if ( fScale >= 0.9 && fScale <= 1.1 ) nPPTX *= fScale; } } } } if (!comphelper::COKit::isActive()) return; SCTAB nTabCount = maTabData.size(); bool bResetWidths = (nPPTX != nOldPPTX); bool bResetHeights = (nPPTY != nOldPPTY); for (SCTAB nTabIdx = 0; nTabIdx < nTabCount; ++nTabIdx) { if (!maTabData[nTabIdx]) continue; if (bResetWidths) if (auto* pWHelper = GetKitWidthHelper(nTabIdx)) pWHelper->invalidateByPosition(0L); if (bResetHeights) if (auto* pHHelper = GetKitHeightHelper(nTabIdx)) pHHelper->invalidateByPosition(0L); } } #define SC_OLD_TABSEP '/' #define SC_NEW_TABSEP '+' void ScViewData::WriteUserData(OUString& rData) { // nZoom (until 364v) or nZoom/nPageZoom/bPageMode (from 364w) // nTab // Tab control width // per sheet: // CursorX/CursorY/HSplitMode/VSplitMode/HSplitPos/VSplitPos/SplitActive/ // PosX[left]/PosX[right]/PosY[top]/PosY[bottom] // when rows bigger than 8192, "+" instead of "/" sal_uInt16 nZoom = static_cast(tools::Long(pThisTab->fZoomY * 100)); rData = OUString::number( nZoom ) + "/"; nZoom = static_cast(tools::Long(pThisTab->fPageZoomY * 100)); rData += OUString::number( nZoom ) + "/"; if (bPagebreak) rData += "1"; else rData += "0"; rData += ";" + OUString::number(GetTabNumber()) + ";" + TAG_TABBARWIDTH + OUString::number( pView->GetTabBarWidth() ); SCTAB nTabCount = mrDoc.GetTableCount(); for (SCTAB i=0; i(maTabData.size()) && maTabData[i]) { OUString cTabSep(SC_OLD_TABSEP); // like 3.1 if ( maTabData[i]->nCurY > MAXROW_30 || maTabData[i]->nPosY[0] > MAXROW_30 || maTabData[i]->nPosY[1] > MAXROW_30 || ( maTabData[i]->eVSplitMode == SC_SPLIT_FIX && maTabData[i]->nFixPosY > MAXROW_30 ) ) { cTabSep = OUStringChar(SC_NEW_TABSEP); // in order to not kill a 3.1-version } rData += OUString::number( maTabData[i]->nCurX ) + cTabSep + OUString::number( maTabData[i]->nCurY ) + cTabSep + OUString::number( maTabData[i]->eHSplitMode ) + cTabSep + OUString::number( maTabData[i]->eVSplitMode ) + cTabSep; if ( maTabData[i]->eHSplitMode == SC_SPLIT_FIX ) rData += OUString::number( maTabData[i]->nFixPosX ); else rData += OUString::number( maTabData[i]->nHSplitPos ); rData += cTabSep; if ( maTabData[i]->eVSplitMode == SC_SPLIT_FIX ) rData += OUString::number( maTabData[i]->nFixPosY ); else rData += OUString::number( maTabData[i]->nVSplitPos ); rData += cTabSep + OUString::number( maTabData[i]->eWhichActive ) + cTabSep + OUString::number( maTabData[i]->nPosX[0] ) + cTabSep + OUString::number( maTabData[i]->nPosX[1] ) + cTabSep + OUString::number( maTabData[i]->nPosY[0] ) + cTabSep + OUString::number( maTabData[i]->nPosY[1] ); } } } void ScViewData::ReadUserData(std::u16string_view rData) { if (rData.empty()) // empty string on "reload" return; // then exit without assertion if ( comphelper::string::getTokenCount(rData, ';') <= 2 ) { // when reload, in page preview, the preview UserData may have been left intact. // we don't want the zoom from the page preview here. OSL_FAIL("ReadUserData: This is not my data"); return; } sal_Int32 nMainIdx {0}; sal_Int32 nIdx {0}; std::u16string_view aZoomStr = o3tl::getToken(rData, 0, ';', nMainIdx); // Zoom/PageZoom/Mode sal_Unicode cMode = o3tl::getToken(aZoomStr, 2, '/', nIdx)[0]; // 0 or "0"/"1" SetPagebreakMode( cMode == '1' ); // SetPagebreakMode must always be called due to CalcPPT / RecalcPixPos() // sheet may have become invalid (for instance last version): SCTAB nNewTab = static_cast(o3tl::toUInt32(o3tl::getToken(rData, 0, ';', nMainIdx))); if (mrDoc.HasTable(nNewTab)) SetTabNo(nNewTab); // if available, get tab bar width: const sal_Int32 nMainIdxRef {nMainIdx}; std::u16string_view aTabOpt = o3tl::getToken(rData, 0, ';', nMainIdx); std::u16string_view aRest; if (o3tl::starts_with(aTabOpt, TAG_TABBARWIDTH, &aRest)) { pView->SetTabBarWidth(o3tl::toInt32(aRest)); } else { // Tab bar width not specified, token to be processed again nMainIdx = nMainIdxRef; } // per sheet SCTAB nPos = 0; while ( nMainIdx>0 ) { aTabOpt = o3tl::getToken(rData, 0, ';', nMainIdx); EnsureTabDataSize(nPos + 1); if (!maTabData[nPos]) maTabData[nPos].reset(new ScViewDataTable(mrDoc)); sal_Unicode cTabSep = 0; if (comphelper::string::getTokenCount(aTabOpt, SC_OLD_TABSEP) >= 11) cTabSep = SC_OLD_TABSEP; else if (comphelper::string::getTokenCount(aTabOpt, SC_NEW_TABSEP) >= 11) cTabSep = SC_NEW_TABSEP; // '+' is only allowed, if we can deal with rows > 8192 if (cTabSep) { nIdx = 0; maTabData[nPos]->nCurX = mrDoc.SanitizeCol(static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx)))); maTabData[nPos]->nCurY = mrDoc.SanitizeRow(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); maTabData[nPos]->eHSplitMode = static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); maTabData[nPos]->eVSplitMode = static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); sal_Int32 nTmp = o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx)); if ( maTabData[nPos]->eHSplitMode == SC_SPLIT_FIX ) { maTabData[nPos]->nFixPosX = mrDoc.SanitizeCol(static_cast(nTmp)); UpdateFixX(nPos); } else maTabData[nPos]->nHSplitPos = nTmp; nTmp = o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx)); if ( maTabData[nPos]->eVSplitMode == SC_SPLIT_FIX ) { maTabData[nPos]->nFixPosY = mrDoc.SanitizeRow(nTmp); UpdateFixY(nPos); } else maTabData[nPos]->nVSplitPos = nTmp; maTabData[nPos]->eWhichActive = static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); maTabData[nPos]->nPosX[0] = mrDoc.SanitizeCol(static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx)))); maTabData[nPos]->nPosX[1] = mrDoc.SanitizeCol(static_cast(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx)))); maTabData[nPos]->nPosY[0] = mrDoc.SanitizeRow(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); maTabData[nPos]->nPosY[1] = mrDoc.SanitizeRow(o3tl::toInt32(o3tl::getToken(aTabOpt, 0, cTabSep, nIdx))); maTabData[nPos]->eWhichActive = maTabData[nPos]->SanitizeWhichActive(); } ++nPos; } RecalcPixPos(); } void ScViewData::WriteExtOptions( ScExtDocOptions& rDocOpt ) const { // *** Fill extended document data for export filters *** // document settings ScExtDocSettings& rDocSett = rDocOpt.GetDocSettings(); // displayed sheet rDocSett.mnDisplTab = GetTabNumber(); // width of the tabbar, relative to frame window width rDocSett.mfTabBarWidth = pView->GetPendingRelTabBarWidth(); if( rDocSett.mfTabBarWidth < 0.0 ) rDocSett.mfTabBarWidth = ScTabView::GetRelTabBarWidth(); bool bLOKActive = comphelper::COKit::isActive(); // sheet settings for( SCTAB nTab = 0; nTab < static_cast(maTabData.size()); ++nTab ) { if( const ScViewDataTable* pViewTab = maTabData[ nTab ].get() ) { ScExtTabSettings& rTabSett = rDocOpt.GetOrCreateTabSettings( nTab ); // split mode ScSplitMode eExHSplit = pViewTab->eHSplitMode; ScSplitMode eExVSplit = pViewTab->eVSplitMode; SCCOL nExFixPosX = pViewTab->nFixPosX; SCROW nExFixPosY = pViewTab->nFixPosY; tools::Long nExHSplitPos = pViewTab->nHSplitPos; tools::Long nExVSplitPos = pViewTab->nVSplitPos; if (bLOKActive) { OverrideWithKitFreeze(eExHSplit, eExVSplit, nExFixPosX, nExFixPosY, nExHSplitPos, nExVSplitPos, nTab); } bool bHSplit = eExHSplit != SC_SPLIT_NONE; bool bVSplit = eExVSplit != SC_SPLIT_NONE; bool bRealSplit = (eExHSplit == SC_SPLIT_NORMAL) || (eExVSplit == SC_SPLIT_NORMAL); bool bFrozen = (eExHSplit == SC_SPLIT_FIX) || (eExVSplit == SC_SPLIT_FIX); OSL_ENSURE( !bRealSplit || !bFrozen, "ScViewData::WriteExtOptions - split and freeze in same sheet" ); rTabSett.mbFrozenPanes = !bRealSplit && bFrozen; // split and freeze position rTabSett.maSplitPos = Point( 0, 0 ); rTabSett.maFreezePos.Set( 0, 0, nTab ); if( bRealSplit ) { Point& rSplitPos = rTabSett.maSplitPos; rSplitPos = Point( bHSplit ? nExHSplitPos : 0, bVSplit ? nExVSplitPos : 0 ); rSplitPos = Application::GetDefaultDevice()->PixelToLogic( rSplitPos, MapMode( MapUnit::MapTwip ) ); if ( pDocShell ) rSplitPos.setX( static_cast(static_cast(rSplitPos.X()) / pDocShell->GetOutputFactor()) ); } else if( bFrozen ) { if( bHSplit ) rTabSett.maFreezePos.SetCol( nExFixPosX ); if( bVSplit ) rTabSett.maFreezePos.SetRow( nExFixPosY ); } // first visible cell in top-left and additional panes rTabSett.maFirstVis.Set( pViewTab->nPosX[ SC_SPLIT_LEFT ], pViewTab->nPosY[ bVSplit ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM ], nTab ); rTabSett.maSecondVis.Set( pViewTab->nPosX[ SC_SPLIT_RIGHT ], pViewTab->nPosY[ SC_SPLIT_BOTTOM ], nTab ); // In the LOK freeze model the frozen (top-left) pane is // anchored at the sheet corner, independent of the scroll offset // active when freezing. Keeping the old offset here shrinks the // exported xSplit/ySplit and drops the freeze on reload. if( bLOKActive && bFrozen ) { if( bHSplit ) rTabSett.maFirstVis.SetCol( 0 ); if( bVSplit ) rTabSett.maFirstVis.SetRow( 0 ); } // active pane switch( pViewTab->eWhichActive ) { // no horizontal split -> always use left panes // no vertical split -> always use top panes case SC_SPLIT_TOPLEFT: rTabSett.meActivePane = SCEXT_PANE_TOPLEFT; break; case SC_SPLIT_TOPRIGHT: rTabSett.meActivePane = bHSplit ? SCEXT_PANE_TOPRIGHT : SCEXT_PANE_TOPLEFT; break; case SC_SPLIT_BOTTOMLEFT: rTabSett.meActivePane = bVSplit ? SCEXT_PANE_BOTTOMLEFT : SCEXT_PANE_TOPLEFT; break; case SC_SPLIT_BOTTOMRIGHT: rTabSett.meActivePane = bHSplit ? (bVSplit ? SCEXT_PANE_BOTTOMRIGHT : SCEXT_PANE_TOPRIGHT) : (bVSplit ? SCEXT_PANE_BOTTOMLEFT : SCEXT_PANE_TOPLEFT); break; } // cursor position rTabSett.maCursor.Set( pViewTab->nCurX, pViewTab->nCurY, nTab ); // sheet selection and selected ranges const ScMarkData& rMarkData = GetMarkData(); rTabSett.mbSelected = rMarkData.GetTableSelect( nTab ); rMarkData.FillRangeListWithMarks( &rTabSett.maSelection, true ); rTabSett.mbShowGrid = pViewTab->bShowGrid; // view mode and zoom rTabSett.mbPageMode = bPagebreak; rTabSett.mnNormalZoom = static_cast< tools::Long >( pViewTab->fZoomY * 100.0 ); rTabSett.mnPageZoom = static_cast< tools::Long >( pViewTab->fPageZoomY * 100.0 ); rTabSett.moExportZoom = GetExportZoom(); } } } void ScViewData::ReadExtOptions( const ScExtDocOptions& rDocOpt ) { // *** Get extended document data from import filters *** if( !rDocOpt.IsChanged() ) return; // document settings const ScExtDocSettings& rDocSett = rDocOpt.GetDocSettings(); // displayed sheet SetTabNo( rDocSett.mnDisplTab ); /* Width of the tabbar, relative to frame window width. We do not have the correct width of the frame window here -> store in ScTabView, which sets the size in the next resize. */ pView->SetPendingRelTabBarWidth( rDocSett.mfTabBarWidth ); // sheet settings SCTAB nLastTab = rDocOpt.GetLastTab(); if (static_cast(maTabData.size()) <= nLastTab) maTabData.resize(nLastTab+1); for( SCTAB nTab = 0; nTab < static_cast(maTabData.size()); ++nTab ) { if( const ScExtTabSettings* pTabSett = rDocOpt.GetTabSettings( nTab ) ) { if( !maTabData[ nTab ] ) maTabData[nTab].reset(new ScViewDataTable(mrDoc)); const ScExtTabSettings& rTabSett = *pTabSett; ScViewDataTable& rViewTab = *maTabData[ nTab ]; // split mode initialization bool bFrozen = rTabSett.mbFrozenPanes; bool bHSplit = bFrozen ? (rTabSett.maFreezePos.Col() > 0) : (rTabSett.maSplitPos.X() > 0); bool bVSplit = bFrozen ? (rTabSett.maFreezePos.Row() > 0) : (rTabSett.maSplitPos.Y() > 0); // first visible cell of top-left pane and additional panes if (rTabSett.maFirstVis.IsValid()) { rViewTab.nPosX[ SC_SPLIT_LEFT ] = rTabSett.maFirstVis.Col(); rViewTab.nPosY[ bVSplit ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM ] = rTabSett.maFirstVis.Row(); } if (rTabSett.maSecondVis.IsValid()) { if (bHSplit) rViewTab.nPosX[ SC_SPLIT_RIGHT ] = rTabSett.maSecondVis.Col(); if (bVSplit) rViewTab.nPosY[ SC_SPLIT_BOTTOM ] = rTabSett.maSecondVis.Row(); } // split mode, split and freeze position rViewTab.eHSplitMode = rViewTab.eVSplitMode = SC_SPLIT_NONE; rViewTab.nHSplitPos = rViewTab.nVSplitPos = 0; rViewTab.nFixPosX = 0; rViewTab.nFixPosY = 0; if( bFrozen ) { if( bHSplit ) { rViewTab.eHSplitMode = SC_SPLIT_FIX; rViewTab.nFixPosX = rTabSett.maFreezePos.Col(); UpdateFixX( nTab ); } if( bVSplit ) { rViewTab.eVSplitMode = SC_SPLIT_FIX; rViewTab.nFixPosY = rTabSett.maFreezePos.Row(); UpdateFixY( nTab ); } } else { Point aPixel = Application::GetDefaultDevice()->LogicToPixel( rTabSett.maSplitPos, MapMode( MapUnit::MapTwip ) ); //! Zoom? // the test for use of printer metrics for text formatting here // effectively results in the nFactor = 1.0 regardless of the Option setting. if (pDocShell && ScModule::get()->GetInputOptions().GetTextWysiwyg()) { double nFactor = pDocShell->GetOutputFactor(); aPixel.setX( static_cast( aPixel.X() * nFactor + 0.5 ) ); } bHSplit = bHSplit && aPixel.X() > 0; bVSplit = bVSplit && aPixel.Y() > 0; if( bHSplit ) { rViewTab.eHSplitMode = SC_SPLIT_NORMAL; rViewTab.nHSplitPos = aPixel.X(); } if( bVSplit ) { rViewTab.eVSplitMode = SC_SPLIT_NORMAL; rViewTab.nVSplitPos = aPixel.Y(); } } // active pane ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT; switch( rTabSett.meActivePane ) { // no horizontal split -> always use left panes // no vertical split -> always use *bottom* panes case SCEXT_PANE_TOPLEFT: ePos = bVSplit ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT; break; case SCEXT_PANE_TOPRIGHT: ePos = bHSplit ? (bVSplit ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT) : (bVSplit ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT); break; case SCEXT_PANE_BOTTOMLEFT: ePos = SC_SPLIT_BOTTOMLEFT; break; case SCEXT_PANE_BOTTOMRIGHT: ePos = bHSplit ? SC_SPLIT_BOTTOMRIGHT : SC_SPLIT_BOTTOMLEFT; break; } rViewTab.eWhichActive = ePos; // cursor position const ScAddress& rCursor = rTabSett.maCursor; if( rCursor.IsValid() ) { rViewTab.nCurX = rCursor.Col(); rViewTab.nCurY = rCursor.Row(); } // sheet selection and selected ranges ScMarkData& rMarkData = GetMarkData(); rMarkData.SelectTable( nTab, rTabSett.mbSelected ); // zoom for each sheet if( rTabSett.mnNormalZoom ) rViewTab.fZoomX = rViewTab.fZoomY = double(rTabSett.mnNormalZoom) / 100; if( rTabSett.mnPageZoom ) rViewTab.fPageZoomX = rViewTab.fPageZoomY = double(rTabSett.mnPageZoom) / 100; rViewTab.bShowGrid = rTabSett.mbShowGrid; // get some settings from displayed Excel sheet, set at Calc document if( nTab == CurrentTabForData() ) { // view mode and default zoom (for new sheets) from current sheet if( rTabSett.mnNormalZoom ) fDefZoomX = fDefZoomY = double(rTabSett.mnNormalZoom) / 100; if( rTabSett.mnPageZoom ) fDefPageZoomX = fDefPageZoomY = double(rTabSett.mnPageZoom) / 100; /* #i46820# set pagebreak mode via SetPagebreakMode(), this will update map modes that are needed to draw text correctly. */ SetPagebreakMode( rTabSett.mbPageMode ); } } } if (comphelper::COKit::isActive()) DeriveKitFreezeAllSheets(); // RecalcPixPos or so - also nMPos - also for ReadUserData ??!?! } void ScViewData::WriteUserDataSequence(cpo::uno::Sequence & rSettings) const { rSettings.realloc(SC_VIEWSETTINGS_COUNT); // + 1, because we have to put the view id in the sequence beans::PropertyValue* pSettings = rSettings.getArray(); sal_uInt16 nViewID(pView->GetViewFrame().GetCurViewId()); pSettings[SC_VIEW_ID].Name = SC_VIEWID; pSettings[SC_VIEW_ID].Value <<= SC_VIEW + OUString::number(nViewID); uno::Reference xNameContainer = document::NamedPropertyValues::create( comphelper::getProcessComponentContext() ); for (SCTAB nTab=0; nTab(maTabData.size()); nTab++) { if (maTabData[nTab]) { cpo::uno::Sequence aTableViewSettings; maTabData[nTab]->WriteUserDataSequence(aTableViewSettings, *this, nTab); OUString sTabName; GetDocument().GetName( nTab, sTabName ); try { xNameContainer->insertByName(sTabName, cpo::uno::Any(aTableViewSettings)); } //#101739#; two tables with the same name are possible catch ( container::ElementExistException& ) { OSL_FAIL("seems there are two tables with the same name"); } catch ( uno::RuntimeException& ) { OSL_FAIL("something went wrong"); } } } pSettings[SC_TABLE_VIEWSETTINGS].Name = SC_TABLES; pSettings[SC_TABLE_VIEWSETTINGS].Value <<= xNameContainer; OUString sName; GetDocument().GetName(GetTabNumber(), sName); // tdf#150317 - sync visible tab (later used for, e.g., thumbnail generation) GetDocument().SetVisibleTab(GetTabNumber()); pSettings[SC_ACTIVE_TABLE].Name = SC_ACTIVETABLE; pSettings[SC_ACTIVE_TABLE].Value <<= sName; pSettings[SC_HORIZONTAL_SCROLL_BAR_WIDTH].Name = SC_HORIZONTALSCROLLBARWIDTH; pSettings[SC_HORIZONTAL_SCROLL_BAR_WIDTH].Value <<= sal_Int32(pView->GetTabBarWidth()); sal_Int32 nZoomValue = tools::Long(pThisTab->fZoomY * 100); sal_Int32 nPageZoomValue = tools::Long(pThisTab->fPageZoomY * 100); pSettings[SC_ZOOM_TYPE].Name = SC_ZOOMTYPE; pSettings[SC_ZOOM_TYPE].Value <<= sal_Int16(pThisTab->eZoomType); if (oExportZoom && comphelper::IsContextFlagActive(u"IsKitExport"_ustr)) nZoomValue = *oExportZoom; pSettings[SC_ZOOM_VALUE].Name = SC_ZOOMVALUE; pSettings[SC_ZOOM_VALUE].Value <<= nZoomValue; pSettings[SC_PAGE_VIEW_ZOOM_VALUE].Name = SC_PAGEVIEWZOOMVALUE; pSettings[SC_PAGE_VIEW_ZOOM_VALUE].Value <<= nPageZoomValue; pSettings[SC_PAGE_BREAK_PREVIEW].Name = SC_SHOWPAGEBREAKPREVIEW; pSettings[SC_PAGE_BREAK_PREVIEW].Value <<= bPagebreak; pSettings[SC_SHOWZERO].Name = SC_UNO_SHOWZERO; pSettings[SC_SHOWZERO].Value <<= maOptions.GetOption(sc::ViewOption::NULLVALS); pSettings[SC_SHOWNOTES].Name = SC_UNO_SHOWNOTES; pSettings[SC_SHOWNOTES].Value <<= maOptions.GetOption(sc::ViewOption::NOTES); pSettings[SC_SHOWNOTEAUTHOR].Name = SC_UNO_SHOWNOTEAUTHOR; pSettings[SC_SHOWNOTEAUTHOR].Value <<= maOptions.GetOption(sc::ViewOption::NOTEAUTHOR); pSettings[SC_SHOWFORMULASMARKS].Name = SC_UNO_SHOWFORMULASMARKS; pSettings[SC_SHOWFORMULASMARKS].Value <<= maOptions.GetOption(sc::ViewOption::FORMULAS_MARKS); pSettings[SC_SHOWGRID].Name = SC_UNO_SHOWGRID; pSettings[SC_SHOWGRID].Value <<= maOptions.GetOption(sc::ViewOption::GRID); pSettings[SC_GRIDCOLOR].Name = SC_UNO_GRIDCOLOR; OUString aColorName; Color aColor = maOptions.GetGridColor(&aColorName); pSettings[SC_GRIDCOLOR].Value <<= aColor; pSettings[SC_SHOWPAGEBR].Name = SC_UNO_SHOWPAGEBR; pSettings[SC_SHOWPAGEBR].Value <<= maOptions.GetOption(sc::ViewOption::PAGEBREAKS); pSettings[SC_COLROWHDR].Name = SC_UNO_COLROWHDR; pSettings[SC_COLROWHDR].Value <<= maOptions.GetOption(sc::ViewOption::HEADER); pSettings[SC_SHEETTABS].Name = SC_UNO_SHEETTABS; pSettings[SC_SHEETTABS].Value <<= maOptions.GetOption(sc::ViewOption::TABCONTROLS); pSettings[SC_OUTLSYMB].Name = SC_UNO_OUTLSYMB; pSettings[SC_OUTLSYMB].Value <<= maOptions.GetOption(sc::ViewOption::OUTLINER); pSettings[SC_VALUE_HIGHLIGHTING].Name = SC_UNO_VALUEHIGH; pSettings[SC_VALUE_HIGHLIGHTING].Value <<= maOptions.GetOption(sc::ViewOption::SYNTAX); pSettings[SC_FORMULA_BAR_HEIGHT].Name = SC_FORMULABARHEIGHT; pSettings[SC_FORMULA_BAR_HEIGHT].Value <<= GetFormulaBarLines();; const ScGridOptions& aGridOpt = maOptions.GetGridOptions(); pSettings[SC_SNAPTORASTER].Name = SC_UNO_SNAPTORASTER; pSettings[SC_SNAPTORASTER].Value <<= aGridOpt.GetUseGridSnap(); pSettings[SC_RASTERVIS].Name = SC_UNO_RASTERVIS; pSettings[SC_RASTERVIS].Value <<= aGridOpt.GetGridVisible(); pSettings[SC_RASTERRESX].Name = SC_UNO_RASTERRESX; pSettings[SC_RASTERRESX].Value <<= static_cast(aGridOpt.GetFieldDrawX()); pSettings[SC_RASTERRESY].Name = SC_UNO_RASTERRESY; pSettings[SC_RASTERRESY].Value <<= static_cast(aGridOpt.GetFieldDrawY()); pSettings[SC_RASTERSUBX].Name = SC_UNO_RASTERSUBX; pSettings[SC_RASTERSUBX].Value <<= static_cast(aGridOpt.GetFieldDivisionX()); pSettings[SC_RASTERSUBY].Name = SC_UNO_RASTERSUBY; pSettings[SC_RASTERSUBY].Value <<= static_cast(aGridOpt.GetFieldDivisionY()); pSettings[SC_RASTERSYNC].Name = SC_UNO_RASTERSYNC; pSettings[SC_RASTERSYNC].Value <<= aGridOpt.GetSynchronize(); pSettings[SC_WINDOW_STATE].Name = SC_WINDOWSTATE; pSettings[SC_WINDOW_STATE].Value <<= ::framework::WindowStateHelper::GetFromWindow( pView->GetWindow() ); // Common SdrModel processing GetDocument().GetDrawLayer()->WriteUserDataSequence(rSettings); } void ScViewData::ReadUserDataSequence(const cpo::uno::Sequence & rSettings) { std::vector aHasZoomVect( GetDocument().GetTableCount(), false ); sal_Int32 nTemp32(0); sal_Int16 nTemp16(0); sal_Int16 nFormulaBarLineCount(0); bool bPageMode(false); EnsureTabDataSize(GetDocument().GetTableCount()); for (const auto& rSetting : rSettings) { // SC_VIEWID has to parse and use by mba OUString sName(rSetting.Name); if (sName == SC_TABLES) { uno::Reference xNameContainer; if ((rSetting.Value >>= xNameContainer) && xNameContainer->hasElements()) { const cpo::uno::Sequence< OUString > aNames(xNameContainer->getElementNames()); for (const OUString& sTabName : aNames) { SCTAB nTab(0); if (GetDocument().GetTable(sTabName, nTab)) { cpo::uno::Any aAny = xNameContainer->getByName(sTabName); cpo::uno::Sequence aTabSettings; if (aAny >>= aTabSettings) { EnsureTabDataSize(nTab + 1); if (!maTabData[nTab]) maTabData[nTab].reset(new ScViewDataTable(mrDoc)); bool bHasZoom = false; maTabData[nTab]->ReadUserDataSequence(aTabSettings, *this, nTab, bHasZoom); aHasZoomVect[nTab] = bHasZoom; } } } } } else if (sName == SC_ACTIVETABLE) { OUString sTabName; if(rSetting.Value >>= sTabName) { SCTAB nTab(0); if (GetDocument().GetTable(sTabName, nTab)) { // When opening a new window we shouldn't see a sheet view mnTabNumber = GetDocument().GetDefaultViewTableNumber(nTab); } } } else if (sName == SC_HORIZONTALSCROLLBARWIDTH) { if (rSetting.Value >>= nTemp32) pView->SetTabBarWidth(nTemp32); } else if (sName == SC_RELHORIZONTALTABBARWIDTH) { double fWidth = 0.0; if (rSetting.Value >>= fWidth) pView->SetPendingRelTabBarWidth( fWidth ); } else if (sName == SC_ZOOMTYPE) { if (rSetting.Value >>= nTemp16) eDefZoomType = SvxZoomType(nTemp16); } else if (sName == SC_ZOOMVALUE) { if (rSetting.Value >>= nTemp32) { double fZoom = double(nTemp32) / 100; fDefZoomX = fDefZoomY = fZoom; } } else if (sName == SC_PAGEVIEWZOOMVALUE) { if (rSetting.Value >>= nTemp32) { double fZoom = double(nTemp32) / 100; fDefPageZoomX = fDefPageZoomY = fZoom; } } else if (sName == SC_FORMULABARHEIGHT) { if (rSetting.Value >>= nFormulaBarLineCount) { SetFormulaBarLines(nFormulaBarLineCount); // Notify formula bar about changed lines ScInputHandler* pInputHdl = ScModule::get()->GetInputHdl(); if (pInputHdl) { ScInputWindow* pInputWin = pInputHdl->GetInputWindow(); if (pInputWin) pInputWin->NumLinesChanged(); } } } else if (sName == SC_SHOWPAGEBREAKPREVIEW) bPageMode = ScUnoHelpFunctions::GetBoolFromAny( rSetting.Value ); else if ( sName == SC_UNO_SHOWZERO ) maOptions.SetOption(sc::ViewOption::NULLVALS, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHOWNOTES ) maOptions.SetOption(sc::ViewOption::NOTES, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHOWNOTEAUTHOR ) maOptions.SetOption(sc::ViewOption::NOTEAUTHOR, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHOWFORMULASMARKS ) maOptions.SetOption(sc::ViewOption::FORMULAS_MARKS, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHOWGRID ) maOptions.SetOption(sc::ViewOption::GRID, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_GRIDCOLOR ) { Color aColor; if (rSetting.Value >>= aColor) maOptions.SetGridColor(aColor, OUString()); } else if ( sName == SC_UNO_SHOWPAGEBR ) maOptions.SetOption(sc::ViewOption::PAGEBREAKS, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_COLROWHDR ) maOptions.SetOption(sc::ViewOption::HEADER, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHEETTABS ) maOptions.SetOption(sc::ViewOption::TABCONTROLS, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_OUTLSYMB ) maOptions.SetOption(sc::ViewOption::OUTLINER, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if ( sName == SC_UNO_SHOWOBJ ) { // #i80528# placeholders not supported anymore if ( rSetting.Value >>= nTemp16 ) maOptions.SetObjMode(sc::ViewObjectType::OLE, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW); } else if ( sName == SC_UNO_SHOWCHARTS ) { // #i80528# placeholders not supported anymore if ( rSetting.Value >>= nTemp16 ) maOptions.SetObjMode(sc::ViewObjectType::CHART, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW); } else if ( sName == SC_UNO_SHOWDRAW ) { // #i80528# placeholders not supported anymore if ( rSetting.Value >>= nTemp16 ) maOptions.SetObjMode(sc::ViewObjectType::DRAW, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW); } else if ( sName == SC_UNO_VALUEHIGH && !comphelper::COKit::isActive() ) maOptions.SetOption(sc::ViewOption::SYNTAX, ScUnoHelpFunctions::GetBoolFromAny(rSetting.Value)); else if (sName == SC_WINDOWSTATE) { // ignored } else { ScGridOptions aGridOpt(maOptions.GetGridOptions()); if ( sName == SC_UNO_SNAPTORASTER ) aGridOpt.SetUseGridSnap( ScUnoHelpFunctions::GetBoolFromAny( rSetting.Value ) ); else if ( sName == SC_UNO_RASTERVIS ) aGridOpt.SetGridVisible( ScUnoHelpFunctions::GetBoolFromAny( rSetting.Value ) ); else if ( sName == SC_UNO_RASTERRESX ) aGridOpt.SetFieldDrawX( static_cast ( ScUnoHelpFunctions::GetInt32FromAny( rSetting.Value ) ) ); else if ( sName == SC_UNO_RASTERRESY ) aGridOpt.SetFieldDrawY( static_cast ( ScUnoHelpFunctions::GetInt32FromAny( rSetting.Value ) ) ); else if ( sName == SC_UNO_RASTERSUBX ) aGridOpt.SetFieldDivisionX( static_cast ( ScUnoHelpFunctions::GetInt32FromAny( rSetting.Value ) ) ); else if ( sName == SC_UNO_RASTERSUBY ) aGridOpt.SetFieldDivisionY( static_cast ( ScUnoHelpFunctions::GetInt32FromAny( rSetting.Value ) ) ); else if ( sName == SC_UNO_RASTERSYNC ) aGridOpt.SetSynchronize( ScUnoHelpFunctions::GetBoolFromAny( rSetting.Value ) ); // Fallback to common SdrModel processing else GetDocument().GetDrawLayer()->ReadUserDataSequenceValue(&rSetting); maOptions.SetGridOptions(aGridOpt); } } // copy default zoom to sheets where a different one wasn't specified for (SCTAB nZoomTab=0; nZoomTab< static_cast(maTabData.size()); ++nZoomTab) if (maTabData[nZoomTab] && ( nZoomTab >= static_cast(aHasZoomVect.size()) || !aHasZoomVect[nZoomTab] )) { maTabData[nZoomTab]->eZoomType = eDefZoomType; maTabData[nZoomTab]->fZoomX = fDefZoomX; maTabData[nZoomTab]->fZoomY = fDefZoomY; maTabData[nZoomTab]->fPageZoomX = fDefPageZoomX; maTabData[nZoomTab]->fPageZoomY = fDefPageZoomY; } if (rSettings.hasElements()) SetPagebreakMode( bPageMode ); // #i47426# write view options to document, needed e.g. for Excel export mrDoc.SetViewOptions(maOptions); if (comphelper::COKit::isActive()) DeriveKitFreezeAllSheets(); } void ScViewData::SetOptions( const ScViewOptions& rOpt ) { // if visibility of horizontal ScrollBar is changed, TabBar may have to be resized... bool bHScrollChanged = (rOpt.GetOption(sc::ViewOption::HSCROLL) != maOptions.GetOption(sc::ViewOption::HSCROLL)); // if graphics are turned on or off, animation has to be started or stopped // graphics are controlled by sc::ViewObjectType::OLE bool bGraphicsChanged = maOptions.GetObjMode(sc::ViewObjectType::OLE) != rOpt.GetObjMode(sc::ViewObjectType::OLE); maOptions = rOpt; OSL_ENSURE( pView, "No View" ); if( pView ) { pView->ViewOptionsHasChanged( bHScrollChanged, bGraphicsChanged ); } } Point ScViewData::GetMousePosPixel() { OSL_ENSURE( pView, "GetMousePosPixel() without View" ); return pView->GetMousePosPixel(); } void ScViewData::UpdateInputHandler( bool bForce ) { if (pView) pView->UpdateInputHandler(bForce); } bool ScViewData::IsOle() const { return pDocShell && pDocShell->IsOle(); } bool ScViewData::UpdateFixX( SCTAB nTab ) // true = value changed { if (!ValidTab(nTab)) // Default nTab = GetTabNumber(); // current table if (!pView || maTabData[nTab]->eHSplitMode != SC_SPLIT_FIX) return false; ScDocument& rLocalDoc = GetDocument(); if (!rLocalDoc.HasTable(nTab)) // if called from reload, the sheet may not exist return false; SCCOL nFix = maTabData[nTab]->nFixPosX; tools::Long nNewPos = 0; for (SCCOL nX=maTabData[nTab]->nPosX[SC_SPLIT_LEFT]; nXGetGridOffset().X(); if (nNewPos != maTabData[nTab]->nHSplitPos) { maTabData[nTab]->nHSplitPos = nNewPos; if (nTab == GetTabNumber()) RecalcPixPos(); // should not be needed return true; } return false; } bool ScViewData::UpdateFixY( SCTAB nTab ) // true = value changed { if (!ValidTab(nTab)) // Default nTab = GetTabNumber(); // current table if (!pView || maTabData[nTab]->eVSplitMode != SC_SPLIT_FIX) return false; ScDocument& rLocalDoc = GetDocument(); if (!rLocalDoc.HasTable(nTab)) // if called from reload, the sheet may not exist return false; SCROW nFix = maTabData[nTab]->nFixPosY; tools::Long nNewPos = 0; for (SCROW nY=maTabData[nTab]->nPosY[SC_SPLIT_TOP]; nYGetGridOffset().Y(); if (nNewPos != maTabData[nTab]->nVSplitPos) { maTabData[nTab]->nVSplitPos = nNewPos; if (nTab == GetTabNumber()) RecalcPixPos(); // should not be needed return true; } return false; } void ScViewData::UpdateOutlinerFlags( Outliner& rOutl ) const { ScDocument& rLocalDoc = GetDocument(); const ScTabViewShell* pTabViewShell = GetViewShell(); const bool bOnlineSpell = pTabViewShell && pTabViewShell->IsAutoSpell(); EEControlBits nCntrl = rOutl.GetControlWord(); nCntrl |= EEControlBits::MARKNONURLFIELDS; nCntrl &= ~EEControlBits::MARKURLFIELDS; // URLs not shaded for output nCntrl |= EEControlBits::AUTOCORRECT; if( bOnlineSpell ) nCntrl |= EEControlBits::ONLINESPELLING; else nCntrl &= ~EEControlBits::ONLINESPELLING; rOutl.SetControlWord(nCntrl); rOutl.SetCalcFieldValueHdl(LINK(ScModule::get(), ScModule, CalcFieldValueHdl)); // don't call GetSpellChecker if online spelling isn't enabled. // The language for AutoCorrect etc. is taken from the pool defaults // (set in ScDocument::UpdateDrawLanguages) if ( bOnlineSpell ) { css::uno::Reference xXSpellChecker1( LinguMgr::GetSpellChecker() ); rOutl.SetSpeller( xXSpellChecker1 ); } rOutl.SetDefaultHorizontalTextDirection(rLocalDoc.GetEditTextDirection(CurrentTabForData())); } ScAddress ScViewData::GetCurPos() const { return ScAddress( GetCurX(), GetCurY(), CurrentTabForData() ); } void ScViewData::SetRefStart( SCCOL nNewX, SCROW nNewY, SCTAB nNewZ ) { nRefStartX = nNewX; nRefStartY = nNewY; nRefStartZ = nNewZ; } void ScViewData::SetRefEnd( SCCOL nNewX, SCROW nNewY, SCTAB nNewZ ) { nRefEndX = nNewX; nRefEndY = nNewY; nRefEndZ = nNewZ; } void ScViewData::AddPixelsWhile( tools::Long & rScrY, tools::Long nEndPixels, SCROW & rPosY, SCROW nEndRow, double nPPTY, const ScDocument * pDoc, SCTAB nTab) { SCROW nRow = rPosY; while (rScrY <= nEndPixels && nRow <= nEndRow) { SCROW nHeightEndRow; sal_uInt16 nHeight = pDoc->GetRowHeight( nRow, nTab, nullptr, &nHeightEndRow); if (nHeightEndRow > nEndRow) nHeightEndRow = nEndRow; if (!nHeight) { if (ValidTab(nTab) && nTab <= pDoc->GetMaxTableNumber()) nRow = nHeightEndRow + 1; else break; } else { SCROW nRows = nHeightEndRow - nRow + 1; sal_Int64 nPixel = ToPixel( nHeight, nPPTY); sal_Int64 nAdd = nPixel * nRows; if (nAdd + rScrY > nEndPixels) { sal_Int64 nDiff = rScrY + nAdd - nEndPixels; nRows -= static_cast(nDiff / nPixel); nAdd = nPixel * nRows; // We're looking for a value that satisfies loop condition. if (nAdd + rScrY <= nEndPixels) { ++nRows; nAdd += nPixel; } } rScrY += static_cast(nAdd); nRow += nRows; } } if (nRow > rPosY) --nRow; rPosY = nRow; } void ScViewData::AddPixelsWhileBackward( tools::Long & rScrY, tools::Long nEndPixels, SCROW & rPosY, SCROW nStartRow, double nPPTY, const ScDocument * pDoc, SCTAB nTab ) { SCROW nRow = rPosY; while (rScrY <= nEndPixels && nRow >= nStartRow) { SCROW nHeightStartRow; sal_uInt16 nHeight = pDoc->GetRowHeight(nRow, nTab, &nHeightStartRow, nullptr); if (nHeightStartRow < nStartRow) nHeightStartRow = nStartRow; if (!nHeight) nRow = nHeightStartRow - 1; else { SCROW nRows = nRow - nHeightStartRow + 1; sal_Int64 nPixel = ToPixel( nHeight, nPPTY); sal_Int64 nAdd = nPixel * nRows; if (nAdd + rScrY > nEndPixels) { sal_Int64 nDiff = nAdd + rScrY - nEndPixels; nRows -= static_cast(nDiff / nPixel); nAdd = nPixel * nRows; // We're looking for a value that satisfies loop condition. if (nAdd + rScrY <= nEndPixels) { ++nRows; nAdd += nPixel; } } rScrY += static_cast(nAdd); nRow -= nRows; } } if (nRow < rPosY) ++nRow; rPosY = nRow; } SCCOLROW ScViewData::GetKitSheetFreezeIndex(bool bIsCol) const { SCCOLROW nFreezeIndex = bIsCol ? mrDoc.GetKitFreezeCol(CurrentTabForData()) : mrDoc.GetKitFreezeRow(CurrentTabForData()); return nFreezeIndex >= 0 ? nFreezeIndex : 0; } bool ScViewData::SetKitSheetFreezeIndex(const SCCOLROW nFreezeIndex, bool bIsCol, SCTAB nForTab) { if (nForTab == -1) { nForTab = CurrentTabForData(); } else if (!ValidTab(nForTab) || !IsValidTabNumber(nForTab)) { SAL_WARN("sc.viewdata", "ScViewData::SetKitSheetFreezeIndex : invalid nForTab = " << nForTab); return false; } return bIsCol ? mrDoc.SetKitFreezeCol(static_cast(nFreezeIndex), nForTab) : mrDoc.SetKitFreezeRow(static_cast(nFreezeIndex), nForTab); } bool ScViewData::RemoveKitFreeze() { bool colUnfreezed = SetKitSheetFreezeIndex(0, true); bool rowUnfreezed = SetKitSheetFreezeIndex(0, false); return colUnfreezed || rowUnfreezed; } void ScViewData::DeriveKitFreezeAllSheets() { SCTAB nMaxTab = static_cast(maTabData.size()) - 1; for (SCTAB nTab = 0; nTab <= nMaxTab; ++nTab) DeriveKitFreezeIfNeeded(nTab); } void ScViewData::DeriveKitFreezeIfNeeded(SCTAB nForTab) { if (!ValidTab(nForTab) || (nForTab >= static_cast(maTabData.size()))) { SAL_WARN("sc.viewdata", "ScViewData::DeriveKitFreezeIfNeeded : invalid nForTab = " << nForTab); return; } ScViewDataTable* pViewTable = maTabData[nForTab].get(); if (!pViewTable) return; bool bConvertToFreezeX = false; bool bConvertToFreezeY = false; SCCOL nFreezeCol = mrDoc.GetKitFreezeCol(nForTab); SCROW nFreezeRow = mrDoc.GetKitFreezeRow(nForTab); if (nFreezeCol == -1) { ScSplitMode eSplitMode = pViewTable->eHSplitMode; if (eSplitMode == SC_SPLIT_FIX) nFreezeCol = pViewTable->nFixPosX; else if (eSplitMode == SC_SPLIT_NORMAL) bConvertToFreezeX = true; else nFreezeCol = 0; } if (nFreezeRow == -1) { ScSplitMode eSplitMode = pViewTable->eVSplitMode; if (eSplitMode == SC_SPLIT_FIX) nFreezeRow = pViewTable->nFixPosY; else if (eSplitMode == SC_SPLIT_NORMAL) bConvertToFreezeY = true; else nFreezeRow = 0; } if (bConvertToFreezeX || bConvertToFreezeY) { SCCOL nCol; SCROW nRow; GetPosFromPixel(bConvertToFreezeX ? pViewTable->nHSplitPos : 0, bConvertToFreezeY ? pViewTable->nVSplitPos : 0, SC_SPLIT_BOTTOMLEFT, nCol, nRow, false /* bTestMerge */, false /* bRepair */, nForTab); if (bConvertToFreezeX) nFreezeCol = nCol; if (bConvertToFreezeY) nFreezeRow = nRow; } mrDoc.SetKitFreezeCol(nFreezeCol, nForTab); mrDoc.SetKitFreezeRow(nFreezeRow, nForTab); } void ScViewData::OverrideWithKitFreeze(ScSplitMode& eExHSplitMode, ScSplitMode& eExVSplitMode, SCCOL& nExFixPosX, SCROW& nExFixPosY, tools::Long& nExHSplitPos, tools::Long& nExVSplitPos, SCTAB nForTab) const { // split mode to potentially use based on original: if it was split, use split mode to preserve that, otherwise use freeze // whether there is actual split/freeze will depend on GetKitFreezeCol/Row const ScSplitMode aExSplitMode = (eExHSplitMode == SC_SPLIT_NORMAL || eExVSplitMode == SC_SPLIT_NORMAL) ? SC_SPLIT_NORMAL : SC_SPLIT_FIX; // initialize split modes and positions in case no split/freeze is set eExHSplitMode = SC_SPLIT_NONE; eExVSplitMode = SC_SPLIT_NONE; nExFixPosX = 0; nExFixPosY = 0; nExHSplitPos = 0; nExVSplitPos = 0; bool bConvertToScrPosX = false; bool bConvertToScrPosY = false; SCCOL nFreezeCol = mrDoc.GetKitFreezeCol(nForTab); SCROW nFreezeRow = mrDoc.GetKitFreezeRow(nForTab); if (nFreezeCol > 0) { eExHSplitMode = aExSplitMode; if (eExHSplitMode == SC_SPLIT_FIX) { nExFixPosX = nFreezeCol; pThisTab->nPosX[SC_SPLIT_RIGHT] = nFreezeCol; } else bConvertToScrPosX = true; } if (nFreezeRow > 0) { eExVSplitMode = aExSplitMode; if (eExVSplitMode == SC_SPLIT_FIX) { nExFixPosY = nFreezeRow; pThisTab->nPosY[SC_SPLIT_BOTTOM] = nFreezeRow; } else bConvertToScrPosY = true; } if (bConvertToScrPosX || bConvertToScrPosY) { Point aExSplitPos = GetScrPos(nFreezeCol, nFreezeRow, SC_SPLIT_BOTTOMLEFT, true, nForTab); if (bConvertToScrPosX) nExHSplitPos = aExSplitPos.X(); if (bConvertToScrPosY) nExVSplitPos = aExSplitPos.Y(); } } SCTAB ScViewData::CurrentTabForData() const { return GetTabNumber(); } sc::SheetViewID ScViewData::GetSheetViewID() const { return mrDoc.GetTableSheetViewID(GetTabNumber()); } void ScViewData::SetSheetViewID(sc::SheetViewID nID) { if (nID != sc::DefaultSheetViewID) { // Get the default tab (in case we're currently on a sheet view tab) SCTAB nDefaultTab = GetDefaultViewTab(); SCTAB nSheetViewTab = mrDoc.GetSheetViewNumber(nDefaultTab, nID); if (ValidTab(nSheetViewTab)) SetTabNo(nSheetViewTab); } else { // Returning to default view — switch back to the default tab SCTAB nDefaultTab = GetDefaultViewTab(); if (nDefaultTab != GetTabNumber()) SetTabNo(nDefaultTab); } } sc::SheetViewID ScViewData::GetSheetViewIDForSheet(SCTAB nTab) const { return mrDoc.GetTableSheetViewID(nTab); } std::shared_ptr ScViewData::GetCurrentSheetViewManager() const { return GetDocument().GetSheetViewManager(GetDefaultViewTab()); } SCTAB ScViewData::GetDefaultViewTab() const { return mrDoc.GetDefaultViewTableNumber(GetTabNumber()); } SCTAB ScViewData::GetLastSheetViewTab(SCTAB nDefaultTab) const { if (nDefaultTab >= 0 && nDefaultTab < static_cast(maTabData.size()) && maTabData[nDefaultTab] && maTabData[nDefaultTab]->nLastSheetViewTab != sc::DefaultSheetViewID) { return maTabData[nDefaultTab]->nLastSheetViewTab; } return nDefaultTab; } void ScViewData::ClearLastSheetViewTab(SCTAB nDefaultTab) { if (nDefaultTab >= 0 && nDefaultTab < static_cast(maTabData.size()) && maTabData[nDefaultTab]) { maTabData[nDefaultTab]->nLastSheetViewTab = sc::DefaultSheetViewID; } } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */