?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sync master with lastest vba changes
[ooovba.git] / sc / source / ui / unoobj / viewuno.cxx
blobbdd6dc6641ffa4cb3cf4b3c3350fddf211d2c22f
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: viewuno.cxx,v $
10 * $Revision: 1.37.24.3 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sc.hxx"
33
34
35
36 #include <svx/fmdpage.hxx>
37 #include <svx/svditer.hxx>
38 #include <svx/svdmark.hxx>
39 #include <svx/svdouno.hxx>
40 #include <svx/svdpage.hxx>
41 #include <svx/svdpagv.hxx>
42 #include <svx/svdview.hxx>
43 #include <svx/unoshape.hxx>
44 #include <svx/unoshcol.hxx>
45 #include <svx/fmshell.hxx>
46 #include <sfx2/bindings.hxx>
47 #include <sfx2/dispatch.hxx>
48 #include <sfx2/printer.hxx>
49 #include <sfx2/request.hxx>
50 #include <sfx2/viewfrm.hxx>
51 #include <rtl/uuid.h>
52 #include <toolkit/helper/convert.hxx>
53
54 #include "drawsh.hxx"
55 #include "drtxtob.hxx"
56 #include "transobj.hxx"
57 #include "editsh.hxx"
58 #include "viewuno.hxx"
59 #include "cellsuno.hxx"
60 #include "miscuno.hxx"
61 #include "tabvwsh.hxx"
62 #include "docsh.hxx"
63 #include "drwlayer.hxx"
64 #include "drawview.hxx"
65 #include "fupoor.hxx"
66 #include "sc.hrc"
67 #include "unoguard.hxx"
68 #include "unonames.hxx"
69 #include "scmod.hxx"
70 #include "appoptio.hxx"
71 #include "gridwin.hxx"
72 #include <com/sun/star/view/DocumentZoomType.hpp>
73 #include "AccessibilityHints.hxx"
74 #include <com/sun/star/awt/MouseButton.hpp>
75 #include <com/sun/star/document/XVbaEventsHelper.hpp>
76 #include <com/sun/star/document/VbaEventId.hpp>
77
78 using namespace com::sun::star;
79 using namespace com::sun::star::document::VbaEventId;
80
81 //------------------------------------------------------------------------
82
83 //! Clipping-Markierungen
84
85 // alles ohne Which-ID, Map nur fuer PropertySetInfo
86
87 const SfxItemPropertyMap* lcl_GetViewOptPropertyMap()
88 {
89 static SfxItemPropertyMap aViewOptPropertyMap_Impl[] =
90 {
91 {MAP_CHAR_LEN(OLD_UNO_COLROWHDR), 0, &getBooleanCppuType(), 0, 0},
92 {MAP_CHAR_LEN(SC_UNO_GRIDCOLOR), 0, &getCppuType((sal_Int32*)0), 0, 0},
93 {MAP_CHAR_LEN(SC_UNO_COLROWHDR), 0, &getBooleanCppuType(), 0, 0},
94 {MAP_CHAR_LEN(SC_UNO_HORSCROLL), 0, &getBooleanCppuType(), 0, 0},
95 {MAP_CHAR_LEN(SC_UNO_SHEETTABS), 0, &getBooleanCppuType(), 0, 0},
96 {MAP_CHAR_LEN(SC_UNO_VERTSCROLL), 0, &getBooleanCppuType(), 0, 0},
97 {MAP_CHAR_LEN(SC_UNO_HIDESPELL), 0, &getBooleanCppuType(), 0, 0}, /* deprecated #i91949 */
98 {MAP_CHAR_LEN(OLD_UNO_HORSCROLL), 0, &getBooleanCppuType(), 0, 0},
99 {MAP_CHAR_LEN(SC_UNO_OUTLSYMB), 0, &getBooleanCppuType(), 0, 0},
100 {MAP_CHAR_LEN(SC_UNO_VALUEHIGH), 0, &getBooleanCppuType(), 0, 0},
101 {MAP_CHAR_LEN(OLD_UNO_OUTLSYMB), 0, &getBooleanCppuType(), 0, 0},
102 {MAP_CHAR_LEN(OLD_UNO_SHEETTABS), 0, &getBooleanCppuType(), 0, 0},
103 {MAP_CHAR_LEN(SC_UNO_SHOWANCHOR), 0, &getBooleanCppuType(), 0, 0},
104 {MAP_CHAR_LEN(SC_UNO_SHOWCHARTS), 0, &getCppuType((sal_Int16*)0), 0, 0},
105 {MAP_CHAR_LEN(SC_UNO_SHOWDRAW), 0, &getCppuType((sal_Int16*)0), 0, 0},
106 {MAP_CHAR_LEN(SC_UNO_SHOWFORM), 0, &getBooleanCppuType(), 0, 0},
107 {MAP_CHAR_LEN(SC_UNO_SHOWGRID), 0, &getBooleanCppuType(), 0, 0},
108 {MAP_CHAR_LEN(SC_UNO_SHOWHELP), 0, &getBooleanCppuType(), 0, 0},
109 {MAP_CHAR_LEN(SC_UNO_SHOWNOTES), 0, &getBooleanCppuType(), 0, 0},
110 {MAP_CHAR_LEN(SC_UNO_SHOWOBJ), 0, &getCppuType((sal_Int16*)0), 0, 0},
111 {MAP_CHAR_LEN(SC_UNO_SHOWPAGEBR), 0, &getBooleanCppuType(), 0, 0},
112 {MAP_CHAR_LEN(SC_UNO_SHOWZERO), 0, &getBooleanCppuType(), 0, 0},
113 {MAP_CHAR_LEN(SC_UNO_SHOWSOLID), 0, &getBooleanCppuType(), 0, 0},
114 {MAP_CHAR_LEN(OLD_UNO_VALUEHIGH), 0, &getBooleanCppuType(), 0, 0},
115 {MAP_CHAR_LEN(OLD_UNO_VERTSCROLL), 0, &getBooleanCppuType(), 0, 0},
116 {MAP_CHAR_LEN(SC_UNO_VISAREA), 0, &getCppuType((awt::Rectangle*)0), 0, 0},
117 {MAP_CHAR_LEN(SC_UNO_ZOOMTYPE), 0, &getCppuType((sal_Int16*)0), 0, 0},
118 {MAP_CHAR_LEN(SC_UNO_ZOOMVALUE), 0, &getCppuType((sal_Int16*)0), 0, 0},
119 {0,0,0,0,0,0}
120 };
121 return aViewOptPropertyMap_Impl;
122 }
123
124 //------------------------------------------------------------------------
125
126 SV_IMPL_PTRARR( XRangeSelectionListenerArr_Impl, XRangeSelectionListenerPtr );
127 SV_IMPL_PTRARR( XRangeSelectionChangeListenerArr_Impl, XRangeSelectionChangeListenerPtr );
128 SV_IMPL_PTRARR( XSelectionChangeListenerArr_Impl, XSelectionChangeListenerPtr );
129 SV_IMPL_PTRARR( XViewPropertyChangeListenerArr_Impl, XViewPropertyChangeListenerPtr );
130 SV_IMPL_PTRARR( XMouseClickHandlerArr_Impl, XMouseClickHandlerPtr );
131 SV_IMPL_PTRARR( XActivationEventListenerArr_Impl, XActivationEventListenerPtr );
132
133 #define SCTABVIEWOBJ_SERVICE "com.sun.star.sheet.SpreadsheetView"
134 #define SCVIEWSETTINGS_SERVICE "com.sun.star.sheet.SpreadsheetViewSettings"
135
136 SC_SIMPLE_SERVICE_INFO( ScViewPaneBase, "ScViewPaneObj", "com.sun.star.sheet.SpreadsheetViewPane" )
137
138 //------------------------------------------------------------------------
139
140 ScViewPaneBase::ScViewPaneBase(ScTabViewShell* pViewSh, USHORT nP) :
141 pViewShell( pViewSh ),
142 nPane( nP )
143 {
144 if (pViewShell)
145 StartListening(*pViewShell);
146 }
147
148 ScViewPaneBase::~ScViewPaneBase()
149 {
150 if (pViewShell)
151 EndListening(*pViewShell);
152 }
153
154 void ScViewPaneBase::Notify( SfxBroadcaster&, const SfxHint& rHint )
155 {
156 if ( rHint.ISA( SfxSimpleHint ) &&
157 ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING )
158 pViewShell = NULL;
159 }
160
161 uno::Any SAL_CALL ScViewPaneBase::queryInterface( const uno::Type& rType )
162 throw(uno::RuntimeException)
163 {
164 SC_QUERYINTERFACE( sheet::XViewPane )
165 SC_QUERYINTERFACE( sheet::XCellRangeReferrer )
166 SC_QUERYINTERFACE( view::XFormLayerAccess )
167 SC_QUERYINTERFACE( view::XControlAccess )
168 SC_QUERYINTERFACE( lang::XServiceInfo )
169 SC_QUERYINTERFACE( lang::XTypeProvider )
170
171 return uno::Any(); // OWeakObject is in derived objects
172 }
173
174 uno::Sequence<uno::Type> SAL_CALL ScViewPaneBase::getTypes() throw(uno::RuntimeException)
175 {
176 static uno::Sequence<uno::Type> aTypes;
177 if ( aTypes.getLength() == 0 )
178 {
179 aTypes.realloc(5);
180 uno::Type* pPtr = aTypes.getArray();
181 pPtr[0] = getCppuType((const uno::Reference<sheet::XViewPane>*)0);
182 pPtr[1] = getCppuType((const uno::Reference<sheet::XCellRangeReferrer>*)0);
183 pPtr[2] = getCppuType((const uno::Reference<view::XFormLayerAccess>*)0);
184 pPtr[3] = getCppuType((const uno::Reference<lang::XServiceInfo>*)0);
185 pPtr[4] = getCppuType((const uno::Reference<lang::XTypeProvider>*)0);
186 }
187 return aTypes;
188 }
189
190 uno::Sequence<sal_Int8> SAL_CALL ScViewPaneBase::getImplementationId()
191 throw(uno::RuntimeException)
192 {
193 static uno::Sequence< sal_Int8 > aId;
194 if( aId.getLength() == 0 )
195 {
196 aId.realloc( 16 );
197 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
198 }
199 return aId;
200 }
201
202 // XViewPane
203
204 sal_Int32 SAL_CALL ScViewPaneBase::getFirstVisibleColumn() throw(uno::RuntimeException)
205 {
206 ScUnoGuard aGuard;
207 if (pViewShell)
208 {
209 ScViewData* pViewData = pViewShell->GetViewData();
210 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
211 pViewData->GetActivePart() :
212 (ScSplitPos) nPane;
213 ScHSplitPos eWhichH = WhichH( eWhich );
214
215 return pViewData->GetPosX( eWhichH );
216 }
217 DBG_ERROR("keine View ?!?"); //! Exception?
218 return 0;
219 }
220
221 void SAL_CALL ScViewPaneBase::setFirstVisibleColumn( sal_Int32 nFirstVisibleColumn )
222 throw(uno::RuntimeException)
223 {
224 ScUnoGuard aGuard;
225 if (pViewShell)
226 {
227 ScViewData* pViewData = pViewShell->GetViewData();
228 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
229 pViewData->GetActivePart() :
230 (ScSplitPos) nPane;
231 ScHSplitPos eWhichH = WhichH( eWhich );
232
233 long nDeltaX = ((long)nFirstVisibleColumn) - pViewData->GetPosX( eWhichH );
234 pViewShell->ScrollX( nDeltaX, eWhichH );
235 }
236 }
237
238 sal_Int32 SAL_CALL ScViewPaneBase::getFirstVisibleRow() throw(uno::RuntimeException)
239 {
240 ScUnoGuard aGuard;
241 if (pViewShell)
242 {
243 ScViewData* pViewData = pViewShell->GetViewData();
244 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
245 pViewData->GetActivePart() :
246 (ScSplitPos) nPane;
247 ScVSplitPos eWhichV = WhichV( eWhich );
248
249 return pViewData->GetPosY( eWhichV );
250 }
251 DBG_ERROR("keine View ?!?"); //! Exception?
252 return 0;
253 }
254
255 void SAL_CALL ScViewPaneBase::setFirstVisibleRow( sal_Int32 nFirstVisibleRow )
256 throw(uno::RuntimeException)
257 {
258 ScUnoGuard aGuard;
259 if (pViewShell)
260 {
261 ScViewData* pViewData = pViewShell->GetViewData();
262 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
263 pViewData->GetActivePart() :
264 (ScSplitPos) nPane;
265 ScVSplitPos eWhichV = WhichV( eWhich );
266
267 long nDeltaY = ((long)nFirstVisibleRow) - pViewData->GetPosY( eWhichV );
268 pViewShell->ScrollY( nDeltaY, eWhichV );
269 }
270 }
271
272 table::CellRangeAddress SAL_CALL ScViewPaneBase::getVisibleRange() throw(uno::RuntimeException)
273 {
274 ScUnoGuard aGuard;
275 table::CellRangeAddress aAdr;
276 if (pViewShell)
277 {
278 ScViewData* pViewData = pViewShell->GetViewData();
279 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
280 pViewData->GetActivePart() :
281 (ScSplitPos) nPane;
282 ScHSplitPos eWhichH = WhichH( eWhich );
283 ScVSplitPos eWhichV = WhichV( eWhich );
284
285 // VisibleCellsX gibt nur komplett sichtbare Zellen,
286 // VisibleRange in Excel auch teilweise sichtbare.
287 //! anpassen ???
288
289 SCCOL nVisX = pViewData->VisibleCellsX( eWhichH );
290 SCROW nVisY = pViewData->VisibleCellsY( eWhichV );
291 if (!nVisX) nVisX = 1; // irgendwas muss ja im Range sein
292 if (!nVisY) nVisY = 1;
293 aAdr.Sheet = pViewData->GetTabNo();
294 aAdr.StartColumn = pViewData->GetPosX( eWhichH );
295 aAdr.StartRow = pViewData->GetPosY( eWhichV );
296 aAdr.EndColumn = aAdr.StartColumn + nVisX - 1;
297 aAdr.EndRow = aAdr.StartRow + nVisY - 1;
298 }
299 return aAdr;
300 }
301
302 // XCellRangeSource
303
304 uno::Reference<table::XCellRange> SAL_CALL ScViewPaneBase::getReferredCells()
305 throw(uno::RuntimeException)
306 {
307 ScUnoGuard aGuard;
308 if (pViewShell)
309 {
310 ScDocShell* pDocSh = pViewShell->GetViewData()->GetDocShell();
311
312 table::CellRangeAddress aAdr(getVisibleRange()); //! Hilfsfunktion mit ScRange?
313 ScRange aRange( (SCCOL)aAdr.StartColumn, (SCROW)aAdr.StartRow, aAdr.Sheet,
314 (SCCOL)aAdr.EndColumn, (SCROW)aAdr.EndRow, aAdr.Sheet );
315 if ( aRange.aStart == aRange.aEnd )
316 return new ScCellObj( pDocSh, aRange.aStart );
317 else
318 return new ScCellRangeObj( pDocSh, aRange );
319 }
320
321 return NULL;
322 }
323
324 namespace
325 {
326 bool lcl_prepareFormShellCall( ScTabViewShell* _pViewShell, USHORT _nPane, FmFormShell*& _rpFormShell, Window*& _rpWindow, SdrView*& _rpSdrView )
327 {
328 if ( !_pViewShell )
329 return false;
330
331 ScViewData* pViewData = _pViewShell->GetViewData();
332 ScSplitPos eWhich = ( _nPane == SC_VIEWPANE_ACTIVE ) ?
333 pViewData->GetActivePart() :
334 (ScSplitPos) _nPane;
335 _rpWindow = _pViewShell->GetWindowByPos( eWhich );
336 _rpSdrView = _pViewShell->GetSdrView();
337 _rpFormShell = _pViewShell->GetFormShell();
338 return ( _rpFormShell != NULL ) && ( _rpSdrView != NULL )&& ( _rpWindow != NULL );
339 }
340 }
341
342 // XFormLayerAccess
343 uno::Reference< form::XFormController > SAL_CALL ScViewPaneBase::getFormController( const uno::Reference< form::XForm >& _Form ) throw (uno::RuntimeException)
344 {
345 ScUnoGuard aGuard;
346
347 uno::Reference< form::XFormController > xController;
348
349 Window* pWindow( NULL );
350 SdrView* pSdrView( NULL );
351 FmFormShell* pFormShell( NULL );
352 if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )
353 xController = pFormShell->GetFormController( _Form, *pSdrView, *pWindow );
354
355 return xController;
356 }
357
358 ::sal_Bool SAL_CALL ScViewPaneBase::isFormDesignMode( ) throw (uno::RuntimeException)
359 {
360 ScUnoGuard aGuard;
361
362 sal_Bool bIsFormDesignMode( sal_True );
363
364 FmFormShell* pFormShell( pViewShell ? pViewShell->GetFormShell() : NULL );
365 if ( pFormShell )
366 bIsFormDesignMode = pFormShell->IsDesignMode();
367
368 return bIsFormDesignMode;
369 }
370
371 void SAL_CALL ScViewPaneBase::setFormDesignMode( ::sal_Bool _DesignMode ) throw (uno::RuntimeException)
372 {
373 ScUnoGuard aGuard;
374
375 Window* pWindow( NULL );
376 SdrView* pSdrView( NULL );
377 FmFormShell* pFormShell( NULL );
378 if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )
379 pFormShell->SetDesignMode( _DesignMode );
380 }
381
382 // XControlAccess
383
384 uno::Reference<awt::XControl> SAL_CALL ScViewPaneBase::getControl(
385 const uno::Reference<awt::XControlModel>& xModel )
386 throw(container::NoSuchElementException, uno::RuntimeException)
387 {
388 ScUnoGuard aGuard;
389
390 uno::Reference<awt::XControl> xRet;
391
392 Window* pWindow( NULL );
393 SdrView* pSdrView( NULL );
394 FmFormShell* pFormShell( NULL );
395 if ( lcl_prepareFormShellCall( pViewShell, nPane, pFormShell, pWindow, pSdrView ) )
396 pFormShell->GetFormControl( xModel, *pSdrView, *pWindow, xRet );
397
398 if ( !xRet.is() )
399 throw container::NoSuchElementException(); // no control found
400
401 return xRet;
402 }
403
404 awt::Rectangle ScViewPaneBase::GetVisArea() const
405 {
406 awt::Rectangle aVisArea;
407 if (pViewShell)
408 {
409 ScSplitPos eWhich = ( nPane == SC_VIEWPANE_ACTIVE ) ?
410 pViewShell->GetViewData()->GetActivePart() :
411 (ScSplitPos) nPane;
412 ScGridWindow* pWindow = (ScGridWindow*)pViewShell->GetWindowByPos(eWhich);
413 ScDocument* pDoc = pViewShell->GetViewData()->GetDocument();
414 if (pWindow && pDoc)
415 {
416 ScHSplitPos eWhichH = ((eWhich == SC_SPLIT_TOPLEFT) || (eWhich == SC_SPLIT_BOTTOMLEFT)) ?
417 SC_SPLIT_LEFT : SC_SPLIT_RIGHT;
418 ScVSplitPos eWhichV = ((eWhich == SC_SPLIT_TOPLEFT) || (eWhich == SC_SPLIT_TOPRIGHT)) ?
419 SC_SPLIT_TOP : SC_SPLIT_BOTTOM;
420 ScAddress aCell(pViewShell->GetViewData()->GetPosX(eWhichH),
421 pViewShell->GetViewData()->GetPosY(eWhichV),
422 pViewShell->GetViewData()->GetTabNo());
423 Rectangle aVisRect(pDoc->GetMMRect(aCell.Col(), aCell.Row(), aCell.Col(), aCell.Row(), aCell.Tab()));
424
425 aVisRect.SetSize(pWindow->PixelToLogic(pWindow->GetSizePixel(), pWindow->GetDrawMapMode(sal_True)));
426
427 aVisArea = AWTRectangle(aVisRect);
428 }
429 }
430 return aVisArea;
431 }
432
433 //------------------------------------------------------------------------
434
435 ScViewPaneObj::ScViewPaneObj(ScTabViewShell* pViewSh, USHORT nP) :
436 ScViewPaneBase( pViewSh, nP )
437 {
438 }
439
440 ScViewPaneObj::~ScViewPaneObj()
441 {
442 }
443
444 uno::Any SAL_CALL ScViewPaneObj::queryInterface( const uno::Type& rType )
445 throw(uno::RuntimeException)
446 {
447 // ScViewPaneBase has everything except OWeakObject
448
449 uno::Any aRet(ScViewPaneBase::queryInterface( rType ));
450 if (!aRet.hasValue())
451 aRet = OWeakObject::queryInterface( rType );
452 return aRet;
453 }
454
455 void SAL_CALL ScViewPaneObj::acquire() throw()
456 {
457 OWeakObject::acquire();
458 }
459
460 void SAL_CALL ScViewPaneObj::release() throw()
461 {
462 OWeakObject::release();
463 }
464
465 // To process sheet compatibile event
466 typedef ::cppu::WeakImplHelper2< awt::XEnhancedMouseClickHandler, view::XSelectionChangeListener > TabViewEventListener_BASE;
467 class ScTabViewEventListener: public TabViewEventListener_BASE
468 {
469 private:
470 uno::Reference< document::XVbaEventsHelper > xVbaEventsHelper;
471 ScTabViewObj* pViewObj;
472
473 public:
474 ScTabViewEventListener( ScTabViewObj* pObj, uno::Reference< document::XVbaEventsHelper >& rVbaEventsHelper);
475 ~ScTabViewEventListener();
476 // XEnhancedMouseClickHandler
477 virtual sal_Bool SAL_CALL mousePressed( const awt::EnhancedMouseEvent& e ) throw (uno::RuntimeException);
478 virtual sal_Bool SAL_CALL mouseReleased( const awt::EnhancedMouseEvent& e ) throw (uno::RuntimeException);
479
480 // XSelectionChangeListener
481 virtual void SAL_CALL selectionChanged( const lang::EventObject& aEvent ) throw ( uno::RuntimeException );
482 // XEventListener
483 virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) throw ( uno::RuntimeException );
484 };
485
486 ScTabViewEventListener::ScTabViewEventListener(ScTabViewObj* pObj, uno::Reference< document::XVbaEventsHelper >& rVbaEventsHelper):
487 pViewObj( pObj ),xVbaEventsHelper( rVbaEventsHelper )
488 {
489 }
490
491 ScTabViewEventListener::~ScTabViewEventListener()
492 {
493 }
494
495 void SAL_CALL ScTabViewEventListener::disposing( const lang::EventObject& /*aEvent*/ ) throw ( uno::RuntimeException )
496 {
497 }
498
499 sal_Bool SAL_CALL ScTabViewEventListener::mousePressed( const awt::EnhancedMouseEvent& e ) throw (uno::RuntimeException)
500 {
501 sal_Bool result = sal_False;
502 // process BeforeDoubleClick and BeforeRightClick events
503 if( e.ClickCount == 2 || e.Buttons == ::com::sun::star::awt::MouseButton::RIGHT )
504 {
505 // ensure the target is a cell
506 uno::Reference< table::XCell > xCell( e.Target, uno::UNO_QUERY );
507 if( xCell.is() && xVbaEventsHelper.is() && pViewObj)
508 {
509 uno::Sequence< uno::Any > aArgs(1);
510 aArgs[0] = pViewObj->getSelection();
511 sal_Int32 nEventId = VBAEVENT_WORKSHEET_BEFORERIGHTCLICK;
512 if( e.ClickCount == 2 )
513 nEventId = VBAEVENT_WORKSHEET_BEFOREDOUBLECLICK;
514
515 result = xVbaEventsHelper->ProcessCompatibleVbaEvent( nEventId, aArgs );
516 // TODO: process Cancel argument
517 }
518 }
519 return result;
520 }
521
522 sal_Bool SAL_CALL ScTabViewEventListener::mouseReleased( const awt::EnhancedMouseEvent&/*e*/) throw (uno::RuntimeException)
523 {
524 return sal_False;
525 }
526
527 void SAL_CALL ScTabViewEventListener::selectionChanged( const lang::EventObject& /*aEvent*/ ) throw ( uno::RuntimeException )
528 {
529 if ( xVbaEventsHelper.is() && pViewObj)
530 {
531 uno::Sequence< uno::Any > aArgs(1);
532 aArgs[0] = pViewObj->getSelection();
533 xVbaEventsHelper->ProcessCompatibleVbaEvent( VBAEVENT_WORKSHEET_SELECTIONCHANGE, aArgs );
534 }
535 }
536
537 //------------------------------------------------------------------------
538
539 // Default-ctor wird fuer SMART_REFLECTION_IMPLEMENTATION gebraucht
540
541 //UNUSED2008-05 ScTabViewObj::ScTabViewObj() :
542 //UNUSED2008-05 ScViewPaneBase( NULL, SC_VIEWPANE_ACTIVE ),
543 //UNUSED2008-05 SfxBaseController( NULL ),
544 //UNUSED2008-05 aPropSet( lcl_GetViewOptPropertyMap() ),
545 //UNUSED2008-05 aMouseClickHandlers( 0 ),
546 //UNUSED2008-05 aActivationListeners( 0 ),
547 //UNUSED2008-05 bDrawSelModeSet(sal_False),
548 //UNUSED2008-05 bFilteredRangeSelection(sal_True)
549 //UNUSED2008-05 {
550 //UNUSED2008-05 }
551
552 ScTabViewObj::ScTabViewObj( ScTabViewShell* pViewSh ) :
553 ScViewPaneBase( pViewSh, SC_VIEWPANE_ACTIVE ),
554 SfxBaseController( pViewSh ),
555 aPropSet( lcl_GetViewOptPropertyMap() ),
556 aMouseClickHandlers( 0 ),
557 aActivationListeners( 0 ),
558 bDrawSelModeSet(sal_False),
559 bFilteredRangeSelection(sal_True)
560 {
561 if( pViewSh )
562 {
563 ScViewData* pViewData = pViewSh->GetViewData();
564 if( pViewData )
565 {
566 uno::Reference< document::XVbaEventsHelper > xVbaEventsHelper (pViewData->GetDocument()->GetVbaEventsHelper(), uno::UNO_QUERY );
567 ScTabViewEventListener* pEventListener = new ScTabViewEventListener( this, xVbaEventsHelper );
568 uno::Reference< awt::XEnhancedMouseClickHandler > aMouseClickHandler( *pEventListener, uno::UNO_QUERY );
569 addEnhancedMouseClickHandler( aMouseClickHandler );
570 uno::Reference< view::XSelectionChangeListener > aSelectionChangeListener( *pEventListener, uno::UNO_QUERY );
571 addSelectionChangeListener( aSelectionChangeListener );
572 }
573 }
574 }
575
576 ScTabViewObj::~ScTabViewObj()
577 {
578 //! Listening oder so
579 if (aMouseClickHandlers.Count())
580 {
581 acquire();
582 EndMouseListening();
583 }
584 if (aActivationListeners.Count())
585 {
586 acquire();
587 EndActivationListening();
588 }
589 }
590
591 uno::Any SAL_CALL ScTabViewObj::queryInterface( const uno::Type& rType )
592 throw(uno::RuntimeException)
593 {
594 SC_QUERYINTERFACE( sheet::XSpreadsheetView )
595 SC_QUERYINTERFACE( sheet::XEnhancedMouseClickBroadcaster )
596 SC_QUERYINTERFACE( sheet::XActivationBroadcaster )
597 SC_QUERYINTERFACE( container::XEnumerationAccess )
598 SC_QUERYINTERFACE( container::XIndexAccess )
599 SC_QUERY_MULTIPLE( container::XElementAccess, container::XIndexAccess )
600 SC_QUERYINTERFACE( view::XSelectionSupplier )
601 SC_QUERYINTERFACE( beans::XPropertySet )
602 SC_QUERYINTERFACE( sheet::XViewSplitable )
603 SC_QUERYINTERFACE( sheet::XViewFreezable )
604 SC_QUERYINTERFACE( sheet::XRangeSelection )
605 SC_QUERYINTERFACE( lang::XUnoTunnel )
606 SC_QUERYINTERFACE( datatransfer::XTransferableSupplier )
607
608 uno::Any aRet(ScViewPaneBase::queryInterface( rType ));
609 if (!aRet.hasValue())
610 aRet = SfxBaseController::queryInterface( rType );
611 return aRet;
612 }
613
614 void SAL_CALL ScTabViewObj::acquire() throw()
615 {
616 SfxBaseController::acquire();
617 }
618
619 void SAL_CALL ScTabViewObj::release() throw()
620 {
621 SfxBaseController::release();
622 }
623
624 void ScTabViewObj::SheetChanged()
625 {
626 if (aActivationListeners.Count() > 0 && GetViewShell())
627 {
628 sheet::ActivationEvent aEvent;
629 uno::Reference< sheet::XSpreadsheetView > xView(this);
630 uno::Reference< uno::XInterface > xSource(xView, uno::UNO_QUERY);
631 aEvent.Source = xSource;
632 aEvent.ActiveSheet = new ScTableSheetObj(GetViewShell()->GetViewData()->GetDocShell(), GetViewShell()->GetViewData()->GetTabNo());
633 for ( USHORT n=0; n<aActivationListeners.Count(); n++ )
634 {
635 try
636 {
637 (*aActivationListeners[n])->activeSpreadsheetChanged( aEvent );
638 }
639 catch( uno::Exception& )
640 {
641 aActivationListeners.DeleteAndDestroy( n );
642 --n; // because it will be increased again in the loop
643 }
644 }
645 }
646 }
647
648 uno::Sequence<uno::Type> SAL_CALL ScTabViewObj::getTypes() throw(uno::RuntimeException)
649 {
650 static uno::Sequence<uno::Type> aTypes;
651 if ( aTypes.getLength() == 0 )
652 {
653 uno::Sequence<uno::Type> aViewPaneTypes(ScViewPaneBase::getTypes());
654 long nViewPaneLen = aViewPaneTypes.getLength();
655 const uno::Type* pViewPanePtr = aViewPaneTypes.getConstArray();
656
657 uno::Sequence<uno::Type> aControllerTypes(SfxBaseController::getTypes());
658 long nControllerLen = aControllerTypes.getLength();
659 const uno::Type* pControllerPtr = aControllerTypes.getConstArray();
660
661 long nParentLen = nViewPaneLen + nControllerLen;
662
663 aTypes.realloc( nParentLen + 12 );
664 uno::Type* pPtr = aTypes.getArray();
665 pPtr[nParentLen + 0] = getCppuType((const uno::Reference<sheet::XSpreadsheetView>*)0);
666 pPtr[nParentLen + 1] = getCppuType((const uno::Reference<container::XEnumerationAccess>*)0);
667 pPtr[nParentLen + 2] = getCppuType((const uno::Reference<container::XIndexAccess>*)0);
668 pPtr[nParentLen + 3] = getCppuType((const uno::Reference<view::XSelectionSupplier>*)0);
669 pPtr[nParentLen + 4] = getCppuType((const uno::Reference<beans::XPropertySet>*)0);
670 pPtr[nParentLen + 5] = getCppuType((const uno::Reference<sheet::XViewSplitable>*)0);
671 pPtr[nParentLen + 6] = getCppuType((const uno::Reference<sheet::XViewFreezable>*)0);
672 pPtr[nParentLen + 7] = getCppuType((const uno::Reference<sheet::XRangeSelection>*)0);
673 pPtr[nParentLen + 8] = getCppuType((const uno::Reference<lang::XUnoTunnel>*)0);
674 pPtr[nParentLen + 9] = getCppuType((const uno::Reference<sheet::XEnhancedMouseClickBroadcaster>*)0);
675 pPtr[nParentLen + 10] = getCppuType((const uno::Reference<sheet::XActivationBroadcaster>*)0);
676 pPtr[nParentLen + 11] = getCppuType((const uno::Reference<datatransfer::XTransferableSupplier>*)0);
677
678 long i;
679 for (i=0; i<nViewPaneLen; i++)
680 pPtr[i] = pViewPanePtr[i]; // parent types first
681 for (i=0; i<nControllerLen; i++)
682 pPtr[nViewPaneLen+i] = pControllerPtr[i];
683 }
684 return aTypes;
685 }
686
687 uno::Sequence<sal_Int8> SAL_CALL ScTabViewObj::getImplementationId()
688 throw(uno::RuntimeException)
689 {
690 static uno::Sequence< sal_Int8 > aId;
691 if( aId.getLength() == 0 )
692 {
693 aId.realloc( 16 );
694 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
695 }
696 return aId;
697 }
698
699 // XDocumentView
700
701 BOOL lcl_TabInRanges( SCTAB nTab, const ScRangeList& rRanges )
702 {
703 ULONG nCount = rRanges.Count();
704 for (ULONG i=0; i<nCount; i++)
705 {
706 const ScRange* pRange = rRanges.GetObject(i);
707 if ( nTab >= pRange->aStart.Tab() && nTab <= pRange->aEnd.Tab() )
708 return TRUE;
709 }
710 return FALSE;
711 }
712
713 void lcl_ShowObject( ScTabViewShell& rViewSh, ScDrawView& rDrawView, SdrObject* pSelObj )
714 {
715 BOOL bFound = FALSE;
716 SCTAB nObjectTab = 0;
717
718 SdrModel* pModel = rDrawView.GetModel();
719 USHORT nPageCount = pModel->GetPageCount();
720 for (USHORT i=0; i<nPageCount && !bFound; i++)
721 {
722 SdrPage* pPage = pModel->GetPage(i);
723 if (pPage)
724 {
725 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
726 SdrObject* pObject = aIter.Next();
727 while (pObject && !bFound)
728 {
729 if ( pObject == pSelObj )
730 {
731 bFound = TRUE;
732 nObjectTab = static_cast<SCTAB>(i);
733 }
734 pObject = aIter.Next();
735 }
736 }
737 }
738
739 if (bFound)
740 {
741 rViewSh.SetTabNo( nObjectTab );
742 rViewSh.ScrollToObject( pSelObj );
743 }
744 }
745
746 sal_Bool SAL_CALL ScTabViewObj::select( const uno::Any& aSelection )
747 throw(lang::IllegalArgumentException, uno::RuntimeException)
748 {
749 ScUnoGuard aGuard;
750 ScTabViewShell* pViewSh = GetViewShell();
751
752 if ( !pViewSh )
753 return FALSE;
754
755 //! Type of aSelection can be some specific interface instead of XInterface
756
757 BOOL bRet = FALSE;
758 uno::Reference<uno::XInterface> xInterface(aSelection, uno::UNO_QUERY);
759 if ( !xInterface.is() ) //clear all selections
760 {
761 ScDrawView* pDrawView = pViewSh->GetScDrawView();
762 if (pDrawView)
763 {
764 pDrawView->ScEndTextEdit();
765 pDrawView->UnmarkAll();
766 }
767 else //#102232#; if there is no DrawView remove range selection
768 pViewSh->Unmark();
769 bRet = TRUE;
770 }
771
772 if (bDrawSelModeSet) // remove DrawSelMode if set by API; if necessary it will be set again later
773 {
774 pViewSh->SetDrawSelMode(sal_False);
775 pViewSh->UpdateLayerLocks();
776 bDrawSelModeSet = sal_False;
777 }
778
779 if (bRet)
780 return bRet;
781
782
783 ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xInterface );
784 uno::Reference<drawing::XShapes> xShapeColl( xInterface, uno::UNO_QUERY );
785 uno::Reference<drawing::XShape> xShapeSel( xInterface, uno::UNO_QUERY );
786 SvxShape* pShapeImp = SvxShape::getImplementation( xShapeSel );
787
788 if (pRangesImp) // Zell-Ranges
789 {
790 ScViewData* pViewData = pViewSh->GetViewData();
791 if ( pViewData->GetDocShell() == pRangesImp->GetDocShell() )
792 {
793 // Zuerst evtl. Drawing-Selektion aufheben
794 // (MarkListHasChanged hebt Tabellen-Selektion auf)
795
796 ScDrawView* pDrawView = pViewSh->GetScDrawView();
797 if (pDrawView)
798 {
799 pDrawView->ScEndTextEdit();
800 pDrawView->UnmarkAll();
801 }
802 FuPoor* pFunc = pViewSh->GetDrawFuncPtr();
803 if ( pFunc && pFunc->GetSlotID() != SID_OBJECT_SELECT )
804 {
805 // Slot der Zeichenfunktion nochmal ausfuehren -> abschalten
806 SfxDispatcher* pDisp = pViewSh->GetDispatcher();
807 if (pDisp)
808 pDisp->Execute( pFunc->GetSlotID(), SFX_CALLMODE_SYNCHRON );
809 }
810 pViewSh->SetDrawShell(FALSE);
811 pViewSh->SetDrawSelMode(FALSE); // nach dem Dispatcher-Execute
812
813 // Ranges selektieren
814
815 const ScRangeList& rRanges = pRangesImp->GetRangeList();
816 ULONG nRangeCount = rRanges.Count();
817 // for empty range list, remove selection (cursor remains where it was)
818 if ( nRangeCount == 0 )
819 pViewSh->Unmark();
820 else if ( nRangeCount == 1 )
821 pViewSh->MarkRange( *rRanges.GetObject(0) );
822 else
823 {
824 // Mehrfachselektion
825
826 const ScRange* pFirst = rRanges.GetObject(0);
827 if ( pFirst && !lcl_TabInRanges( pViewData->GetTabNo(), rRanges ) )
828 pViewSh->SetTabNo( pFirst->aStart.Tab() );
829 pViewSh->DoneBlockMode();
830 pViewSh->InitOwnBlockMode();
831 pViewData->GetMarkData().MarkFromRangeList( rRanges, TRUE );
832 pViewSh->MarkDataChanged();
833 pViewData->GetDocShell()->PostPaintGridAll(); // Markierung (alt&neu)
834 if ( pFirst )
835 {
836 pViewSh->AlignToCursor( pFirst->aStart.Col(), pFirst->aStart.Row(),
837 SC_FOLLOW_JUMP );
838 pViewSh->SetCursor( pFirst->aStart.Col(), pFirst->aStart.Row() );
839 }
840
841 //! Methode an der View, um RangeList zu selektieren
842 }
843 bRet = TRUE;
844 }
845 }
846 else if ( pShapeImp || xShapeColl.is() ) // Drawing-Layer
847 {
848 ScDrawView* pDrawView = pViewSh->GetScDrawView();
849 if (pDrawView)
850 {
851 pDrawView->ScEndTextEdit();
852 pDrawView->UnmarkAll();
853
854 if (pShapeImp) // einzelnes Shape
855 {
856 SdrObject *pObj = pShapeImp->GetSdrObject();
857 if (pObj)
858 {
859 lcl_ShowObject( *pViewSh, *pDrawView, pObj );
860 SdrPageView* pPV = pDrawView->GetSdrPageView();
861 if ( pPV && pObj->GetPage() == pPV->GetPage() )
862 {
863 pDrawView->MarkObj( pObj, pPV );
864 bRet = TRUE;
865 }
866 }
867 }
868 else // Shape-Collection (xShapeColl ist nicht 0)
869 {
870 // Es wird auf die Tabelle des ersten Objekts umgeschaltet,
871 // und alle Objekte selektiert, die auf dieser Tabelle liegen
872 //! Exception, wenn Objekte auf verschiedenen Tabellen?
873
874 SdrPageView* pPV = NULL;
875 long nCount = xShapeColl->getCount();
876 if (nCount)
877 {
878 sal_Bool bAllMarked(sal_True);
879 for ( long i = 0; i < nCount; i++ )
880 {
881 uno::Reference<drawing::XShape> xShapeInt(xShapeColl->getByIndex(i), uno::UNO_QUERY);
882 if (xShapeInt.is())
883 {
884 SvxShape* pShape = SvxShape::getImplementation( xShapeInt );
885 if (pShape)
886 {
887 SdrObject *pObj = pShape->GetSdrObject();
888 if (pObj)
889 {
890 if (!bDrawSelModeSet && (pObj->GetLayer() == SC_LAYER_BACK))
891 {
892 pViewSh->SetDrawSelMode(sal_True);
893 pViewSh->UpdateLayerLocks();
894 bDrawSelModeSet = sal_True;
895 }
896 if (!pPV) // erstes Objekt
897 {
898 lcl_ShowObject( *pViewSh, *pDrawView, pObj );
899 pPV = pDrawView->GetSdrPageView();
900 }
901 if ( pPV && pObj->GetPage() == pPV->GetPage() )
902 {
903 if (pDrawView->IsObjMarkable( pObj, pPV ))
904 pDrawView->MarkObj( pObj, pPV );
905 else
906 bAllMarked = sal_False;
907 }
908 }
909 }
910 }
911 }
912 if (bAllMarked)
913 bRet = TRUE;
914 }
915 else
916 bRet = TRUE; // empty XShapes (all shapes are deselected)
917 }
918
919 if (bRet)
920 pViewSh->SetDrawShell(TRUE);
921 }
922 }
923
924 if (!bRet)
925 throw lang::IllegalArgumentException();
926
927 return bRet;
928 }
929
930 uno::Any SAL_CALL ScTabViewObj::getSelection() throw(uno::RuntimeException)
931 {
932 ScUnoGuard aGuard;
933 ScTabViewShell* pViewSh = GetViewShell();
934 ScCellRangesBase* pObj = NULL;
935 if (pViewSh)
936 {
937 // Ist auf dem Drawing-Layer etwas selektiert?
938
939 SdrView* pDrawView = pViewSh->GetSdrView();
940 if (pDrawView)
941 {
942 const SdrMarkList& rMarkList = pDrawView->GetMarkedObjectList();
943 ULONG nMarkCount = rMarkList.GetMarkCount();
944 if (nMarkCount)
945 {
946 // ShapeCollection erzeugen (wie in SdXImpressView::getSelection im Draw)
947 // Zurueckgegeben wird XInterfaceRef, das muss das UsrObject-XInterface sein
948
949 SvxShapeCollection* pShapes = new SvxShapeCollection();
950 uno::Reference<uno::XInterface> xRet(static_cast<cppu::OWeakObject*>(pShapes));
951
952 for (ULONG i=0; i<nMarkCount; i++)
953 {
954 SdrObject* pDrawObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
955 if (pDrawObj)
956 {
957 uno::Reference<drawing::XShape> xShape( pDrawObj->getUnoShape(), uno::UNO_QUERY );
958 if (xShape.is())
959 pShapes->add(xShape);
960 }
961 }
962 return uno::makeAny(xRet);
963 }
964 }
965
966 // sonst Tabellen-(Zellen-)Selektion
967
968 ScViewData* pViewData = pViewSh->GetViewData();
969 ScDocShell* pDocSh = pViewData->GetDocShell();
970
971 const ScMarkData& rMark = pViewData->GetMarkData();
972 SCTAB nTabs = rMark.GetSelectCount();
973
974 ScRange aRange;
975 ScMarkType eMarkType = pViewData->GetSimpleArea(aRange);
976
977 if (!bFilteredRangeSelection)
978 {
979 if (eMarkType == SC_MARK_SIMPLE_FILTERED)
980 eMarkType = SC_MARK_SIMPLE;
981 else if (eMarkType == SC_MARK_FILTERED)
982 eMarkType = SC_MARK_MULTI;
983 }
984
985 if ( nTabs == 1 && (eMarkType == SC_MARK_SIMPLE) )
986 {
987 if (aRange.aStart == aRange.aEnd)
988 pObj = new ScCellObj( pDocSh, aRange.aStart );
989 else
990 pObj = new ScCellRangeObj( pDocSh, aRange );
991 }
992 else if ( nTabs == 1 && (eMarkType == SC_MARK_SIMPLE_FILTERED) )
993 {
994 ScMarkData aFilteredMark( rMark );
995 ScViewUtil::UnmarkFiltered( aFilteredMark, pDocSh->GetDocument());
996 ScRangeList aRangeList;
997 aFilteredMark.FillRangeListWithMarks( &aRangeList, FALSE);
998 // Theoretically a selection may start and end on a filtered row.
999 switch (aRangeList.Count())
1000 {
1001 case 0:
1002 // No unfiltered row, we have to return some object, so
1003 // here is one with no ranges.
1004 pObj = new ScCellRangesObj( pDocSh, aRangeList );
1005 break;
1006 case 1:
1007 {
1008 const ScRange& rRange = *(aRangeList.GetObject(0));
1009 if (rRange.aStart == rRange.aEnd)
1010 pObj = new ScCellObj( pDocSh, rRange.aStart );
1011 else
1012 pObj = new ScCellRangeObj( pDocSh, rRange );
1013 }
1014 break;
1015 default:
1016 pObj = new ScCellRangesObj( pDocSh, aRangeList );
1017 }
1018 }
1019 else // Mehrfachselektion
1020 {
1021 ScRangeListRef xRanges;
1022 pViewData->GetMultiArea( xRanges );
1023
1024 // bei mehreren Tabellen Ranges kopieren
1025 //! sollte eigentlich schon in ScMarkData::FillRangeListWithMarks passieren?
1026 if ( nTabs > 1 )
1027 rMark.ExtendRangeListTables( xRanges );
1028
1029 pObj = new ScCellRangesObj( pDocSh, *xRanges );
1030 }
1031
1032 if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
1033 {
1034 // remember if the selection was from the cursor position without anything selected
1035 // (used when rendering the selection)
1036
1037 pObj->SetCursorOnly( TRUE );
1038 }
1039 }
1040
1041 return uno::makeAny(uno::Reference<uno::XInterface>(static_cast<cppu::OWeakObject*>(pObj)));
1042 }
1043
1044
1045 #if 0
1046 // XPrintable
1047
1048 rtl::OUString ScTabViewObj::getPrinterName(void) const
1049 {
1050 ScUnoGuard aGuard;
1051 ScTabViewShell* pViewSh = GetViewShell();
1052 if (pViewSh)
1053 {
1054 SfxPrinter* pPrinter = pViewSh->GetPrinter(TRUE);
1055 if (pPrinter)
1056 return pPrinter->GetName();
1057 }
1058
1059 DBG_ERROR("getPrinterName: keine View oder kein Printer");
1060 return rtl::OUString();
1061 }
1062
1063 void ScTabViewObj::setPrinterName(const rtl::OUString& PrinterName)
1064 {
1065 ScUnoGuard aGuard;
1066 // Drucker setzen - wie in SfxViewShell::ExecPrint_Impl
1067
1068 ScTabViewShell* pViewSh = GetViewShell();
1069 if (pViewSh)
1070 {
1071 SfxPrinter* pPrinter = pViewSh->GetPrinter(TRUE);
1072 if (pPrinter)
1073 {
1074 String aString(PrinterName);
1075 SfxPrinter* pNewPrinter = new SfxPrinter( pPrinter->GetOptions().Clone(), aString );
1076 if (pNewPrinter->IsKnown())
1077 pViewSh->SetPrinter( pNewPrinter, SFX_PRINTER_PRINTER );
1078 else
1079 delete pNewPrinter;
1080 }
1081 }
1082 }
1083
1084 XPropertySetRef ScTabViewObj::createPrintOptions(void)
1085 {
1086 ScUnoGuard aGuard;
1087 return new ScPrintSettingsObj; //! ScPrintSettingsObj implementieren!
1088 }
1089
1090 void ScTabViewObj::print(const XPropertySetRef& xOptions)
1091 {
1092 ScUnoGuard aGuard;
1093 ScTabViewShell* pViewSh = GetViewShell();
1094 if (pViewSh)
1095 {
1096 //! xOptions auswerten (wie denn?)
1097
1098 SfxRequest aReq( SID_PRINTDOCDIRECT, SFX_CALLMODE_SYNCHRON, pViewSh->GetPool() );
1099 pViewSh->ExecuteSlot( aReq );
1100 }
1101 }
1102 #endif
1103
1104 // XEnumerationAccess
1105
1106 uno::Reference<container::XEnumeration> SAL_CALL ScTabViewObj::createEnumeration()
1107 throw(uno::RuntimeException)
1108 {
1109 ScUnoGuard aGuard;
1110 return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SpreadsheetViewPanesEnumeration")));
1111 }
1112
1113 // XIndexAccess
1114
1115 sal_Int32 SAL_CALL ScTabViewObj::getCount() throw(uno::RuntimeException)
1116 {
1117 ScUnoGuard aGuard;
1118 ScTabViewShell* pViewSh = GetViewShell();
1119 USHORT nPanes = 0;
1120 if (pViewSh)
1121 {
1122 nPanes = 1;
1123 ScViewData* pViewData = pViewSh->GetViewData();
1124 if ( pViewData->GetHSplitMode() != SC_SPLIT_NONE )
1125 nPanes *= 2;
1126 if ( pViewData->GetVSplitMode() != SC_SPLIT_NONE )
1127 nPanes *= 2;
1128 }
1129 return nPanes;
1130 }
1131
1132 uno::Any SAL_CALL ScTabViewObj::getByIndex( sal_Int32 nIndex )
1133 throw(lang::IndexOutOfBoundsException,
1134 lang::WrappedTargetException, uno::RuntimeException)
1135 {
1136 ScUnoGuard aGuard;
1137 uno::Reference<sheet::XViewPane> xPane(GetObjectByIndex_Impl((USHORT)nIndex));
1138 if (xPane.is())
1139 return uno::makeAny(xPane);
1140 else
1141 throw lang::IndexOutOfBoundsException();
1142 // return uno::Any();
1143 }
1144
1145 uno::Type SAL_CALL ScTabViewObj::getElementType() throw(uno::RuntimeException)
1146 {
1147 ScUnoGuard aGuard;
1148 return getCppuType((uno::Reference<sheet::XViewPane>*)0);
1149 }
1150
1151 sal_Bool SAL_CALL ScTabViewObj::hasElements() throw(uno::RuntimeException)
1152 {
1153 ScUnoGuard aGuard;
1154 return ( getCount() != 0 );
1155 }
1156
1157 // XSpreadsheetView
1158
1159 ScViewPaneObj* ScTabViewObj::GetObjectByIndex_Impl(USHORT nIndex) const
1160 {
1161 static ScSplitPos ePosHV[4] =
1162 { SC_SPLIT_TOPLEFT, SC_SPLIT_BOTTOMLEFT, SC_SPLIT_TOPRIGHT, SC_SPLIT_BOTTOMRIGHT };
1163
1164 ScTabViewShell* pViewSh = GetViewShell();
1165 if (pViewSh)
1166 {
1167 ScSplitPos eWhich = SC_SPLIT_BOTTOMLEFT; // default Position
1168 BOOL bError = FALSE;
1169 ScViewData* pViewData = pViewSh->GetViewData();
1170 BOOL bHor = ( pViewData->GetHSplitMode() != SC_SPLIT_NONE );
1171 BOOL bVer = ( pViewData->GetVSplitMode() != SC_SPLIT_NONE );
1172 if ( bHor && bVer )
1173 {
1174 // links oben, links unten, rechts oben, rechts unten - wie in Excel
1175 if ( nIndex < 4 )
1176 eWhich = ePosHV[nIndex];
1177 else
1178 bError = TRUE;
1179 }
1180 else if ( bHor )
1181 {
1182 if ( nIndex > 1 )
1183 bError = TRUE;
1184 else if ( nIndex == 1 )
1185 eWhich = SC_SPLIT_BOTTOMRIGHT;
1186 // sonst SC_SPLIT_BOTTOMLEFT
1187 }
1188 else if ( bVer )
1189 {
1190 if ( nIndex > 1 )
1191 bError = TRUE;
1192 else if ( nIndex == 0 )
1193 eWhich = SC_SPLIT_TOPLEFT;
1194 // sonst SC_SPLIT_BOTTOMLEFT
1195 }
1196 else if ( nIndex > 0 )
1197 bError = TRUE; // nicht geteilt: nur 0 gueltig
1198
1199 if (!bError)
1200 return new ScViewPaneObj( pViewSh, sal::static_int_cast<USHORT>(eWhich) );
1201 }
1202
1203 return NULL;
1204 }
1205
1206 uno::Reference<sheet::XSpreadsheet> SAL_CALL ScTabViewObj::getActiveSheet()
1207 throw(uno::RuntimeException)
1208 {
1209 ScUnoGuard aGuard;
1210 ScTabViewShell* pViewSh = GetViewShell();
1211 if (pViewSh)
1212 {
1213 ScViewData* pData = pViewSh->GetViewData();
1214 SCTAB nTab = pData->GetTabNo();
1215 return new ScTableSheetObj( pData->GetDocShell(), nTab );
1216 }
1217 return NULL;
1218 }
1219
1220 void SAL_CALL ScTabViewObj::setActiveSheet( const uno::Reference<sheet::XSpreadsheet>& xActiveSheet )
1221 throw(uno::RuntimeException)
1222 {
1223 ScUnoGuard aGuard;
1224
1225 ScTabViewShell* pViewSh = GetViewShell();
1226 if ( pViewSh && xActiveSheet.is() )
1227 {
1228 // XSpreadsheet und ScCellRangesBase -> muss ein Sheet sein
1229
1230 ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xActiveSheet );
1231 if ( pRangesImp && pViewSh->GetViewData()->GetDocShell() == pRangesImp->GetDocShell() )
1232 {
1233 const ScRangeList& rRanges = pRangesImp->GetRangeList();
1234 if ( rRanges.Count() == 1 )
1235 {
1236 SCTAB nNewTab = rRanges.GetObject(0)->aStart.Tab();
1237 if ( pViewSh->GetViewData()->GetDocument()->HasTable(nNewTab) )
1238 pViewSh->SetTabNo( nNewTab );
1239 }
1240 }
1241 }
1242 }
1243
1244 uno::Reference< uno::XInterface > ScTabViewObj::GetClickedObject(const Point& rPoint) const
1245 {
1246 uno::Reference< uno::XInterface > xTarget;
1247 if (GetViewShell())
1248 {
1249 SCsCOL nX;
1250 SCsROW nY;
1251 ScViewData* pData = GetViewShell()->GetViewData();
1252 ScSplitPos eSplitMode = pData->GetActivePart();
1253 SCTAB nTab(pData->GetTabNo());
1254 pData->GetPosFromPixel( rPoint.X(), rPoint.Y(), eSplitMode, nX, nY);
1255
1256 ScAddress aCellPos (nX, nY, nTab);
1257 ScCellObj* pCellObj = new ScCellObj(pData->GetDocShell(), aCellPos);
1258
1259 xTarget.set(uno::Reference<table::XCell>(pCellObj), uno::UNO_QUERY);
1260
1261 ScDocument* pDoc = pData->GetDocument();
1262 if (pDoc && pDoc->GetDrawLayer())
1263 {
1264 SdrPage* pDrawPage = NULL;
1265 ScDrawLayer* pDrawLayer = pDoc->GetDrawLayer();
1266 if (pDrawLayer->HasObjects() && (pDrawLayer->GetPageCount() > nTab))
1267 pDrawPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab));
1268
1269 SdrView* pDrawView = GetViewShell()->GetSdrView();
1270
1271 if (pDrawPage && pDrawView)
1272 {
1273 Window* pActiveWin = pData->GetActiveWin();
1274 Point aPos = pActiveWin->PixelToLogic(rPoint);
1275
1276 USHORT nHitLog = (USHORT) pActiveWin->PixelToLogic(
1277 Size(pDrawView->GetHitTolerancePixel(),0)).Width();
1278
1279 sal_uInt32 nCount(pDrawPage->GetObjCount());
1280 sal_Bool bFound(sal_False);
1281 sal_uInt32 i(0);
1282 while (i < nCount && !bFound)
1283 {
1284 SdrObject* pObj = pDrawPage->GetObj(i);
1285 if (pObj && pObj->IsHit(aPos, nHitLog))
1286 {
1287 xTarget.set(pObj->getUnoShape(), uno::UNO_QUERY);
1288 bFound = sal_True;
1289 }
1290 ++i;
1291 }
1292 }
1293 }
1294 }
1295 return xTarget;
1296 }
1297
1298 sal_Bool ScTabViewObj::MousePressed( const awt::MouseEvent& e )
1299 throw (::uno::RuntimeException)
1300 {
1301 sal_Bool bReturn(sal_False);
1302
1303 if (aMouseClickHandlers.Count())
1304 {
1305 uno::Reference< uno::XInterface > xTarget = GetClickedObject(Point(e.X, e.Y));
1306
1307 if (xTarget.is())
1308 {
1309 awt::EnhancedMouseEvent aMouseEvent;
1310
1311 aMouseEvent.Buttons = e.Buttons;
1312 aMouseEvent.X = e.X;
1313 aMouseEvent.Y = e.Y;
1314 aMouseEvent.ClickCount = e.ClickCount;
1315 aMouseEvent.PopupTrigger = e.PopupTrigger;
1316 aMouseEvent.Target = xTarget;
1317
1318 for ( USHORT n=0; n<aMouseClickHandlers.Count(); n++ )
1319 {
1320 try
1321 {
1322 if (!(*aMouseClickHandlers[n])->mousePressed( aMouseEvent ))
1323 bReturn = sal_True;
1324 }
1325 catch ( uno::Exception& )
1326 {
1327 aMouseClickHandlers.DeleteAndDestroy(n);
1328 --n; // because it will be increased again in the loop
1329 }
1330 }
1331 }
1332 }
1333 return bReturn;
1334 }
1335
1336 sal_Bool ScTabViewObj::MouseReleased( const awt::MouseEvent& e )
1337 throw (uno::RuntimeException)
1338 {
1339 sal_Bool bReturn(sal_False);
1340
1341 if (aMouseClickHandlers.Count())
1342 {
1343 uno::Reference< uno::XInterface > xTarget = GetClickedObject(Point(e.X, e.Y));
1344
1345 if (xTarget.is())
1346 {
1347 awt::EnhancedMouseEvent aMouseEvent;
1348
1349 aMouseEvent.Buttons = e.Buttons;
1350 aMouseEvent.X = e.X;
1351 aMouseEvent.Y = e.Y;
1352 aMouseEvent.ClickCount = e.ClickCount;
1353 aMouseEvent.PopupTrigger = e.PopupTrigger;
1354 aMouseEvent.Target = xTarget;
1355
1356 for ( USHORT n=0; n<aMouseClickHandlers.Count(); n++ )
1357 {
1358 try
1359 {
1360 if (!(*aMouseClickHandlers[n])->mouseReleased( aMouseEvent ))
1361 bReturn = sal_True;
1362 }
1363 catch ( uno::Exception& )
1364 {
1365 aMouseClickHandlers.DeleteAndDestroy(n);
1366 --n; // because it will be increased again in the loop
1367 }
1368 }
1369 }
1370 }
1371 return bReturn;
1372 }
1373
1374 // XEnhancedMouseClickBroadcaster
1375
1376 void ScTabViewObj::StartMouseListening()
1377 {
1378 }
1379
1380 void ScTabViewObj::EndMouseListening()
1381 {
1382 USHORT nCount(aMouseClickHandlers.Count());
1383 lang::EventObject aEvent;
1384 aEvent.Source = (cppu::OWeakObject*)this;
1385 for ( USHORT n=0; n<nCount; n++ )
1386 {
1387 try
1388 {
1389 (*aMouseClickHandlers[n])->disposing(aEvent);
1390 }
1391 catch ( uno::Exception& )
1392 {
1393 }
1394 }
1395 aMouseClickHandlers.DeleteAndDestroy(0, nCount);
1396 }
1397
1398 void ScTabViewObj::StartActivationListening()
1399 {
1400 }
1401
1402 void ScTabViewObj::EndActivationListening()
1403 {
1404 USHORT nCount = aActivationListeners.Count();
1405 lang::EventObject aEvent;
1406 aEvent.Source = (cppu::OWeakObject*)this;
1407 for ( USHORT n=0; n<nCount; n++ )
1408 {
1409 try
1410 {
1411 (*aActivationListeners[n])->disposing(aEvent);
1412 }
1413 catch ( uno::Exception& )
1414 {
1415 }
1416 }
1417 aActivationListeners.DeleteAndDestroy(0, nCount);
1418 }
1419
1420 void SAL_CALL ScTabViewObj::addEnhancedMouseClickHandler( const uno::Reference< awt::XEnhancedMouseClickHandler >& aListener )
1421 throw (uno::RuntimeException)
1422 {
1423 ScUnoGuard aGuard;
1424
1425 if (aListener.is())
1426 {
1427 USHORT nCount = aMouseClickHandlers.Count();
1428 uno::Reference<awt::XEnhancedMouseClickHandler> *pObj =
1429 new uno::Reference<awt::XEnhancedMouseClickHandler>( aListener );
1430 aMouseClickHandlers.Insert( pObj, nCount );
1431
1432 if (aMouseClickHandlers.Count() == 1 && nCount == 0) // only if a listener added
1433 StartMouseListening();
1434 }
1435 }
1436
1437 void SAL_CALL ScTabViewObj::removeEnhancedMouseClickHandler( const uno::Reference< awt::XEnhancedMouseClickHandler >& aListener )
1438 throw (uno::RuntimeException)
1439 {
1440 ScUnoGuard aGuard;
1441 USHORT nCount = aMouseClickHandlers.Count();
1442 for ( USHORT n=nCount; n--; )
1443 {
1444 uno::Reference<awt::XEnhancedMouseClickHandler> *pObj = aMouseClickHandlers[n];
1445 if ( *pObj == aListener )
1446 aMouseClickHandlers.DeleteAndDestroy( n );
1447 }
1448 if ((aMouseClickHandlers.Count() == 0) && (nCount > 0)) // only if last listener removed
1449 EndMouseListening();
1450 }
1451
1452 // XActivationBroadcaster
1453
1454 void SAL_CALL ScTabViewObj::addActivationEventListener( const uno::Reference< sheet::XActivationEventListener >& aListener )
1455 throw (uno::RuntimeException)
1456 {
1457 ScUnoGuard aGuard;
1458
1459 if (aListener.is())
1460 {
1461 USHORT nCount = aActivationListeners.Count();
1462 uno::Reference<sheet::XActivationEventListener> *pObj =
1463 new uno::Reference<sheet::XActivationEventListener>( aListener );
1464 aActivationListeners.Insert( pObj, nCount );
1465
1466 if (aActivationListeners.Count() == 1 && nCount == 0) // only if a listener added
1467 StartActivationListening();
1468 }
1469 }
1470
1471 void SAL_CALL ScTabViewObj::removeActivationEventListener( const uno::Reference< sheet::XActivationEventListener >& aListener )
1472 throw (uno::RuntimeException)
1473 {
1474 ScUnoGuard aGuard;
1475 USHORT nCount = aActivationListeners.Count();
1476 for ( USHORT n=nCount; n--; )
1477 {
1478 uno::Reference<sheet::XActivationEventListener> *pObj = aActivationListeners[n];
1479 if ( *pObj == aListener )
1480 aActivationListeners.DeleteAndDestroy( n );
1481 }
1482 if ((aActivationListeners.Count() == 0) && (nCount > 0)) // only if last listener removed
1483 EndActivationListening();
1484 }
1485
1486 // PageBreakMode / Zoom sind Properties
1487
1488 #if 0
1489
1490 BOOL ScTabViewObj::getPagebreakMode(void) const
1491 {
1492 ScUnoGuard aGuard;
1493 ScTabViewShell* pViewSh = GetViewShell();
1494 if (pViewSh)
1495 return pViewSh->GetViewData()->IsPagebreakMode();
1496 return FALSE;
1497 }
1498
1499 void ScTabViewObj::setPagebreakMode(BOOL PagebreakMode)
1500 {
1501 ScUnoGuard aGuard;
1502 ScTabViewShell* pViewSh = GetViewShell();
1503 if (pViewSh)
1504 pViewSh->SetPagebreakMode(PagebreakMode);
1505 }
1506
1507 #endif
1508
1509 INT16 ScTabViewObj::GetZoom(void) const
1510 {
1511 ScTabViewShell* pViewSh = GetViewShell();
1512 if (pViewSh)
1513 {
1514 const Fraction& rZoomY = pViewSh->GetViewData()->GetZoomY(); // Y wird angezeigt
1515 return (INT16)(( rZoomY.GetNumerator() * 100 ) / rZoomY.GetDenominator());
1516 }
1517 return 0;
1518 }
1519
1520 void ScTabViewObj::SetZoom(INT16 nZoom)
1521 {
1522 ScTabViewShell* pViewSh = GetViewShell();
1523 if (pViewSh)
1524 {
1525 if ( nZoom != GetZoom() && nZoom != 0 )
1526 {
1527 if (!pViewSh->GetViewData()->IsPagebreakMode())
1528 {
1529 ScModule* pScMod = SC_MOD();
1530 ScAppOptions aNewOpt(pScMod->GetAppOptions());
1531 aNewOpt.SetZoom( nZoom );
1532 aNewOpt.SetZoomType( pViewSh->GetViewData()->GetView()->GetZoomType() );
1533 pScMod->SetAppOptions( aNewOpt );
1534 }
1535 }
1536 Fraction aFract( nZoom, 100 );
1537 pViewSh->SetZoom( aFract, aFract, TRUE );
1538 pViewSh->PaintGrid();
1539 pViewSh->PaintTop();
1540 pViewSh->PaintLeft();
1541 pViewSh->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
1542 pViewSh->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
1543 }
1544 }
1545
1546 INT16 ScTabViewObj::GetZoomType(void) const
1547 {
1548 INT16 aZoomType = view::DocumentZoomType::OPTIMAL;
1549 ScTabViewShell* pViewSh = GetViewShell();
1550 if (pViewSh)
1551 {
1552 SvxZoomType eZoomType = pViewSh->GetViewData()->GetView()->GetZoomType();
1553 switch (eZoomType)
1554 {
1555 case SVX_ZOOM_PERCENT:
1556 aZoomType = view::DocumentZoomType::BY_VALUE;
1557 break;
1558 case SVX_ZOOM_OPTIMAL:
1559 aZoomType = view::DocumentZoomType::OPTIMAL;
1560 break;
1561 case SVX_ZOOM_WHOLEPAGE:
1562 aZoomType = view::DocumentZoomType::ENTIRE_PAGE;
1563 break;
1564 case SVX_ZOOM_PAGEWIDTH:
1565 aZoomType = view::DocumentZoomType::PAGE_WIDTH;
1566 break;
1567 case SVX_ZOOM_PAGEWIDTH_NOBORDER:
1568 aZoomType = view::DocumentZoomType::PAGE_WIDTH_EXACT;
1569 break;
1570 }
1571 }
1572 return aZoomType;
1573 }
1574
1575 void ScTabViewObj::SetZoomType(INT16 aZoomType)
1576 {
1577 ScTabViewShell* pViewSh = GetViewShell();
1578 if (pViewSh)
1579 {
1580 ScDBFunc* pView = pViewSh->GetViewData()->GetView();
1581 if (pView)
1582 {
1583 SvxZoomType eZoomType;
1584 switch (aZoomType)
1585 {
1586 case view::DocumentZoomType::BY_VALUE:
1587 eZoomType = SVX_ZOOM_PERCENT;
1588 break;
1589 case view::DocumentZoomType::OPTIMAL:
1590 eZoomType = SVX_ZOOM_OPTIMAL;
1591 break;
1592 case view::DocumentZoomType::ENTIRE_PAGE:
1593 eZoomType = SVX_ZOOM_WHOLEPAGE;
1594 break;
1595 case view::DocumentZoomType::PAGE_WIDTH:
1596 eZoomType = SVX_ZOOM_PAGEWIDTH;
1597 break;
1598 case view::DocumentZoomType::PAGE_WIDTH_EXACT:
1599 eZoomType = SVX_ZOOM_PAGEWIDTH_NOBORDER;
1600 break;
1601 default:
1602 eZoomType = SVX_ZOOM_OPTIMAL;
1603 }
1604 sal_Int16 nZoom(GetZoom());
1605 sal_Int16 nOldZoom(nZoom);
1606 if ( eZoomType == SVX_ZOOM_PERCENT )
1607 {
1608 if ( nZoom < MINZOOM ) nZoom = MINZOOM;
1609 if ( nZoom > MAXZOOM ) nZoom = MAXZOOM;
1610 }
1611 else
1612 nZoom = pView->CalcZoom( eZoomType, nOldZoom );
1613
1614 switch ( eZoomType )
1615 {
1616 case SVX_ZOOM_WHOLEPAGE:
1617 case SVX_ZOOM_PAGEWIDTH:
1618 pView->SetZoomType( eZoomType, TRUE );
1619 break;
1620
1621 default:
1622 pView->SetZoomType( SVX_ZOOM_PERCENT, TRUE );
1623 }
1624 SetZoom( nZoom );
1625 }
1626 }
1627 }
1628
1629 sal_Bool SAL_CALL ScTabViewObj::getIsWindowSplit() throw(uno::RuntimeException)
1630 {
1631 ScUnoGuard aGuard;
1632 // wie Menue-Slot SID_WINDOW_SPLIT
1633
1634 ScTabViewShell* pViewSh = GetViewShell();
1635 if (pViewSh)
1636 {
1637 ScViewData* pViewData = pViewSh->GetViewData();
1638 return ( pViewData->GetHSplitMode() == SC_SPLIT_NORMAL ||
1639 pViewData->GetVSplitMode() == SC_SPLIT_NORMAL );
1640 }
1641
1642 return FALSE;
1643 }
1644
1645 sal_Bool SAL_CALL ScTabViewObj::hasFrozenPanes() throw(uno::RuntimeException)
1646 {
1647 ScUnoGuard aGuard;
1648 // wie Menue-Slot SID_WINDOW_FIX
1649
1650 ScTabViewShell* pViewSh = GetViewShell();
1651 if (pViewSh)
1652 {
1653 ScViewData* pViewData = pViewSh->GetViewData();
1654 return ( pViewData->GetHSplitMode() == SC_SPLIT_FIX ||
1655 pViewData->GetVSplitMode() == SC_SPLIT_FIX );
1656 }
1657
1658 return FALSE;
1659 }
1660
1661 sal_Int32 SAL_CALL ScTabViewObj::getSplitHorizontal() throw(uno::RuntimeException)
1662 {
1663 ScUnoGuard aGuard;
1664 ScTabViewShell* pViewSh = GetViewShell();
1665 if (pViewSh)
1666 {
1667 ScViewData* pViewData = pViewSh->GetViewData();
1668 if ( pViewData->GetHSplitMode() != SC_SPLIT_NONE )
1669 return pViewData->GetHSplitPos();
1670 }
1671 return 0;
1672 }
1673
1674 sal_Int32 SAL_CALL ScTabViewObj::getSplitVertical() throw(uno::RuntimeException)
1675 {
1676 ScUnoGuard aGuard;
1677 ScTabViewShell* pViewSh = GetViewShell();
1678 if (pViewSh)
1679 {
1680 ScViewData* pViewData = pViewSh->GetViewData();
1681 if ( pViewData->GetVSplitMode() != SC_SPLIT_NONE )
1682 return pViewData->GetVSplitPos();
1683 }
1684 return 0;
1685 }
1686
1687 sal_Int32 SAL_CALL ScTabViewObj::getSplitColumn() throw(uno::RuntimeException)
1688 {
1689 ScUnoGuard aGuard;
1690 ScTabViewShell* pViewSh = GetViewShell();
1691 if (pViewSh)
1692 {
1693 ScViewData* pViewData = pViewSh->GetViewData();
1694 if ( pViewData->GetHSplitMode() != SC_SPLIT_NONE )
1695 {
1696 long nSplit = pViewData->GetHSplitPos();
1697
1698 ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
1699 if ( pViewData->GetVSplitMode() != SC_SPLIT_NONE )
1700 ePos = SC_SPLIT_TOPLEFT;
1701
1702 SCsCOL nCol;
1703 SCsROW nRow;
1704 pViewData->GetPosFromPixel( nSplit, 0, ePos, nCol, nRow, FALSE );
1705 if ( nCol > 0 )
1706 return nCol;
1707 }
1708 }
1709 return 0;
1710 }
1711
1712 sal_Int32 SAL_CALL ScTabViewObj::getSplitRow() throw(uno::RuntimeException)
1713 {
1714 ScUnoGuard aGuard;
1715 ScTabViewShell* pViewSh = GetViewShell();
1716 if (pViewSh)
1717 {
1718 ScViewData* pViewData = pViewSh->GetViewData();
1719 if ( pViewData->GetVSplitMode() != SC_SPLIT_NONE )
1720 {
1721 long nSplit = pViewData->GetVSplitPos();
1722
1723 ScSplitPos ePos = SC_SPLIT_TOPLEFT; // es ist vertikal geteilt
1724 SCsCOL nCol;
1725 SCsROW nRow;
1726 pViewData->GetPosFromPixel( 0, nSplit, ePos, nCol, nRow, FALSE );
1727 if ( nRow > 0 )
1728 return nRow;
1729 }
1730 }
1731 return 0;
1732 }
1733
1734 void SAL_CALL ScTabViewObj::splitAtPosition( sal_Int32 nPixelX, sal_Int32 nPixelY )
1735 throw(uno::RuntimeException)
1736 {
1737 ScUnoGuard aGuard;
1738 ScTabViewShell* pViewSh = GetViewShell();
1739 if (pViewSh)
1740 {
1741 pViewSh->SplitAtPixel( Point( nPixelX, nPixelY ), TRUE, TRUE );
1742 pViewSh->FreezeSplitters( FALSE );
1743 pViewSh->InvalidateSplit();
1744 }
1745 }
1746
1747 void SAL_CALL ScTabViewObj::freezeAtPosition( sal_Int32 nColumns, sal_Int32 nRows )
1748 throw(uno::RuntimeException)
1749 {
1750 ScUnoGuard aGuard;
1751 ScTabViewShell* pViewSh = GetViewShell();
1752 if (pViewSh)
1753 {
1754 // erst alles aufheben -> kein Stress mit Scrolling zwischendurch o.ae.
1755
1756 pViewSh->RemoveSplit();
1757
1758 Point aWinStart;
1759 Window* pWin = pViewSh->GetWindowByPos( SC_SPLIT_BOTTOMLEFT );
1760 if (pWin)
1761 aWinStart = pWin->GetPosPixel();
1762
1763 ScViewData* pViewData = pViewSh->GetViewData();
1764 Point aSplit(pViewData->GetScrPos( (SCCOL)nColumns, (SCROW)nRows, SC_SPLIT_BOTTOMLEFT, TRUE ));
1765 aSplit += aWinStart;
1766
1767 pViewSh->SplitAtPixel( aSplit, TRUE, TRUE );
1768 pViewSh->FreezeSplitters( TRUE );
1769 pViewSh->InvalidateSplit();
1770 }
1771 }
1772
1773 void SAL_CALL ScTabViewObj::addSelectionChangeListener(
1774 const uno::Reference<view::XSelectionChangeListener>& xListener )
1775 throw(uno::RuntimeException)
1776 {
1777 ScUnoGuard aGuard;
1778 uno::Reference<view::XSelectionChangeListener>* pObj =
1779 new uno::Reference<view::XSelectionChangeListener>( xListener );
1780 aSelectionListeners.Insert( pObj, aSelectionListeners.Count() );
1781 }
1782
1783 void SAL_CALL ScTabViewObj::removeSelectionChangeListener(
1784 const uno::Reference< view::XSelectionChangeListener >& xListener )
1785 throw(uno::RuntimeException)
1786 {
1787 ScUnoGuard aGuard;
1788 USHORT nCount = aSelectionListeners.Count();
1789 for ( USHORT n=nCount; n--; )
1790 {
1791 uno::Reference<view::XSelectionChangeListener> *pObj = aSelectionListeners[n];
1792 if ( *pObj == xListener ) //! wozu der Mumpitz mit queryInterface?
1793 {
1794 aSelectionListeners.DeleteAndDestroy( n );
1795 break;
1796 }
1797 }
1798 }
1799
1800 void ScTabViewObj::SelectionChanged()
1801 {
1802 lang::EventObject aEvent;
1803 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
1804 for ( USHORT n=0; n<aSelectionListeners.Count(); n++ )
1805 (*aSelectionListeners[n])->selectionChanged( aEvent );
1806 }
1807
1808
1809 // XPropertySet (View-Optionen)
1810 //! auch an der Applikation anbieten?
1811
1812 uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTabViewObj::getPropertySetInfo()
1813 throw(uno::RuntimeException)
1814 {
1815 ScUnoGuard aGuard;
1816 static uno::Reference<beans::XPropertySetInfo> aRef(
1817 new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ));
1818 return aRef;
1819 }
1820
1821 void SAL_CALL ScTabViewObj::setPropertyValue(
1822 const rtl::OUString& aPropertyName, const uno::Any& aValue )
1823 throw(beans::UnknownPropertyException, beans::PropertyVetoException,
1824 lang::IllegalArgumentException, lang::WrappedTargetException,
1825 uno::RuntimeException)
1826 {
1827 ScUnoGuard aGuard;
1828 String aString(aPropertyName);
1829
1830 if ( aString.EqualsAscii(SC_UNO_FILTERED_RANGE_SELECTION) )
1831 {
1832 bFilteredRangeSelection = ScUnoHelpFunctions::GetBoolFromAny(aValue);
1833 return;
1834 }
1835
1836 ScTabViewShell* pViewSh = GetViewShell();
1837 if (pViewSh)
1838 {
1839 ScViewData* pViewData = pViewSh->GetViewData();
1840 const ScViewOptions& rOldOpt = pViewSh->GetViewData()->GetOptions();
1841 ScViewOptions aNewOpt(rOldOpt);
1842
1843 if ( aString.EqualsAscii( SC_UNO_COLROWHDR ) || aString.EqualsAscii( OLD_UNO_COLROWHDR ) )
1844 aNewOpt.SetOption( VOPT_HEADER, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1845 else if ( aString.EqualsAscii( SC_UNO_HORSCROLL ) || aString.EqualsAscii( OLD_UNO_HORSCROLL ) )
1846 aNewOpt.SetOption( VOPT_HSCROLL, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1847 else if ( aString.EqualsAscii( SC_UNO_OUTLSYMB ) || aString.EqualsAscii( OLD_UNO_OUTLSYMB ) )
1848 aNewOpt.SetOption( VOPT_OUTLINER, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1849 else if ( aString.EqualsAscii( SC_UNO_SHEETTABS ) || aString.EqualsAscii( OLD_UNO_SHEETTABS ) )
1850 aNewOpt.SetOption( VOPT_TABCONTROLS, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1851 else if ( aString.EqualsAscii( SC_UNO_SHOWANCHOR ) )
1852 aNewOpt.SetOption( VOPT_ANCHOR, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1853 else if ( aString.EqualsAscii( SC_UNO_SHOWFORM ) )
1854 aNewOpt.SetOption( VOPT_FORMULAS, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1855 else if ( aString.EqualsAscii( SC_UNO_SHOWGRID ) )
1856 aNewOpt.SetOption( VOPT_GRID, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1857 else if ( aString.EqualsAscii( SC_UNO_SHOWHELP ) )
1858 aNewOpt.SetOption( VOPT_HELPLINES, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1859 else if ( aString.EqualsAscii( SC_UNO_SHOWNOTES ) )
1860 aNewOpt.SetOption( VOPT_NOTES, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1861 else if ( aString.EqualsAscii( SC_UNO_SHOWPAGEBR ) )
1862 aNewOpt.SetOption( VOPT_PAGEBREAKS, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1863 else if ( aString.EqualsAscii( SC_UNO_SHOWZERO ) )
1864 aNewOpt.SetOption( VOPT_NULLVALS, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1865 else if ( aString.EqualsAscii( SC_UNO_SHOWSOLID ) )
1866 aNewOpt.SetOption( VOPT_SOLIDHANDLES, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1867 else if ( aString.EqualsAscii( SC_UNO_VALUEHIGH ) || aString.EqualsAscii( OLD_UNO_VALUEHIGH ) )
1868 aNewOpt.SetOption( VOPT_SYNTAX, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1869 else if ( aString.EqualsAscii( SC_UNO_VERTSCROLL ) || aString.EqualsAscii( OLD_UNO_VERTSCROLL ) )
1870 aNewOpt.SetOption( VOPT_VSCROLL, ScUnoHelpFunctions::GetBoolFromAny( aValue ) );
1871 else if ( aString.EqualsAscii( SC_UNO_SHOWOBJ ) )
1872 {
1873 sal_Int16 nIntVal = 0;
1874 if ( aValue >>= nIntVal )
1875 {
1876 //#i80528# adapt to new range eventually
1877 if((sal_Int16)VOBJ_MODE_HIDE < nIntVal) nIntVal = (sal_Int16)VOBJ_MODE_SHOW;
1878
1879 aNewOpt.SetObjMode( VOBJ_TYPE_OLE, (ScVObjMode)nIntVal);
1880 }
1881 }
1882 else if ( aString.EqualsAscii( SC_UNO_SHOWCHARTS ) )
1883 {
1884 sal_Int16 nIntVal = 0;
1885 if ( aValue >>= nIntVal )
1886 {
1887 //#i80528# adapt to new range eventually
1888 if((sal_Int16)VOBJ_MODE_HIDE < nIntVal) nIntVal = (sal_Int16)VOBJ_MODE_SHOW;
1889
1890 aNewOpt.SetObjMode( VOBJ_TYPE_CHART, (ScVObjMode)nIntVal);
1891 }
1892 }
1893 else if ( aString.EqualsAscii( SC_UNO_SHOWDRAW ) )
1894 {
1895 sal_Int16 nIntVal = 0;
1896 if ( aValue >>= nIntVal )
1897 {
1898 //#i80528# adapt to new range eventually
1899 if((sal_Int16)VOBJ_MODE_HIDE < nIntVal) nIntVal = (sal_Int16)VOBJ_MODE_SHOW;
1900
1901 aNewOpt.SetObjMode( VOBJ_TYPE_DRAW, (ScVObjMode)nIntVal);
1902 }
1903 }
1904 else if ( aString.EqualsAscii( SC_UNO_GRIDCOLOR ) )
1905 {
1906 sal_Int32 nIntVal = 0;
1907 if ( aValue >>= nIntVal )
1908 aNewOpt.SetGridColor( nIntVal, String() );
1909 }
1910 else if ( aString.EqualsAscii( SC_UNO_ZOOMTYPE ) )
1911 {
1912 sal_Int16 nIntVal = 0;
1913 if ( aValue >>= nIntVal )
1914 SetZoomType(nIntVal);
1915 }
1916 else if ( aString.EqualsAscii( SC_UNO_ZOOMVALUE ) )
1917 {
1918 sal_Int16 nIntVal = 0;
1919 if ( aValue >>= nIntVal )
1920 SetZoom(nIntVal);
1921 }
1922
1923 // Optionen werden an der View und am Dokument (fuer neue Views) gesetzt,
1924 // damit sie beim Speichern erhalten bleiben.
1925 //! An der App (Module) braeuchte man noch eine Extra-Moeglichkeit,
1926 //! das einzustellen (fuer neue Dokumente)
1927
1928 if ( aNewOpt != rOldOpt )
1929 {
1930 pViewData->SetOptions( aNewOpt );
1931 pViewData->GetDocument()->SetViewOptions( aNewOpt );
1932 pViewData->GetDocShell()->SetDocumentModified(); //! wirklich?
1933
1934 pViewSh->UpdateFixPos();
1935 pViewSh->PaintGrid();
1936 pViewSh->PaintTop();
1937 pViewSh->PaintLeft();
1938 pViewSh->PaintExtras();
1939 pViewSh->InvalidateBorder();
1940
1941 SfxBindings& rBindings = pViewSh->GetViewFrame()->GetBindings();
1942 rBindings.Invalidate( FID_TOGGLEHEADERS ); // -> Checks im Menue
1943 rBindings.Invalidate( FID_TOGGLESYNTAX );
1944 }
1945 }
1946 }
1947
1948 uno::Any SAL_CALL ScTabViewObj::getPropertyValue( const rtl::OUString& aPropertyName )
1949 throw(beans::UnknownPropertyException, lang::WrappedTargetException,
1950 uno::RuntimeException)
1951 {
1952 ScUnoGuard aGuard;
1953 String aString(aPropertyName);
1954 uno::Any aRet;
1955
1956 if ( aString.EqualsAscii(SC_UNO_FILTERED_RANGE_SELECTION) )
1957 {
1958 ScUnoHelpFunctions::SetBoolInAny(aRet, bFilteredRangeSelection);
1959 return aRet;
1960 }
1961
1962 ScTabViewShell* pViewSh = GetViewShell();
1963 if (pViewSh)
1964 {
1965 const ScViewOptions& rOpt = pViewSh->GetViewData()->GetOptions();
1966
1967 if ( aString.EqualsAscii( SC_UNO_COLROWHDR ) || aString.EqualsAscii( OLD_UNO_COLROWHDR ) )
1968 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_HEADER ) );
1969 else if ( aString.EqualsAscii( SC_UNO_HORSCROLL ) || aString.EqualsAscii( OLD_UNO_HORSCROLL ) )
1970 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_HSCROLL ) );
1971 else if ( aString.EqualsAscii( SC_UNO_OUTLSYMB ) || aString.EqualsAscii( OLD_UNO_OUTLSYMB ) )
1972 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_OUTLINER ) );
1973 else if ( aString.EqualsAscii( SC_UNO_SHEETTABS ) || aString.EqualsAscii( OLD_UNO_SHEETTABS ) )
1974 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_TABCONTROLS ) );
1975 else if ( aString.EqualsAscii( SC_UNO_SHOWANCHOR ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_ANCHOR ) );
1976 else if ( aString.EqualsAscii( SC_UNO_SHOWFORM ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_FORMULAS ) );
1977 else if ( aString.EqualsAscii( SC_UNO_SHOWGRID ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_GRID ) );
1978 else if ( aString.EqualsAscii( SC_UNO_SHOWHELP ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_HELPLINES ) );
1979 else if ( aString.EqualsAscii( SC_UNO_SHOWNOTES ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_NOTES ) );
1980 else if ( aString.EqualsAscii( SC_UNO_SHOWPAGEBR ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_PAGEBREAKS ) );
1981 else if ( aString.EqualsAscii( SC_UNO_SHOWZERO ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_NULLVALS ) );
1982 else if ( aString.EqualsAscii( SC_UNO_SHOWSOLID ) ) ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_SOLIDHANDLES ) );
1983 else if ( aString.EqualsAscii( SC_UNO_VALUEHIGH ) || aString.EqualsAscii( OLD_UNO_VALUEHIGH ) )
1984 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_SYNTAX ) );
1985 else if ( aString.EqualsAscii( SC_UNO_VERTSCROLL ) || aString.EqualsAscii( OLD_UNO_VERTSCROLL ) )
1986 ScUnoHelpFunctions::SetBoolInAny( aRet, rOpt.GetOption( VOPT_VSCROLL ) );
1987 else if ( aString.EqualsAscii( SC_UNO_SHOWOBJ ) ) aRet <<= (sal_Int16)( rOpt.GetObjMode( VOBJ_TYPE_OLE ) );
1988 else if ( aString.EqualsAscii( SC_UNO_SHOWCHARTS ) ) aRet <<= (sal_Int16)( rOpt.GetObjMode( VOBJ_TYPE_CHART ) );
1989 else if ( aString.EqualsAscii( SC_UNO_SHOWDRAW ) ) aRet <<= (sal_Int16)( rOpt.GetObjMode( VOBJ_TYPE_DRAW ) );
1990 else if ( aString.EqualsAscii( SC_UNO_GRIDCOLOR ) ) aRet <<= (sal_Int32)( rOpt.GetGridColor().GetColor() );
1991 else if ( aString.EqualsAscii( SC_UNO_VISAREA ) ) aRet <<= GetVisArea();
1992 else if ( aString.EqualsAscii( SC_UNO_ZOOMTYPE ) ) aRet <<= GetZoomType();
1993 else if ( aString.EqualsAscii( SC_UNO_ZOOMVALUE ) ) aRet <<= GetZoom();
1994 }
1995
1996 return aRet;
1997 }
1998
1999 void SAL_CALL ScTabViewObj::addPropertyChangeListener( const ::rtl::OUString& /* aPropertyName */,
2000 const uno::Reference<beans::XPropertyChangeListener >& xListener )
2001 throw(beans::UnknownPropertyException,
2002 lang::WrappedTargetException,
2003 uno::RuntimeException)
2004 {
2005 ScUnoGuard aGuard;
2006 uno::Reference<beans::XPropertyChangeListener>* pObj =
2007 new uno::Reference<beans::XPropertyChangeListener>( xListener );
2008 aPropertyChgListeners.Insert( pObj, aPropertyChgListeners.Count() );
2009 }
2010
2011 void SAL_CALL ScTabViewObj::removePropertyChangeListener( const ::rtl::OUString& /* aPropertyName */,
2012 const uno::Reference<beans::XPropertyChangeListener >& xListener )
2013 throw(beans::UnknownPropertyException,
2014 lang::WrappedTargetException,
2015 uno::RuntimeException)
2016 {
2017 ScUnoGuard aGuard;
2018 USHORT nCount = aPropertyChgListeners.Count();
2019 for ( USHORT n=nCount; n--; )
2020 {
2021 uno::Reference<beans::XPropertyChangeListener> *pObj = aPropertyChgListeners[n];
2022 if ( *pObj == xListener ) //! wozu der Mumpitz mit queryInterface?
2023 {
2024 aPropertyChgListeners.DeleteAndDestroy( n );
2025 break;
2026 }
2027 }
2028 }
2029
2030 void SAL_CALL ScTabViewObj::addVetoableChangeListener( const ::rtl::OUString& /* PropertyName */,
2031 const uno::Reference<beans::XVetoableChangeListener >& /* aListener */ )
2032 throw(beans::UnknownPropertyException,
2033 lang::WrappedTargetException,
2034 uno::RuntimeException)
2035 {
2036 }
2037
2038 void SAL_CALL ScTabViewObj::removeVetoableChangeListener( const ::rtl::OUString& /* PropertyName */,
2039 const uno::Reference<beans::XVetoableChangeListener >& /* aListener */ )
2040 throw(beans::UnknownPropertyException,
2041 lang::WrappedTargetException,
2042 uno::RuntimeException)
2043 {
2044 }
2045
2046 void ScTabViewObj::VisAreaChanged()
2047 {
2048 beans::PropertyChangeEvent aEvent;
2049 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
2050 for ( USHORT n=0; n<aPropertyChgListeners.Count(); n++ )
2051 (*aPropertyChgListeners[n])->propertyChange( aEvent );
2052 }
2053
2054 // XRangeSelection
2055
2056 void SAL_CALL ScTabViewObj::startRangeSelection(
2057 const uno::Sequence<beans::PropertyValue>& aArguments )
2058 throw(uno::RuntimeException)
2059 {
2060 ScUnoGuard aGuard;
2061 ScTabViewShell* pViewSh = GetViewShell();
2062 if (pViewSh)
2063 {
2064 String aInitVal, aTitle;
2065 BOOL bCloseOnButtonUp = FALSE;
2066 BOOL bSingleCell = FALSE;
2067 BOOL bMultiSelection = FALSE;
2068
2069 rtl::OUString aStrVal;
2070 const beans::PropertyValue* pPropArray = aArguments.getConstArray();
2071 long nPropCount = aArguments.getLength();
2072 for (long i = 0; i < nPropCount; i++)
2073 {
2074 const beans::PropertyValue& rProp = pPropArray[i];
2075 String aPropName(rProp.Name);
2076
2077 if (aPropName.EqualsAscii( SC_UNONAME_CLOSEONUP ))
2078 bCloseOnButtonUp = ScUnoHelpFunctions::GetBoolFromAny( rProp.Value );
2079 else if (aPropName.EqualsAscii( SC_UNONAME_TITLE ))
2080 {
2081 if ( rProp.Value >>= aStrVal )
2082 aTitle = String( aStrVal );
2083 }
2084 else if (aPropName.EqualsAscii( SC_UNONAME_INITVAL ))
2085 {
2086 if ( rProp.Value >>= aStrVal )
2087 aInitVal = String( aStrVal );
2088 }
2089 else if (aPropName.EqualsAscii( SC_UNONAME_SINGLECELL ))
2090 bSingleCell = ScUnoHelpFunctions::GetBoolFromAny( rProp.Value );
2091 else if (aPropName.EqualsAscii( SC_UNONAME_MULTISEL ))
2092 bMultiSelection = ScUnoHelpFunctions::GetBoolFromAny( rProp.Value );
2093 }
2094
2095 pViewSh->StartSimpleRefDialog( aTitle, aInitVal, bCloseOnButtonUp, bSingleCell, bMultiSelection );
2096 }
2097 }
2098
2099 void SAL_CALL ScTabViewObj::abortRangeSelection() throw(uno::RuntimeException)
2100 {
2101 ScUnoGuard aGuard;
2102 ScTabViewShell* pViewSh = GetViewShell();
2103 if (pViewSh)
2104 pViewSh->StopSimpleRefDialog();
2105 }
2106
2107 void SAL_CALL ScTabViewObj::addRangeSelectionListener(
2108 const uno::Reference<sheet::XRangeSelectionListener>& xListener )
2109 throw(uno::RuntimeException)
2110 {
2111 ScUnoGuard aGuard;
2112 uno::Reference<sheet::XRangeSelectionListener>* pObj =
2113 new uno::Reference<sheet::XRangeSelectionListener>( xListener );
2114 aRangeSelListeners.Insert( pObj, aRangeSelListeners.Count() );
2115 }
2116
2117 void SAL_CALL ScTabViewObj::removeRangeSelectionListener(
2118 const uno::Reference<sheet::XRangeSelectionListener>& xListener )
2119 throw(uno::RuntimeException)
2120 {
2121 ScUnoGuard aGuard;
2122 USHORT nCount = aRangeSelListeners.Count();
2123 for ( USHORT n=nCount; n--; )
2124 {
2125 uno::Reference<sheet::XRangeSelectionListener> *pObj = aRangeSelListeners[n];
2126 if ( *pObj == xListener )
2127 {
2128 aRangeSelListeners.DeleteAndDestroy( n );
2129 break;
2130 }
2131 }
2132 }
2133
2134 void SAL_CALL ScTabViewObj::addRangeSelectionChangeListener(
2135 const uno::Reference<sheet::XRangeSelectionChangeListener>& xListener )
2136 throw(uno::RuntimeException)
2137 {
2138 ScUnoGuard aGuard;
2139 uno::Reference<sheet::XRangeSelectionChangeListener>* pObj =
2140 new uno::Reference<sheet::XRangeSelectionChangeListener>( xListener );
2141 aRangeChgListeners.Insert( pObj, aRangeChgListeners.Count() );
2142 }
2143
2144 void SAL_CALL ScTabViewObj::removeRangeSelectionChangeListener(
2145 const uno::Reference<sheet::XRangeSelectionChangeListener>& xListener )
2146 throw(uno::RuntimeException)
2147 {
2148 ScUnoGuard aGuard;
2149 USHORT nCount = aRangeChgListeners.Count();
2150 for ( USHORT n=nCount; n--; )
2151 {
2152 uno::Reference<sheet::XRangeSelectionChangeListener> *pObj = aRangeChgListeners[n];
2153 if ( *pObj == xListener )
2154 {
2155 aRangeChgListeners.DeleteAndDestroy( n );
2156 break;
2157 }
2158 }
2159 }
2160
2161 void ScTabViewObj::RangeSelDone( const String& rText )
2162 {
2163 sheet::RangeSelectionEvent aEvent;
2164 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
2165 aEvent.RangeDescriptor = rtl::OUString( rText );
2166
2167 for ( USHORT n=0; n<aRangeSelListeners.Count(); n++ )
2168 (*aRangeSelListeners[n])->done( aEvent );
2169 }
2170
2171 void ScTabViewObj::RangeSelAborted( const String& rText )
2172 {
2173 sheet::RangeSelectionEvent aEvent;
2174 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
2175 aEvent.RangeDescriptor = rtl::OUString( rText );
2176
2177 for ( USHORT n=0; n<aRangeSelListeners.Count(); n++ )
2178 (*aRangeSelListeners[n])->aborted( aEvent );
2179 }
2180
2181 void ScTabViewObj::RangeSelChanged( const String& rText )
2182 {
2183 sheet::RangeSelectionEvent aEvent;
2184 aEvent.Source.set(static_cast<cppu::OWeakObject*>(this));
2185 aEvent.RangeDescriptor = rtl::OUString( rText );
2186
2187 for ( USHORT n=0; n<aRangeChgListeners.Count(); n++ )
2188 (*aRangeChgListeners[n])->descriptorChanged( aEvent );
2189 }
2190
2191 // XServiceInfo
2192
2193 rtl::OUString SAL_CALL ScTabViewObj::getImplementationName() throw(uno::RuntimeException)
2194 {
2195 return rtl::OUString::createFromAscii( "ScTabViewObj" );
2196 }
2197
2198 sal_Bool SAL_CALL ScTabViewObj::supportsService( const rtl::OUString& rServiceName )
2199 throw(uno::RuntimeException)
2200 {
2201 String aServiceStr( rServiceName );
2202 return aServiceStr.EqualsAscii( SCTABVIEWOBJ_SERVICE ) ||
2203 aServiceStr.EqualsAscii( SCVIEWSETTINGS_SERVICE );
2204 }
2205
2206 uno::Sequence<rtl::OUString> SAL_CALL ScTabViewObj::getSupportedServiceNames()
2207 throw(uno::RuntimeException)
2208 {
2209 uno::Sequence<rtl::OUString> aRet(2);
2210 rtl::OUString* pArray = aRet.getArray();
2211 pArray[0] = rtl::OUString::createFromAscii( SCTABVIEWOBJ_SERVICE );
2212 pArray[1] = rtl::OUString::createFromAscii( SCVIEWSETTINGS_SERVICE );
2213 return aRet;
2214 }
2215
2216 // XUnoTunnel
2217
2218 sal_Int64 SAL_CALL ScTabViewObj::getSomething(
2219 const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException)
2220 {
2221 if ( rId.getLength() == 16 &&
2222 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
2223 rId.getConstArray(), 16 ) )
2224 {
2225 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
2226 }
2227 return 0;
2228 }
2229
2230 // static
2231 const uno::Sequence<sal_Int8>& ScTabViewObj::getUnoTunnelId()
2232 {
2233 static uno::Sequence<sal_Int8> * pSeq = 0;
2234 if( !pSeq )
2235 {
2236 osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
2237 if( !pSeq )
2238 {
2239 static uno::Sequence< sal_Int8 > aSeq( 16 );
2240 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
2241 pSeq = &aSeq;
2242 }
2243 }
2244 return *pSeq;
2245 }
2246
2247 // static
2248 ScTabViewObj* ScTabViewObj::getImplementation( const uno::Reference<uno::XInterface> xObj )
2249 {
2250 ScTabViewObj* pRet = NULL;
2251 uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY );
2252 if (xUT.is())
2253 pRet = reinterpret_cast<ScTabViewObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId())));
2254 return pRet;
2255 }
2256
2257 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > SAL_CALL ScTabViewObj::getTransferable( ) throw (::com::sun::star::uno::RuntimeException)
2258 {
2259 ScUnoGuard aGuard;
2260 ScEditShell* pShell = PTR_CAST( ScEditShell, GetViewShell()->GetViewFrame()->GetDispatcher()->GetShell(0) );
2261 if (pShell)
2262 return pShell->GetEditView()->GetTransferable();
2263
2264 ScDrawTextObjectBar* pTextShell = PTR_CAST( ScDrawTextObjectBar, GetViewShell()->GetViewFrame()->GetDispatcher()->GetShell(0) );
2265 if (pTextShell)
2266 {
2267 ScViewData* pViewData = GetViewShell()->GetViewData();
2268 ScDrawView* pView = pViewData->GetScDrawView();
2269 OutlinerView* pOutView = pView->GetTextEditOutlinerView();
2270 if (pOutView)
2271 return pOutView->GetEditView().GetTransferable();
2272 }
2273
2274 ScDrawShell* pDrawShell = PTR_CAST( ScDrawShell, GetViewShell()->GetViewFrame()->GetDispatcher()->GetShell(0) );
2275 if (pDrawShell)
2276 return pDrawShell->GetDrawView()->CopyToTransferable();
2277
2278 ScTransferObj* pObj = GetViewShell()->CopyToTransferable();
2279 uno::Reference<datatransfer::XTransferable> xTransferable( pObj );
2280 return xTransferable;
2281 }
2282
2283 void SAL_CALL ScTabViewObj::insertTransferable( const ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& xTrans ) throw (::com::sun::star::datatransfer::UnsupportedFlavorException, ::com::sun::star::uno::RuntimeException)
2284 {
2285 ScUnoGuard aGuard;
2286 ScEditShell* pShell = PTR_CAST( ScEditShell, GetViewShell()->GetViewFrame()->GetDispatcher()->GetShell(0) );
2287 if (pShell)
2288 pShell->GetEditView()->InsertText( xTrans, ::rtl::OUString(), FALSE );
2289 else
2290 {
2291 ScDrawTextObjectBar* pTextShell = PTR_CAST( ScDrawTextObjectBar, GetViewShell()->GetViewFrame()->GetDispatcher()->GetShell(0) );
2292 if (pTextShell)
2293 {
2294 ScViewData* pViewData = GetViewShell()->GetViewData();
2295 ScDrawView* pView = pViewData->GetScDrawView();
2296 OutlinerView* pOutView = pView->GetTextEditOutlinerView();
2297 if ( pOutView )
2298 {
2299 pOutView->GetEditView().InsertText( xTrans, ::rtl::OUString(), FALSE );
2300 return;
2301 }
2302 }
2303
2304 GetViewShell()->PasteFromTransferable( xTrans );
2305 }
2306 }
2307
2308 //------------------------------------------------------------------------
2309
2310
2311
2312
vba interoperability for OOo