| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| #include "AccessibleSpreadsheet.hxx" |
| #include "AccessibilityHints.hxx" |
| #include "AccessibleCell.hxx" |
| #include "AccessibleDocument.hxx" |
| #include "tabvwsh.hxx" |
| #include "document.hxx" |
| #include "unoguard.hxx" |
| #include "hints.hxx" |
| #include "scmod.hxx" |
| |
| #ifndef _UTL_ACCESSIBLESTATESETHELPER_HXX |
| #include <unotools/accessiblestatesethelper.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLEROLE_HPP_ |
| #include <com/sun/star/accessibility/AccessibleRole.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLESTATETYPE_HPP_ |
| #include <com/sun/star/accessibility/AccessibleStateType.hpp> |
| #endif |
| #include <com/sun/star/accessibility/AccessibleEventId.hpp> |
| #include <com/sun/star/accessibility/AccessibleTableModelChangeType.hpp> |
| #include <rtl/uuid.h> |
| #include <tools/debug.hxx> |
| #include <tools/gen.hxx> |
| #include <svtools/colorcfg.hxx> |
| #include "scresid.hxx" |
| #include "sc.hrc" |
| #include <algorithm> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::accessibility; |
| |
| bool CompMinCol(const std::pair<sal_uInt16,sal_uInt16> & pc1,const std::pair<sal_uInt16,sal_uInt16> &pc2) |
| { |
| return pc1.first < pc2.first; |
| } |
| ScMyAddress ScAccessibleSpreadsheet::CalcScAddressFromRangeList(ScRangeList *pMarkedRanges,sal_Int32 nSelectedChildIndex) |
| { |
| if (pMarkedRanges->Count() <= 1) |
| { |
| ScRange* pRange = pMarkedRanges->First(); |
| if (pRange) |
| { |
| // MT IA2: Not used. |
| // const int nRowNum = pRange->aEnd.Row() - pRange->aStart.Row() + 1; |
| const int nColNum = pRange->aEnd.Col() - pRange->aStart.Col() + 1; |
| const int nCurCol = nSelectedChildIndex % nColNum; |
| const int nCurRow = (nSelectedChildIndex - nCurCol)/nColNum; |
| return ScMyAddress(static_cast<SCCOL>(pRange->aStart.Col() + nCurCol), pRange->aStart.Row() + nCurRow, maActiveCell.Tab()); |
| } |
| } |
| else |
| { |
| sal_Int32 nMinRow = MAXROW; |
| sal_Int32 nMaxRow = 0; |
| m_vecTempRange.clear(); |
| ScRange* pRange = pMarkedRanges->First(); |
| while (pRange) |
| { |
| if (pRange->aStart.Tab() != pRange->aEnd.Tab()) |
| { |
| if ((maActiveCell.Tab() >= pRange->aStart.Tab()) || |
| maActiveCell.Tab() <= pRange->aEnd.Tab()) |
| { |
| m_vecTempRange.push_back(pRange); |
| nMinRow = std::min(pRange->aStart.Row(),nMinRow); |
| nMaxRow = std::max(pRange->aEnd.Row(),nMaxRow); |
| } |
| else |
| DBG_ERROR("Range of wrong table"); |
| } |
| else if(pRange->aStart.Tab() == maActiveCell.Tab()) |
| { |
| m_vecTempRange.push_back(pRange); |
| nMinRow = std::min(pRange->aStart.Row(),nMinRow); |
| nMaxRow = std::max(pRange->aEnd.Row(),nMaxRow); |
| } |
| else |
| DBG_ERROR("Range of wrong table"); |
| pRange = pMarkedRanges->Next(); |
| } |
| int nCurrentIndex = 0 ; |
| for(sal_Int32 row = nMinRow ; row <= nMaxRow ; ++row) |
| { |
| m_vecTempCol.clear(); |
| { |
| VEC_RANGE::const_iterator vi = m_vecTempRange.begin(); |
| for (; vi < m_vecTempRange.end(); ++vi) |
| { |
| ScRange *p = *vi; |
| if ( row >= p->aStart.Row() && row <= p->aEnd.Row()) |
| { |
| m_vecTempCol.push_back(std::make_pair(p->aStart.Col(),p->aEnd.Col())); |
| } |
| } |
| } |
| std::sort(m_vecTempCol.begin(),m_vecTempCol.end(),CompMinCol); |
| { |
| VEC_COL::const_iterator vic = m_vecTempCol.begin(); |
| for(; vic != m_vecTempCol.end(); ++vic) |
| { |
| const PAIR_COL &pariCol = *vic; |
| sal_uInt16 nCol = pariCol.second - pariCol.first + 1; |
| if (nCol + nCurrentIndex > nSelectedChildIndex) |
| { |
| return ScMyAddress(static_cast<SCCOL>(pariCol.first + nSelectedChildIndex - nCurrentIndex), row, maActiveCell.Tab()); |
| } |
| nCurrentIndex += nCol; |
| } |
| } |
| } |
| } |
| return ScMyAddress(0,0,maActiveCell.Tab()); |
| } |
| sal_Bool ScAccessibleSpreadsheet::CalcScRangeDifferenceMax(ScRange *pSrc,ScRange *pDest,int nMax,VEC_MYADDR &vecRet,int &nSize) |
| { |
| //Src Must be :Src > Dest |
| if (pDest->In(*pSrc)) |
| {//Here is Src In Dest,Src <= Dest |
| return sal_False; |
| } |
| if (!pDest->Intersects(*pSrc)) |
| { |
| int nCellCount = sal_uInt32(pDest->aEnd.Col() - pDest->aStart.Col() + 1) |
| * sal_uInt32(pDest->aEnd.Row() - pDest->aStart.Row() + 1) |
| * sal_uInt32(pDest->aEnd.Tab() - pDest->aStart.Tab() + 1); |
| if (nCellCount + nSize > nMax) |
| { |
| return sal_True; |
| } |
| else if(nCellCount > 0) |
| { |
| nCellCount +=nSize; |
| for (sal_Int32 row = pDest->aStart.Row(); row <= pDest->aEnd.Row();++row) |
| { |
| for (sal_uInt16 col = pDest->aStart.Col(); col <= pDest->aEnd.Col();++col) |
| { |
| vecRet.push_back(ScMyAddress(col,row,pDest->aStart.Tab())); |
| } |
| } |
| } |
| return sal_False; |
| } |
| sal_Int32 nMinRow = pSrc->aStart.Row(); |
| sal_Int32 nMaxRow = pSrc->aEnd.Row(); |
| for (; nMinRow <= nMaxRow ; ++nMinRow,--nMaxRow) |
| { |
| for (sal_uInt16 col = pSrc->aStart.Col(); col <= pSrc->aEnd.Col();++col) |
| { |
| if (nSize > nMax) |
| { |
| return sal_True; |
| } |
| ScMyAddress cell(col,nMinRow,pSrc->aStart.Tab()); |
| if(!pDest->In(cell)) |
| {//In Src ,Not In Dest |
| vecRet.push_back(cell); |
| ++nSize; |
| } |
| } |
| if (nMinRow != nMaxRow) |
| { |
| for (sal_uInt16 col = pSrc->aStart.Col(); col <= pSrc->aEnd.Col();++col) |
| { |
| if (nSize > nMax) |
| { |
| return sal_True; |
| } |
| ScMyAddress cell(col,nMaxRow,pSrc->aStart.Tab()); |
| if(!pDest->In(cell)) |
| {//In Src ,Not In Dest |
| vecRet.push_back(cell); |
| ++nSize; |
| } |
| } |
| } |
| } |
| return sal_False; |
| } |
| //In Src , Not in Dest |
| sal_Bool ScAccessibleSpreadsheet::CalcScRangeListDifferenceMax(ScRangeList *pSrc,ScRangeList *pDest,int nMax,VEC_MYADDR &vecRet) |
| { |
| if (pSrc == NULL || pDest == NULL) |
| { |
| return sal_False; |
| } |
| int nSize =0; |
| if (pDest->GetCellCount() == 0)//if the Dest Rang List is empty |
| { |
| if (pSrc->GetCellCount() > sal_uInt32(nMax))//if the Src Cell count is greater then nMax |
| { |
| return sal_True; |
| } |
| //now the cell count is less then nMax |
| vecRet.reserve(10); |
| ScRange* pRange = pSrc->First(); |
| while (pRange) |
| { |
| for (sal_Int32 row = pRange->aStart.Row(); row <= pRange->aEnd.Row();++row) |
| { |
| for (sal_uInt16 col = pRange->aStart.Col(); col <= pRange->aEnd.Col();++col) |
| { |
| vecRet.push_back(ScMyAddress(col,row,pRange->aStart.Tab())); |
| } |
| } |
| pRange = pSrc->Next(); |
| } |
| return sal_False; |
| } |
| //the Dest Rang List is not empty |
| vecRet.reserve(10); |
| ScRange* pRange = pSrc->First(); |
| while (pRange) |
| { |
| ScRange* pRangeDest = pDest->First(); |
| while (pRangeDest) |
| { |
| if (CalcScRangeDifferenceMax(pRange,pRangeDest,nMax,vecRet,nSize)) |
| { |
| return sal_True; |
| } |
| pRangeDest = pDest->Next(); |
| } |
| pRange = pSrc->Next(); |
| } |
| return sal_False; |
| } |
| //===== internal ============================================================ |
| |
| ScAccessibleSpreadsheet::ScAccessibleSpreadsheet( |
| ScAccessibleDocument* pAccDoc, |
| ScTabViewShell* pViewShell, |
| SCTAB nTab, |
| ScSplitPos eSplitPos) |
| : |
| ScAccessibleTableBase (pAccDoc, GetDocument(pViewShell), |
| ScRange(ScAddress(0, 0, nTab),ScAddress(MAXCOL, MAXROW, nTab))), |
| mbIsSpreadsheet( sal_True ), |
| m_bFormulaMode(sal_False), |
| m_bFormulaLastMode(sal_False), |
| m_pAccFormulaCell(NULL), |
| m_nMinX(0),m_nMaxX(0),m_nMinY(0),m_nMaxY(0) |
| { |
| ConstructScAccessibleSpreadsheet( pAccDoc, pViewShell, nTab, eSplitPos ); |
| } |
| |
| ScAccessibleSpreadsheet::ScAccessibleSpreadsheet( |
| ScAccessibleSpreadsheet& rParent, const ScRange& rRange ) : |
| ScAccessibleTableBase( rParent.mpAccDoc, rParent.mpDoc, rRange), |
| mbIsSpreadsheet( sal_False ) |
| { |
| ConstructScAccessibleSpreadsheet( rParent.mpAccDoc, rParent.mpViewShell, rParent.mnTab, rParent.meSplitPos ); |
| } |
| |
| ScAccessibleSpreadsheet::~ScAccessibleSpreadsheet() |
| { |
| if (mpMarkedRanges) |
| delete mpMarkedRanges; |
| if (mpViewShell) |
| mpViewShell->RemoveAccessibilityObject(*this); |
| } |
| |
| void ScAccessibleSpreadsheet::ConstructScAccessibleSpreadsheet( |
| ScAccessibleDocument* pAccDoc, |
| ScTabViewShell* pViewShell, |
| SCTAB nTab, |
| ScSplitPos eSplitPos) |
| { |
| mpViewShell = pViewShell; |
| mpMarkedRanges = 0; |
| mpSortedMarkedCells = 0; |
| mpAccDoc = pAccDoc; |
| mpAccCell = 0; |
| meSplitPos = eSplitPos; |
| mnTab = nTab; |
| mbHasSelection = sal_False; |
| mbDelIns = sal_False; |
| mbIsFocusSend = sal_False; |
| maVisCells = GetVisCells(GetVisArea(mpViewShell, meSplitPos)); |
| if (mpViewShell) |
| { |
| mpViewShell->AddAccessibilityObject(*this); |
| |
| const ScViewData& rViewData = *mpViewShell->GetViewData(); |
| const ScMarkData& rMarkData = rViewData.GetMarkData(); |
| maActiveCell = rViewData.GetCurPos(); |
| mbHasSelection = rMarkData.GetTableSelect(maActiveCell.Tab()) && |
| (rMarkData.IsMarked() || rMarkData.IsMultiMarked()); |
| mpAccCell = GetAccessibleCellAt(maActiveCell.Row(), maActiveCell.Col()); |
| mpAccCell->acquire(); |
| mpAccCell->Init(); |
| ScDocument* pScDoc= GetDocument(mpViewShell); |
| if (pScDoc) |
| { |
| pScDoc->GetName( maActiveCell.Tab(), m_strOldTabName ); |
| } |
| } |
| } |
| |
| void SAL_CALL ScAccessibleSpreadsheet::disposing() |
| { |
| ScUnoGuard aGuard; |
| if (mpViewShell) |
| { |
| mpViewShell->RemoveAccessibilityObject(*this); |
| mpViewShell = NULL; |
| } |
| if (mpAccCell) |
| { |
| mpAccCell->release(); |
| mpAccCell = NULL; |
| } |
| |
| ScAccessibleTableBase::disposing(); |
| } |
| |
| void ScAccessibleSpreadsheet::CompleteSelectionChanged(sal_Bool bNewState) |
| { |
| if (IsFormulaMode()) |
| { |
| return ; |
| } |
| if (mpMarkedRanges) |
| DELETEZ(mpMarkedRanges); |
| mbHasSelection = bNewState; |
| |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::STATE_CHANGED; |
| if (bNewState) |
| aEvent.NewValue = uno::makeAny(AccessibleStateType::SELECTED); |
| else |
| aEvent.OldValue = uno::makeAny(AccessibleStateType::SELECTED); |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| |
| CommitChange(aEvent); |
| } |
| |
| void ScAccessibleSpreadsheet::LostFocus() |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| uno::Reference< XAccessible > xOld = mpAccCell; |
| aEvent.OldValue <<= xOld; |
| |
| CommitChange(aEvent); |
| |
| CommitFocusLost(); |
| } |
| |
| void ScAccessibleSpreadsheet::GotFocus() |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| uno::Reference< XAccessible > xNew; |
| if (IsFormulaMode()) |
| { |
| if (!m_pAccFormulaCell || !m_bFormulaLastMode) |
| { |
| ScAddress aFormulaAddr; |
| if(!GetFormulaCurrentFocusCell(aFormulaAddr)) |
| { |
| return; |
| } |
| m_pAccFormulaCell = GetAccessibleCellAt(aFormulaAddr.Row(),aFormulaAddr.Col()); |
| |
| m_pAccFormulaCell->acquire(); |
| m_pAccFormulaCell->Init(); |
| |
| |
| } |
| xNew = m_pAccFormulaCell; |
| } |
| else |
| { |
| if(mpAccCell->GetCellAddress() == maActiveCell) |
| { |
| xNew = mpAccCell; |
| } |
| else |
| { |
| CommitFocusCell(maActiveCell); |
| return ; |
| } |
| } |
| aEvent.NewValue <<= xNew; |
| |
| CommitChange(aEvent); |
| } |
| |
| void ScAccessibleSpreadsheet::BoundingBoxChanged() |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::BOUNDRECT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| |
| CommitChange(aEvent); |
| } |
| |
| void ScAccessibleSpreadsheet::VisAreaChanged() |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::VISIBLE_DATA_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| |
| CommitChange(aEvent); |
| } |
| |
| //===== SfxListener ===================================================== |
| |
| void ScAccessibleSpreadsheet::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) |
| { |
| if (rHint.ISA( SfxSimpleHint ) ) |
| { |
| const SfxSimpleHint& rRef = (const SfxSimpleHint&)rHint; |
| if ((rRef.GetId() == SC_HINT_ACC_CURSORCHANGED)) |
| { |
| if (mpViewShell) |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| |
| m_bFormulaMode = pViewData->IsRefMode() || SC_MOD()->IsFormulaMode(); |
| if ( m_bFormulaMode ) |
| { |
| NotifyRefMode(); |
| m_bFormulaLastMode = true; |
| return ; |
| } |
| if (m_bFormulaLastMode) |
| {//Last Notify Mode Is Formula Mode. |
| m_vecFormulaLastMyAddr.clear(); |
| RemoveFormulaSelection(sal_True); |
| if(m_pAccFormulaCell) |
| { |
| m_pAccFormulaCell->release(); |
| m_pAccFormulaCell =NULL; |
| } |
| //Remove All Selection |
| } |
| m_bFormulaLastMode = m_bFormulaMode; |
| |
| AccessibleEventObject aEvent; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| ScAddress aNewCell = pViewData->GetCurPos(); |
| if(aNewCell.Tab() != maActiveCell.Tab()) |
| { |
| aEvent.EventId = AccessibleEventId::PAGE_CHANGED; |
| ScAccessibleDocument *pAccDoc = |
| static_cast<ScAccessibleDocument*>(getAccessibleParent().get()); |
| if(pAccDoc) |
| { |
| pAccDoc->CommitChange(aEvent); |
| } |
| } |
| sal_Bool bNewPosCell = (aNewCell != maActiveCell) || mpViewShell->GetForceFocusOnCurCell(); // i123629 |
| sal_Bool bNewPosCellFocus=sal_False; |
| if ( bNewPosCell && IsFocused() && aNewCell.Tab() == maActiveCell.Tab() ) |
| {//single Focus |
| bNewPosCellFocus=sal_True; |
| } |
| ScMarkData &refScMarkData = pViewData->GetMarkData(); |
| // MT IA2: Not used |
| // int nSelCount = refScMarkData.GetSelectCount(); |
| sal_Bool bIsMark =refScMarkData.IsMarked(); |
| sal_Bool bIsMultMark = refScMarkData.IsMultiMarked(); |
| sal_Bool bNewMarked = refScMarkData.GetTableSelect(aNewCell.Tab()) && ( bIsMark || bIsMultMark ); |
| // sal_Bool bNewCellSelected = isAccessibleSelected(aNewCell.Row(), aNewCell.Col()); |
| sal_uInt16 nTab = pViewData->GetTabNo(); |
| ScRange aMarkRange; |
| refScMarkData.GetMarkArea(aMarkRange); |
| aEvent.OldValue <<= ::com::sun::star::uno::Any(); |
| //Mark All |
| if ( !bNewPosCellFocus && |
| (bNewMarked || bIsMark || bIsMultMark ) && |
| aMarkRange == ScRange( 0,0,nTab, MAXCOL,MAXROW,nTab ) ) |
| { |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_WITHIN; |
| aEvent.NewValue <<= ::com::sun::star::uno::Any(); |
| CommitChange(aEvent); |
| return ; |
| } |
| if (!mpMarkedRanges) |
| { |
| mpMarkedRanges = new ScRangeList(); |
| } |
| refScMarkData.FillRangeListWithMarks(mpMarkedRanges, sal_True); |
| |
| //For Whole Col Row |
| sal_Bool bWholeRow = ::labs(aMarkRange.aStart.Row() - aMarkRange.aEnd.Row()) == MAXROW ; |
| sal_Bool bWholeCol = ::abs(aMarkRange.aStart.Col() - aMarkRange.aEnd.Col()) == MAXCOL ; |
| if ((bNewMarked || bIsMark || bIsMultMark ) && (bWholeCol || bWholeRow)) |
| { |
| if ( aMarkRange != m_aLastWithInMarkRange ) |
| { |
| RemoveSelection(refScMarkData); |
| if(bNewPosCell) |
| { |
| CommitFocusCell(aNewCell); |
| } |
| sal_Bool bLastIsWholeColRow = |
| ::labs(m_aLastWithInMarkRange.aStart.Row() - m_aLastWithInMarkRange.aEnd.Row()) == MAXROW && bWholeRow || |
| ::abs(m_aLastWithInMarkRange.aStart.Col() - m_aLastWithInMarkRange.aEnd.Col()) == MAXCOL && bWholeCol ; |
| sal_Bool bSelSmaller= |
| bLastIsWholeColRow && |
| !aMarkRange.In(m_aLastWithInMarkRange) && |
| aMarkRange.Intersects(m_aLastWithInMarkRange); |
| if( !bSelSmaller ) |
| { |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_WITHIN; |
| aEvent.NewValue <<= ::com::sun::star::uno::Any(); |
| CommitChange(aEvent); |
| } |
| m_aLastWithInMarkRange = aMarkRange; |
| } |
| return ; |
| } |
| m_aLastWithInMarkRange = aMarkRange; |
| int nNewMarkCount = mpMarkedRanges->GetCellCount(); |
| sal_Bool bSendSingle= (0 == nNewMarkCount) && bNewPosCell; |
| if (bSendSingle) |
| { |
| RemoveSelection(refScMarkData); |
| if(bNewPosCellFocus) |
| { |
| CommitFocusCell(aNewCell); |
| } |
| uno::Reference< XAccessible > xChild ; |
| if (bNewPosCellFocus) |
| { |
| xChild = mpAccCell; |
| } |
| else |
| { |
| xChild = getAccessibleCellAt(aNewCell.Row(),aNewCell.Col()); |
| |
| maActiveCell = aNewCell; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS; |
| aEvent.NewValue <<= xChild; |
| aEvent.OldValue <<= uno::Reference< XAccessible >(); |
| CommitChange(aEvent); |
| } |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED; |
| aEvent.NewValue <<= xChild; |
| CommitChange(aEvent); |
| OSL_ASSERT(m_mapSelectionSend.count(aNewCell) == 0 ); |
| m_mapSelectionSend.insert(MAP_ADDR_XACC::value_type(aNewCell,xChild)); |
| |
| } |
| else |
| { |
| ScRange aDelRange; |
| sal_Bool bIsDel = pViewData->GetDelMark( aDelRange ); |
| if ( (!bIsDel || (bIsDel && aMarkRange != aDelRange)) && |
| bNewMarked && |
| nNewMarkCount > 0 && |
| !IsSameMarkCell() ) |
| { |
| RemoveSelection(refScMarkData); |
| if(bNewPosCellFocus) |
| { |
| CommitFocusCell(aNewCell); |
| } |
| VEC_MYADDR vecNew; |
| if(CalcScRangeListDifferenceMax(mpMarkedRanges,&m_LastMarkedRanges,10,vecNew)) |
| { |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_WITHIN; |
| aEvent.NewValue <<= ::com::sun::star::uno::Any(); |
| CommitChange(aEvent); |
| } |
| else |
| { |
| VEC_MYADDR::iterator viAddr = vecNew.begin(); |
| for(; viAddr < vecNew.end() ; ++viAddr ) |
| { |
| uno::Reference< XAccessible > xChild = getAccessibleCellAt(viAddr->Row(),viAddr->Col()); |
| if (!(bNewPosCellFocus && *viAddr == aNewCell) ) |
| { |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS; |
| aEvent.NewValue <<= xChild; |
| CommitChange(aEvent); |
| } |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_ADD; |
| aEvent.NewValue <<= xChild; |
| CommitChange(aEvent); |
| m_mapSelectionSend.insert(MAP_ADDR_XACC::value_type(*viAddr,xChild)); |
| } |
| } |
| } |
| } |
| if (bNewPosCellFocus && maActiveCell != aNewCell) |
| { |
| CommitFocusCell(aNewCell); |
| } |
| m_LastMarkedRanges = *mpMarkedRanges; |
| } |
| } |
| else if ((rRef.GetId() == SC_HINT_DATACHANGED)) |
| { |
| if (!mbDelIns) |
| CommitTableModelChange(maRange.aStart.Row(), maRange.aStart.Col(), maRange.aEnd.Row(), maRange.aEnd.Col(), AccessibleTableModelChangeType::UPDATE); |
| else |
| mbDelIns = sal_False; |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| ScAddress aNewCell = pViewData->GetCurPos(); |
| if( maActiveCell == aNewCell) |
| { |
| ScDocument* pScDoc= GetDocument(mpViewShell); |
| if (pScDoc) |
| { |
| String valStr; |
| pScDoc->GetString(aNewCell.Col(),aNewCell.Row(),aNewCell.Tab(), valStr); |
| if(m_strCurCellValue != valStr) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::VALUE_CHANGED; |
| mpAccCell->CommitChange(aEvent); |
| m_strCurCellValue=valStr; |
| } |
| String tabName; |
| pScDoc->GetName( maActiveCell.Tab(), tabName ); |
| if( m_strOldTabName != tabName ) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::NAME_CHANGED; |
| String sOldName(ScResId(STR_ACC_TABLE_NAME)); |
| sOldName.SearchAndReplaceAscii("%1", m_strOldTabName); |
| aEvent.OldValue <<= ::rtl::OUString( sOldName ); |
| String sNewName(ScResId(STR_ACC_TABLE_NAME)); |
| sNewName.SearchAndReplaceAscii("%1", tabName); |
| aEvent.NewValue <<= ::rtl::OUString( sNewName ); |
| CommitChange( aEvent ); |
| m_strOldTabName = tabName; |
| } |
| } |
| } |
| } |
| // no longer needed, because the document calls the VisAreaChanged method |
| /* else if (rRef.GetId() == SC_HINT_ACC_VISAREACHANGED) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::VISIBLE_DATA_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| |
| CommitChange(aEvent);*/ |
| // commented out, because to use a ModelChangeEvent is not the right way |
| // at the moment there is no way, but the Java/Gnome Api should be extended sometime |
| /* if (mpViewShell) |
| { |
| Rectangle aNewVisCells(GetVisCells(GetVisArea(mpViewShell, meSplitPos))); |
| |
| Rectangle aNewPos(aNewVisCells); |
| |
| if (aNewVisCells.IsOver(maVisCells)) |
| aNewPos.Union(maVisCells); |
| else |
| CommitTableModelChange(maVisCells.Top(), maVisCells.Left(), maVisCells.Bottom(), maVisCells.Right(), AccessibleTableModelChangeType::UPDATE); |
| |
| maVisCells = aNewVisCells; |
| |
| CommitTableModelChange(aNewPos.Top(), aNewPos.Left(), aNewPos.Bottom(), aNewPos.Right(), AccessibleTableModelChangeType::UPDATE); |
| } |
| }*/ |
| // no longer needed, because the document calls the BoundingBoxChanged method |
| /* else if (rRef.GetId() == SC_HINT_ACC_WINDOWRESIZED) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::BOUNDRECT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| |
| CommitChange(aEvent); |
| }*/ |
| } |
| else if (rHint.ISA( ScUpdateRefHint )) |
| { |
| const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; |
| if (rRef.GetMode() == URM_INSDEL && rRef.GetDz() == 0) //#107250# test whether table is inserted or deleted |
| { |
| if (((rRef.GetRange().aStart.Col() == maRange.aStart.Col()) && |
| (rRef.GetRange().aEnd.Col() == maRange.aEnd.Col())) || |
| ((rRef.GetRange().aStart.Row() == maRange.aStart.Row()) && |
| (rRef.GetRange().aEnd.Row() == maRange.aEnd.Row()))) |
| { |
| // ignore next SC_HINT_DATACHANGED notification |
| mbDelIns = sal_True; |
| |
| sal_Int16 nId(0); |
| SCsCOL nX(rRef.GetDx()); |
| SCsROW nY(rRef.GetDy()); |
| ScRange aRange(rRef.GetRange()); |
| if ((nX < 0) || (nY < 0)) |
| { |
| DBG_ASSERT(!((nX < 0) && (nY < 0)), "should not be possible to remove row and column at the same time"); |
| nId = AccessibleTableModelChangeType::DELETE; |
| if (nX < 0) |
| { |
| nX = -nX; |
| nY = aRange.aEnd.Row() - aRange.aStart.Row(); |
| } |
| else |
| { |
| nY = -nY; |
| nX = aRange.aEnd.Col() - aRange.aStart.Col(); |
| } |
| } |
| else if ((nX > 0) || (nY > 0)) |
| { |
| DBG_ASSERT(!((nX > 0) && (nY > 0)), "should not be possible to add row and column at the same time"); |
| nId = AccessibleTableModelChangeType::INSERT; |
| if (nX < 0) |
| nY = aRange.aEnd.Row() - aRange.aStart.Row(); |
| else |
| nX = aRange.aEnd.Col() - aRange.aStart.Col(); |
| } |
| else |
| { |
| DBG_ERROR("is it a deletion or a insertion?"); |
| } |
| |
| CommitTableModelChange(rRef.GetRange().aStart.Row(), |
| rRef.GetRange().aStart.Col(), |
| rRef.GetRange().aStart.Row() + nY, |
| rRef.GetRange().aStart.Col() + nX, nId); |
| |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessibleContext >(this); |
| uno::Reference< XAccessible > xNew = mpAccCell; |
| aEvent.NewValue <<= xNew; |
| |
| CommitChange(aEvent); |
| } |
| } |
| } |
| |
| ScAccessibleTableBase::Notify(rBC, rHint); |
| } |
| void ScAccessibleSpreadsheet::RemoveSelection(ScMarkData &refScMarkData) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| aEvent.OldValue <<= ::com::sun::star::uno::Any(); |
| MAP_ADDR_XACC::iterator miRemove = m_mapSelectionSend.begin(); |
| for(; miRemove != m_mapSelectionSend.end() ;) |
| { |
| if (refScMarkData.IsCellMarked(miRemove->first.Col(),miRemove->first.Row(),sal_True) || |
| refScMarkData.IsCellMarked(miRemove->first.Col(),miRemove->first.Row(),sal_False) ) |
| { |
| ++miRemove; |
| continue; |
| } |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_REMOVE; |
| aEvent.NewValue <<= miRemove->second; |
| CommitChange(aEvent); |
| MAP_ADDR_XACC::iterator miNext = miRemove; |
| ++miNext; |
| m_mapSelectionSend.erase(miRemove); |
| miRemove = miNext; |
| } |
| } |
| void ScAccessibleSpreadsheet::CommitFocusCell(const ScAddress &aNewCell) |
| { |
| OSL_ASSERT(!IsFormulaMode()); |
| if(IsFormulaMode()) |
| { |
| return ; |
| } |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| uno::Reference< XAccessible > xOld = mpAccCell; |
| mpAccCell->release(); |
| mpAccCell=NULL; |
| aEvent.OldValue <<= xOld; |
| mpAccCell = GetAccessibleCellAt(aNewCell.Row(), aNewCell.Col()); |
| mpAccCell->acquire(); |
| mpAccCell->Init(); |
| uno::Reference< XAccessible > xNew = mpAccCell; |
| aEvent.NewValue <<= xNew; |
| maActiveCell = aNewCell; |
| ScDocument* pScDoc= GetDocument(mpViewShell); |
| if (pScDoc) |
| { |
| pScDoc->GetString(maActiveCell.Col(),maActiveCell.Row(),maActiveCell.Tab(), m_strCurCellValue); |
| } |
| CommitChange(aEvent); |
| } |
| sal_Bool ScAccessibleSpreadsheet::IsSameMarkCell() |
| { |
| return m_LastMarkedRanges == *mpMarkedRanges; |
| } |
| //===== XAccessibleTable ================================================ |
| |
| uno::Reference< XAccessibleTable > SAL_CALL ScAccessibleSpreadsheet::getAccessibleRowHeaders( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| uno::Reference< XAccessibleTable > xAccessibleTable; |
| if( mpDoc && mbIsSpreadsheet ) |
| { |
| if( const ScRange* pRowRange = mpDoc->GetRepeatRowRange( mnTab ) ) |
| { |
| SCROW nStart = pRowRange->aStart.Row(); |
| SCROW nEnd = pRowRange->aEnd.Row(); |
| if( (0 <= nStart) && (nStart <= nEnd) && (nEnd <= MAXROW) ) |
| xAccessibleTable.set( new ScAccessibleSpreadsheet( *this, ScRange( 0, nStart, mnTab, MAXCOL, nEnd, mnTab ) ) ); |
| } |
| } |
| return xAccessibleTable; |
| } |
| |
| uno::Reference< XAccessibleTable > SAL_CALL ScAccessibleSpreadsheet::getAccessibleColumnHeaders( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| uno::Reference< XAccessibleTable > xAccessibleTable; |
| if( mpDoc && mbIsSpreadsheet ) |
| { |
| if( const ScRange* pColRange = mpDoc->GetRepeatColRange( mnTab ) ) |
| { |
| SCCOL nStart = pColRange->aStart.Col(); |
| SCCOL nEnd = pColRange->aEnd.Col(); |
| if( (0 <= nStart) && (nStart <= nEnd) && (nEnd <= MAXCOL) ) |
| xAccessibleTable.set( new ScAccessibleSpreadsheet( *this, ScRange( nStart, 0, mnTab, nEnd, MAXROW, mnTab ) ) ); |
| } |
| } |
| return xAccessibleTable; |
| } |
| |
| uno::Sequence< sal_Int32 > SAL_CALL ScAccessibleSpreadsheet::getSelectedAccessibleRows( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| uno::Sequence<sal_Int32> aSequence; |
| if (IsFormulaMode()) |
| { |
| return aSequence; |
| } |
| if (mpViewShell && mpViewShell->GetViewData()) |
| { |
| aSequence.realloc(maRange.aEnd.Row() - maRange.aStart.Row() + 1); |
| const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData(); |
| sal_Int32* pSequence = aSequence.getArray(); |
| sal_Int32 nCount(0); |
| for (SCROW i = maRange.aStart.Row(); i <= maRange.aEnd.Row(); ++i) |
| { |
| if (rMarkdata.IsRowMarked(i)) |
| { |
| pSequence[nCount] = i; |
| ++nCount; |
| } |
| } |
| aSequence.realloc(nCount); |
| } |
| else |
| aSequence.realloc(0); |
| return aSequence; |
| } |
| |
| uno::Sequence< sal_Int32 > SAL_CALL ScAccessibleSpreadsheet::getSelectedAccessibleColumns( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| uno::Sequence<sal_Int32> aSequence; |
| if (IsFormulaMode()) |
| { |
| return aSequence; |
| } |
| if (mpViewShell && mpViewShell->GetViewData()) |
| { |
| aSequence.realloc(maRange.aEnd.Col() - maRange.aStart.Col() + 1); |
| const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData(); |
| sal_Int32* pSequence = aSequence.getArray(); |
| sal_Int32 nCount(0); |
| for (SCCOL i = maRange.aStart.Col(); i <= maRange.aEnd.Col(); ++i) |
| { |
| if (rMarkdata.IsColumnMarked(i)) |
| { |
| pSequence[nCount] = i; |
| ++nCount; |
| } |
| } |
| aSequence.realloc(nCount); |
| } |
| else |
| aSequence.realloc(0); |
| return aSequence; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::isAccessibleRowSelected( sal_Int32 nRow ) |
| throw (uno::RuntimeException, lang::IndexOutOfBoundsException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| |
| if ((nRow > (maRange.aEnd.Row() - maRange.aStart.Row())) || (nRow < 0)) |
| throw lang::IndexOutOfBoundsException(); |
| |
| sal_Bool bResult(sal_False); |
| if (mpViewShell && mpViewShell->GetViewData()) |
| { |
| const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData(); |
| bResult = rMarkdata.IsRowMarked((SCROW)nRow); |
| } |
| return bResult; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::isAccessibleColumnSelected( sal_Int32 nColumn ) |
| throw (uno::RuntimeException, lang::IndexOutOfBoundsException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| if ((nColumn > (maRange.aEnd.Col() - maRange.aStart.Col())) || (nColumn < 0)) |
| throw lang::IndexOutOfBoundsException(); |
| |
| sal_Bool bResult(sal_False); |
| if (mpViewShell && mpViewShell->GetViewData()) |
| { |
| const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData(); |
| bResult = rMarkdata.IsColumnMarked((SCCOL)nColumn); |
| } |
| return bResult; |
| } |
| |
| ScAccessibleCell* ScAccessibleSpreadsheet::GetAccessibleCellAt(sal_Int32 nRow, sal_Int32 nColumn) |
| { |
| ScAccessibleCell* pAccessibleCell = NULL; |
| if (IsFormulaMode()) |
| { |
| ScAddress aCellAddress(static_cast<SCCOL>(nColumn), nRow, mpViewShell->GetViewData()->GetTabNo()); |
| if ((aCellAddress == m_aFormulaActiveCell) && m_pAccFormulaCell) |
| { |
| pAccessibleCell = m_pAccFormulaCell; |
| } |
| else |
| pAccessibleCell = new ScAccessibleCell(this, mpViewShell, aCellAddress, GetAccessibleIndexFormula(nRow, nColumn), meSplitPos, mpAccDoc); |
| } |
| else |
| { |
| ScAddress aCellAddress(static_cast<SCCOL>(maRange.aStart.Col() + nColumn), |
| static_cast<SCROW>(maRange.aStart.Row() + nRow), maRange.aStart.Tab()); |
| if ((aCellAddress == maActiveCell) && mpAccCell) |
| { |
| pAccessibleCell = mpAccCell; |
| } |
| else |
| pAccessibleCell = new ScAccessibleCell(this, mpViewShell, aCellAddress, getAccessibleIndex(nRow, nColumn), meSplitPos, mpAccDoc); |
| } |
| |
| return pAccessibleCell; |
| } |
| |
| uno::Reference< XAccessible > SAL_CALL ScAccessibleSpreadsheet::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) |
| throw (uno::RuntimeException, lang::IndexOutOfBoundsException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (!IsFormulaMode()) |
| { |
| if (nRow > (maRange.aEnd.Row() - maRange.aStart.Row()) || |
| nRow < 0 || |
| nColumn > (maRange.aEnd.Col() - maRange.aStart.Col()) || |
| nColumn < 0) |
| throw lang::IndexOutOfBoundsException(); |
| } |
| uno::Reference<XAccessible> xAccessible; |
| ScAccessibleCell* pAccessibleCell = GetAccessibleCellAt(nRow, nColumn); |
| xAccessible = pAccessibleCell; |
| pAccessibleCell->Init(); |
| return xAccessible; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) |
| throw (uno::RuntimeException, lang::IndexOutOfBoundsException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| |
| if (IsFormulaMode()) |
| { |
| ScAddress addr(static_cast<SCCOL>(nColumn), nRow, 0); |
| return IsScAddrFormulaSel(addr); |
| } |
| if ((nColumn > (maRange.aEnd.Col() - maRange.aStart.Col())) || (nColumn < 0) || |
| (nRow > (maRange.aEnd.Row() - maRange.aStart.Row())) || (nRow < 0)) |
| throw lang::IndexOutOfBoundsException(); |
| |
| sal_Bool bResult(sal_False); |
| if (mpViewShell) |
| { |
| const ScMarkData& rMarkdata = mpViewShell->GetViewData()->GetMarkData(); |
| bResult = rMarkdata.IsCellMarked(static_cast<SCCOL>(nColumn), static_cast<SCROW>(nRow)); |
| } |
| return bResult; |
| } |
| |
| //===== XAccessibleComponent ============================================ |
| |
| uno::Reference< XAccessible > SAL_CALL ScAccessibleSpreadsheet::getAccessibleAtPoint( |
| const awt::Point& rPoint ) |
| throw (uno::RuntimeException) |
| { |
| uno::Reference< XAccessible > xAccessible; |
| if (containsPoint(rPoint)) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (mpViewShell) |
| { |
| SCsCOL nX; |
| SCsROW nY; |
| mpViewShell->GetViewData()->GetPosFromPixel( rPoint.X, rPoint.Y, meSplitPos, nX, nY); |
| try{ |
| xAccessible = getAccessibleCellAt(nY, nX); |
| } |
| catch( ::com::sun::star::lang::IndexOutOfBoundsException e) |
| { |
| return NULL; |
| } |
| } |
| } |
| return xAccessible; |
| } |
| |
| void SAL_CALL ScAccessibleSpreadsheet::grabFocus( ) |
| throw (uno::RuntimeException) |
| { |
| if (getAccessibleParent().is()) |
| { |
| uno::Reference<XAccessibleComponent> xAccessibleComponent(getAccessibleParent()->getAccessibleContext(), uno::UNO_QUERY); |
| if (xAccessibleComponent.is()) |
| xAccessibleComponent->grabFocus(); |
| } |
| } |
| |
| sal_Int32 SAL_CALL ScAccessibleSpreadsheet::getForeground( ) |
| throw (uno::RuntimeException) |
| { |
| return COL_BLACK; |
| } |
| |
| sal_Int32 SAL_CALL ScAccessibleSpreadsheet::getBackground( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| return SC_MOD()->GetColorConfig().GetColorValue( ::svtools::DOCCOLOR ).nColor; |
| } |
| |
| //===== XAccessibleContext ============================================== |
| |
| uno::Reference<XAccessibleRelationSet> SAL_CALL ScAccessibleSpreadsheet::getAccessibleRelationSet(void) |
| throw (::com::sun::star::uno::RuntimeException) |
| { |
| utl::AccessibleRelationSetHelper* pRelationSet = NULL; |
| if(mpAccDoc) |
| pRelationSet = mpAccDoc->GetRelationSet(NULL); |
| if (!pRelationSet) |
| pRelationSet = new utl::AccessibleRelationSetHelper(); |
| return pRelationSet; |
| } |
| |
| uno::Reference<XAccessibleStateSet> SAL_CALL |
| ScAccessibleSpreadsheet::getAccessibleStateSet(void) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| uno::Reference<XAccessibleStateSet> xParentStates; |
| if (getAccessibleParent().is()) |
| { |
| uno::Reference<XAccessibleContext> xParentContext = getAccessibleParent()->getAccessibleContext(); |
| xParentStates = xParentContext->getAccessibleStateSet(); |
| } |
| utl::AccessibleStateSetHelper* pStateSet = new utl::AccessibleStateSetHelper(); |
| if (IsDefunc(xParentStates)) |
| pStateSet->AddState(AccessibleStateType::DEFUNC); |
| else |
| { |
| pStateSet->AddState(AccessibleStateType::MANAGES_DESCENDANTS); |
| if (IsEditable(xParentStates)) |
| pStateSet->AddState(AccessibleStateType::EDITABLE); |
| pStateSet->AddState(AccessibleStateType::ENABLED); |
| pStateSet->AddState(AccessibleStateType::FOCUSABLE); |
| if (IsFocused()) |
| pStateSet->AddState(AccessibleStateType::FOCUSED); |
| pStateSet->AddState(AccessibleStateType::MULTI_SELECTABLE); |
| pStateSet->AddState(AccessibleStateType::OPAQUE); |
| pStateSet->AddState(AccessibleStateType::SELECTABLE); |
| if (IsCompleteSheetSelected()) |
| pStateSet->AddState(AccessibleStateType::SELECTED); |
| if (isShowing()) |
| pStateSet->AddState(AccessibleStateType::SHOWING); |
| if (isVisible()) |
| pStateSet->AddState(AccessibleStateType::VISIBLE); |
| } |
| return pStateSet; |
| } |
| |
| ///===== XAccessibleSelection =========================================== |
| |
| void SAL_CALL |
| ScAccessibleSpreadsheet::selectAccessibleChild( sal_Int32 nChildIndex ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (nChildIndex < 0 || nChildIndex >= getAccessibleChildCount()) |
| throw lang::IndexOutOfBoundsException(); |
| |
| if (mpViewShell) |
| { |
| sal_Int32 nCol(getAccessibleColumn(nChildIndex)); |
| sal_Int32 nRow(getAccessibleRow(nChildIndex)); |
| |
| SelectCell(nRow, nCol, sal_False); |
| } |
| } |
| |
| void SAL_CALL |
| ScAccessibleSpreadsheet::clearAccessibleSelection( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (mpViewShell) |
| { |
| if (!IsFormulaMode()) |
| mpViewShell->Unmark(); |
| } |
| } |
| |
| void SAL_CALL |
| ScAccessibleSpreadsheet::selectAllAccessibleChildren( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| if (mpViewShell) |
| { |
| if (IsFormulaMode()) |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| mpViewShell->InitRefMode( 0, 0, pViewData->GetTabNo(), SC_REFTYPE_REF ); |
| pViewData->SetRefStart(0,0,pViewData->GetTabNo()); |
| pViewData->SetRefStart(MAXCOL,MAXROW,pViewData->GetTabNo()); |
| mpViewShell->UpdateRef(MAXCOL, MAXROW, pViewData->GetTabNo()); |
| } |
| else |
| mpViewShell->SelectAll(); |
| } |
| } |
| |
| sal_Int32 SAL_CALL |
| ScAccessibleSpreadsheet::getSelectedAccessibleChildCount( ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| sal_Int32 nResult(0); |
| if (mpViewShell) |
| { |
| if (IsFormulaMode()) |
| { |
| nResult = GetRowAll() * GetColAll() ; |
| } |
| else |
| { |
| if (!mpMarkedRanges) |
| { |
| mpMarkedRanges = new ScRangeList(); |
| ScMarkData aMarkData(mpViewShell->GetViewData()->GetMarkData()); |
| //aMarkData.MarkToMulti(); |
| aMarkData.FillRangeListWithMarks(mpMarkedRanges, sal_False); |
| } |
| // is possible, because there shouldn't be overlapped ranges in it |
| if (mpMarkedRanges) |
| nResult = mpMarkedRanges->GetCellCount(); |
| } |
| } |
| return nResult; |
| } |
| |
| uno::Reference<XAccessible > SAL_CALL |
| ScAccessibleSpreadsheet::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| uno::Reference < XAccessible > xAccessible; |
| if (IsFormulaMode()) |
| { |
| if(CheckChildIndex(nSelectedChildIndex)) |
| { |
| ScAddress addr = GetChildIndexAddress(nSelectedChildIndex); |
| xAccessible = getAccessibleCellAt(addr.Row(), addr.Col()); |
| } |
| return xAccessible; |
| } |
| if (mpViewShell) |
| { |
| if (!mpMarkedRanges) |
| { |
| mpMarkedRanges = new ScRangeList(); |
| mpViewShell->GetViewData()->GetMarkData().FillRangeListWithMarks(mpMarkedRanges, sal_False); |
| } |
| if (mpMarkedRanges) |
| { |
| //if (!mpSortedMarkedCells) |
| // CreateSortedMarkedCells(); |
| //if (mpSortedMarkedCells) |
| //{ |
| // if ((nSelectedChildIndex < 0) || |
| // (mpSortedMarkedCells->size() <= static_cast<sal_uInt32>(nSelectedChildIndex))) |
| // throw lang::IndexOutOfBoundsException(); |
| // else |
| // xAccessible = getAccessibleCellAt((*mpSortedMarkedCells)[nSelectedChildIndex].Row(), (*mpSortedMarkedCells)[nSelectedChildIndex].Col()); |
| if ((nSelectedChildIndex < 0) || |
| (mpMarkedRanges->GetCellCount() <= static_cast<sal_uInt32>(nSelectedChildIndex))) |
| { |
| throw lang::IndexOutOfBoundsException(); |
| } |
| ScMyAddress addr = CalcScAddressFromRangeList(mpMarkedRanges,nSelectedChildIndex); |
| if( m_mapSelectionSend.find(addr) != m_mapSelectionSend.end() ) |
| xAccessible = m_mapSelectionSend[addr]; |
| else |
| xAccessible = getAccessibleCellAt(addr.Row(), addr.Col()); |
| } |
| } |
| return xAccessible; |
| } |
| |
| void SAL_CALL |
| ScAccessibleSpreadsheet::deselectAccessibleChild( sal_Int32 nChildIndex ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| |
| if (nChildIndex < 0 || nChildIndex >= getAccessibleChildCount()) |
| throw lang::IndexOutOfBoundsException(); |
| |
| if (mpViewShell) |
| { |
| sal_Int32 nCol(getAccessibleColumn(nChildIndex)); |
| sal_Int32 nRow(getAccessibleRow(nChildIndex)); |
| |
| if (IsFormulaMode()) |
| { |
| if(IsScAddrFormulaSel( |
| ScAddress(static_cast<SCCOL>(nCol), nRow,mpViewShell->GetViewData()->GetTabNo())) |
| ) |
| { |
| SelectCell(nRow, nCol, sal_True); |
| } |
| return ; |
| } |
| if (mpViewShell->GetViewData()->GetMarkData().IsCellMarked(static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow))) |
| SelectCell(nRow, nCol, sal_True); |
| } |
| } |
| |
| void ScAccessibleSpreadsheet::SelectCell(sal_Int32 nRow, sal_Int32 nCol, sal_Bool bDeselect) |
| { |
| if (IsFormulaMode()) |
| { |
| if (bDeselect) |
| {//?? |
| return ; |
| } |
| else |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| |
| mpViewShell->InitRefMode( static_cast<SCCOL>(nCol), nRow, pViewData->GetTabNo(), SC_REFTYPE_REF ); |
| mpViewShell->UpdateRef(static_cast<SCCOL>(nCol), nRow, pViewData->GetTabNo()); |
| } |
| return ; |
| } |
| mpViewShell->SetTabNo( maRange.aStart.Tab() ); |
| |
| mpViewShell->DoneBlockMode( sal_True ); // continue selecting |
| mpViewShell->InitBlockMode( static_cast<SCCOL>(nCol), static_cast<SCROW>(nRow), maRange.aStart.Tab(), bDeselect, sal_False, sal_False ); |
| |
| mpViewShell->SelectionChanged(); |
| } |
| |
| //===== XServiceInfo ==================================================== |
| |
| ::rtl::OUString SAL_CALL ScAccessibleSpreadsheet::getImplementationName(void) |
| throw (uno::RuntimeException) |
| { |
| return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM ("ScAccessibleSpreadsheet")); |
| } |
| |
| uno::Sequence< ::rtl::OUString> SAL_CALL |
| ScAccessibleSpreadsheet::getSupportedServiceNames (void) |
| throw (uno::RuntimeException) |
| { |
| uno::Sequence< ::rtl::OUString > aSequence = ScAccessibleTableBase::getSupportedServiceNames(); |
| sal_Int32 nOldSize(aSequence.getLength()); |
| aSequence.realloc(nOldSize + 1); |
| ::rtl::OUString* pNames = aSequence.getArray(); |
| |
| pNames[nOldSize] = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.AccessibleSpreadsheet")); |
| |
| return aSequence; |
| } |
| |
| //===== XTypeProvider ======================================================= |
| |
| uno::Sequence<sal_Int8> SAL_CALL |
| ScAccessibleSpreadsheet::getImplementationId(void) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| static uno::Sequence<sal_Int8> aId; |
| if (aId.getLength() == 0) |
| { |
| aId.realloc (16); |
| rtl_createUuid (reinterpret_cast<sal_uInt8 *>(aId.getArray()), 0, sal_True); |
| } |
| return aId; |
| } |
| |
| ///===== XAccessibleEventBroadcaster ===================================== |
| |
| void SAL_CALL ScAccessibleSpreadsheet::addEventListener(const uno::Reference<XAccessibleEventListener>& xListener) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| IsObjectValid(); |
| ScAccessibleTableBase::addEventListener(xListener); |
| } |
| |
| //==== internal ========================================================= |
| |
| Rectangle ScAccessibleSpreadsheet::GetBoundingBoxOnScreen() const |
| throw (uno::RuntimeException) |
| { |
| Rectangle aRect; |
| if (mpViewShell) |
| { |
| Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos); |
| if (pWindow) |
| aRect = pWindow->GetWindowExtentsRelative(NULL); |
| } |
| return aRect; |
| } |
| |
| Rectangle ScAccessibleSpreadsheet::GetBoundingBox() const |
| throw (uno::RuntimeException) |
| { |
| Rectangle aRect; |
| if (mpViewShell) |
| { |
| Window* pWindow = mpViewShell->GetWindowByPos(meSplitPos); |
| if (pWindow) |
| //#101986#; extends to the same window, because the parent is the document and it has the same window |
| aRect = pWindow->GetWindowExtentsRelative(pWindow); |
| } |
| return aRect; |
| } |
| |
| sal_Bool ScAccessibleSpreadsheet::IsDefunc( |
| const uno::Reference<XAccessibleStateSet>& rxParentStates) |
| { |
| return ScAccessibleContextBase::IsDefunc() || (mpViewShell == NULL) || !getAccessibleParent().is() || |
| (rxParentStates.is() && rxParentStates->contains(AccessibleStateType::DEFUNC)); |
| } |
| |
| sal_Bool ScAccessibleSpreadsheet::IsEditable( |
| const uno::Reference<XAccessibleStateSet>& /* rxParentStates */) |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| sal_Bool bProtected(sal_False); |
| if (mpDoc && mpDoc->IsTabProtected(maRange.aStart.Tab())) |
| bProtected = sal_True; |
| return !bProtected; |
| } |
| |
| sal_Bool ScAccessibleSpreadsheet::IsFocused() |
| { |
| sal_Bool bFocused(sal_False); |
| if (mpViewShell) |
| { |
| if (mpViewShell->GetViewData()->GetActivePart() == meSplitPos) |
| bFocused = mpViewShell->GetActiveWin()->HasFocus(); |
| } |
| return bFocused; |
| } |
| |
| sal_Bool ScAccessibleSpreadsheet::IsCompleteSheetSelected() |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| sal_Bool bResult(sal_False); |
| if(mpViewShell) |
| { |
| //#103800#; use a copy of MarkData |
| ScMarkData aMarkData(mpViewShell->GetViewData()->GetMarkData()); |
| aMarkData.MarkToMulti(); |
| if (aMarkData.IsAllMarked(maRange)) |
| bResult = sal_True; |
| } |
| return bResult; |
| } |
| |
| ScDocument* ScAccessibleSpreadsheet::GetDocument(ScTabViewShell* pViewShell) |
| { |
| ScDocument* pDoc = NULL; |
| if (pViewShell) |
| pDoc = pViewShell->GetViewData()->GetDocument(); |
| return pDoc; |
| } |
| |
| Rectangle ScAccessibleSpreadsheet::GetVisArea(ScTabViewShell* pViewShell, ScSplitPos eSplitPos) |
| { |
| Rectangle aVisArea; |
| if (pViewShell) |
| { |
| Window* pWindow = pViewShell->GetWindowByPos(eSplitPos); |
| if (pWindow) |
| { |
| aVisArea.SetPos(pViewShell->GetViewData()->GetPixPos(eSplitPos)); |
| aVisArea.SetSize(pWindow->GetSizePixel()); |
| } |
| } |
| return aVisArea; |
| } |
| |
| Rectangle ScAccessibleSpreadsheet::GetVisCells(const Rectangle& rVisArea) |
| { |
| if (mpViewShell) |
| { |
| SCsCOL nStartX, nEndX; |
| SCsROW nStartY, nEndY; |
| |
| mpViewShell->GetViewData()->GetPosFromPixel( 1, 1, meSplitPos, nStartX, nStartY); |
| mpViewShell->GetViewData()->GetPosFromPixel( rVisArea.GetWidth(), rVisArea.GetHeight(), meSplitPos, nEndX, nEndY); |
| |
| return Rectangle(nStartX, nStartY, nEndX, nEndY); |
| } |
| else |
| return Rectangle(); |
| } |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::selectRow( sal_Int32 row ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| |
| mpViewShell->SetTabNo( maRange.aStart.Tab() ); |
| mpViewShell->DoneBlockMode( sal_True ); // continue selecting |
| mpViewShell->InitBlockMode( 0, row, maRange.aStart.Tab(), sal_False, sal_False, sal_True ); |
| mpViewShell->MarkCursor( MAXCOL, row, maRange.aStart.Tab(), sal_False, sal_True ); |
| mpViewShell->SelectionChanged(); |
| return sal_True; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::selectColumn( sal_Int32 column ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| |
| mpViewShell->SetTabNo( maRange.aStart.Tab() ); |
| mpViewShell->DoneBlockMode( sal_True ); // continue selecting |
| mpViewShell->InitBlockMode( static_cast<SCCOL>(column), 0, maRange.aStart.Tab(), sal_False, sal_True, sal_False ); |
| mpViewShell->MarkCursor( static_cast<SCCOL>(column), MAXROW, maRange.aStart.Tab(), sal_True, sal_False ); |
| mpViewShell->SelectionChanged(); |
| return sal_True; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::unselectRow( sal_Int32 row ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| |
| mpViewShell->SetTabNo( maRange.aStart.Tab() ); |
| mpViewShell->DoneBlockMode( sal_True ); // continue selecting |
| mpViewShell->InitBlockMode( 0, row, maRange.aStart.Tab(), sal_False, sal_False, sal_True, sal_True ); |
| mpViewShell->MarkCursor( MAXCOL, row, maRange.aStart.Tab(), sal_False, sal_True ); |
| mpViewShell->SelectionChanged(); |
| mpViewShell->DoneBlockMode( sal_True ); |
| return sal_True; |
| } |
| |
| sal_Bool SAL_CALL ScAccessibleSpreadsheet::unselectColumn( sal_Int32 column ) |
| throw (lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| if (IsFormulaMode()) |
| { |
| return sal_False; |
| } |
| |
| mpViewShell->SetTabNo( maRange.aStart.Tab() ); |
| mpViewShell->DoneBlockMode( sal_True ); // continue selecting |
| mpViewShell->InitBlockMode( static_cast<SCCOL>(column), 0, maRange.aStart.Tab(), sal_False, sal_True, sal_False, sal_True ); |
| mpViewShell->MarkCursor( static_cast<SCCOL>(column), MAXROW, maRange.aStart.Tab(), sal_True, sal_False ); |
| mpViewShell->SelectionChanged(); |
| mpViewShell->DoneBlockMode( sal_True ); |
| return sal_True; |
| } |
| |
| void ScAccessibleSpreadsheet::FireFirstCellFocus() |
| { |
| if (IsFormulaMode()) |
| { |
| return ; |
| } |
| if (mbIsFocusSend) |
| { |
| return ; |
| } |
| mbIsFocusSend = sal_True; |
| AccessibleEventObject aEvent; |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| aEvent.NewValue <<= getAccessibleCellAt(maActiveCell.Row(), maActiveCell.Col()); |
| CommitChange(aEvent); |
| } |
| void ScAccessibleSpreadsheet::NotifyRefMode() |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| sal_uInt16 nRefStartX =pViewData->GetRefStartX(); |
| sal_Int32 nRefStartY=pViewData->GetRefStartY(); |
| sal_uInt16 nRefEndX=pViewData->GetRefEndX(); |
| sal_Int32 nRefEndY=pViewData->GetRefEndY(); |
| ScAddress aFormulaAddr; |
| if(!GetFormulaCurrentFocusCell(aFormulaAddr)) |
| { |
| return ; |
| } |
| if (m_aFormulaActiveCell != aFormulaAddr) |
| {//New Focus |
| m_nMinX =std::min(nRefStartX,nRefEndX); |
| m_nMaxX =std::max(nRefStartX,nRefEndX); |
| m_nMinY = std::min(nRefStartY,nRefEndY); |
| m_nMaxY = std::max(nRefStartY,nRefEndY); |
| RemoveFormulaSelection(); |
| AccessibleEventObject aEvent; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| uno::Reference< XAccessible > xOld = m_pAccFormulaCell; |
| aEvent.OldValue <<= xOld; |
| m_pAccFormulaCell = GetAccessibleCellAt(aFormulaAddr.Row(), aFormulaAddr.Col()); |
| m_pAccFormulaCell->acquire(); |
| m_pAccFormulaCell->Init(); |
| uno::Reference< XAccessible > xNew = m_pAccFormulaCell; |
| aEvent.NewValue <<= xNew; |
| CommitChange(aEvent); |
| if (nRefStartX == nRefEndX && nRefStartY == nRefEndY) |
| {//Selection Single |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED; |
| aEvent.NewValue <<= xNew; |
| CommitChange(aEvent); |
| m_mapFormulaSelectionSend.insert(MAP_ADDR_XACC::value_type(aFormulaAddr,xNew)); |
| m_vecFormulaLastMyAddr.clear(); |
| m_vecFormulaLastMyAddr.push_back(aFormulaAddr); |
| } |
| else |
| { |
| VEC_MYADDR vecCurSel; |
| int nCurSize = (m_nMaxX - m_nMinX +1)*(m_nMaxY - m_nMinY +1) ; |
| vecCurSel.reserve(nCurSize); |
| for (sal_uInt16 x = m_nMinX ; x <= m_nMaxX ; ++x) |
| { |
| for (sal_Int32 y = m_nMinY ; y <= m_nMaxY ; ++y) |
| { |
| ScMyAddress aAddr(x,y,0); |
| vecCurSel.push_back(aAddr); |
| } |
| } |
| std::sort(vecCurSel.begin(), vecCurSel.end()); |
| VEC_MYADDR vecNew; |
| std::set_difference(vecCurSel.begin(),vecCurSel.end(), |
| m_vecFormulaLastMyAddr.begin(),m_vecFormulaLastMyAddr.end(), |
| std::back_insert_iterator<VEC_MYADDR>(vecNew)); |
| int nNewSize = vecNew.size(); |
| if ( nNewSize > 10 ) |
| { |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_WITHIN; |
| aEvent.NewValue <<= ::com::sun::star::uno::Any(); |
| CommitChange(aEvent); |
| } |
| else |
| { |
| VEC_MYADDR::iterator viAddr = vecNew.begin(); |
| for(; viAddr != vecNew.end() ; ++viAddr ) |
| { |
| uno::Reference< XAccessible > xChild; |
| if (*viAddr == aFormulaAddr) |
| { |
| xChild = m_pAccFormulaCell; |
| } |
| else |
| { |
| xChild = getAccessibleCellAt(viAddr->Row(),viAddr->Col()); |
| aEvent.EventId = AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS; |
| aEvent.NewValue <<= xChild; |
| CommitChange(aEvent); |
| } |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_ADD; |
| aEvent.NewValue <<= xChild; |
| CommitChange(aEvent); |
| m_mapFormulaSelectionSend.insert(MAP_ADDR_XACC::value_type(*viAddr,xChild)); |
| } |
| } |
| m_vecFormulaLastMyAddr.swap(vecCurSel); |
| } |
| } |
| m_aFormulaActiveCell = aFormulaAddr; |
| } |
| void ScAccessibleSpreadsheet::RemoveFormulaSelection(sal_Bool bRemoveAll ) |
| { |
| AccessibleEventObject aEvent; |
| aEvent.Source = uno::Reference< XAccessible >(this); |
| aEvent.OldValue <<= ::com::sun::star::uno::Any(); |
| MAP_ADDR_XACC::iterator miRemove = m_mapFormulaSelectionSend.begin(); |
| for(; miRemove != m_mapFormulaSelectionSend.end() ;) |
| { |
| if( !bRemoveAll && IsScAddrFormulaSel(miRemove->first) ) |
| { |
| ++miRemove; |
| continue; |
| } |
| aEvent.EventId = AccessibleEventId::SELECTION_CHANGED_REMOVE; |
| aEvent.NewValue <<= miRemove->second; |
| CommitChange(aEvent); |
| MAP_ADDR_XACC::iterator miNext = miRemove; |
| ++miNext; |
| m_mapFormulaSelectionSend.erase(miRemove); |
| miRemove = miNext; |
| } |
| } |
| sal_Bool ScAccessibleSpreadsheet::IsScAddrFormulaSel(const ScAddress &addr) const |
| { |
| if( addr.Col() >= m_nMinX && addr.Col() <= m_nMaxX && |
| addr.Row() >= m_nMinY && addr.Row() <= m_nMaxY && |
| addr.Tab() == mpViewShell->GetViewData()->GetTabNo() ) |
| { |
| return sal_True; |
| } |
| return sal_False; |
| } |
| sal_Bool ScAccessibleSpreadsheet::CheckChildIndex(sal_Int32 nIndex) const |
| { |
| sal_Int32 nMaxIndex = (m_nMaxX - m_nMinX +1)*(m_nMaxY - m_nMinY +1) -1 ; |
| return nIndex <= nMaxIndex && nIndex >= 0 ; |
| } |
| ScAddress ScAccessibleSpreadsheet::GetChildIndexAddress(sal_Int32 nIndex) const |
| { |
| sal_Int32 nRowAll = GetRowAll(); |
| sal_uInt16 nColAll = GetColAll(); |
| if (nIndex < 0 || nIndex >= nRowAll * nColAll ) |
| { |
| return ScAddress(); |
| } |
| return ScAddress( |
| static_cast<SCCOL>((nIndex - nIndex % nRowAll) / nRowAll + + m_nMinX), |
| nIndex % nRowAll + m_nMinY, |
| mpViewShell->GetViewData()->GetTabNo() |
| ); |
| } |
| sal_Int32 ScAccessibleSpreadsheet::GetAccessibleIndexFormula( sal_Int32 nRow, sal_Int32 nColumn ) |
| { |
| sal_uInt16 nColRelative = sal_uInt16(nColumn) - GetColAll(); |
| sal_Int32 nRowRelative = nRow - GetRowAll(); |
| if (nRow < 0 || nColumn < 0 || nRowRelative >= GetRowAll() || nColRelative >= GetColAll() ) |
| { |
| return -1; |
| } |
| return GetRowAll() * nRowRelative + nColRelative; |
| } |
| sal_Bool ScAccessibleSpreadsheet::IsFormulaMode() |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| m_bFormulaMode = pViewData->IsRefMode() || SC_MOD()->IsFormulaMode(); |
| return m_bFormulaMode ; |
| } |
| sal_Bool ScAccessibleSpreadsheet::GetFormulaCurrentFocusCell(ScAddress &addr) |
| { |
| ScViewData *pViewData = mpViewShell->GetViewData(); |
| sal_uInt16 nRefX=0; |
| sal_Int32 nRefY=0; |
| if(m_bFormulaLastMode) |
| { |
| nRefX=pViewData->GetRefEndX(); |
| nRefY=pViewData->GetRefEndY(); |
| } |
| else |
| { |
| nRefX=pViewData->GetRefStartX(); |
| nRefY=pViewData->GetRefStartY(); |
| } |
| if( /* Always true: nRefX >= 0 && */ nRefX <= MAXCOL && nRefY >= 0 && nRefY <= MAXROW) |
| { |
| addr = ScAddress(nRefX,nRefY,pViewData->GetTabNo()); |
| return sal_True; |
| } |
| return sal_False; |
| } |
| uno::Reference < XAccessible > ScAccessibleSpreadsheet::GetActiveCell() |
| { |
| if( m_mapSelectionSend.find( maActiveCell ) != m_mapSelectionSend.end() ) |
| return m_mapSelectionSend[maActiveCell]; |
| else |
| return getAccessibleCellAt(maActiveCell.Row(), maActiveCell .Col()); |
| } |
