1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sc.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski #include "scitems.hxx"
28*b1cdbd2cSJim Jagielski
29*b1cdbd2cSJim Jagielski #include <memory> //auto_ptr
30*b1cdbd2cSJim Jagielski #include <editeng/adjitem.hxx>
31*b1cdbd2cSJim Jagielski #include <svx/algitem.hxx>
32*b1cdbd2cSJim Jagielski #include <svx/dbexch.hrc>
33*b1cdbd2cSJim Jagielski #include <editeng/editview.hxx>
34*b1cdbd2cSJim Jagielski #include <editeng/editstat.hxx>
35*b1cdbd2cSJim Jagielski #include <editeng/flditem.hxx>
36*b1cdbd2cSJim Jagielski #include <svx/svdetc.hxx>
37*b1cdbd2cSJim Jagielski #include <editeng/editobj.hxx>
38*b1cdbd2cSJim Jagielski #include <sfx2/dispatch.hxx>
39*b1cdbd2cSJim Jagielski #include <sfx2/viewfrm.hxx>
40*b1cdbd2cSJim Jagielski #include <sfx2/docfile.hxx>
41*b1cdbd2cSJim Jagielski #include <svl/stritem.hxx>
42*b1cdbd2cSJim Jagielski #include <svtools/svlbox.hxx>
43*b1cdbd2cSJim Jagielski #include <svtools/svtabbx.hxx>
44*b1cdbd2cSJim Jagielski #include <svl/urlbmk.hxx>
45*b1cdbd2cSJim Jagielski #include <tools/urlobj.hxx>
46*b1cdbd2cSJim Jagielski #include <vcl/cursor.hxx>
47*b1cdbd2cSJim Jagielski #include <vcl/sound.hxx>
48*b1cdbd2cSJim Jagielski #include <vcl/graph.hxx>
49*b1cdbd2cSJim Jagielski #include <vcl/hatch.hxx>
50*b1cdbd2cSJim Jagielski #include <sot/formats.hxx>
51*b1cdbd2cSJim Jagielski #include <sot/clsids.hxx>
52*b1cdbd2cSJim Jagielski
53*b1cdbd2cSJim Jagielski #include <svx/svdview.hxx> // fuer Command-Handler (COMMAND_INSERTTEXT)
54*b1cdbd2cSJim Jagielski #include <editeng/outliner.hxx> // fuer Command-Handler (COMMAND_INSERTTEXT)
55*b1cdbd2cSJim Jagielski #include <svx/svditer.hxx>
56*b1cdbd2cSJim Jagielski #include <svx/svdocapt.hxx>
57*b1cdbd2cSJim Jagielski #include <svx/svdpagv.hxx>
58*b1cdbd2cSJim Jagielski
59*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
60*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
61*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotTableHeaderData.hpp>
62*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotTableResultData.hpp>
63*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotTablePositionData.hpp>
64*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotTablePositionType.hpp>
65*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/MemberResultFlags.hpp>
66*b1cdbd2cSJim Jagielski #include <com/sun/star/awt/KeyModifier.hpp>
67*b1cdbd2cSJim Jagielski #include <com/sun/star/awt/MouseButton.hpp>
68*b1cdbd2cSJim Jagielski #include <com/sun/star/script/vba/VBAEventId.hpp>
69*b1cdbd2cSJim Jagielski #include <com/sun/star/script/vba/XVBAEventProcessor.hpp>
70*b1cdbd2cSJim Jagielski
71*b1cdbd2cSJim Jagielski #include "gridwin.hxx"
72*b1cdbd2cSJim Jagielski #include "tabvwsh.hxx"
73*b1cdbd2cSJim Jagielski #include "docsh.hxx"
74*b1cdbd2cSJim Jagielski #include "viewdata.hxx"
75*b1cdbd2cSJim Jagielski #include "tabview.hxx"
76*b1cdbd2cSJim Jagielski #include "select.hxx"
77*b1cdbd2cSJim Jagielski #include "scmod.hxx"
78*b1cdbd2cSJim Jagielski #include "document.hxx"
79*b1cdbd2cSJim Jagielski #include "attrib.hxx"
80*b1cdbd2cSJim Jagielski #include "dbcolect.hxx"
81*b1cdbd2cSJim Jagielski #include "stlpool.hxx"
82*b1cdbd2cSJim Jagielski #include "printfun.hxx"
83*b1cdbd2cSJim Jagielski #include "cbutton.hxx"
84*b1cdbd2cSJim Jagielski #include "sc.hrc"
85*b1cdbd2cSJim Jagielski #include "globstr.hrc"
86*b1cdbd2cSJim Jagielski #include "editutil.hxx"
87*b1cdbd2cSJim Jagielski #include "scresid.hxx"
88*b1cdbd2cSJim Jagielski #include "inputhdl.hxx"
89*b1cdbd2cSJim Jagielski #include "uiitems.hxx" // Filter-Dialog - auslagern !!!
90*b1cdbd2cSJim Jagielski #include "filtdlg.hxx"
91*b1cdbd2cSJim Jagielski #include "impex.hxx" // Sylk-ID fuer CB
92*b1cdbd2cSJim Jagielski #include "cell.hxx" // fuer Edit-Felder
93*b1cdbd2cSJim Jagielski #include "patattr.hxx"
94*b1cdbd2cSJim Jagielski #include "notemark.hxx"
95*b1cdbd2cSJim Jagielski #include "rfindlst.hxx"
96*b1cdbd2cSJim Jagielski #include "docpool.hxx"
97*b1cdbd2cSJim Jagielski #include "output.hxx"
98*b1cdbd2cSJim Jagielski #include "docfunc.hxx"
99*b1cdbd2cSJim Jagielski #include "dbdocfun.hxx"
100*b1cdbd2cSJim Jagielski #include "dpobject.hxx"
101*b1cdbd2cSJim Jagielski #include "dpoutput.hxx"
102*b1cdbd2cSJim Jagielski #include "transobj.hxx"
103*b1cdbd2cSJim Jagielski #include "drwtrans.hxx"
104*b1cdbd2cSJim Jagielski #include "seltrans.hxx"
105*b1cdbd2cSJim Jagielski #include "sizedev.hxx"
106*b1cdbd2cSJim Jagielski #include "AccessibilityHints.hxx"
107*b1cdbd2cSJim Jagielski #include "dpsave.hxx"
108*b1cdbd2cSJim Jagielski #include "viewuno.hxx"
109*b1cdbd2cSJim Jagielski #include "compiler.hxx"
110*b1cdbd2cSJim Jagielski #include "editable.hxx"
111*b1cdbd2cSJim Jagielski #include "fillinfo.hxx"
112*b1cdbd2cSJim Jagielski #include "scitems.hxx"
113*b1cdbd2cSJim Jagielski #include "userdat.hxx"
114*b1cdbd2cSJim Jagielski #include "drwlayer.hxx"
115*b1cdbd2cSJim Jagielski #include "attrib.hxx"
116*b1cdbd2cSJim Jagielski #include "validat.hxx"
117*b1cdbd2cSJim Jagielski #include "tabprotection.hxx"
118*b1cdbd2cSJim Jagielski #include "postit.hxx"
119*b1cdbd2cSJim Jagielski #include "dpcontrol.hxx"
120*b1cdbd2cSJim Jagielski #include "cellsuno.hxx"
121*b1cdbd2cSJim Jagielski
122*b1cdbd2cSJim Jagielski #include "drawview.hxx"
123*b1cdbd2cSJim Jagielski #include <svx/sdrpagewindow.hxx>
124*b1cdbd2cSJim Jagielski #include <svx/sdr/overlay/overlaymanager.hxx>
125*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
126*b1cdbd2cSJim Jagielski #include <svx/sdr/overlay/overlayselection.hxx>
127*b1cdbd2cSJim Jagielski
128*b1cdbd2cSJim Jagielski using namespace com::sun::star;
129*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Sequence;
130*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Any;
131*b1cdbd2cSJim Jagielski
132*b1cdbd2cSJim Jagielski const sal_uInt8 SC_NESTEDBUTTON_NONE = 0;
133*b1cdbd2cSJim Jagielski const sal_uInt8 SC_NESTEDBUTTON_DOWN = 1;
134*b1cdbd2cSJim Jagielski const sal_uInt8 SC_NESTEDBUTTON_UP = 2;
135*b1cdbd2cSJim Jagielski
136*b1cdbd2cSJim Jagielski #define SC_AUTOFILTER_ALL 0
137*b1cdbd2cSJim Jagielski #define SC_AUTOFILTER_TOP10 1
138*b1cdbd2cSJim Jagielski #define SC_AUTOFILTER_CUSTOM 2
139*b1cdbd2cSJim Jagielski
140*b1cdbd2cSJim Jagielski // Modi fuer die FilterListBox
141*b1cdbd2cSJim Jagielski enum ScFilterBoxMode
142*b1cdbd2cSJim Jagielski {
143*b1cdbd2cSJim Jagielski SC_FILTERBOX_FILTER,
144*b1cdbd2cSJim Jagielski SC_FILTERBOX_DATASELECT,
145*b1cdbd2cSJim Jagielski SC_FILTERBOX_SCENARIO,
146*b1cdbd2cSJim Jagielski SC_FILTERBOX_PAGEFIELD
147*b1cdbd2cSJim Jagielski };
148*b1cdbd2cSJim Jagielski
149*b1cdbd2cSJim Jagielski extern SfxViewShell* pScActiveViewShell; // global.cxx
150*b1cdbd2cSJim Jagielski extern sal_uInt16 nScClickMouseModifier; // global.cxx
151*b1cdbd2cSJim Jagielski extern sal_uInt16 nScFillModeMouseModifier; // global.cxx
152*b1cdbd2cSJim Jagielski
153*b1cdbd2cSJim Jagielski #define SC_FILTERLISTBOX_LINES 12
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski // ============================================================================
156*b1cdbd2cSJim Jagielski
VisibleRange()157*b1cdbd2cSJim Jagielski ScGridWindow::VisibleRange::VisibleRange() :
158*b1cdbd2cSJim Jagielski mnCol1(0), mnCol2(MAXCOL), mnRow1(0), mnRow2(MAXROW)
159*b1cdbd2cSJim Jagielski {
160*b1cdbd2cSJim Jagielski }
161*b1cdbd2cSJim Jagielski
isInside(SCCOL nCol,SCROW nRow) const162*b1cdbd2cSJim Jagielski bool ScGridWindow::VisibleRange::isInside(SCCOL nCol, SCROW nRow) const
163*b1cdbd2cSJim Jagielski {
164*b1cdbd2cSJim Jagielski return mnCol1 <= nCol && nCol <= mnCol2 && mnRow1 <= nRow && nRow <= mnRow2;
165*b1cdbd2cSJim Jagielski }
166*b1cdbd2cSJim Jagielski
167*b1cdbd2cSJim Jagielski // ============================================================================
168*b1cdbd2cSJim Jagielski
169*b1cdbd2cSJim Jagielski class ScFilterListBox : public ListBox
170*b1cdbd2cSJim Jagielski {
171*b1cdbd2cSJim Jagielski private:
172*b1cdbd2cSJim Jagielski ScGridWindow* pGridWin;
173*b1cdbd2cSJim Jagielski SCCOL nCol;
174*b1cdbd2cSJim Jagielski SCROW nRow;
175*b1cdbd2cSJim Jagielski sal_Bool bButtonDown;
176*b1cdbd2cSJim Jagielski sal_Bool bInit;
177*b1cdbd2cSJim Jagielski sal_Bool bCancelled;
178*b1cdbd2cSJim Jagielski sal_Bool bInSelect;
179*b1cdbd2cSJim Jagielski bool mbListHasDates;
180*b1cdbd2cSJim Jagielski sal_uLong nSel;
181*b1cdbd2cSJim Jagielski ScFilterBoxMode eMode;
182*b1cdbd2cSJim Jagielski
183*b1cdbd2cSJim Jagielski protected:
184*b1cdbd2cSJim Jagielski virtual void LoseFocus();
185*b1cdbd2cSJim Jagielski void SelectHdl();
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski public:
188*b1cdbd2cSJim Jagielski ScFilterListBox( Window* pParent, ScGridWindow* pGrid,
189*b1cdbd2cSJim Jagielski SCCOL nNewCol, SCROW nNewRow, ScFilterBoxMode eNewMode );
190*b1cdbd2cSJim Jagielski ~ScFilterListBox();
191*b1cdbd2cSJim Jagielski
192*b1cdbd2cSJim Jagielski virtual long PreNotify( NotifyEvent& rNEvt );
193*b1cdbd2cSJim Jagielski virtual void Select();
194*b1cdbd2cSJim Jagielski
GetCol() const195*b1cdbd2cSJim Jagielski SCCOL GetCol() const { return nCol; }
GetRow() const196*b1cdbd2cSJim Jagielski SCROW GetRow() const { return nRow; }
GetMode() const197*b1cdbd2cSJim Jagielski ScFilterBoxMode GetMode() const { return eMode; }
IsDataSelect() const198*b1cdbd2cSJim Jagielski sal_Bool IsDataSelect() const { return (eMode == SC_FILTERBOX_DATASELECT); }
199*b1cdbd2cSJim Jagielski void EndInit();
IsInInit() const200*b1cdbd2cSJim Jagielski sal_Bool IsInInit() const { return bInit; }
SetCancelled()201*b1cdbd2cSJim Jagielski void SetCancelled() { bCancelled = sal_True; }
IsInSelect() const202*b1cdbd2cSJim Jagielski sal_Bool IsInSelect() const { return bInSelect; }
SetListHasDates(bool b)203*b1cdbd2cSJim Jagielski void SetListHasDates(bool b) { mbListHasDates = b; }
HasDates() const204*b1cdbd2cSJim Jagielski bool HasDates() const { return mbListHasDates; }
205*b1cdbd2cSJim Jagielski };
206*b1cdbd2cSJim Jagielski
207*b1cdbd2cSJim Jagielski //-------------------------------------------------------------------
208*b1cdbd2cSJim Jagielski
209*b1cdbd2cSJim Jagielski // ListBox in einem FloatingWindow (pParent)
ScFilterListBox(Window * pParent,ScGridWindow * pGrid,SCCOL nNewCol,SCROW nNewRow,ScFilterBoxMode eNewMode)210*b1cdbd2cSJim Jagielski ScFilterListBox::ScFilterListBox( Window* pParent, ScGridWindow* pGrid,
211*b1cdbd2cSJim Jagielski SCCOL nNewCol, SCROW nNewRow, ScFilterBoxMode eNewMode ) :
212*b1cdbd2cSJim Jagielski ListBox( pParent, WB_AUTOHSCROLL ),
213*b1cdbd2cSJim Jagielski pGridWin( pGrid ),
214*b1cdbd2cSJim Jagielski nCol( nNewCol ),
215*b1cdbd2cSJim Jagielski nRow( nNewRow ),
216*b1cdbd2cSJim Jagielski bButtonDown( sal_False ),
217*b1cdbd2cSJim Jagielski bInit( sal_True ),
218*b1cdbd2cSJim Jagielski bCancelled( sal_False ),
219*b1cdbd2cSJim Jagielski bInSelect( sal_False ),
220*b1cdbd2cSJim Jagielski mbListHasDates(false),
221*b1cdbd2cSJim Jagielski nSel( 0 ),
222*b1cdbd2cSJim Jagielski eMode( eNewMode )
223*b1cdbd2cSJim Jagielski {
224*b1cdbd2cSJim Jagielski }
225*b1cdbd2cSJim Jagielski
~ScFilterListBox()226*b1cdbd2cSJim Jagielski __EXPORT ScFilterListBox::~ScFilterListBox()
227*b1cdbd2cSJim Jagielski {
228*b1cdbd2cSJim Jagielski if (IsMouseCaptured())
229*b1cdbd2cSJim Jagielski ReleaseMouse();
230*b1cdbd2cSJim Jagielski }
231*b1cdbd2cSJim Jagielski
EndInit()232*b1cdbd2cSJim Jagielski void ScFilterListBox::EndInit()
233*b1cdbd2cSJim Jagielski {
234*b1cdbd2cSJim Jagielski sal_uInt16 nPos = GetSelectEntryPos();
235*b1cdbd2cSJim Jagielski if ( LISTBOX_ENTRY_NOTFOUND == nPos )
236*b1cdbd2cSJim Jagielski nSel = 0;
237*b1cdbd2cSJim Jagielski else
238*b1cdbd2cSJim Jagielski nSel = nPos;
239*b1cdbd2cSJim Jagielski
240*b1cdbd2cSJim Jagielski bInit = sal_False;
241*b1cdbd2cSJim Jagielski }
242*b1cdbd2cSJim Jagielski
LoseFocus()243*b1cdbd2cSJim Jagielski void __EXPORT ScFilterListBox::LoseFocus()
244*b1cdbd2cSJim Jagielski {
245*b1cdbd2cSJim Jagielski #ifndef UNX
246*b1cdbd2cSJim Jagielski Hide();
247*b1cdbd2cSJim Jagielski #endif
248*b1cdbd2cSJim Jagielski }
249*b1cdbd2cSJim Jagielski
250*b1cdbd2cSJim Jagielski // -----------------------------------------------------------------------
251*b1cdbd2cSJim Jagielski
PreNotify(NotifyEvent & rNEvt)252*b1cdbd2cSJim Jagielski long ScFilterListBox::PreNotify( NotifyEvent& rNEvt )
253*b1cdbd2cSJim Jagielski {
254*b1cdbd2cSJim Jagielski long nDone = 0;
255*b1cdbd2cSJim Jagielski if ( rNEvt.GetType() == EVENT_KEYINPUT )
256*b1cdbd2cSJim Jagielski {
257*b1cdbd2cSJim Jagielski KeyEvent aKeyEvt = *rNEvt.GetKeyEvent();
258*b1cdbd2cSJim Jagielski KeyCode aCode = aKeyEvt.GetKeyCode();
259*b1cdbd2cSJim Jagielski if ( !aCode.GetModifier() ) // ohne alle Modifiers
260*b1cdbd2cSJim Jagielski {
261*b1cdbd2cSJim Jagielski sal_uInt16 nKey = aCode.GetCode();
262*b1cdbd2cSJim Jagielski if ( nKey == KEY_RETURN )
263*b1cdbd2cSJim Jagielski {
264*b1cdbd2cSJim Jagielski SelectHdl(); // auswaehlen
265*b1cdbd2cSJim Jagielski nDone = 1;
266*b1cdbd2cSJim Jagielski }
267*b1cdbd2cSJim Jagielski else if ( nKey == KEY_ESCAPE )
268*b1cdbd2cSJim Jagielski {
269*b1cdbd2cSJim Jagielski pGridWin->ClickExtern(); // loescht die List-Box !!!
270*b1cdbd2cSJim Jagielski nDone = 1;
271*b1cdbd2cSJim Jagielski }
272*b1cdbd2cSJim Jagielski }
273*b1cdbd2cSJim Jagielski }
274*b1cdbd2cSJim Jagielski
275*b1cdbd2cSJim Jagielski return nDone ? nDone : ListBox::PreNotify( rNEvt );
276*b1cdbd2cSJim Jagielski }
277*b1cdbd2cSJim Jagielski
Select()278*b1cdbd2cSJim Jagielski void __EXPORT ScFilterListBox::Select()
279*b1cdbd2cSJim Jagielski {
280*b1cdbd2cSJim Jagielski ListBox::Select();
281*b1cdbd2cSJim Jagielski SelectHdl();
282*b1cdbd2cSJim Jagielski }
283*b1cdbd2cSJim Jagielski
SelectHdl()284*b1cdbd2cSJim Jagielski void __EXPORT ScFilterListBox::SelectHdl()
285*b1cdbd2cSJim Jagielski {
286*b1cdbd2cSJim Jagielski if ( !IsTravelSelect() && !bInit && !bCancelled )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski sal_uInt16 nPos = GetSelectEntryPos();
289*b1cdbd2cSJim Jagielski if ( LISTBOX_ENTRY_NOTFOUND != nPos )
290*b1cdbd2cSJim Jagielski {
291*b1cdbd2cSJim Jagielski nSel = nPos;
292*b1cdbd2cSJim Jagielski if (!bButtonDown)
293*b1cdbd2cSJim Jagielski {
294*b1cdbd2cSJim Jagielski // #i81298# set bInSelect flag, so the box isn't deleted from modifications within FilterSelect
295*b1cdbd2cSJim Jagielski bInSelect = sal_True;
296*b1cdbd2cSJim Jagielski pGridWin->FilterSelect( nSel );
297*b1cdbd2cSJim Jagielski bInSelect = sal_False;
298*b1cdbd2cSJim Jagielski }
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski }
301*b1cdbd2cSJim Jagielski }
302*b1cdbd2cSJim Jagielski
303*b1cdbd2cSJim Jagielski // ============================================================================
304*b1cdbd2cSJim Jagielski
305*b1cdbd2cSJim Jagielski // use a System floating window for the above filter listbox
306*b1cdbd2cSJim Jagielski class ScFilterFloatingWindow : public FloatingWindow
307*b1cdbd2cSJim Jagielski {
308*b1cdbd2cSJim Jagielski public:
309*b1cdbd2cSJim Jagielski ScFilterFloatingWindow( Window* pParent, WinBits nStyle = WB_STDFLOATWIN );
310*b1cdbd2cSJim Jagielski virtual ~ScFilterFloatingWindow();
311*b1cdbd2cSJim Jagielski // required for System FloatingWindows that will not process KeyInput by themselves
312*b1cdbd2cSJim Jagielski virtual Window* GetPreferredKeyInputWindow();
313*b1cdbd2cSJim Jagielski };
314*b1cdbd2cSJim Jagielski
ScFilterFloatingWindow(Window * pParent,WinBits nStyle)315*b1cdbd2cSJim Jagielski ScFilterFloatingWindow::ScFilterFloatingWindow( Window* pParent, WinBits nStyle ) :
316*b1cdbd2cSJim Jagielski FloatingWindow( pParent, nStyle|WB_SYSTEMWINDOW ) // make it a system floater
317*b1cdbd2cSJim Jagielski {}
318*b1cdbd2cSJim Jagielski
~ScFilterFloatingWindow()319*b1cdbd2cSJim Jagielski ScFilterFloatingWindow::~ScFilterFloatingWindow()
320*b1cdbd2cSJim Jagielski {
321*b1cdbd2cSJim Jagielski EndPopupMode();
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
GetPreferredKeyInputWindow()324*b1cdbd2cSJim Jagielski Window* ScFilterFloatingWindow::GetPreferredKeyInputWindow()
325*b1cdbd2cSJim Jagielski {
326*b1cdbd2cSJim Jagielski // redirect keyinput in the child window
327*b1cdbd2cSJim Jagielski return GetWindow(WINDOW_FIRSTCHILD) ? GetWindow(WINDOW_FIRSTCHILD)->GetPreferredKeyInputWindow() : NULL; // will be the FilterBox
328*b1cdbd2cSJim Jagielski }
329*b1cdbd2cSJim Jagielski
330*b1cdbd2cSJim Jagielski // ============================================================================
331*b1cdbd2cSJim Jagielski
lcl_IsEditableMatrix(ScDocument * pDoc,const ScRange & rRange)332*b1cdbd2cSJim Jagielski sal_Bool lcl_IsEditableMatrix( ScDocument* pDoc, const ScRange& rRange )
333*b1cdbd2cSJim Jagielski {
334*b1cdbd2cSJim Jagielski // wenn es ein editierbarer Bereich ist, und rechts unten eine Matrix-Zelle
335*b1cdbd2cSJim Jagielski // mit Origin links oben liegt, enthaelt der Bereich genau die Matrix.
336*b1cdbd2cSJim Jagielski //! Direkt die MatrixEdges Funktionen von der Column herausreichen ???
337*b1cdbd2cSJim Jagielski
338*b1cdbd2cSJim Jagielski if ( !pDoc->IsBlockEditable( rRange.aStart.Tab(), rRange.aStart.Col(),rRange.aStart.Row(),
339*b1cdbd2cSJim Jagielski rRange.aEnd.Col(),rRange.aEnd.Row() ) )
340*b1cdbd2cSJim Jagielski return sal_False;
341*b1cdbd2cSJim Jagielski
342*b1cdbd2cSJim Jagielski ScAddress aPos;
343*b1cdbd2cSJim Jagielski const ScBaseCell* pCell = pDoc->GetCell( rRange.aEnd );
344*b1cdbd2cSJim Jagielski return ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA &&
345*b1cdbd2cSJim Jagielski ((ScFormulaCell*)pCell)->GetMatrixOrigin(aPos) && aPos == rRange.aStart );
346*b1cdbd2cSJim Jagielski
347*b1cdbd2cSJim Jagielski }
348*b1cdbd2cSJim Jagielski
lcl_UnLockComment(ScDrawView * pView,SdrPageView * pPV,SdrModel * pDrDoc,const Point & rPos,ScViewData * pViewData)349*b1cdbd2cSJim Jagielski void lcl_UnLockComment( ScDrawView* pView, SdrPageView* pPV, SdrModel* pDrDoc, const Point& rPos, ScViewData* pViewData )
350*b1cdbd2cSJim Jagielski {
351*b1cdbd2cSJim Jagielski if (!pView && !pPV && !pDrDoc && !pViewData)
352*b1cdbd2cSJim Jagielski return;
353*b1cdbd2cSJim Jagielski
354*b1cdbd2cSJim Jagielski ScDocument& rDoc = *pViewData->GetDocument();
355*b1cdbd2cSJim Jagielski ScAddress aCellPos( pViewData->GetCurX(), pViewData->GetCurY(), pViewData->GetTabNo() );
356*b1cdbd2cSJim Jagielski ScPostIt* pNote = rDoc.GetNote( aCellPos );
357*b1cdbd2cSJim Jagielski SdrObject* pObj = pNote ? pNote->GetCaption() : 0;
358*b1cdbd2cSJim Jagielski if( pObj && pObj->GetLogicRect().IsInside( rPos ) && ScDrawLayer::IsNoteCaption( pObj ) )
359*b1cdbd2cSJim Jagielski {
360*b1cdbd2cSJim Jagielski const ScProtectionAttr* pProtAttr = static_cast< const ScProtectionAttr* > (rDoc.GetAttr( aCellPos.Col(), aCellPos.Row(), aCellPos.Tab(), ATTR_PROTECTION ) );
361*b1cdbd2cSJim Jagielski bool bProtectAttr = pProtAttr->GetProtection() || pProtAttr->GetHideCell() ;
362*b1cdbd2cSJim Jagielski bool bProtectDoc = rDoc.IsTabProtected( aCellPos.Tab() ) || pViewData->GetSfxDocShell()->IsReadOnly() ;
363*b1cdbd2cSJim Jagielski // unlock internal layer (if not protected), will be relocked in ScDrawView::MarkListHasChanged()
364*b1cdbd2cSJim Jagielski pView->LockInternalLayer( bProtectDoc && bProtectAttr );
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski }
367*b1cdbd2cSJim Jagielski
lcl_GetHyperlinkCell(ScDocument * pDoc,SCCOL & rPosX,SCROW & rPosY,SCTAB nTab,ScBaseCell * & rpCell)368*b1cdbd2cSJim Jagielski sal_Bool lcl_GetHyperlinkCell(ScDocument* pDoc, SCCOL& rPosX, SCROW& rPosY, SCTAB nTab, ScBaseCell*& rpCell )
369*b1cdbd2cSJim Jagielski {
370*b1cdbd2cSJim Jagielski sal_Bool bFound = sal_False;
371*b1cdbd2cSJim Jagielski do
372*b1cdbd2cSJim Jagielski {
373*b1cdbd2cSJim Jagielski pDoc->GetCell( rPosX, rPosY, nTab, rpCell );
374*b1cdbd2cSJim Jagielski if ( !rpCell || rpCell->GetCellType() == CELLTYPE_NOTE )
375*b1cdbd2cSJim Jagielski {
376*b1cdbd2cSJim Jagielski if ( rPosX <= 0 )
377*b1cdbd2cSJim Jagielski return sal_False; // alles leer bis links
378*b1cdbd2cSJim Jagielski else
379*b1cdbd2cSJim Jagielski --rPosX; // weitersuchen
380*b1cdbd2cSJim Jagielski }
381*b1cdbd2cSJim Jagielski else if ( rpCell->GetCellType() == CELLTYPE_EDIT)
382*b1cdbd2cSJim Jagielski bFound = sal_True;
383*b1cdbd2cSJim Jagielski else if (rpCell->GetCellType() == CELLTYPE_FORMULA &&
384*b1cdbd2cSJim Jagielski static_cast<ScFormulaCell*>(rpCell)->IsHyperLinkCell())
385*b1cdbd2cSJim Jagielski bFound = sal_True;
386*b1cdbd2cSJim Jagielski else
387*b1cdbd2cSJim Jagielski return sal_False; // andere Zelle
388*b1cdbd2cSJim Jagielski }
389*b1cdbd2cSJim Jagielski while ( !bFound );
390*b1cdbd2cSJim Jagielski
391*b1cdbd2cSJim Jagielski return bFound;
392*b1cdbd2cSJim Jagielski }
393*b1cdbd2cSJim Jagielski
394*b1cdbd2cSJim Jagielski // ---------------------------------------------------------------------------
395*b1cdbd2cSJim Jagielski // WB_DIALOGCONTROL noetig fuer UNO-Controls
ScGridWindow(Window * pParent,ScViewData * pData,ScSplitPos eWhichPos)396*b1cdbd2cSJim Jagielski ScGridWindow::ScGridWindow( Window* pParent, ScViewData* pData, ScSplitPos eWhichPos )
397*b1cdbd2cSJim Jagielski : Window( pParent, WB_CLIPCHILDREN | WB_DIALOGCONTROL ),
398*b1cdbd2cSJim Jagielski DropTargetHelper( this ),
399*b1cdbd2cSJim Jagielski DragSourceHelper( this ),
400*b1cdbd2cSJim Jagielski mpOOCursors( NULL ),
401*b1cdbd2cSJim Jagielski mpOOSelection( NULL ),
402*b1cdbd2cSJim Jagielski mpOOAutoFill( NULL ),
403*b1cdbd2cSJim Jagielski mpOODragRect( NULL ),
404*b1cdbd2cSJim Jagielski mpOOHeader( NULL ),
405*b1cdbd2cSJim Jagielski mpOOShrink( NULL ),
406*b1cdbd2cSJim Jagielski mpAutoFillRect(static_cast<Rectangle*>(NULL)),
407*b1cdbd2cSJim Jagielski pViewData( pData ),
408*b1cdbd2cSJim Jagielski eWhich( eWhichPos ),
409*b1cdbd2cSJim Jagielski pNoteMarker( NULL ),
410*b1cdbd2cSJim Jagielski pFilterBox( NULL ),
411*b1cdbd2cSJim Jagielski pFilterFloat( NULL ),
412*b1cdbd2cSJim Jagielski mpDPFieldPopup(NULL),
413*b1cdbd2cSJim Jagielski mpFilterButton(NULL),
414*b1cdbd2cSJim Jagielski nCursorHideCount( 0 ),
415*b1cdbd2cSJim Jagielski bMarking( sal_False ),
416*b1cdbd2cSJim Jagielski nButtonDown( 0 ),
417*b1cdbd2cSJim Jagielski bEEMouse( sal_False ),
418*b1cdbd2cSJim Jagielski nMouseStatus( SC_GM_NONE ),
419*b1cdbd2cSJim Jagielski nNestedButtonState( SC_NESTEDBUTTON_NONE ),
420*b1cdbd2cSJim Jagielski bDPMouse( sal_False ),
421*b1cdbd2cSJim Jagielski bRFMouse( sal_False ),
422*b1cdbd2cSJim Jagielski nPagebreakMouse( SC_PD_NONE ),
423*b1cdbd2cSJim Jagielski bPagebreakDrawn( sal_False ),
424*b1cdbd2cSJim Jagielski nPageScript( 0 ),
425*b1cdbd2cSJim Jagielski bDragRect( sal_False ),
426*b1cdbd2cSJim Jagielski meDragInsertMode( INS_NONE ),
427*b1cdbd2cSJim Jagielski nCurrentPointer( 0 ),
428*b1cdbd2cSJim Jagielski bIsInScroll( sal_False ),
429*b1cdbd2cSJim Jagielski bIsInPaint( sal_False ),
430*b1cdbd2cSJim Jagielski aComboButton( this ),
431*b1cdbd2cSJim Jagielski aCurMousePos( 0,0 ),
432*b1cdbd2cSJim Jagielski nPaintCount( 0 ),
433*b1cdbd2cSJim Jagielski bNeedsRepaint( sal_False ),
434*b1cdbd2cSJim Jagielski bAutoMarkVisible( sal_False ),
435*b1cdbd2cSJim Jagielski bListValButton( sal_False )
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski switch(eWhich)
438*b1cdbd2cSJim Jagielski {
439*b1cdbd2cSJim Jagielski case SC_SPLIT_TOPLEFT:
440*b1cdbd2cSJim Jagielski eHWhich = SC_SPLIT_LEFT;
441*b1cdbd2cSJim Jagielski eVWhich = SC_SPLIT_TOP;
442*b1cdbd2cSJim Jagielski break;
443*b1cdbd2cSJim Jagielski case SC_SPLIT_TOPRIGHT:
444*b1cdbd2cSJim Jagielski eHWhich = SC_SPLIT_RIGHT;
445*b1cdbd2cSJim Jagielski eVWhich = SC_SPLIT_TOP;
446*b1cdbd2cSJim Jagielski break;
447*b1cdbd2cSJim Jagielski case SC_SPLIT_BOTTOMLEFT:
448*b1cdbd2cSJim Jagielski eHWhich = SC_SPLIT_LEFT;
449*b1cdbd2cSJim Jagielski eVWhich = SC_SPLIT_BOTTOM;
450*b1cdbd2cSJim Jagielski break;
451*b1cdbd2cSJim Jagielski case SC_SPLIT_BOTTOMRIGHT:
452*b1cdbd2cSJim Jagielski eHWhich = SC_SPLIT_RIGHT;
453*b1cdbd2cSJim Jagielski eVWhich = SC_SPLIT_BOTTOM;
454*b1cdbd2cSJim Jagielski break;
455*b1cdbd2cSJim Jagielski default:
456*b1cdbd2cSJim Jagielski DBG_ERROR("GridWindow: falsche Position");
457*b1cdbd2cSJim Jagielski }
458*b1cdbd2cSJim Jagielski
459*b1cdbd2cSJim Jagielski SetBackground();
460*b1cdbd2cSJim Jagielski
461*b1cdbd2cSJim Jagielski SetMapMode(pViewData->GetLogicMode(eWhich));
462*b1cdbd2cSJim Jagielski // EnableDrop();
463*b1cdbd2cSJim Jagielski EnableChildTransparentMode();
464*b1cdbd2cSJim Jagielski SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS );
465*b1cdbd2cSJim Jagielski
466*b1cdbd2cSJim Jagielski SetHelpId( HID_SC_WIN_GRIDWIN );
467*b1cdbd2cSJim Jagielski SetUniqueId( HID_SC_WIN_GRIDWIN );
468*b1cdbd2cSJim Jagielski
469*b1cdbd2cSJim Jagielski SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
470*b1cdbd2cSJim Jagielski EnableRTL( sal_False );
471*b1cdbd2cSJim Jagielski }
472*b1cdbd2cSJim Jagielski
~ScGridWindow()473*b1cdbd2cSJim Jagielski __EXPORT ScGridWindow::~ScGridWindow()
474*b1cdbd2cSJim Jagielski {
475*b1cdbd2cSJim Jagielski // #114409#
476*b1cdbd2cSJim Jagielski ImpDestroyOverlayObjects();
477*b1cdbd2cSJim Jagielski
478*b1cdbd2cSJim Jagielski delete pFilterBox;
479*b1cdbd2cSJim Jagielski delete pFilterFloat;
480*b1cdbd2cSJim Jagielski delete pNoteMarker;
481*b1cdbd2cSJim Jagielski }
482*b1cdbd2cSJim Jagielski
Resize(const Size &)483*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::Resize( const Size& )
484*b1cdbd2cSJim Jagielski {
485*b1cdbd2cSJim Jagielski // gar nix
486*b1cdbd2cSJim Jagielski }
487*b1cdbd2cSJim Jagielski
ClickExtern()488*b1cdbd2cSJim Jagielski void ScGridWindow::ClickExtern()
489*b1cdbd2cSJim Jagielski {
490*b1cdbd2cSJim Jagielski do
491*b1cdbd2cSJim Jagielski {
492*b1cdbd2cSJim Jagielski // #i81298# don't delete the filter box when called from its select handler
493*b1cdbd2cSJim Jagielski // (possible through row header size update)
494*b1cdbd2cSJim Jagielski // #i84277# when initializing the filter box, a Basic error can deactivate the view
495*b1cdbd2cSJim Jagielski if ( pFilterBox && ( pFilterBox->IsInSelect() || pFilterBox->IsInInit() ) )
496*b1cdbd2cSJim Jagielski {
497*b1cdbd2cSJim Jagielski break;
498*b1cdbd2cSJim Jagielski }
499*b1cdbd2cSJim Jagielski
500*b1cdbd2cSJim Jagielski DELETEZ(pFilterBox);
501*b1cdbd2cSJim Jagielski DELETEZ(pFilterFloat);
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski while (false);
504*b1cdbd2cSJim Jagielski
505*b1cdbd2cSJim Jagielski if (mpDPFieldPopup.get())
506*b1cdbd2cSJim Jagielski {
507*b1cdbd2cSJim Jagielski mpDPFieldPopup->close(false);
508*b1cdbd2cSJim Jagielski mpDPFieldPopup.reset();
509*b1cdbd2cSJim Jagielski }
510*b1cdbd2cSJim Jagielski }
511*b1cdbd2cSJim Jagielski
IMPL_LINK(ScGridWindow,PopupModeEndHdl,FloatingWindow *,EMPTYARG)512*b1cdbd2cSJim Jagielski IMPL_LINK( ScGridWindow, PopupModeEndHdl, FloatingWindow*, EMPTYARG )
513*b1cdbd2cSJim Jagielski {
514*b1cdbd2cSJim Jagielski if (pFilterBox)
515*b1cdbd2cSJim Jagielski pFilterBox->SetCancelled(); // nicht mehr auswaehlen
516*b1cdbd2cSJim Jagielski GrabFocus();
517*b1cdbd2cSJim Jagielski return 0;
518*b1cdbd2cSJim Jagielski }
519*b1cdbd2cSJim Jagielski
IMPL_LINK(ScGridWindow,PopupSpellingHdl,SpellCallbackInfo *,pInfo)520*b1cdbd2cSJim Jagielski IMPL_LINK( ScGridWindow, PopupSpellingHdl, SpellCallbackInfo*, pInfo )
521*b1cdbd2cSJim Jagielski {
522*b1cdbd2cSJim Jagielski if( pInfo->nCommand == SPELLCMD_STARTSPELLDLG )
523*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( SID_SPELL_DIALOG, SFX_CALLMODE_ASYNCHRON );
524*b1cdbd2cSJim Jagielski return 0;
525*b1cdbd2cSJim Jagielski }
526*b1cdbd2cSJim Jagielski
ExecPageFieldSelect(SCCOL nCol,SCROW nRow,sal_Bool bHasSelection,const String & rStr)527*b1cdbd2cSJim Jagielski void ScGridWindow::ExecPageFieldSelect( SCCOL nCol, SCROW nRow, sal_Bool bHasSelection, const String& rStr )
528*b1cdbd2cSJim Jagielski {
529*b1cdbd2cSJim Jagielski //! gridwin2 ?
530*b1cdbd2cSJim Jagielski
531*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
532*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
533*b1cdbd2cSJim Jagielski ScDPObject* pDPObj = pDoc->GetDPAtCursor(nCol, nRow, nTab);
534*b1cdbd2cSJim Jagielski if ( pDPObj && nCol > 0 )
535*b1cdbd2cSJim Jagielski {
536*b1cdbd2cSJim Jagielski // look for the dimension header left of the drop-down arrow
537*b1cdbd2cSJim Jagielski sal_uInt16 nOrient = sheet::DataPilotFieldOrientation_HIDDEN;
538*b1cdbd2cSJim Jagielski long nField = pDPObj->GetHeaderDim( ScAddress( nCol-1, nRow, nTab ), nOrient );
539*b1cdbd2cSJim Jagielski if ( nField >= 0 && nOrient == sheet::DataPilotFieldOrientation_PAGE )
540*b1cdbd2cSJim Jagielski {
541*b1cdbd2cSJim Jagielski ScDPSaveData aSaveData( *pDPObj->GetSaveData() );
542*b1cdbd2cSJim Jagielski
543*b1cdbd2cSJim Jagielski sal_Bool bIsDataLayout;
544*b1cdbd2cSJim Jagielski String aDimName = pDPObj->GetDimName( nField, bIsDataLayout );
545*b1cdbd2cSJim Jagielski if ( !bIsDataLayout )
546*b1cdbd2cSJim Jagielski {
547*b1cdbd2cSJim Jagielski ScDPSaveDimension* pDim = aSaveData.GetDimensionByName(aDimName);
548*b1cdbd2cSJim Jagielski
549*b1cdbd2cSJim Jagielski if ( bHasSelection )
550*b1cdbd2cSJim Jagielski pDim->SetCurrentPage( &rStr );
551*b1cdbd2cSJim Jagielski else
552*b1cdbd2cSJim Jagielski pDim->SetCurrentPage( NULL );
553*b1cdbd2cSJim Jagielski
554*b1cdbd2cSJim Jagielski ScDPObject aNewObj( *pDPObj );
555*b1cdbd2cSJim Jagielski aNewObj.SetSaveData( aSaveData );
556*b1cdbd2cSJim Jagielski ScDBDocFunc aFunc( *pViewData->GetDocShell() );
557*b1cdbd2cSJim Jagielski aFunc.DataPilotUpdate( pDPObj, &aNewObj, sal_True, sal_False );
558*b1cdbd2cSJim Jagielski pViewData->GetView()->CursorPosChanged(); // shells may be switched
559*b1cdbd2cSJim Jagielski }
560*b1cdbd2cSJim Jagielski }
561*b1cdbd2cSJim Jagielski }
562*b1cdbd2cSJim Jagielski }
563*b1cdbd2cSJim Jagielski
LaunchPageFieldMenu(SCCOL nCol,SCROW nRow)564*b1cdbd2cSJim Jagielski void ScGridWindow::LaunchPageFieldMenu( SCCOL nCol, SCROW nRow )
565*b1cdbd2cSJim Jagielski {
566*b1cdbd2cSJim Jagielski //! merge position/size handling with DoAutoFilterMenue
567*b1cdbd2cSJim Jagielski
568*b1cdbd2cSJim Jagielski delete pFilterBox;
569*b1cdbd2cSJim Jagielski delete pFilterFloat;
570*b1cdbd2cSJim Jagielski
571*b1cdbd2cSJim Jagielski sal_uInt16 i;
572*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
573*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
574*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
575*b1cdbd2cSJim Jagielski
576*b1cdbd2cSJim Jagielski long nSizeX = 0;
577*b1cdbd2cSJim Jagielski long nSizeY = 0;
578*b1cdbd2cSJim Jagielski long nHeight = 0;
579*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nCol, nRow, nSizeX, nSizeY );
580*b1cdbd2cSJim Jagielski Point aPos = pViewData->GetScrPos( nCol, nRow, eWhich );
581*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
582*b1cdbd2cSJim Jagielski aPos.X() -= nSizeX;
583*b1cdbd2cSJim Jagielski
584*b1cdbd2cSJim Jagielski Rectangle aCellRect( OutputToScreenPixel(aPos), Size(nSizeX,nSizeY) );
585*b1cdbd2cSJim Jagielski
586*b1cdbd2cSJim Jagielski aPos.X() -= 1;
587*b1cdbd2cSJim Jagielski aPos.Y() += nSizeY - 1;
588*b1cdbd2cSJim Jagielski
589*b1cdbd2cSJim Jagielski pFilterFloat = new ScFilterFloatingWindow( this, WinBits(WB_BORDER) ); // not resizable etc.
590*b1cdbd2cSJim Jagielski pFilterFloat->SetPopupModeEndHdl( LINK( this, ScGridWindow, PopupModeEndHdl ) );
591*b1cdbd2cSJim Jagielski pFilterBox = new ScFilterListBox( pFilterFloat, this, nCol, nRow, SC_FILTERBOX_PAGEFIELD );
592*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
593*b1cdbd2cSJim Jagielski pFilterBox->EnableMirroring();
594*b1cdbd2cSJim Jagielski
595*b1cdbd2cSJim Jagielski nSizeX += 1;
596*b1cdbd2cSJim Jagielski
597*b1cdbd2cSJim Jagielski {
598*b1cdbd2cSJim Jagielski Font aOldFont = GetFont(); SetFont( pFilterBox->GetFont() );
599*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode(); SetMapMode( MAP_PIXEL );
600*b1cdbd2cSJim Jagielski
601*b1cdbd2cSJim Jagielski nHeight = GetTextHeight();
602*b1cdbd2cSJim Jagielski nHeight *= SC_FILTERLISTBOX_LINES;
603*b1cdbd2cSJim Jagielski
604*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
605*b1cdbd2cSJim Jagielski SetFont( aOldFont );
606*b1cdbd2cSJim Jagielski }
607*b1cdbd2cSJim Jagielski
608*b1cdbd2cSJim Jagielski // SetSize comes later
609*b1cdbd2cSJim Jagielski
610*b1cdbd2cSJim Jagielski TypedScStrCollection aStrings( 128, 128 );
611*b1cdbd2cSJim Jagielski
612*b1cdbd2cSJim Jagielski // get list box entries and selection
613*b1cdbd2cSJim Jagielski sal_Bool bHasCurrentPage = sal_False;
614*b1cdbd2cSJim Jagielski String aCurrentPage;
615*b1cdbd2cSJim Jagielski ScDPObject* pDPObj = pDoc->GetDPAtCursor(nCol, nRow, nTab);
616*b1cdbd2cSJim Jagielski if ( pDPObj && nCol > 0 )
617*b1cdbd2cSJim Jagielski {
618*b1cdbd2cSJim Jagielski // look for the dimension header left of the drop-down arrow
619*b1cdbd2cSJim Jagielski sal_uInt16 nOrient = sheet::DataPilotFieldOrientation_HIDDEN;
620*b1cdbd2cSJim Jagielski long nField = pDPObj->GetHeaderDim( ScAddress( nCol-1, nRow, nTab ), nOrient );
621*b1cdbd2cSJim Jagielski if ( nField >= 0 && nOrient == sheet::DataPilotFieldOrientation_PAGE )
622*b1cdbd2cSJim Jagielski {
623*b1cdbd2cSJim Jagielski pDPObj->FillPageList( aStrings, nField );
624*b1cdbd2cSJim Jagielski
625*b1cdbd2cSJim Jagielski // get current page from SaveData
626*b1cdbd2cSJim Jagielski
627*b1cdbd2cSJim Jagielski ScDPSaveData* pSaveData = pDPObj->GetSaveData();
628*b1cdbd2cSJim Jagielski sal_Bool bIsDataLayout;
629*b1cdbd2cSJim Jagielski String aDimName = pDPObj->GetDimName( nField, bIsDataLayout );
630*b1cdbd2cSJim Jagielski if ( pSaveData && !bIsDataLayout )
631*b1cdbd2cSJim Jagielski {
632*b1cdbd2cSJim Jagielski ScDPSaveDimension* pDim = pSaveData->GetExistingDimensionByName(aDimName);
633*b1cdbd2cSJim Jagielski if ( pDim && pDim->HasCurrentPage() )
634*b1cdbd2cSJim Jagielski {
635*b1cdbd2cSJim Jagielski aCurrentPage = pDim->GetCurrentPage();
636*b1cdbd2cSJim Jagielski bHasCurrentPage = sal_True;
637*b1cdbd2cSJim Jagielski }
638*b1cdbd2cSJim Jagielski }
639*b1cdbd2cSJim Jagielski }
640*b1cdbd2cSJim Jagielski }
641*b1cdbd2cSJim Jagielski
642*b1cdbd2cSJim Jagielski // include all entry widths for the size of the drop-down
643*b1cdbd2cSJim Jagielski long nMaxText = 0;
644*b1cdbd2cSJim Jagielski sal_uInt16 nCount = aStrings.GetCount();
645*b1cdbd2cSJim Jagielski for (i=0; i<nCount; i++)
646*b1cdbd2cSJim Jagielski {
647*b1cdbd2cSJim Jagielski TypedStrData* pData = aStrings[i];
648*b1cdbd2cSJim Jagielski long nTextWidth = pFilterBox->GetTextWidth( pData->GetString() );
649*b1cdbd2cSJim Jagielski if ( nTextWidth > nMaxText )
650*b1cdbd2cSJim Jagielski nMaxText = nTextWidth;
651*b1cdbd2cSJim Jagielski }
652*b1cdbd2cSJim Jagielski
653*b1cdbd2cSJim Jagielski // add scrollbar width if needed (string entries are counted here)
654*b1cdbd2cSJim Jagielski // (scrollbar is shown if the box is exactly full?)
655*b1cdbd2cSJim Jagielski if ( nCount >= SC_FILTERLISTBOX_LINES )
656*b1cdbd2cSJim Jagielski nMaxText += GetSettings().GetStyleSettings().GetScrollBarSize();
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski nMaxText += 4; // for borders
659*b1cdbd2cSJim Jagielski
660*b1cdbd2cSJim Jagielski if ( nMaxText > nSizeX )
661*b1cdbd2cSJim Jagielski nSizeX = nMaxText; // just modify width - starting position is unchanged
662*b1cdbd2cSJim Jagielski
663*b1cdbd2cSJim Jagielski // adjust position and size to window
664*b1cdbd2cSJim Jagielski
665*b1cdbd2cSJim Jagielski Size aParentSize = GetParent()->GetOutputSizePixel();
666*b1cdbd2cSJim Jagielski Size aSize( nSizeX, nHeight );
667*b1cdbd2cSJim Jagielski
668*b1cdbd2cSJim Jagielski if ( aSize.Height() > aParentSize.Height() )
669*b1cdbd2cSJim Jagielski aSize.Height() = aParentSize.Height();
670*b1cdbd2cSJim Jagielski if ( aPos.Y() + aSize.Height() > aParentSize.Height() )
671*b1cdbd2cSJim Jagielski aPos.Y() = aParentSize.Height() - aSize.Height();
672*b1cdbd2cSJim Jagielski
673*b1cdbd2cSJim Jagielski pFilterBox->SetSizePixel( aSize );
674*b1cdbd2cSJim Jagielski pFilterBox->Show(); // Show must be called before SetUpdateMode
675*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_False);
676*b1cdbd2cSJim Jagielski
677*b1cdbd2cSJim Jagielski pFilterFloat->SetOutputSizePixel( aSize );
678*b1cdbd2cSJim Jagielski pFilterFloat->StartPopupMode( aCellRect, FLOATWIN_POPUPMODE_DOWN|FLOATWIN_POPUPMODE_GRABFOCUS);
679*b1cdbd2cSJim Jagielski
680*b1cdbd2cSJim Jagielski // fill the list box
681*b1cdbd2cSJim Jagielski sal_Bool bWait = ( nCount > 100 );
682*b1cdbd2cSJim Jagielski
683*b1cdbd2cSJim Jagielski if (bWait)
684*b1cdbd2cSJim Jagielski EnterWait();
685*b1cdbd2cSJim Jagielski
686*b1cdbd2cSJim Jagielski for (i=0; i<nCount; i++)
687*b1cdbd2cSJim Jagielski pFilterBox->InsertEntry( aStrings[i]->GetString() );
688*b1cdbd2cSJim Jagielski
689*b1cdbd2cSJim Jagielski pFilterBox->SetSeparatorPos( 0 );
690*b1cdbd2cSJim Jagielski
691*b1cdbd2cSJim Jagielski if (bWait)
692*b1cdbd2cSJim Jagielski LeaveWait();
693*b1cdbd2cSJim Jagielski
694*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_True);
695*b1cdbd2cSJim Jagielski
696*b1cdbd2cSJim Jagielski sal_uInt16 nSelPos = LISTBOX_ENTRY_NOTFOUND;
697*b1cdbd2cSJim Jagielski if (bHasCurrentPage)
698*b1cdbd2cSJim Jagielski nSelPos = pFilterBox->GetEntryPos( aCurrentPage );
699*b1cdbd2cSJim Jagielski
700*b1cdbd2cSJim Jagielski if ( nSelPos == LISTBOX_ENTRY_NOTFOUND )
701*b1cdbd2cSJim Jagielski nSelPos = 0; // first entry
702*b1cdbd2cSJim Jagielski
703*b1cdbd2cSJim Jagielski pFilterBox->GrabFocus();
704*b1cdbd2cSJim Jagielski
705*b1cdbd2cSJim Jagielski // call Select after GrabFocus, so the focus rectangle ends up in the right position
706*b1cdbd2cSJim Jagielski if ( nSelPos != LISTBOX_ENTRY_NOTFOUND )
707*b1cdbd2cSJim Jagielski pFilterBox->SelectEntryPos( nSelPos );
708*b1cdbd2cSJim Jagielski
709*b1cdbd2cSJim Jagielski pFilterBox->EndInit();
710*b1cdbd2cSJim Jagielski
711*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_FILTER;
712*b1cdbd2cSJim Jagielski CaptureMouse();
713*b1cdbd2cSJim Jagielski }
714*b1cdbd2cSJim Jagielski
LaunchDPFieldMenu(SCCOL nCol,SCROW nRow)715*b1cdbd2cSJim Jagielski void ScGridWindow::LaunchDPFieldMenu( SCCOL nCol, SCROW nRow )
716*b1cdbd2cSJim Jagielski {
717*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
718*b1cdbd2cSJim Jagielski ScDPObject* pDPObj = pViewData->GetDocument()->GetDPAtCursor(nCol, nRow, nTab);
719*b1cdbd2cSJim Jagielski if (!pDPObj)
720*b1cdbd2cSJim Jagielski return;
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski // Get the geometry of the cell.
723*b1cdbd2cSJim Jagielski Point aScrPos = pViewData->GetScrPos(nCol, nRow, eWhich);
724*b1cdbd2cSJim Jagielski long nSizeX, nSizeY;
725*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel(nCol, nRow, nSizeX, nSizeY);
726*b1cdbd2cSJim Jagielski Size aScrSize(nSizeX-1, nSizeY-1);
727*b1cdbd2cSJim Jagielski
728*b1cdbd2cSJim Jagielski DPLaunchFieldPopupMenu(OutputToScreenPixel(aScrPos), aScrSize, ScAddress(nCol, nRow, nTab), pDPObj);
729*b1cdbd2cSJim Jagielski }
730*b1cdbd2cSJim Jagielski
DoScenarioMenue(const ScRange & rScenRange)731*b1cdbd2cSJim Jagielski void ScGridWindow::DoScenarioMenue( const ScRange& rScenRange )
732*b1cdbd2cSJim Jagielski {
733*b1cdbd2cSJim Jagielski delete pFilterBox;
734*b1cdbd2cSJim Jagielski delete pFilterFloat;
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski SCCOL nCol = rScenRange.aEnd.Col(); // Zelle unterhalb des Buttons
737*b1cdbd2cSJim Jagielski SCROW nRow = rScenRange.aStart.Row();
738*b1cdbd2cSJim Jagielski if (nRow == 0)
739*b1cdbd2cSJim Jagielski {
740*b1cdbd2cSJim Jagielski nRow = rScenRange.aEnd.Row() + 1; // Bereich ganz oben -> Button unterhalb
741*b1cdbd2cSJim Jagielski if (nRow>MAXROW) nRow = MAXROW;
742*b1cdbd2cSJim Jagielski //! Texthoehe addieren (wenn sie an der View gespeichert ist...)
743*b1cdbd2cSJim Jagielski }
744*b1cdbd2cSJim Jagielski
745*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
746*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
747*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
748*b1cdbd2cSJim Jagielski
749*b1cdbd2cSJim Jagielski long nSizeX = 0;
750*b1cdbd2cSJim Jagielski long nSizeY = 0;
751*b1cdbd2cSJim Jagielski long nHeight = 0;
752*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nCol, nRow, nSizeX, nSizeY );
753*b1cdbd2cSJim Jagielski Point aPos = pViewData->GetScrPos( nCol, nRow, eWhich );
754*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
755*b1cdbd2cSJim Jagielski aPos.X() -= nSizeX;
756*b1cdbd2cSJim Jagielski Rectangle aCellRect( OutputToScreenPixel(aPos), Size(nSizeX,nSizeY) );
757*b1cdbd2cSJim Jagielski aCellRect.Top() -= nSizeY;
758*b1cdbd2cSJim Jagielski aCellRect.Bottom() -= nSizeY - 1;
759*b1cdbd2cSJim Jagielski // Die ListBox direkt unter der schwarzen Linie auf dem Zellgitter
760*b1cdbd2cSJim Jagielski // (wenn die Linie verdeckt wird, sieht es komisch aus...)
761*b1cdbd2cSJim Jagielski
762*b1cdbd2cSJim Jagielski pFilterFloat = new ScFilterFloatingWindow( this, WinBits(WB_BORDER) ); // nicht resizable etc.
763*b1cdbd2cSJim Jagielski pFilterFloat->SetPopupModeEndHdl( LINK( this, ScGridWindow, PopupModeEndHdl ) );
764*b1cdbd2cSJim Jagielski pFilterBox = new ScFilterListBox( pFilterFloat, this, nCol, nRow, SC_FILTERBOX_SCENARIO );
765*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
766*b1cdbd2cSJim Jagielski pFilterBox->EnableMirroring();
767*b1cdbd2cSJim Jagielski
768*b1cdbd2cSJim Jagielski nSizeX += 1;
769*b1cdbd2cSJim Jagielski
770*b1cdbd2cSJim Jagielski {
771*b1cdbd2cSJim Jagielski Font aOldFont = GetFont(); SetFont( pFilterBox->GetFont() );
772*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode(); SetMapMode( MAP_PIXEL );
773*b1cdbd2cSJim Jagielski
774*b1cdbd2cSJim Jagielski nHeight = GetTextHeight();
775*b1cdbd2cSJim Jagielski nHeight *= SC_FILTERLISTBOX_LINES;
776*b1cdbd2cSJim Jagielski
777*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
778*b1cdbd2cSJim Jagielski SetFont( aOldFont );
779*b1cdbd2cSJim Jagielski }
780*b1cdbd2cSJim Jagielski
781*b1cdbd2cSJim Jagielski // SetSize spaeter
782*b1cdbd2cSJim Jagielski /*
783*b1cdbd2cSJim Jagielski pFilterBox->SetSelectionMode( SINGLE_SELECTION );
784*b1cdbd2cSJim Jagielski pFilterBox->SetTabs( nFilterBoxTabs, MapUnit( MAP_APPFONT ));
785*b1cdbd2cSJim Jagielski pFilterBox->SetTabJustify( 1, bLayoutRTL ? AdjustRight : AdjustLeft );
786*b1cdbd2cSJim Jagielski */
787*b1cdbd2cSJim Jagielski
788*b1cdbd2cSJim Jagielski // ParentSize Abfrage fehlt
789*b1cdbd2cSJim Jagielski Size aSize( nSizeX, nHeight );
790*b1cdbd2cSJim Jagielski pFilterBox->SetSizePixel( aSize );
791*b1cdbd2cSJim Jagielski pFilterBox->Show(); // Show muss vor SetUpdateMode kommen !!!
792*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_False);
793*b1cdbd2cSJim Jagielski
794*b1cdbd2cSJim Jagielski // SetOutputSizePixel/StartPopupMode erst unten, wenn die Groesse feststeht
795*b1cdbd2cSJim Jagielski
796*b1cdbd2cSJim Jagielski // Listbox fuellen
797*b1cdbd2cSJim Jagielski
798*b1cdbd2cSJim Jagielski long nMaxText = 0;
799*b1cdbd2cSJim Jagielski String aCurrent;
800*b1cdbd2cSJim Jagielski String aTabName;
801*b1cdbd2cSJim Jagielski SCTAB nTabCount = pDoc->GetTableCount();
802*b1cdbd2cSJim Jagielski SCTAB nEntryCount = 0;
803*b1cdbd2cSJim Jagielski for (SCTAB i=nTab+1; i<nTabCount && pDoc->IsScenario(i); i++)
804*b1cdbd2cSJim Jagielski {
805*b1cdbd2cSJim Jagielski if (pDoc->HasScenarioRange( i, rScenRange ))
806*b1cdbd2cSJim Jagielski if (pDoc->GetName( i, aTabName ))
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski pFilterBox->InsertEntry( aTabName );
809*b1cdbd2cSJim Jagielski if (pDoc->IsActiveScenario(i))
810*b1cdbd2cSJim Jagielski aCurrent = aTabName;
811*b1cdbd2cSJim Jagielski long nTextWidth = pFilterBox->GetTextWidth( aTabName );
812*b1cdbd2cSJim Jagielski if ( nTextWidth > nMaxText )
813*b1cdbd2cSJim Jagielski nMaxText = nTextWidth;
814*b1cdbd2cSJim Jagielski ++nEntryCount;
815*b1cdbd2cSJim Jagielski }
816*b1cdbd2cSJim Jagielski }
817*b1cdbd2cSJim Jagielski if (nEntryCount > SC_FILTERLISTBOX_LINES)
818*b1cdbd2cSJim Jagielski nMaxText += GetSettings().GetStyleSettings().GetScrollBarSize();
819*b1cdbd2cSJim Jagielski nMaxText += 4; // fuer Rand
820*b1cdbd2cSJim Jagielski if ( nMaxText > 300 )
821*b1cdbd2cSJim Jagielski nMaxText = 300; // auch nicht uebertreiben (Pixel)
822*b1cdbd2cSJim Jagielski
823*b1cdbd2cSJim Jagielski if (nMaxText > nSizeX) // Groesse auf benoetigte Groesse anpassen
824*b1cdbd2cSJim Jagielski {
825*b1cdbd2cSJim Jagielski long nDiff = nMaxText - nSizeX;
826*b1cdbd2cSJim Jagielski aSize = Size( nMaxText, nHeight );
827*b1cdbd2cSJim Jagielski pFilterBox->SetSizePixel( aSize );
828*b1cdbd2cSJim Jagielski pFilterFloat->SetOutputSizePixel( aSize );
829*b1cdbd2cSJim Jagielski
830*b1cdbd2cSJim Jagielski if ( !bLayoutRTL )
831*b1cdbd2cSJim Jagielski {
832*b1cdbd2cSJim Jagielski // also move popup position
833*b1cdbd2cSJim Jagielski long nNewX = aCellRect.Left() - nDiff;
834*b1cdbd2cSJim Jagielski if ( nNewX < 0 )
835*b1cdbd2cSJim Jagielski nNewX = 0;
836*b1cdbd2cSJim Jagielski aCellRect.Left() = nNewX;
837*b1cdbd2cSJim Jagielski }
838*b1cdbd2cSJim Jagielski }
839*b1cdbd2cSJim Jagielski
840*b1cdbd2cSJim Jagielski pFilterFloat->SetOutputSizePixel( aSize );
841*b1cdbd2cSJim Jagielski pFilterFloat->StartPopupMode( aCellRect, FLOATWIN_POPUPMODE_DOWN|FLOATWIN_POPUPMODE_GRABFOCUS );
842*b1cdbd2cSJim Jagielski
843*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_True);
844*b1cdbd2cSJim Jagielski pFilterBox->GrabFocus();
845*b1cdbd2cSJim Jagielski
846*b1cdbd2cSJim Jagielski // Select erst nach GrabFocus, damit das Focus-Rechteck richtig landet
847*b1cdbd2cSJim Jagielski //! SvLBoxEntry* pSelect = NULL;
848*b1cdbd2cSJim Jagielski sal_uInt16 nPos = LISTBOX_ENTRY_NOTFOUND;
849*b1cdbd2cSJim Jagielski if (aCurrent.Len())
850*b1cdbd2cSJim Jagielski {
851*b1cdbd2cSJim Jagielski nPos = pFilterBox->GetEntryPos( aCurrent );
852*b1cdbd2cSJim Jagielski //! pSelect = pFilterBox->GetEntry( nPos );
853*b1cdbd2cSJim Jagielski }
854*b1cdbd2cSJim Jagielski if (/*!pSelect*/ LISTBOX_ENTRY_NOTFOUND == nPos && pFilterBox->GetEntryCount() > 0 )
855*b1cdbd2cSJim Jagielski nPos = 0;
856*b1cdbd2cSJim Jagielski //! pSelect = pFilterBox->GetEntry(0); // einer sollte immer selektiert sein
857*b1cdbd2cSJim Jagielski if (/*pSelect*/ LISTBOX_ENTRY_NOTFOUND != nPos )
858*b1cdbd2cSJim Jagielski pFilterBox->SelectEntryPos(nPos);
859*b1cdbd2cSJim Jagielski
860*b1cdbd2cSJim Jagielski pFilterBox->EndInit();
861*b1cdbd2cSJim Jagielski
862*b1cdbd2cSJim Jagielski // Szenario-Auswahl kommt aus MouseButtonDown:
863*b1cdbd2cSJim Jagielski // der naechste MouseMove auf die Filterbox ist wie ein ButtonDown
864*b1cdbd2cSJim Jagielski
865*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_FILTER;
866*b1cdbd2cSJim Jagielski CaptureMouse();
867*b1cdbd2cSJim Jagielski }
868*b1cdbd2cSJim Jagielski
HasScenarioRange(sal_uInt16 nCol,sal_Int32 nRow,ScRange & rScenRange)869*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::HasScenarioRange( sal_uInt16 nCol, sal_Int32 nRow, ScRange& rScenRange )
870*b1cdbd2cSJim Jagielski {
871*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
872*b1cdbd2cSJim Jagielski sal_uInt16 nTab = pViewData->GetTabNo();
873*b1cdbd2cSJim Jagielski sal_uInt16 nTabCount = pDoc->GetTableCount();
874*b1cdbd2cSJim Jagielski if ( nTab+1<nTabCount && pDoc->IsScenario(nTab+1) && !pDoc->IsScenario(nTab) )
875*b1cdbd2cSJim Jagielski {
876*b1cdbd2cSJim Jagielski sal_uInt16 i;
877*b1cdbd2cSJim Jagielski ScMarkData aMarks;
878*b1cdbd2cSJim Jagielski for (i=nTab+1; i<nTabCount && pDoc->IsScenario(i); i++)
879*b1cdbd2cSJim Jagielski pDoc->MarkScenario( i, nTab, aMarks, sal_False, SC_SCENARIO_SHOWFRAME );
880*b1cdbd2cSJim Jagielski ScRangeList aRanges;
881*b1cdbd2cSJim Jagielski aMarks.FillRangeListWithMarks( &aRanges, sal_False );
882*b1cdbd2cSJim Jagielski sal_uInt16 nRangeCount = (sal_uInt16)aRanges.Count();
883*b1cdbd2cSJim Jagielski for (i=0; i<nRangeCount; i++)
884*b1cdbd2cSJim Jagielski {
885*b1cdbd2cSJim Jagielski ScRange aRange = *aRanges.GetObject(i);
886*b1cdbd2cSJim Jagielski pDoc->ExtendTotalMerge( aRange );
887*b1cdbd2cSJim Jagielski sal_Bool bTextBelow = ( aRange.aStart.Row() == 0 );
888*b1cdbd2cSJim Jagielski sal_Bool bIsInScen = sal_False;
889*b1cdbd2cSJim Jagielski if ( bTextBelow )
890*b1cdbd2cSJim Jagielski {
891*b1cdbd2cSJim Jagielski bIsInScen = (aRange.aStart.Col() == nCol && aRange.aEnd.Row() == nRow-1);
892*b1cdbd2cSJim Jagielski }
893*b1cdbd2cSJim Jagielski else
894*b1cdbd2cSJim Jagielski {
895*b1cdbd2cSJim Jagielski bIsInScen = (aRange.aStart.Col() == nCol && aRange.aStart.Row() == nRow+1);
896*b1cdbd2cSJim Jagielski }
897*b1cdbd2cSJim Jagielski if (bIsInScen)
898*b1cdbd2cSJim Jagielski {
899*b1cdbd2cSJim Jagielski rScenRange = aRange;
900*b1cdbd2cSJim Jagielski return sal_True;
901*b1cdbd2cSJim Jagielski }
902*b1cdbd2cSJim Jagielski }
903*b1cdbd2cSJim Jagielski }
904*b1cdbd2cSJim Jagielski return sal_False;
905*b1cdbd2cSJim Jagielski }
DoAutoFilterMenue(SCCOL nCol,SCROW nRow,sal_Bool bDataSelect)906*b1cdbd2cSJim Jagielski void ScGridWindow::DoAutoFilterMenue( SCCOL nCol, SCROW nRow, sal_Bool bDataSelect )
907*b1cdbd2cSJim Jagielski {
908*b1cdbd2cSJim Jagielski delete pFilterBox;
909*b1cdbd2cSJim Jagielski delete pFilterFloat;
910*b1cdbd2cSJim Jagielski
911*b1cdbd2cSJim Jagielski sal_uInt16 i;
912*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
913*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
914*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
915*b1cdbd2cSJim Jagielski
916*b1cdbd2cSJim Jagielski long nSizeX = 0;
917*b1cdbd2cSJim Jagielski long nSizeY = 0;
918*b1cdbd2cSJim Jagielski long nHeight = 0;
919*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nCol, nRow, nSizeX, nSizeY );
920*b1cdbd2cSJim Jagielski // The button height should not use the merged cell height, should still use single row height
921*b1cdbd2cSJim Jagielski nSizeY = pViewData->ToPixel(pDoc->GetRowHeight(nRow, nTab), pViewData->GetPPTY());
922*b1cdbd2cSJim Jagielski Point aPos = pViewData->GetScrPos( nCol, nRow, eWhich );
923*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
924*b1cdbd2cSJim Jagielski aPos.X() -= nSizeX;
925*b1cdbd2cSJim Jagielski
926*b1cdbd2cSJim Jagielski Rectangle aCellRect( OutputToScreenPixel(aPos), Size(nSizeX,nSizeY) );
927*b1cdbd2cSJim Jagielski
928*b1cdbd2cSJim Jagielski aPos.X() -= 1;
929*b1cdbd2cSJim Jagielski aPos.Y() += nSizeY - 1;
930*b1cdbd2cSJim Jagielski
931*b1cdbd2cSJim Jagielski pFilterFloat = new ScFilterFloatingWindow( this, WinBits(WB_BORDER) ); // nicht resizable etc.
932*b1cdbd2cSJim Jagielski pFilterFloat->SetPopupModeEndHdl( LINK( this, ScGridWindow, PopupModeEndHdl ) );
933*b1cdbd2cSJim Jagielski pFilterBox = new ScFilterListBox(
934*b1cdbd2cSJim Jagielski pFilterFloat, this, nCol, nRow, bDataSelect ? SC_FILTERBOX_DATASELECT : SC_FILTERBOX_FILTER );
935*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
936*b1cdbd2cSJim Jagielski pFilterBox->EnableMirroring();
937*b1cdbd2cSJim Jagielski
938*b1cdbd2cSJim Jagielski nSizeX += 1;
939*b1cdbd2cSJim Jagielski
940*b1cdbd2cSJim Jagielski {
941*b1cdbd2cSJim Jagielski Font aOldFont = GetFont(); SetFont( pFilterBox->GetFont() );
942*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode(); SetMapMode( MAP_PIXEL );
943*b1cdbd2cSJim Jagielski
944*b1cdbd2cSJim Jagielski nHeight = GetTextHeight();
945*b1cdbd2cSJim Jagielski nHeight *= SC_FILTERLISTBOX_LINES;
946*b1cdbd2cSJim Jagielski
947*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
948*b1cdbd2cSJim Jagielski SetFont( aOldFont );
949*b1cdbd2cSJim Jagielski }
950*b1cdbd2cSJim Jagielski
951*b1cdbd2cSJim Jagielski // SetSize spaeter
952*b1cdbd2cSJim Jagielski /*
953*b1cdbd2cSJim Jagielski pFilterBox->SetSelectionMode( SINGLE_SELECTION );
954*b1cdbd2cSJim Jagielski pFilterBox->SetTabs( nFilterBoxTabs, MapUnit( MAP_APPFONT ));
955*b1cdbd2cSJim Jagielski pFilterBox->SetTabJustify( 1, bLayoutRTL ? AdjustRight : AdjustLeft );
956*b1cdbd2cSJim Jagielski */
957*b1cdbd2cSJim Jagielski
958*b1cdbd2cSJim Jagielski sal_Bool bEmpty = sal_False;
959*b1cdbd2cSJim Jagielski TypedScStrCollection aStrings( 128, 128 );
960*b1cdbd2cSJim Jagielski if ( bDataSelect ) // Auswahl-Liste
961*b1cdbd2cSJim Jagielski {
962*b1cdbd2cSJim Jagielski // Liste fuellen
963*b1cdbd2cSJim Jagielski aStrings.SetCaseSensitive( sal_True );
964*b1cdbd2cSJim Jagielski pDoc->GetDataEntries( nCol, nRow, nTab, aStrings );
965*b1cdbd2cSJim Jagielski if ( aStrings.GetCount() == 0 )
966*b1cdbd2cSJim Jagielski bEmpty = sal_True;
967*b1cdbd2cSJim Jagielski }
968*b1cdbd2cSJim Jagielski else // AutoFilter
969*b1cdbd2cSJim Jagielski {
970*b1cdbd2cSJim Jagielski //! wird der Titel ueberhaupt ausgewertet ???
971*b1cdbd2cSJim Jagielski String aString;
972*b1cdbd2cSJim Jagielski pDoc->GetString( nCol, nRow, nTab, aString );
973*b1cdbd2cSJim Jagielski pFilterBox->SetText( aString );
974*b1cdbd2cSJim Jagielski
975*b1cdbd2cSJim Jagielski long nMaxText = 0;
976*b1cdbd2cSJim Jagielski
977*b1cdbd2cSJim Jagielski // default entries
978*b1cdbd2cSJim Jagielski static const sal_uInt16 nDefIDs[] = { SCSTR_ALLFILTER, SCSTR_TOP10FILTER, SCSTR_STDFILTER };
979*b1cdbd2cSJim Jagielski const sal_uInt16 nDefCount = sizeof(nDefIDs) / sizeof(sal_uInt16);
980*b1cdbd2cSJim Jagielski for (i=0; i<nDefCount; i++)
981*b1cdbd2cSJim Jagielski {
982*b1cdbd2cSJim Jagielski String aEntry( (ScResId) nDefIDs[i] );
983*b1cdbd2cSJim Jagielski pFilterBox->InsertEntry( aEntry );
984*b1cdbd2cSJim Jagielski long nTextWidth = pFilterBox->GetTextWidth( aEntry );
985*b1cdbd2cSJim Jagielski if ( nTextWidth > nMaxText )
986*b1cdbd2cSJim Jagielski nMaxText = nTextWidth;
987*b1cdbd2cSJim Jagielski }
988*b1cdbd2cSJim Jagielski pFilterBox->SetSeparatorPos( nDefCount - 1 );
989*b1cdbd2cSJim Jagielski
990*b1cdbd2cSJim Jagielski // get list entries
991*b1cdbd2cSJim Jagielski bool bHasDates = false;
992*b1cdbd2cSJim Jagielski pDoc->GetFilterEntries( nCol, nRow, nTab, true, aStrings, bHasDates);
993*b1cdbd2cSJim Jagielski pFilterBox->SetListHasDates(bHasDates);
994*b1cdbd2cSJim Jagielski
995*b1cdbd2cSJim Jagielski // check widths of numerical entries (string entries are not included)
996*b1cdbd2cSJim Jagielski // so all numbers are completely visible
997*b1cdbd2cSJim Jagielski sal_uInt16 nCount = aStrings.GetCount();
998*b1cdbd2cSJim Jagielski for (i=0; i<nCount; i++)
999*b1cdbd2cSJim Jagielski {
1000*b1cdbd2cSJim Jagielski TypedStrData* pData = aStrings[i];
1001*b1cdbd2cSJim Jagielski if ( !pData->IsStrData() ) // only numerical entries
1002*b1cdbd2cSJim Jagielski {
1003*b1cdbd2cSJim Jagielski long nTextWidth = pFilterBox->GetTextWidth( pData->GetString() );
1004*b1cdbd2cSJim Jagielski if ( nTextWidth > nMaxText )
1005*b1cdbd2cSJim Jagielski nMaxText = nTextWidth;
1006*b1cdbd2cSJim Jagielski }
1007*b1cdbd2cSJim Jagielski }
1008*b1cdbd2cSJim Jagielski
1009*b1cdbd2cSJim Jagielski // add scrollbar width if needed (string entries are counted here)
1010*b1cdbd2cSJim Jagielski // (scrollbar is shown if the box is exactly full?)
1011*b1cdbd2cSJim Jagielski if ( nCount + nDefCount >= SC_FILTERLISTBOX_LINES )
1012*b1cdbd2cSJim Jagielski nMaxText += GetSettings().GetStyleSettings().GetScrollBarSize();
1013*b1cdbd2cSJim Jagielski
1014*b1cdbd2cSJim Jagielski nMaxText += 4; // for borders
1015*b1cdbd2cSJim Jagielski
1016*b1cdbd2cSJim Jagielski if ( nMaxText > nSizeX )
1017*b1cdbd2cSJim Jagielski nSizeX = nMaxText; // just modify width - starting position is unchanged
1018*b1cdbd2cSJim Jagielski }
1019*b1cdbd2cSJim Jagielski
1020*b1cdbd2cSJim Jagielski if (!bEmpty)
1021*b1cdbd2cSJim Jagielski {
1022*b1cdbd2cSJim Jagielski // Position und Groesse an Fenster anpassen
1023*b1cdbd2cSJim Jagielski //! vorher Abfrage, ob die Eintraege hineinpassen (Breite)
1024*b1cdbd2cSJim Jagielski
1025*b1cdbd2cSJim Jagielski Size aParentSize = GetParent()->GetOutputSizePixel();
1026*b1cdbd2cSJim Jagielski Size aSize( nSizeX, nHeight );
1027*b1cdbd2cSJim Jagielski
1028*b1cdbd2cSJim Jagielski if ( aSize.Height() > aParentSize.Height() )
1029*b1cdbd2cSJim Jagielski aSize.Height() = aParentSize.Height();
1030*b1cdbd2cSJim Jagielski if ( aPos.Y() + aSize.Height() > aParentSize.Height() )
1031*b1cdbd2cSJim Jagielski aPos.Y() = aParentSize.Height() - aSize.Height();
1032*b1cdbd2cSJim Jagielski
1033*b1cdbd2cSJim Jagielski pFilterBox->SetSizePixel( aSize );
1034*b1cdbd2cSJim Jagielski pFilterBox->Show(); // Show muss vor SetUpdateMode kommen !!!
1035*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_False);
1036*b1cdbd2cSJim Jagielski
1037*b1cdbd2cSJim Jagielski pFilterFloat->SetOutputSizePixel( aSize );
1038*b1cdbd2cSJim Jagielski pFilterFloat->StartPopupMode( aCellRect, FLOATWIN_POPUPMODE_DOWN|FLOATWIN_POPUPMODE_GRABFOCUS);
1039*b1cdbd2cSJim Jagielski
1040*b1cdbd2cSJim Jagielski // Listbox fuellen
1041*b1cdbd2cSJim Jagielski sal_uInt16 nCount = aStrings.GetCount();
1042*b1cdbd2cSJim Jagielski sal_Bool bWait = ( nCount > 100 );
1043*b1cdbd2cSJim Jagielski
1044*b1cdbd2cSJim Jagielski if (bWait)
1045*b1cdbd2cSJim Jagielski EnterWait();
1046*b1cdbd2cSJim Jagielski
1047*b1cdbd2cSJim Jagielski for (i=0; i<nCount; i++)
1048*b1cdbd2cSJim Jagielski pFilterBox->InsertEntry( aStrings[i]->GetString() );
1049*b1cdbd2cSJim Jagielski
1050*b1cdbd2cSJim Jagielski if (bWait)
1051*b1cdbd2cSJim Jagielski LeaveWait();
1052*b1cdbd2cSJim Jagielski
1053*b1cdbd2cSJim Jagielski pFilterBox->SetUpdateMode(sal_True);
1054*b1cdbd2cSJim Jagielski }
1055*b1cdbd2cSJim Jagielski
1056*b1cdbd2cSJim Jagielski //! SvLBoxEntry* pSelect = NULL;
1057*b1cdbd2cSJim Jagielski sal_uInt16 nSelPos = LISTBOX_ENTRY_NOTFOUND;
1058*b1cdbd2cSJim Jagielski
1059*b1cdbd2cSJim Jagielski if (!bDataSelect) // AutoFilter: aktiven Eintrag selektieren
1060*b1cdbd2cSJim Jagielski {
1061*b1cdbd2cSJim Jagielski ScDBData* pDBData = pDoc->GetDBAtCursor( nCol, nRow, nTab );
1062*b1cdbd2cSJim Jagielski if (pDBData)
1063*b1cdbd2cSJim Jagielski {
1064*b1cdbd2cSJim Jagielski ScQueryParam aParam;
1065*b1cdbd2cSJim Jagielski pDBData->GetQueryParam( aParam ); // kann nur MAXQUERY Eintraege ergeben
1066*b1cdbd2cSJim Jagielski
1067*b1cdbd2cSJim Jagielski sal_Bool bValid = sal_True;
1068*b1cdbd2cSJim Jagielski for (SCSIZE j=0; j<MAXQUERY && bValid; j++) // bisherige Filter-Einstellungen
1069*b1cdbd2cSJim Jagielski if (aParam.GetEntry(j).bDoQuery)
1070*b1cdbd2cSJim Jagielski {
1071*b1cdbd2cSJim Jagielski //! Abfrage mit DrawButtons zusammenfassen!
1072*b1cdbd2cSJim Jagielski
1073*b1cdbd2cSJim Jagielski ScQueryEntry& rEntry = aParam.GetEntry(j);
1074*b1cdbd2cSJim Jagielski if (j>0)
1075*b1cdbd2cSJim Jagielski if (rEntry.eConnect != SC_AND)
1076*b1cdbd2cSJim Jagielski bValid = sal_False;
1077*b1cdbd2cSJim Jagielski if (rEntry.nField == nCol)
1078*b1cdbd2cSJim Jagielski {
1079*b1cdbd2cSJim Jagielski if (rEntry.eOp == SC_EQUAL)
1080*b1cdbd2cSJim Jagielski {
1081*b1cdbd2cSJim Jagielski String* pStr = rEntry.pStr;
1082*b1cdbd2cSJim Jagielski if (pStr)
1083*b1cdbd2cSJim Jagielski {
1084*b1cdbd2cSJim Jagielski nSelPos = pFilterBox->GetEntryPos( *pStr );
1085*b1cdbd2cSJim Jagielski //! pSelect = pFilterBox->GetEntry( nPos );
1086*b1cdbd2cSJim Jagielski }
1087*b1cdbd2cSJim Jagielski }
1088*b1cdbd2cSJim Jagielski else if (rEntry.eOp == SC_TOPVAL && rEntry.pStr &&
1089*b1cdbd2cSJim Jagielski rEntry.pStr->EqualsAscii("10"))
1090*b1cdbd2cSJim Jagielski nSelPos = SC_AUTOFILTER_TOP10;
1091*b1cdbd2cSJim Jagielski else
1092*b1cdbd2cSJim Jagielski nSelPos = SC_AUTOFILTER_CUSTOM;
1093*b1cdbd2cSJim Jagielski }
1094*b1cdbd2cSJim Jagielski }
1095*b1cdbd2cSJim Jagielski
1096*b1cdbd2cSJim Jagielski if (!bValid)
1097*b1cdbd2cSJim Jagielski nSelPos = SC_AUTOFILTER_CUSTOM;
1098*b1cdbd2cSJim Jagielski }
1099*b1cdbd2cSJim Jagielski }
1100*b1cdbd2cSJim Jagielski else
1101*b1cdbd2cSJim Jagielski {
1102*b1cdbd2cSJim Jagielski
1103*b1cdbd2cSJim Jagielski sal_uLong nIndex = ((SfxUInt32Item*)pDoc->GetAttr(
1104*b1cdbd2cSJim Jagielski nCol, nRow, nTab, ATTR_VALIDDATA ))->GetValue();
1105*b1cdbd2cSJim Jagielski if ( nIndex )
1106*b1cdbd2cSJim Jagielski {
1107*b1cdbd2cSJim Jagielski const ScValidationData* pData = pDoc->GetValidationEntry( nIndex );
1108*b1cdbd2cSJim Jagielski if (pData)
1109*b1cdbd2cSJim Jagielski {
1110*b1cdbd2cSJim Jagielski TypedStrData* pNew = NULL;
1111*b1cdbd2cSJim Jagielski String aDocStr;
1112*b1cdbd2cSJim Jagielski pDoc->GetString( nCol, nRow, nTab, aDocStr );
1113*b1cdbd2cSJim Jagielski if ( pDoc->HasValueData( nCol, nRow, nTab ) )
1114*b1cdbd2cSJim Jagielski {
1115*b1cdbd2cSJim Jagielski double fVal = pDoc->GetValue(ScAddress(nCol, nRow, nTab));
1116*b1cdbd2cSJim Jagielski pNew = new TypedStrData( aDocStr, fVal, SC_STRTYPE_VALUE );
1117*b1cdbd2cSJim Jagielski }
1118*b1cdbd2cSJim Jagielski else
1119*b1cdbd2cSJim Jagielski pNew = new TypedStrData( aDocStr, 0.0, SC_STRTYPE_STANDARD );
1120*b1cdbd2cSJim Jagielski
1121*b1cdbd2cSJim Jagielski bool bSortList = ( pData->GetListType() == ValidListType::SORTEDASCENDING);
1122*b1cdbd2cSJim Jagielski if ( bSortList )
1123*b1cdbd2cSJim Jagielski {
1124*b1cdbd2cSJim Jagielski sal_uInt16 nStrIndex;
1125*b1cdbd2cSJim Jagielski if (aStrings.Search(pNew,nStrIndex))
1126*b1cdbd2cSJim Jagielski nSelPos = nStrIndex;
1127*b1cdbd2cSJim Jagielski }
1128*b1cdbd2cSJim Jagielski else
1129*b1cdbd2cSJim Jagielski {
1130*b1cdbd2cSJim Jagielski sal_uInt16 nCount = aStrings.GetCount();
1131*b1cdbd2cSJim Jagielski for (i = 0; ((i < nCount) && ( LISTBOX_ENTRY_NOTFOUND == nSelPos)); i++)
1132*b1cdbd2cSJim Jagielski {
1133*b1cdbd2cSJim Jagielski if ( aStrings.Compare(aStrings[i], pNew)==0 )
1134*b1cdbd2cSJim Jagielski nSelPos = i;
1135*b1cdbd2cSJim Jagielski }
1136*b1cdbd2cSJim Jagielski }
1137*b1cdbd2cSJim Jagielski delete pNew;
1138*b1cdbd2cSJim Jagielski }
1139*b1cdbd2cSJim Jagielski }
1140*b1cdbd2cSJim Jagielski }
1141*b1cdbd2cSJim Jagielski
1142*b1cdbd2cSJim Jagielski // neu (309): irgendwas muss immer selektiert sein:
1143*b1cdbd2cSJim Jagielski if ( LISTBOX_ENTRY_NOTFOUND == nSelPos && pFilterBox->GetEntryCount() > 0 && !bDataSelect)
1144*b1cdbd2cSJim Jagielski nSelPos = 0;
1145*b1cdbd2cSJim Jagielski
1146*b1cdbd2cSJim Jagielski // keine leere Auswahl-Liste anzeigen:
1147*b1cdbd2cSJim Jagielski
1148*b1cdbd2cSJim Jagielski if ( bEmpty )
1149*b1cdbd2cSJim Jagielski {
1150*b1cdbd2cSJim Jagielski DELETEZ(pFilterBox); // war nix
1151*b1cdbd2cSJim Jagielski DELETEZ(pFilterFloat);
1152*b1cdbd2cSJim Jagielski Sound::Beep(); // bemerkbar machen
1153*b1cdbd2cSJim Jagielski }
1154*b1cdbd2cSJim Jagielski else
1155*b1cdbd2cSJim Jagielski {
1156*b1cdbd2cSJim Jagielski // pFilterBox->Show(); // schon vorne
1157*b1cdbd2cSJim Jagielski pFilterBox->GrabFocus();
1158*b1cdbd2cSJim Jagielski
1159*b1cdbd2cSJim Jagielski // Select erst nach GrabFocus, damit das Focus-Rechteck richtig landet
1160*b1cdbd2cSJim Jagielski if ( LISTBOX_ENTRY_NOTFOUND != nSelPos )
1161*b1cdbd2cSJim Jagielski pFilterBox->SelectEntryPos( nSelPos );
1162*b1cdbd2cSJim Jagielski else
1163*b1cdbd2cSJim Jagielski {
1164*b1cdbd2cSJim Jagielski if (bDataSelect)
1165*b1cdbd2cSJim Jagielski pFilterBox->SetNoSelection();
1166*b1cdbd2cSJim Jagielski }
1167*b1cdbd2cSJim Jagielski
1168*b1cdbd2cSJim Jagielski pFilterBox->EndInit();
1169*b1cdbd2cSJim Jagielski
1170*b1cdbd2cSJim Jagielski if (!bDataSelect)
1171*b1cdbd2cSJim Jagielski {
1172*b1cdbd2cSJim Jagielski // AutoFilter (aus MouseButtonDown):
1173*b1cdbd2cSJim Jagielski // der naechste MouseMove auf die Filterbox ist wie ein ButtonDown
1174*b1cdbd2cSJim Jagielski
1175*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_FILTER;
1176*b1cdbd2cSJim Jagielski CaptureMouse();
1177*b1cdbd2cSJim Jagielski }
1178*b1cdbd2cSJim Jagielski }
1179*b1cdbd2cSJim Jagielski }
1180*b1cdbd2cSJim Jagielski
FilterSelect(sal_uLong nSel)1181*b1cdbd2cSJim Jagielski void ScGridWindow::FilterSelect( sal_uLong nSel )
1182*b1cdbd2cSJim Jagielski {
1183*b1cdbd2cSJim Jagielski String aString;
1184*b1cdbd2cSJim Jagielski /*
1185*b1cdbd2cSJim Jagielski SvLBoxEntry* pEntry = pFilterBox->GetEntry( nSel );
1186*b1cdbd2cSJim Jagielski if (pEntry)
1187*b1cdbd2cSJim Jagielski {
1188*b1cdbd2cSJim Jagielski SvLBoxString* pStringEntry = (SvLBoxString*) pEntry->GetFirstItem( SV_ITEM_ID_LBOXSTRING );
1189*b1cdbd2cSJim Jagielski if ( pStringEntry )
1190*b1cdbd2cSJim Jagielski aString = pStringEntry->GetText();
1191*b1cdbd2cSJim Jagielski }
1192*b1cdbd2cSJim Jagielski */
1193*b1cdbd2cSJim Jagielski aString = pFilterBox->GetEntry( static_cast< sal_uInt16 >( nSel ) );
1194*b1cdbd2cSJim Jagielski
1195*b1cdbd2cSJim Jagielski SCCOL nCol = pFilterBox->GetCol();
1196*b1cdbd2cSJim Jagielski SCROW nRow = pFilterBox->GetRow();
1197*b1cdbd2cSJim Jagielski switch ( pFilterBox->GetMode() )
1198*b1cdbd2cSJim Jagielski {
1199*b1cdbd2cSJim Jagielski case SC_FILTERBOX_DATASELECT:
1200*b1cdbd2cSJim Jagielski ExecDataSelect( nCol, nRow, aString );
1201*b1cdbd2cSJim Jagielski break;
1202*b1cdbd2cSJim Jagielski case SC_FILTERBOX_FILTER:
1203*b1cdbd2cSJim Jagielski ExecFilter( nSel, nCol, nRow, aString, pFilterBox->HasDates() );
1204*b1cdbd2cSJim Jagielski break;
1205*b1cdbd2cSJim Jagielski case SC_FILTERBOX_SCENARIO:
1206*b1cdbd2cSJim Jagielski pViewData->GetView()->UseScenario( aString );
1207*b1cdbd2cSJim Jagielski break;
1208*b1cdbd2cSJim Jagielski case SC_FILTERBOX_PAGEFIELD:
1209*b1cdbd2cSJim Jagielski // first entry is "all"
1210*b1cdbd2cSJim Jagielski ExecPageFieldSelect( nCol, nRow, (nSel != 0), aString );
1211*b1cdbd2cSJim Jagielski break;
1212*b1cdbd2cSJim Jagielski }
1213*b1cdbd2cSJim Jagielski
1214*b1cdbd2cSJim Jagielski if (pFilterFloat)
1215*b1cdbd2cSJim Jagielski pFilterFloat->EndPopupMode();
1216*b1cdbd2cSJim Jagielski
1217*b1cdbd2cSJim Jagielski GrabFocus(); // unter OS/2 stimmt der Focus sonst nicht
1218*b1cdbd2cSJim Jagielski }
1219*b1cdbd2cSJim Jagielski
ExecDataSelect(SCCOL nCol,SCROW nRow,const String & rStr)1220*b1cdbd2cSJim Jagielski void ScGridWindow::ExecDataSelect( SCCOL nCol, SCROW nRow, const String& rStr )
1221*b1cdbd2cSJim Jagielski {
1222*b1cdbd2cSJim Jagielski if ( rStr.Len() )
1223*b1cdbd2cSJim Jagielski {
1224*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
1225*b1cdbd2cSJim Jagielski ScViewFunc* pView = pViewData->GetView();
1226*b1cdbd2cSJim Jagielski pView->EnterData( nCol, nRow, nTab, rStr );
1227*b1cdbd2cSJim Jagielski
1228*b1cdbd2cSJim Jagielski // #i52307# CellContentChanged is not in EnterData so it isn't called twice
1229*b1cdbd2cSJim Jagielski // if the cursor is moved afterwards.
1230*b1cdbd2cSJim Jagielski pView->CellContentChanged();
1231*b1cdbd2cSJim Jagielski }
1232*b1cdbd2cSJim Jagielski }
1233*b1cdbd2cSJim Jagielski
ExecFilter(sal_uLong nSel,SCCOL nCol,SCROW nRow,const String & aValue,bool bCheckForDates)1234*b1cdbd2cSJim Jagielski void ScGridWindow::ExecFilter( sal_uLong nSel,
1235*b1cdbd2cSJim Jagielski SCCOL nCol, SCROW nRow,
1236*b1cdbd2cSJim Jagielski const String& aValue, bool bCheckForDates )
1237*b1cdbd2cSJim Jagielski {
1238*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
1239*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
1240*b1cdbd2cSJim Jagielski
1241*b1cdbd2cSJim Jagielski ScDBData* pDBData = pDoc->GetDBAtCursor( nCol, nRow, nTab );
1242*b1cdbd2cSJim Jagielski if (pDBData)
1243*b1cdbd2cSJim Jagielski {
1244*b1cdbd2cSJim Jagielski ScQueryParam aParam;
1245*b1cdbd2cSJim Jagielski pDBData->GetQueryParam( aParam ); // kann nur MAXQUERY Eintraege ergeben
1246*b1cdbd2cSJim Jagielski
1247*b1cdbd2cSJim Jagielski if (SC_AUTOFILTER_CUSTOM == nSel)
1248*b1cdbd2cSJim Jagielski {
1249*b1cdbd2cSJim Jagielski SCTAB nAreaTab;
1250*b1cdbd2cSJim Jagielski SCCOL nStartCol;
1251*b1cdbd2cSJim Jagielski SCROW nStartRow;
1252*b1cdbd2cSJim Jagielski SCCOL nEndCol;
1253*b1cdbd2cSJim Jagielski SCROW nEndRow;
1254*b1cdbd2cSJim Jagielski pDBData->GetArea( nAreaTab, nStartCol,nStartRow,nEndCol,nEndRow );
1255*b1cdbd2cSJim Jagielski pViewData->GetView()->MarkRange( ScRange( nStartCol,nStartRow,nAreaTab,nEndCol,nEndRow,nAreaTab));
1256*b1cdbd2cSJim Jagielski pViewData->GetView()->SetCursor(nCol,nRow); //! auch ueber Slot ??
1257*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( SID_FILTER, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD );
1258*b1cdbd2cSJim Jagielski }
1259*b1cdbd2cSJim Jagielski else
1260*b1cdbd2cSJim Jagielski {
1261*b1cdbd2cSJim Jagielski sal_Bool bDeleteOld = sal_False;
1262*b1cdbd2cSJim Jagielski SCSIZE nQueryPos = 0;
1263*b1cdbd2cSJim Jagielski sal_Bool bFound = sal_False;
1264*b1cdbd2cSJim Jagielski if (!aParam.bInplace)
1265*b1cdbd2cSJim Jagielski bDeleteOld = sal_True;
1266*b1cdbd2cSJim Jagielski if (aParam.bRegExp)
1267*b1cdbd2cSJim Jagielski bDeleteOld = sal_True;
1268*b1cdbd2cSJim Jagielski for (SCSIZE i=0; i<MAXQUERY && !bDeleteOld; i++) // bisherige Filter-Einstellungen
1269*b1cdbd2cSJim Jagielski if (aParam.GetEntry(i).bDoQuery)
1270*b1cdbd2cSJim Jagielski {
1271*b1cdbd2cSJim Jagielski //! Abfrage mit DrawButtons zusammenfassen!
1272*b1cdbd2cSJim Jagielski
1273*b1cdbd2cSJim Jagielski ScQueryEntry& rEntry = aParam.GetEntry(i);
1274*b1cdbd2cSJim Jagielski if (i>0)
1275*b1cdbd2cSJim Jagielski if (rEntry.eConnect != SC_AND)
1276*b1cdbd2cSJim Jagielski bDeleteOld = sal_True;
1277*b1cdbd2cSJim Jagielski
1278*b1cdbd2cSJim Jagielski if (rEntry.nField == nCol)
1279*b1cdbd2cSJim Jagielski {
1280*b1cdbd2cSJim Jagielski if (bFound) // diese Spalte zweimal?
1281*b1cdbd2cSJim Jagielski bDeleteOld = sal_True;
1282*b1cdbd2cSJim Jagielski nQueryPos = i;
1283*b1cdbd2cSJim Jagielski bFound = sal_True;
1284*b1cdbd2cSJim Jagielski }
1285*b1cdbd2cSJim Jagielski if (!bFound)
1286*b1cdbd2cSJim Jagielski nQueryPos = i + 1;
1287*b1cdbd2cSJim Jagielski }
1288*b1cdbd2cSJim Jagielski
1289*b1cdbd2cSJim Jagielski if (bDeleteOld)
1290*b1cdbd2cSJim Jagielski {
1291*b1cdbd2cSJim Jagielski SCSIZE nEC = aParam.GetEntryCount();
1292*b1cdbd2cSJim Jagielski for (SCSIZE i=0; i<nEC; i++)
1293*b1cdbd2cSJim Jagielski aParam.GetEntry(i).Clear();
1294*b1cdbd2cSJim Jagielski nQueryPos = 0;
1295*b1cdbd2cSJim Jagielski aParam.bInplace = sal_True;
1296*b1cdbd2cSJim Jagielski aParam.bRegExp = sal_False;
1297*b1cdbd2cSJim Jagielski }
1298*b1cdbd2cSJim Jagielski
1299*b1cdbd2cSJim Jagielski if ( nQueryPos < MAXQUERY || SC_AUTOFILTER_ALL == nSel ) // loeschen geht immer
1300*b1cdbd2cSJim Jagielski {
1301*b1cdbd2cSJim Jagielski if (nSel)
1302*b1cdbd2cSJim Jagielski {
1303*b1cdbd2cSJim Jagielski ScQueryEntry& rNewEntry = aParam.GetEntry(nQueryPos);
1304*b1cdbd2cSJim Jagielski
1305*b1cdbd2cSJim Jagielski rNewEntry.bDoQuery = sal_True;
1306*b1cdbd2cSJim Jagielski rNewEntry.bQueryByString = sal_True;
1307*b1cdbd2cSJim Jagielski rNewEntry.nField = nCol;
1308*b1cdbd2cSJim Jagielski rNewEntry.bQueryByDate = bCheckForDates;
1309*b1cdbd2cSJim Jagielski if ( nSel == SC_AUTOFILTER_TOP10 )
1310*b1cdbd2cSJim Jagielski {
1311*b1cdbd2cSJim Jagielski rNewEntry.eOp = SC_TOPVAL;
1312*b1cdbd2cSJim Jagielski *rNewEntry.pStr = String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("10"));
1313*b1cdbd2cSJim Jagielski }
1314*b1cdbd2cSJim Jagielski else
1315*b1cdbd2cSJim Jagielski {
1316*b1cdbd2cSJim Jagielski rNewEntry.eOp = SC_EQUAL;
1317*b1cdbd2cSJim Jagielski *rNewEntry.pStr = aValue;
1318*b1cdbd2cSJim Jagielski }
1319*b1cdbd2cSJim Jagielski if (nQueryPos > 0)
1320*b1cdbd2cSJim Jagielski rNewEntry.eConnect = SC_AND;
1321*b1cdbd2cSJim Jagielski }
1322*b1cdbd2cSJim Jagielski else
1323*b1cdbd2cSJim Jagielski {
1324*b1cdbd2cSJim Jagielski if (bFound)
1325*b1cdbd2cSJim Jagielski aParam.DeleteQuery(nQueryPos);
1326*b1cdbd2cSJim Jagielski }
1327*b1cdbd2cSJim Jagielski
1328*b1cdbd2cSJim Jagielski // #100597# end edit mode - like in ScCellShell::ExecuteDB
1329*b1cdbd2cSJim Jagielski if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
1330*b1cdbd2cSJim Jagielski {
1331*b1cdbd2cSJim Jagielski SC_MOD()->InputEnterHandler();
1332*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->UpdateInputHandler();
1333*b1cdbd2cSJim Jagielski }
1334*b1cdbd2cSJim Jagielski
1335*b1cdbd2cSJim Jagielski pViewData->GetView()->Query( aParam, NULL, sal_True );
1336*b1cdbd2cSJim Jagielski pDBData->SetQueryParam( aParam ); // speichern
1337*b1cdbd2cSJim Jagielski }
1338*b1cdbd2cSJim Jagielski else // "Zuviele Bedingungen"
1339*b1cdbd2cSJim Jagielski pViewData->GetView()->ErrorMessage( STR_FILTER_TOOMANY );
1340*b1cdbd2cSJim Jagielski }
1341*b1cdbd2cSJim Jagielski }
1342*b1cdbd2cSJim Jagielski else
1343*b1cdbd2cSJim Jagielski {
1344*b1cdbd2cSJim Jagielski DBG_ERROR("Wo ist der Datenbankbereich?");
1345*b1cdbd2cSJim Jagielski }
1346*b1cdbd2cSJim Jagielski }
1347*b1cdbd2cSJim Jagielski
SetPointer(const Pointer & rPointer)1348*b1cdbd2cSJim Jagielski void ScGridWindow::SetPointer( const Pointer& rPointer )
1349*b1cdbd2cSJim Jagielski {
1350*b1cdbd2cSJim Jagielski nCurrentPointer = 0;
1351*b1cdbd2cSJim Jagielski Window::SetPointer( rPointer );
1352*b1cdbd2cSJim Jagielski }
1353*b1cdbd2cSJim Jagielski
MoveMouseStatus(ScGridWindow & rDestWin)1354*b1cdbd2cSJim Jagielski void ScGridWindow::MoveMouseStatus( ScGridWindow& rDestWin )
1355*b1cdbd2cSJim Jagielski {
1356*b1cdbd2cSJim Jagielski if (nButtonDown)
1357*b1cdbd2cSJim Jagielski {
1358*b1cdbd2cSJim Jagielski rDestWin.nButtonDown = nButtonDown;
1359*b1cdbd2cSJim Jagielski rDestWin.nMouseStatus = nMouseStatus;
1360*b1cdbd2cSJim Jagielski }
1361*b1cdbd2cSJim Jagielski
1362*b1cdbd2cSJim Jagielski if (bRFMouse)
1363*b1cdbd2cSJim Jagielski {
1364*b1cdbd2cSJim Jagielski rDestWin.bRFMouse = bRFMouse;
1365*b1cdbd2cSJim Jagielski rDestWin.bRFSize = bRFSize;
1366*b1cdbd2cSJim Jagielski rDestWin.nRFIndex = nRFIndex;
1367*b1cdbd2cSJim Jagielski rDestWin.nRFAddX = nRFAddX;
1368*b1cdbd2cSJim Jagielski rDestWin.nRFAddY = nRFAddY;
1369*b1cdbd2cSJim Jagielski bRFMouse = sal_False;
1370*b1cdbd2cSJim Jagielski }
1371*b1cdbd2cSJim Jagielski
1372*b1cdbd2cSJim Jagielski if (nPagebreakMouse)
1373*b1cdbd2cSJim Jagielski {
1374*b1cdbd2cSJim Jagielski rDestWin.nPagebreakMouse = nPagebreakMouse;
1375*b1cdbd2cSJim Jagielski rDestWin.nPagebreakBreak = nPagebreakBreak;
1376*b1cdbd2cSJim Jagielski rDestWin.nPagebreakPrev = nPagebreakPrev;
1377*b1cdbd2cSJim Jagielski rDestWin.aPagebreakSource = aPagebreakSource;
1378*b1cdbd2cSJim Jagielski rDestWin.aPagebreakDrag = aPagebreakDrag;
1379*b1cdbd2cSJim Jagielski nPagebreakMouse = SC_PD_NONE;
1380*b1cdbd2cSJim Jagielski }
1381*b1cdbd2cSJim Jagielski }
1382*b1cdbd2cSJim Jagielski
TestMouse(const MouseEvent & rMEvt,sal_Bool bAction)1383*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::TestMouse( const MouseEvent& rMEvt, sal_Bool bAction )
1384*b1cdbd2cSJim Jagielski {
1385*b1cdbd2cSJim Jagielski // MouseEvent buttons must only be checked if bAction==TRUE
1386*b1cdbd2cSJim Jagielski // to allow changing the mouse pointer in MouseMove,
1387*b1cdbd2cSJim Jagielski // but not start AutoFill with right button (#74229#).
1388*b1cdbd2cSJim Jagielski // with bAction==sal_True, SetFillMode / SetDragMode is called
1389*b1cdbd2cSJim Jagielski
1390*b1cdbd2cSJim Jagielski if ( bAction && !rMEvt.IsLeft() )
1391*b1cdbd2cSJim Jagielski return sal_False;
1392*b1cdbd2cSJim Jagielski
1393*b1cdbd2cSJim Jagielski sal_Bool bNewPointer = sal_False;
1394*b1cdbd2cSJim Jagielski
1395*b1cdbd2cSJim Jagielski SfxInPlaceClient* pClient = pViewData->GetViewShell()->GetIPClient();
1396*b1cdbd2cSJim Jagielski sal_Bool bOleActive = ( pClient && pClient->IsObjectInPlaceActive() );
1397*b1cdbd2cSJim Jagielski
1398*b1cdbd2cSJim Jagielski if ( pViewData->IsActive() && !bOleActive )
1399*b1cdbd2cSJim Jagielski {
1400*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
1401*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
1402*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1403*b1cdbd2cSJim Jagielski
1404*b1cdbd2cSJim Jagielski // Auto-Fill
1405*b1cdbd2cSJim Jagielski
1406*b1cdbd2cSJim Jagielski ScRange aMarkRange;
1407*b1cdbd2cSJim Jagielski if (pViewData->GetSimpleArea( aMarkRange ) == SC_MARK_SIMPLE)
1408*b1cdbd2cSJim Jagielski {
1409*b1cdbd2cSJim Jagielski if (aMarkRange.aStart.Tab() == pViewData->GetTabNo() && mpAutoFillRect)
1410*b1cdbd2cSJim Jagielski {
1411*b1cdbd2cSJim Jagielski Point aMousePos = rMEvt.GetPosPixel();
1412*b1cdbd2cSJim Jagielski if (mpAutoFillRect->IsInside(aMousePos))
1413*b1cdbd2cSJim Jagielski {
1414*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_CROSS ) ); //! dickeres Kreuz ?
1415*b1cdbd2cSJim Jagielski if (bAction)
1416*b1cdbd2cSJim Jagielski {
1417*b1cdbd2cSJim Jagielski SCCOL nX = aMarkRange.aEnd.Col();
1418*b1cdbd2cSJim Jagielski SCROW nY = aMarkRange.aEnd.Row();
1419*b1cdbd2cSJim Jagielski
1420*b1cdbd2cSJim Jagielski if ( lcl_IsEditableMatrix( pViewData->GetDocument(), aMarkRange ) )
1421*b1cdbd2cSJim Jagielski pViewData->SetDragMode(
1422*b1cdbd2cSJim Jagielski aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), nX, nY, SC_FILL_MATRIX );
1423*b1cdbd2cSJim Jagielski else
1424*b1cdbd2cSJim Jagielski pViewData->SetFillMode(
1425*b1cdbd2cSJim Jagielski aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), nX, nY );
1426*b1cdbd2cSJim Jagielski
1427*b1cdbd2cSJim Jagielski // #108266# The simple selection must also be recognized when dragging,
1428*b1cdbd2cSJim Jagielski // where the Marking flag is set and MarkToSimple won't work anymore.
1429*b1cdbd2cSJim Jagielski pViewData->GetMarkData().MarkToSimple();
1430*b1cdbd2cSJim Jagielski }
1431*b1cdbd2cSJim Jagielski bNewPointer = sal_True;
1432*b1cdbd2cSJim Jagielski }
1433*b1cdbd2cSJim Jagielski }
1434*b1cdbd2cSJim Jagielski }
1435*b1cdbd2cSJim Jagielski
1436*b1cdbd2cSJim Jagielski // Embedded-Rechteck
1437*b1cdbd2cSJim Jagielski
1438*b1cdbd2cSJim Jagielski if (pDoc->IsEmbedded())
1439*b1cdbd2cSJim Jagielski {
1440*b1cdbd2cSJim Jagielski ScRange aRange;
1441*b1cdbd2cSJim Jagielski pDoc->GetEmbedded( aRange );
1442*b1cdbd2cSJim Jagielski if ( pViewData->GetTabNo() == aRange.aStart.Tab() )
1443*b1cdbd2cSJim Jagielski {
1444*b1cdbd2cSJim Jagielski Point aStartPos = pViewData->GetScrPos( aRange.aStart.Col(), aRange.aStart.Row(), eWhich );
1445*b1cdbd2cSJim Jagielski Point aEndPos = pViewData->GetScrPos( aRange.aEnd.Col()+1, aRange.aEnd.Row()+1, eWhich );
1446*b1cdbd2cSJim Jagielski Point aMousePos = rMEvt.GetPosPixel();
1447*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
1448*b1cdbd2cSJim Jagielski {
1449*b1cdbd2cSJim Jagielski aStartPos.X() += 2;
1450*b1cdbd2cSJim Jagielski aEndPos.X() += 2;
1451*b1cdbd2cSJim Jagielski }
1452*b1cdbd2cSJim Jagielski sal_Bool bTop = ( aMousePos.X() >= aStartPos.X()-3 && aMousePos.X() <= aStartPos.X()+1 &&
1453*b1cdbd2cSJim Jagielski aMousePos.Y() >= aStartPos.Y()-3 && aMousePos.Y() <= aStartPos.Y()+1 );
1454*b1cdbd2cSJim Jagielski sal_Bool bBottom = ( aMousePos.X() >= aEndPos.X()-3 && aMousePos.X() <= aEndPos.X()+1 &&
1455*b1cdbd2cSJim Jagielski aMousePos.Y() >= aEndPos.Y()-3 && aMousePos.Y() <= aEndPos.Y()+1 );
1456*b1cdbd2cSJim Jagielski if ( bTop || bBottom )
1457*b1cdbd2cSJim Jagielski {
1458*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_CROSS ) );
1459*b1cdbd2cSJim Jagielski if (bAction)
1460*b1cdbd2cSJim Jagielski {
1461*b1cdbd2cSJim Jagielski sal_uInt8 nMode = bTop ? SC_FILL_EMBED_LT : SC_FILL_EMBED_RB;
1462*b1cdbd2cSJim Jagielski pViewData->SetDragMode(
1463*b1cdbd2cSJim Jagielski aRange.aStart.Col(), aRange.aStart.Row(),
1464*b1cdbd2cSJim Jagielski aRange.aEnd.Col(), aRange.aEnd.Row(), nMode );
1465*b1cdbd2cSJim Jagielski }
1466*b1cdbd2cSJim Jagielski bNewPointer = sal_True;
1467*b1cdbd2cSJim Jagielski }
1468*b1cdbd2cSJim Jagielski }
1469*b1cdbd2cSJim Jagielski }
1470*b1cdbd2cSJim Jagielski }
1471*b1cdbd2cSJim Jagielski
1472*b1cdbd2cSJim Jagielski if (!bNewPointer && bAction)
1473*b1cdbd2cSJim Jagielski {
1474*b1cdbd2cSJim Jagielski // SetPointer( POINTER_ARROW ); // in Fu...
1475*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
1476*b1cdbd2cSJim Jagielski }
1477*b1cdbd2cSJim Jagielski
1478*b1cdbd2cSJim Jagielski return bNewPointer;
1479*b1cdbd2cSJim Jagielski }
1480*b1cdbd2cSJim Jagielski
MouseButtonDown(const MouseEvent & rMEvt)1481*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::MouseButtonDown( const MouseEvent& rMEvt )
1482*b1cdbd2cSJim Jagielski {
1483*b1cdbd2cSJim Jagielski nNestedButtonState = SC_NESTEDBUTTON_DOWN;
1484*b1cdbd2cSJim Jagielski
1485*b1cdbd2cSJim Jagielski HandleMouseButtonDown( rMEvt );
1486*b1cdbd2cSJim Jagielski
1487*b1cdbd2cSJim Jagielski if ( nNestedButtonState == SC_NESTEDBUTTON_UP )
1488*b1cdbd2cSJim Jagielski {
1489*b1cdbd2cSJim Jagielski // #i41690# If an object is deactivated from MouseButtonDown, it might reschedule,
1490*b1cdbd2cSJim Jagielski // so MouseButtonUp comes before the MouseButtonDown call is finished. In this case,
1491*b1cdbd2cSJim Jagielski // simulate another MouseButtonUp call, so the selection state is consistent.
1492*b1cdbd2cSJim Jagielski
1493*b1cdbd2cSJim Jagielski nButtonDown = rMEvt.GetButtons();
1494*b1cdbd2cSJim Jagielski FakeButtonUp();
1495*b1cdbd2cSJim Jagielski
1496*b1cdbd2cSJim Jagielski if ( IsTracking() )
1497*b1cdbd2cSJim Jagielski EndTracking(); // normally done in VCL as part of MouseButtonUp handling
1498*b1cdbd2cSJim Jagielski }
1499*b1cdbd2cSJim Jagielski nNestedButtonState = SC_NESTEDBUTTON_NONE;
1500*b1cdbd2cSJim Jagielski }
1501*b1cdbd2cSJim Jagielski
HandleMouseButtonDown(const MouseEvent & rMEvt)1502*b1cdbd2cSJim Jagielski void ScGridWindow::HandleMouseButtonDown( const MouseEvent& rMEvt )
1503*b1cdbd2cSJim Jagielski {
1504*b1cdbd2cSJim Jagielski // We have to check if a context menu is shown and we have an UI
1505*b1cdbd2cSJim Jagielski // active inplace client. In that case we have to ignore the event.
1506*b1cdbd2cSJim Jagielski // Otherwise we would crash (context menu has been
1507*b1cdbd2cSJim Jagielski // opened by inplace client and we would deactivate the inplace client,
1508*b1cdbd2cSJim Jagielski // the contex menu is closed by VCL asynchronously which in the end
1509*b1cdbd2cSJim Jagielski // would work on deleted objects or the context menu has no parent anymore)
1510*b1cdbd2cSJim Jagielski // See #126086# and #128122#
1511*b1cdbd2cSJim Jagielski SfxViewShell* pViewSh = pViewData->GetViewShell();
1512*b1cdbd2cSJim Jagielski SfxInPlaceClient* pClient = pViewSh->GetIPClient();
1513*b1cdbd2cSJim Jagielski if ( pClient &&
1514*b1cdbd2cSJim Jagielski pClient->IsObjectInPlaceActive() &&
1515*b1cdbd2cSJim Jagielski PopupMenu::IsInExecute() )
1516*b1cdbd2cSJim Jagielski return;
1517*b1cdbd2cSJim Jagielski
1518*b1cdbd2cSJim Jagielski aCurMousePos = rMEvt.GetPosPixel();
1519*b1cdbd2cSJim Jagielski
1520*b1cdbd2cSJim Jagielski // Filter-Popup beendet sich mit eigenem Mausklick, nicht erst beim Klick
1521*b1cdbd2cSJim Jagielski // in das GridWindow, darum ist die folgende Abfrage nicht mehr noetig:
1522*b1cdbd2cSJim Jagielski #if 0
1523*b1cdbd2cSJim Jagielski // merken, dass FilterBox geloescht wird, damit sichergestellt
1524*b1cdbd2cSJim Jagielski // ist, dass in diesem Handler nicht an gleicher Stelle wieder
1525*b1cdbd2cSJim Jagielski // eine neue geoeffnet wird.
1526*b1cdbd2cSJim Jagielski sal_Bool bWasFilterBox = ( pFilterBox != NULL &&
1527*b1cdbd2cSJim Jagielski ((Window*)pFilterBox)->IsVisible() &&
1528*b1cdbd2cSJim Jagielski !pFilterBox->IsDataSelect() );
1529*b1cdbd2cSJim Jagielski SCCOL nOldColFBox = bWasFilterBox ? pFilterBox->GetCol() : 0;
1530*b1cdbd2cSJim Jagielski SCROW nOldRowFBox = bWasFilterBox ? pFilterBox->GetRow() : 0;
1531*b1cdbd2cSJim Jagielski #endif
1532*b1cdbd2cSJim Jagielski
1533*b1cdbd2cSJim Jagielski ClickExtern(); // loescht FilterBox, wenn vorhanden
1534*b1cdbd2cSJim Jagielski
1535*b1cdbd2cSJim Jagielski HideNoteMarker(); // Notiz-Anzeige
1536*b1cdbd2cSJim Jagielski
1537*b1cdbd2cSJim Jagielski bEEMouse = sal_False;
1538*b1cdbd2cSJim Jagielski
1539*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
1540*b1cdbd2cSJim Jagielski if (pScMod->IsModalMode(pViewData->GetSfxDocShell()))
1541*b1cdbd2cSJim Jagielski {
1542*b1cdbd2cSJim Jagielski Sound::Beep();
1543*b1cdbd2cSJim Jagielski return;
1544*b1cdbd2cSJim Jagielski }
1545*b1cdbd2cSJim Jagielski
1546*b1cdbd2cSJim Jagielski pScActiveViewShell = pViewData->GetViewShell(); // falls auf Link geklickt wird
1547*b1cdbd2cSJim Jagielski nScClickMouseModifier = rMEvt.GetModifier(); // um Control-Klick immer zu erkennen
1548*b1cdbd2cSJim Jagielski
1549*b1cdbd2cSJim Jagielski sal_Bool bDetective = pViewData->GetViewShell()->IsAuditShell();
1550*b1cdbd2cSJim Jagielski sal_Bool bRefMode = pViewData->IsRefMode(); // Referenz angefangen
1551*b1cdbd2cSJim Jagielski sal_Bool bFormulaMode = pScMod->IsFormulaMode(); // naechster Klick -> Referenz
1552*b1cdbd2cSJim Jagielski sal_Bool bEditMode = pViewData->HasEditView(eWhich); // auch bei Mode==SC_INPUT_TYPE
1553*b1cdbd2cSJim Jagielski sal_Bool bDouble = (rMEvt.GetClicks() == 2);
1554*b1cdbd2cSJim Jagielski
1555*b1cdbd2cSJim Jagielski // DeactivateIP passiert nur noch bei MarkListHasChanged
1556*b1cdbd2cSJim Jagielski
1557*b1cdbd2cSJim Jagielski // im GrabFocus Aufruf kann eine Fehlermeldung hochkommen
1558*b1cdbd2cSJim Jagielski // (z.B. beim Umbenennen von Tabellen per Tab-Reiter)
1559*b1cdbd2cSJim Jagielski
1560*b1cdbd2cSJim Jagielski if ( !nButtonDown || !bDouble ) // single (first) click is always valid
1561*b1cdbd2cSJim Jagielski nButtonDown = rMEvt.GetButtons(); // set nButtonDown first, so StopMarking works
1562*b1cdbd2cSJim Jagielski
1563*b1cdbd2cSJim Jagielski // pViewData->GetViewShell()->GetViewFrame()->GetWindow().GrabFocus();
1564*b1cdbd2cSJim Jagielski if ( ( bEditMode && pViewData->GetActivePart() == eWhich ) || !bFormulaMode )
1565*b1cdbd2cSJim Jagielski GrabFocus();
1566*b1cdbd2cSJim Jagielski
1567*b1cdbd2cSJim Jagielski // #i31846# need to cancel a double click if the first click has set the "ignore" state,
1568*b1cdbd2cSJim Jagielski // but a single (first) click is always valid
1569*b1cdbd2cSJim Jagielski if ( nMouseStatus == SC_GM_IGNORE && bDouble )
1570*b1cdbd2cSJim Jagielski {
1571*b1cdbd2cSJim Jagielski nButtonDown = 0;
1572*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
1573*b1cdbd2cSJim Jagielski return;
1574*b1cdbd2cSJim Jagielski }
1575*b1cdbd2cSJim Jagielski
1576*b1cdbd2cSJim Jagielski if ( bDetective ) // Detektiv-Fuell-Modus
1577*b1cdbd2cSJim Jagielski {
1578*b1cdbd2cSJim Jagielski if ( rMEvt.IsLeft() && !rMEvt.GetModifier() )
1579*b1cdbd2cSJim Jagielski {
1580*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
1581*b1cdbd2cSJim Jagielski SCsCOL nPosX;
1582*b1cdbd2cSJim Jagielski SCsROW nPosY;
1583*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
1584*b1cdbd2cSJim Jagielski
1585*b1cdbd2cSJim Jagielski SfxInt16Item aPosXItem( SID_RANGE_COL, nPosX );
1586*b1cdbd2cSJim Jagielski SfxInt32Item aPosYItem( SID_RANGE_ROW, nPosY );
1587*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( SID_FILL_SELECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
1588*b1cdbd2cSJim Jagielski &aPosXItem, &aPosYItem, (void*)0L );
1589*b1cdbd2cSJim Jagielski
1590*b1cdbd2cSJim Jagielski }
1591*b1cdbd2cSJim Jagielski nButtonDown = 0;
1592*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
1593*b1cdbd2cSJim Jagielski return;
1594*b1cdbd2cSJim Jagielski }
1595*b1cdbd2cSJim Jagielski
1596*b1cdbd2cSJim Jagielski if (!bDouble)
1597*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
1598*b1cdbd2cSJim Jagielski
1599*b1cdbd2cSJim Jagielski if (!bFormulaMode)
1600*b1cdbd2cSJim Jagielski {
1601*b1cdbd2cSJim Jagielski if ( pViewData->GetActivePart() != eWhich )
1602*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( eWhich );
1603*b1cdbd2cSJim Jagielski }
1604*b1cdbd2cSJim Jagielski else
1605*b1cdbd2cSJim Jagielski {
1606*b1cdbd2cSJim Jagielski ScViewSelectionEngine* pSelEng = pViewData->GetView()->GetSelEngine();
1607*b1cdbd2cSJim Jagielski pSelEng->SetWindow(this);
1608*b1cdbd2cSJim Jagielski pSelEng->SetWhich(eWhich);
1609*b1cdbd2cSJim Jagielski pSelEng->SetVisibleArea( Rectangle(Point(), GetOutputSizePixel()) );
1610*b1cdbd2cSJim Jagielski }
1611*b1cdbd2cSJim Jagielski
1612*b1cdbd2cSJim Jagielski if (bEditMode && (pViewData->GetRefTabNo() == pViewData->GetTabNo()))
1613*b1cdbd2cSJim Jagielski {
1614*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
1615*b1cdbd2cSJim Jagielski SCsCOL nPosX;
1616*b1cdbd2cSJim Jagielski SCsROW nPosY;
1617*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
1618*b1cdbd2cSJim Jagielski
1619*b1cdbd2cSJim Jagielski EditView* pEditView;
1620*b1cdbd2cSJim Jagielski SCCOL nEditCol;
1621*b1cdbd2cSJim Jagielski SCROW nEditRow;
1622*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
1623*b1cdbd2cSJim Jagielski SCCOL nEndCol = pViewData->GetEditEndCol();
1624*b1cdbd2cSJim Jagielski SCROW nEndRow = pViewData->GetEditEndRow();
1625*b1cdbd2cSJim Jagielski
1626*b1cdbd2cSJim Jagielski if ( nPosX >= (SCsCOL) nEditCol && nPosX <= (SCsCOL) nEndCol &&
1627*b1cdbd2cSJim Jagielski nPosY >= (SCsROW) nEditRow && nPosY <= (SCsROW) nEndRow )
1628*b1cdbd2cSJim Jagielski {
1629*b1cdbd2cSJim Jagielski // #53966# beim Klick in die Tabellen-EditView immer den Focus umsetzen
1630*b1cdbd2cSJim Jagielski if (bFormulaMode) // sonst ist es oben schon passiert
1631*b1cdbd2cSJim Jagielski GrabFocus();
1632*b1cdbd2cSJim Jagielski
1633*b1cdbd2cSJim Jagielski pScMod->SetInputMode( SC_INPUT_TABLE );
1634*b1cdbd2cSJim Jagielski bEEMouse = sal_True;
1635*b1cdbd2cSJim Jagielski bEditMode = pEditView->MouseButtonDown( rMEvt );
1636*b1cdbd2cSJim Jagielski return;
1637*b1cdbd2cSJim Jagielski }
1638*b1cdbd2cSJim Jagielski }
1639*b1cdbd2cSJim Jagielski
1640*b1cdbd2cSJim Jagielski if (pScMod->GetIsWaterCan())
1641*b1cdbd2cSJim Jagielski {
1642*b1cdbd2cSJim Jagielski //! was is mit'm Mac ???
1643*b1cdbd2cSJim Jagielski if ( rMEvt.GetModifier() + rMEvt.GetButtons() == MOUSE_RIGHT )
1644*b1cdbd2cSJim Jagielski {
1645*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_WATERUNDO;
1646*b1cdbd2cSJim Jagielski return;
1647*b1cdbd2cSJim Jagielski }
1648*b1cdbd2cSJim Jagielski }
1649*b1cdbd2cSJim Jagielski
1650*b1cdbd2cSJim Jagielski // Reihenfolge passend zum angezeigten Cursor:
1651*b1cdbd2cSJim Jagielski // RangeFinder, AutoFill, PageBreak, Drawing
1652*b1cdbd2cSJim Jagielski
1653*b1cdbd2cSJim Jagielski if ( HitRangeFinder( rMEvt.GetPosPixel(), bRFSize, &nRFIndex, &nRFAddX, &nRFAddY ) )
1654*b1cdbd2cSJim Jagielski {
1655*b1cdbd2cSJim Jagielski bRFMouse = sal_True; // die anderen Variablen sind oben initialisiert
1656*b1cdbd2cSJim Jagielski
1657*b1cdbd2cSJim Jagielski if ( pViewData->GetActivePart() != eWhich )
1658*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( eWhich ); //! schon oben immer ???
1659*b1cdbd2cSJim Jagielski
1660*b1cdbd2cSJim Jagielski // CaptureMouse();
1661*b1cdbd2cSJim Jagielski StartTracking();
1662*b1cdbd2cSJim Jagielski return;
1663*b1cdbd2cSJim Jagielski }
1664*b1cdbd2cSJim Jagielski
1665*b1cdbd2cSJim Jagielski sal_Bool bCrossPointer = TestMouse( rMEvt, sal_True );
1666*b1cdbd2cSJim Jagielski if ( bCrossPointer )
1667*b1cdbd2cSJim Jagielski {
1668*b1cdbd2cSJim Jagielski if ( bDouble )
1669*b1cdbd2cSJim Jagielski pViewData->GetView()->FillCrossDblClick();
1670*b1cdbd2cSJim Jagielski else
1671*b1cdbd2cSJim Jagielski pScMod->InputEnterHandler(); // Autofill etc.
1672*b1cdbd2cSJim Jagielski }
1673*b1cdbd2cSJim Jagielski
1674*b1cdbd2cSJim Jagielski if ( !bCrossPointer )
1675*b1cdbd2cSJim Jagielski {
1676*b1cdbd2cSJim Jagielski nPagebreakMouse = HitPageBreak( rMEvt.GetPosPixel(), &aPagebreakSource,
1677*b1cdbd2cSJim Jagielski &nPagebreakBreak, &nPagebreakPrev );
1678*b1cdbd2cSJim Jagielski if (nPagebreakMouse)
1679*b1cdbd2cSJim Jagielski {
1680*b1cdbd2cSJim Jagielski bPagebreakDrawn = sal_False;
1681*b1cdbd2cSJim Jagielski // CaptureMouse();
1682*b1cdbd2cSJim Jagielski StartTracking();
1683*b1cdbd2cSJim Jagielski PagebreakMove( rMEvt, sal_False );
1684*b1cdbd2cSJim Jagielski return;
1685*b1cdbd2cSJim Jagielski }
1686*b1cdbd2cSJim Jagielski }
1687*b1cdbd2cSJim Jagielski
1688*b1cdbd2cSJim Jagielski if (!bFormulaMode && !bEditMode && rMEvt.IsLeft())
1689*b1cdbd2cSJim Jagielski {
1690*b1cdbd2cSJim Jagielski if ( !bCrossPointer && DrawMouseButtonDown(rMEvt) )
1691*b1cdbd2cSJim Jagielski {
1692*b1cdbd2cSJim Jagielski //if (DrawHasMarkedObj())
1693*b1cdbd2cSJim Jagielski // pViewData->GetViewShell()->SetDrawShellOrSub(); // Draw-Objekt selektiert
1694*b1cdbd2cSJim Jagielski return;
1695*b1cdbd2cSJim Jagielski }
1696*b1cdbd2cSJim Jagielski
1697*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->SetDrawShell( sal_False ); // kein Draw-Objekt selektiert
1698*b1cdbd2cSJim Jagielski
1699*b1cdbd2cSJim Jagielski // TestMouse schon oben passiert
1700*b1cdbd2cSJim Jagielski }
1701*b1cdbd2cSJim Jagielski
1702*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
1703*b1cdbd2cSJim Jagielski SCsCOL nPosX;
1704*b1cdbd2cSJim Jagielski SCsROW nPosY;
1705*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
1706*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
1707*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
1708*b1cdbd2cSJim Jagielski
1709*b1cdbd2cSJim Jagielski
1710*b1cdbd2cSJim Jagielski //
1711*b1cdbd2cSJim Jagielski // AutoFilter buttons
1712*b1cdbd2cSJim Jagielski //
1713*b1cdbd2cSJim Jagielski
1714*b1cdbd2cSJim Jagielski if ( !bDouble && !bFormulaMode && rMEvt.IsLeft() )
1715*b1cdbd2cSJim Jagielski {
1716*b1cdbd2cSJim Jagielski SCsCOL nRealPosX;
1717*b1cdbd2cSJim Jagielski SCsROW nRealPosY;
1718*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nRealPosX, nRealPosY, false );//the real row/col
1719*b1cdbd2cSJim Jagielski ScMergeFlagAttr* pRealPosAttr = (ScMergeFlagAttr*)
1720*b1cdbd2cSJim Jagielski pDoc->GetAttr( nRealPosX, nRealPosY, nTab, ATTR_MERGE_FLAG );
1721*b1cdbd2cSJim Jagielski ScMergeFlagAttr* pAttr = (ScMergeFlagAttr*)
1722*b1cdbd2cSJim Jagielski pDoc->GetAttr( nPosX, nPosY, nTab, ATTR_MERGE_FLAG );
1723*b1cdbd2cSJim Jagielski if( pRealPosAttr->HasAutoFilter() )
1724*b1cdbd2cSJim Jagielski {
1725*b1cdbd2cSJim Jagielski SC_MOD()->InputEnterHandler();
1726*b1cdbd2cSJim Jagielski if (DoAutoFilterButton( nRealPosX, nRealPosY, rMEvt))
1727*b1cdbd2cSJim Jagielski return;
1728*b1cdbd2cSJim Jagielski }
1729*b1cdbd2cSJim Jagielski if( pAttr->HasAutoFilter() )
1730*b1cdbd2cSJim Jagielski {
1731*b1cdbd2cSJim Jagielski SC_MOD()->InputEnterHandler(); //Add for i85305
1732*b1cdbd2cSJim Jagielski if (DoAutoFilterButton( nPosX, nPosY, rMEvt))
1733*b1cdbd2cSJim Jagielski return;
1734*b1cdbd2cSJim Jagielski }
1735*b1cdbd2cSJim Jagielski if (pAttr->HasButton())
1736*b1cdbd2cSJim Jagielski {
1737*b1cdbd2cSJim Jagielski DoPushButton( nPosX, nPosY, rMEvt ); // setzt evtl. bPivotMouse / bDPMouse
1738*b1cdbd2cSJim Jagielski return;
1739*b1cdbd2cSJim Jagielski }
1740*b1cdbd2cSJim Jagielski
1741*b1cdbd2cSJim Jagielski // List Validity drop-down button
1742*b1cdbd2cSJim Jagielski
1743*b1cdbd2cSJim Jagielski if ( bListValButton )
1744*b1cdbd2cSJim Jagielski {
1745*b1cdbd2cSJim Jagielski Rectangle aButtonRect = GetListValButtonRect( aListValPos );
1746*b1cdbd2cSJim Jagielski if ( aButtonRect.IsInside( aPos ) )
1747*b1cdbd2cSJim Jagielski {
1748*b1cdbd2cSJim Jagielski DoAutoFilterMenue( aListValPos.Col(), aListValPos.Row(), sal_True );
1749*b1cdbd2cSJim Jagielski
1750*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_FILTER; // not set in DoAutoFilterMenue for bDataSelect
1751*b1cdbd2cSJim Jagielski CaptureMouse();
1752*b1cdbd2cSJim Jagielski return;
1753*b1cdbd2cSJim Jagielski }
1754*b1cdbd2cSJim Jagielski }
1755*b1cdbd2cSJim Jagielski }
1756*b1cdbd2cSJim Jagielski
1757*b1cdbd2cSJim Jagielski //
1758*b1cdbd2cSJim Jagielski // scenario selection
1759*b1cdbd2cSJim Jagielski //
1760*b1cdbd2cSJim Jagielski
1761*b1cdbd2cSJim Jagielski ScRange aScenRange;
1762*b1cdbd2cSJim Jagielski if ( rMEvt.IsLeft() && HasScenarioButton( aPos, aScenRange ) )
1763*b1cdbd2cSJim Jagielski {
1764*b1cdbd2cSJim Jagielski DoScenarioMenue( aScenRange );
1765*b1cdbd2cSJim Jagielski return;
1766*b1cdbd2cSJim Jagielski }
1767*b1cdbd2cSJim Jagielski
1768*b1cdbd2cSJim Jagielski //
1769*b1cdbd2cSJim Jagielski // Doppelklick angefangen ?
1770*b1cdbd2cSJim Jagielski //
1771*b1cdbd2cSJim Jagielski
1772*b1cdbd2cSJim Jagielski // StopMarking kann aus DrawMouseButtonDown gerufen werden
1773*b1cdbd2cSJim Jagielski
1774*b1cdbd2cSJim Jagielski if ( nMouseStatus != SC_GM_IGNORE && !bRefMode )
1775*b1cdbd2cSJim Jagielski {
1776*b1cdbd2cSJim Jagielski if ( bDouble && !bCrossPointer )
1777*b1cdbd2cSJim Jagielski {
1778*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_TABDOWN)
1779*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_DBLDOWN;
1780*b1cdbd2cSJim Jagielski }
1781*b1cdbd2cSJim Jagielski else
1782*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_TABDOWN;
1783*b1cdbd2cSJim Jagielski }
1784*b1cdbd2cSJim Jagielski
1785*b1cdbd2cSJim Jagielski //
1786*b1cdbd2cSJim Jagielski // Links in Edit-Zellen
1787*b1cdbd2cSJim Jagielski //
1788*b1cdbd2cSJim Jagielski
1789*b1cdbd2cSJim Jagielski sal_Bool bAlt = rMEvt.IsMod2();
1790*b1cdbd2cSJim Jagielski if ( !bAlt && rMEvt.IsLeft() &&
1791*b1cdbd2cSJim Jagielski GetEditUrl(rMEvt.GetPosPixel()) ) // Klick auf Link: Cursor nicht bewegen
1792*b1cdbd2cSJim Jagielski {
1793*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_REFHAND ) );
1794*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_URLDOWN; // auch nur dann beim ButtonUp ausfuehren
1795*b1cdbd2cSJim Jagielski return;
1796*b1cdbd2cSJim Jagielski }
1797*b1cdbd2cSJim Jagielski
1798*b1cdbd2cSJim Jagielski //
1799*b1cdbd2cSJim Jagielski // Gridwin - SelectionEngine
1800*b1cdbd2cSJim Jagielski //
1801*b1cdbd2cSJim Jagielski
1802*b1cdbd2cSJim Jagielski if ( rMEvt.IsLeft() )
1803*b1cdbd2cSJim Jagielski {
1804*b1cdbd2cSJim Jagielski ScViewSelectionEngine* pSelEng = pViewData->GetView()->GetSelEngine();
1805*b1cdbd2cSJim Jagielski pSelEng->SetWindow(this);
1806*b1cdbd2cSJim Jagielski pSelEng->SetWhich(eWhich);
1807*b1cdbd2cSJim Jagielski pSelEng->SetVisibleArea( Rectangle(Point(), GetOutputSizePixel()) );
1808*b1cdbd2cSJim Jagielski
1809*b1cdbd2cSJim Jagielski // SelMouseButtonDown an der View setzt noch das bMoveIsShift Flag
1810*b1cdbd2cSJim Jagielski if ( pViewData->GetView()->SelMouseButtonDown( rMEvt ) )
1811*b1cdbd2cSJim Jagielski {
1812*b1cdbd2cSJim Jagielski if (IsMouseCaptured())
1813*b1cdbd2cSJim Jagielski {
1814*b1cdbd2cSJim Jagielski // Tracking statt CaptureMouse, damit sauber abgebrochen werden kann
1815*b1cdbd2cSJim Jagielski //! Irgendwann sollte die SelectionEngine selber StartTracking rufen!?!
1816*b1cdbd2cSJim Jagielski ReleaseMouse();
1817*b1cdbd2cSJim Jagielski StartTracking();
1818*b1cdbd2cSJim Jagielski }
1819*b1cdbd2cSJim Jagielski pViewData->GetMarkData().SetMarking(sal_True);
1820*b1cdbd2cSJim Jagielski return;
1821*b1cdbd2cSJim Jagielski }
1822*b1cdbd2cSJim Jagielski }
1823*b1cdbd2cSJim Jagielski }
1824*b1cdbd2cSJim Jagielski
MouseButtonUp(const MouseEvent & rMEvt)1825*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::MouseButtonUp( const MouseEvent& rMEvt )
1826*b1cdbd2cSJim Jagielski {
1827*b1cdbd2cSJim Jagielski aCurMousePos = rMEvt.GetPosPixel();
1828*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
1829*b1cdbd2cSJim Jagielski ScMarkData& rMark = pViewData->GetMarkData();
1830*b1cdbd2cSJim Jagielski
1831*b1cdbd2cSJim Jagielski // #i41690# detect a MouseButtonUp call from within MouseButtonDown
1832*b1cdbd2cSJim Jagielski // (possible through Reschedule from storing an OLE object that is deselected)
1833*b1cdbd2cSJim Jagielski
1834*b1cdbd2cSJim Jagielski if ( nNestedButtonState == SC_NESTEDBUTTON_DOWN )
1835*b1cdbd2cSJim Jagielski nNestedButtonState = SC_NESTEDBUTTON_UP;
1836*b1cdbd2cSJim Jagielski
1837*b1cdbd2cSJim Jagielski if (nButtonDown != rMEvt.GetButtons())
1838*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_IGNORE; // reset und return
1839*b1cdbd2cSJim Jagielski
1840*b1cdbd2cSJim Jagielski nButtonDown = 0;
1841*b1cdbd2cSJim Jagielski
1842*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_IGNORE)
1843*b1cdbd2cSJim Jagielski {
1844*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
1845*b1cdbd2cSJim Jagielski // Selection-Engine: Markieren abbrechen
1846*b1cdbd2cSJim Jagielski pViewData->GetView()->GetSelEngine()->Reset();
1847*b1cdbd2cSJim Jagielski rMark.SetMarking(sal_False);
1848*b1cdbd2cSJim Jagielski if (pViewData->IsAnyFillMode())
1849*b1cdbd2cSJim Jagielski {
1850*b1cdbd2cSJim Jagielski pViewData->GetView()->StopRefMode();
1851*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
1852*b1cdbd2cSJim Jagielski }
1853*b1cdbd2cSJim Jagielski StopMarking();
1854*b1cdbd2cSJim Jagielski DrawEndAction(); // Markieren/Verschieben auf Drawing-Layer abbrechen
1855*b1cdbd2cSJim Jagielski ReleaseMouse();
1856*b1cdbd2cSJim Jagielski return;
1857*b1cdbd2cSJim Jagielski }
1858*b1cdbd2cSJim Jagielski
1859*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_FILTER)
1860*b1cdbd2cSJim Jagielski {
1861*b1cdbd2cSJim Jagielski if ( pFilterBox && pFilterBox->GetMode() == SC_FILTERBOX_FILTER )
1862*b1cdbd2cSJim Jagielski {
1863*b1cdbd2cSJim Jagielski if (mpFilterButton.get())
1864*b1cdbd2cSJim Jagielski {
1865*b1cdbd2cSJim Jagielski bool bFilterActive = IsAutoFilterActive(
1866*b1cdbd2cSJim Jagielski pFilterBox->GetCol(), pFilterBox->GetRow(), pViewData->GetTabNo() );
1867*b1cdbd2cSJim Jagielski
1868*b1cdbd2cSJim Jagielski mpFilterButton->setHasHiddenMember(bFilterActive);
1869*b1cdbd2cSJim Jagielski mpFilterButton->setPopupPressed(false);
1870*b1cdbd2cSJim Jagielski HideCursor();
1871*b1cdbd2cSJim Jagielski mpFilterButton->draw();
1872*b1cdbd2cSJim Jagielski ShowCursor();
1873*b1cdbd2cSJim Jagielski }
1874*b1cdbd2cSJim Jagielski }
1875*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
1876*b1cdbd2cSJim Jagielski ReleaseMouse();
1877*b1cdbd2cSJim Jagielski return; // da muss nix mehr passieren
1878*b1cdbd2cSJim Jagielski }
1879*b1cdbd2cSJim Jagielski
1880*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
1881*b1cdbd2cSJim Jagielski if (pScMod->IsModalMode(pViewData->GetSfxDocShell()))
1882*b1cdbd2cSJim Jagielski return;
1883*b1cdbd2cSJim Jagielski
1884*b1cdbd2cSJim Jagielski SfxBindings& rBindings = pViewData->GetBindings();
1885*b1cdbd2cSJim Jagielski if (bEEMouse && pViewData->HasEditView( eWhich ))
1886*b1cdbd2cSJim Jagielski {
1887*b1cdbd2cSJim Jagielski EditView* pEditView;
1888*b1cdbd2cSJim Jagielski SCCOL nEditCol;
1889*b1cdbd2cSJim Jagielski SCROW nEditRow;
1890*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
1891*b1cdbd2cSJim Jagielski pEditView->MouseButtonUp( rMEvt );
1892*b1cdbd2cSJim Jagielski
1893*b1cdbd2cSJim Jagielski if ( rMEvt.IsMiddle() &&
1894*b1cdbd2cSJim Jagielski GetSettings().GetMouseSettings().GetMiddleButtonAction() == MOUSE_MIDDLE_PASTESELECTION )
1895*b1cdbd2cSJim Jagielski {
1896*b1cdbd2cSJim Jagielski // EditView may have pasted from selection
1897*b1cdbd2cSJim Jagielski pScMod->InputChanged( pEditView );
1898*b1cdbd2cSJim Jagielski }
1899*b1cdbd2cSJim Jagielski else
1900*b1cdbd2cSJim Jagielski pScMod->InputSelection( pEditView ); // parentheses etc.
1901*b1cdbd2cSJim Jagielski
1902*b1cdbd2cSJim Jagielski pViewData->GetView()->InvalidateAttribs();
1903*b1cdbd2cSJim Jagielski rBindings.Invalidate( SID_HYPERLINK_GETLINK );
1904*b1cdbd2cSJim Jagielski bEEMouse = sal_False;
1905*b1cdbd2cSJim Jagielski return;
1906*b1cdbd2cSJim Jagielski }
1907*b1cdbd2cSJim Jagielski
1908*b1cdbd2cSJim Jagielski if (bDPMouse)
1909*b1cdbd2cSJim Jagielski {
1910*b1cdbd2cSJim Jagielski DPMouseButtonUp( rMEvt ); // resets bDPMouse
1911*b1cdbd2cSJim Jagielski return;
1912*b1cdbd2cSJim Jagielski }
1913*b1cdbd2cSJim Jagielski
1914*b1cdbd2cSJim Jagielski if (bRFMouse)
1915*b1cdbd2cSJim Jagielski {
1916*b1cdbd2cSJim Jagielski RFMouseMove( rMEvt, sal_True ); // Range wieder richtigherum
1917*b1cdbd2cSJim Jagielski bRFMouse = sal_False;
1918*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_ARROW ) );
1919*b1cdbd2cSJim Jagielski ReleaseMouse();
1920*b1cdbd2cSJim Jagielski return;
1921*b1cdbd2cSJim Jagielski }
1922*b1cdbd2cSJim Jagielski
1923*b1cdbd2cSJim Jagielski if (nPagebreakMouse)
1924*b1cdbd2cSJim Jagielski {
1925*b1cdbd2cSJim Jagielski PagebreakMove( rMEvt, sal_True );
1926*b1cdbd2cSJim Jagielski nPagebreakMouse = SC_PD_NONE;
1927*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_ARROW ) );
1928*b1cdbd2cSJim Jagielski ReleaseMouse();
1929*b1cdbd2cSJim Jagielski return;
1930*b1cdbd2cSJim Jagielski }
1931*b1cdbd2cSJim Jagielski
1932*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_WATERUNDO) // Undo im Giesskannenmodus
1933*b1cdbd2cSJim Jagielski {
1934*b1cdbd2cSJim Jagielski ::svl::IUndoManager* pMgr = pViewData->GetDocShell()->GetUndoManager();
1935*b1cdbd2cSJim Jagielski if ( pMgr->GetUndoActionCount() && pMgr->GetUndoActionId() == STR_UNDO_APPLYCELLSTYLE )
1936*b1cdbd2cSJim Jagielski pMgr->Undo();
1937*b1cdbd2cSJim Jagielski else
1938*b1cdbd2cSJim Jagielski Sound::Beep();
1939*b1cdbd2cSJim Jagielski return;
1940*b1cdbd2cSJim Jagielski }
1941*b1cdbd2cSJim Jagielski
1942*b1cdbd2cSJim Jagielski if (DrawMouseButtonUp(rMEvt)) // includes format paint brush handling for drawing objects
1943*b1cdbd2cSJim Jagielski {
1944*b1cdbd2cSJim Jagielski ScTabViewShell* pViewShell = pViewData->GetViewShell();
1945*b1cdbd2cSJim Jagielski SfxBindings& rBindings=pViewShell->GetViewFrame()->GetBindings();
1946*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_WIDTH);
1947*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_HEIGHT);
1948*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_X);
1949*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_Y);
1950*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_ANGLE);
1951*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_ROT_X);
1952*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_ROT_Y);
1953*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_AUTOWIDTH);
1954*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_AUTOHEIGHT);
1955*b1cdbd2cSJim Jagielski return;
1956*b1cdbd2cSJim Jagielski }
1957*b1cdbd2cSJim Jagielski
1958*b1cdbd2cSJim Jagielski rMark.SetMarking(sal_False);
1959*b1cdbd2cSJim Jagielski
1960*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_ARROW ) );
1961*b1cdbd2cSJim Jagielski
1962*b1cdbd2cSJim Jagielski if (pViewData->IsFillMode() ||
1963*b1cdbd2cSJim Jagielski ( pViewData->GetFillMode() == SC_FILL_MATRIX && rMEvt.IsMod1() ))
1964*b1cdbd2cSJim Jagielski {
1965*b1cdbd2cSJim Jagielski nScFillModeMouseModifier = rMEvt.GetModifier();
1966*b1cdbd2cSJim Jagielski SCCOL nStartCol;
1967*b1cdbd2cSJim Jagielski SCROW nStartRow;
1968*b1cdbd2cSJim Jagielski SCCOL nEndCol;
1969*b1cdbd2cSJim Jagielski SCROW nEndRow;
1970*b1cdbd2cSJim Jagielski pViewData->GetFillData( nStartCol, nStartRow, nEndCol, nEndRow );
1971*b1cdbd2cSJim Jagielski // DBG_ASSERT( nStartCol==pViewData->GetRefStartX() && nStartRow==pViewData->GetRefStartY(),
1972*b1cdbd2cSJim Jagielski // "Block falsch fuer AutoFill" );
1973*b1cdbd2cSJim Jagielski ScRange aDelRange;
1974*b1cdbd2cSJim Jagielski sal_Bool bIsDel = pViewData->GetDelMark( aDelRange );
1975*b1cdbd2cSJim Jagielski
1976*b1cdbd2cSJim Jagielski ScViewFunc* pView = pViewData->GetView();
1977*b1cdbd2cSJim Jagielski pView->StopRefMode();
1978*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
1979*b1cdbd2cSJim Jagielski pView->GetFunctionSet()->SetAnchorFlag( sal_False ); // #i5819# don't use AutoFill anchor flag for selection
1980*b1cdbd2cSJim Jagielski
1981*b1cdbd2cSJim Jagielski if ( bIsDel )
1982*b1cdbd2cSJim Jagielski {
1983*b1cdbd2cSJim Jagielski pView->MarkRange( aDelRange, sal_False );
1984*b1cdbd2cSJim Jagielski pView->DeleteContents( IDF_CONTENTS );
1985*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
1986*b1cdbd2cSJim Jagielski ScRange aBlockRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab );
1987*b1cdbd2cSJim Jagielski if ( aBlockRange != aDelRange )
1988*b1cdbd2cSJim Jagielski {
1989*b1cdbd2cSJim Jagielski if ( aDelRange.aStart.Row() == nStartRow )
1990*b1cdbd2cSJim Jagielski aBlockRange.aEnd.SetCol( aDelRange.aStart.Col() - 1 );
1991*b1cdbd2cSJim Jagielski else
1992*b1cdbd2cSJim Jagielski aBlockRange.aEnd.SetRow( aDelRange.aStart.Row() - 1 );
1993*b1cdbd2cSJim Jagielski pView->MarkRange( aBlockRange, sal_False );
1994*b1cdbd2cSJim Jagielski }
1995*b1cdbd2cSJim Jagielski }
1996*b1cdbd2cSJim Jagielski else
1997*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( FID_FILL_AUTO, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD );
1998*b1cdbd2cSJim Jagielski }
1999*b1cdbd2cSJim Jagielski else if (pViewData->GetFillMode() == SC_FILL_MATRIX)
2000*b1cdbd2cSJim Jagielski {
2001*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
2002*b1cdbd2cSJim Jagielski SCCOL nStartCol;
2003*b1cdbd2cSJim Jagielski SCROW nStartRow;
2004*b1cdbd2cSJim Jagielski SCCOL nEndCol;
2005*b1cdbd2cSJim Jagielski SCROW nEndRow;
2006*b1cdbd2cSJim Jagielski pViewData->GetFillData( nStartCol, nStartRow, nEndCol, nEndRow );
2007*b1cdbd2cSJim Jagielski ScRange aBlockRange( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab );
2008*b1cdbd2cSJim Jagielski SCCOL nFillCol = pViewData->GetRefEndX();
2009*b1cdbd2cSJim Jagielski SCROW nFillRow = pViewData->GetRefEndY();
2010*b1cdbd2cSJim Jagielski ScAddress aEndPos( nFillCol, nFillRow, nTab );
2011*b1cdbd2cSJim Jagielski
2012*b1cdbd2cSJim Jagielski ScTabView* pView = pViewData->GetView();
2013*b1cdbd2cSJim Jagielski pView->StopRefMode();
2014*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
2015*b1cdbd2cSJim Jagielski pView->GetFunctionSet()->SetAnchorFlag( sal_False );
2016*b1cdbd2cSJim Jagielski
2017*b1cdbd2cSJim Jagielski if ( aEndPos != aBlockRange.aEnd )
2018*b1cdbd2cSJim Jagielski {
2019*b1cdbd2cSJim Jagielski pViewData->GetDocShell()->GetDocFunc().ResizeMatrix( aBlockRange, aEndPos, sal_False );
2020*b1cdbd2cSJim Jagielski pViewData->GetView()->MarkRange( ScRange( aBlockRange.aStart, aEndPos ) );
2021*b1cdbd2cSJim Jagielski }
2022*b1cdbd2cSJim Jagielski }
2023*b1cdbd2cSJim Jagielski else if (pViewData->IsAnyFillMode())
2024*b1cdbd2cSJim Jagielski {
2025*b1cdbd2cSJim Jagielski // Embedded-Area has been changed
2026*b1cdbd2cSJim Jagielski ScTabView* pView = pViewData->GetView();
2027*b1cdbd2cSJim Jagielski pView->StopRefMode();
2028*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
2029*b1cdbd2cSJim Jagielski pView->GetFunctionSet()->SetAnchorFlag( sal_False );
2030*b1cdbd2cSJim Jagielski pViewData->GetDocShell()->UpdateOle(pViewData);
2031*b1cdbd2cSJim Jagielski }
2032*b1cdbd2cSJim Jagielski
2033*b1cdbd2cSJim Jagielski sal_Bool bRefMode = pViewData->IsRefMode();
2034*b1cdbd2cSJim Jagielski if (bRefMode)
2035*b1cdbd2cSJim Jagielski pScMod->EndReference();
2036*b1cdbd2cSJim Jagielski
2037*b1cdbd2cSJim Jagielski //
2038*b1cdbd2cSJim Jagielski // Giesskannen-Modus (Gestalter)
2039*b1cdbd2cSJim Jagielski //
2040*b1cdbd2cSJim Jagielski
2041*b1cdbd2cSJim Jagielski if (pScMod->GetIsWaterCan())
2042*b1cdbd2cSJim Jagielski {
2043*b1cdbd2cSJim Jagielski // Abfrage auf Undo schon oben
2044*b1cdbd2cSJim Jagielski
2045*b1cdbd2cSJim Jagielski ScStyleSheetPool* pStylePool = (ScStyleSheetPool*)
2046*b1cdbd2cSJim Jagielski (pViewData->GetDocument()->
2047*b1cdbd2cSJim Jagielski GetStyleSheetPool());
2048*b1cdbd2cSJim Jagielski if ( pStylePool )
2049*b1cdbd2cSJim Jagielski {
2050*b1cdbd2cSJim Jagielski SfxStyleSheet* pStyleSheet = (SfxStyleSheet*)
2051*b1cdbd2cSJim Jagielski pStylePool->GetActualStyleSheet();
2052*b1cdbd2cSJim Jagielski
2053*b1cdbd2cSJim Jagielski if ( pStyleSheet )
2054*b1cdbd2cSJim Jagielski {
2055*b1cdbd2cSJim Jagielski SfxStyleFamily eFamily = pStyleSheet->GetFamily();
2056*b1cdbd2cSJim Jagielski
2057*b1cdbd2cSJim Jagielski switch ( eFamily )
2058*b1cdbd2cSJim Jagielski {
2059*b1cdbd2cSJim Jagielski case SFX_STYLE_FAMILY_PARA:
2060*b1cdbd2cSJim Jagielski pViewData->GetView()->SetStyleSheetToMarked( pStyleSheet );
2061*b1cdbd2cSJim Jagielski pViewData->GetView()->DoneBlockMode();
2062*b1cdbd2cSJim Jagielski break;
2063*b1cdbd2cSJim Jagielski
2064*b1cdbd2cSJim Jagielski case SFX_STYLE_FAMILY_PAGE:
2065*b1cdbd2cSJim Jagielski pViewData->GetDocument()->SetPageStyle( pViewData->GetTabNo(),
2066*b1cdbd2cSJim Jagielski pStyleSheet->GetName() );
2067*b1cdbd2cSJim Jagielski
2068*b1cdbd2cSJim Jagielski ScPrintFunc( pViewData->GetDocShell(),
2069*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->GetPrinter(sal_True),
2070*b1cdbd2cSJim Jagielski pViewData->GetTabNo() ).UpdatePages();
2071*b1cdbd2cSJim Jagielski
2072*b1cdbd2cSJim Jagielski rBindings.Invalidate( SID_STATUS_PAGESTYLE );
2073*b1cdbd2cSJim Jagielski break;
2074*b1cdbd2cSJim Jagielski
2075*b1cdbd2cSJim Jagielski default:
2076*b1cdbd2cSJim Jagielski break;
2077*b1cdbd2cSJim Jagielski }
2078*b1cdbd2cSJim Jagielski }
2079*b1cdbd2cSJim Jagielski }
2080*b1cdbd2cSJim Jagielski }
2081*b1cdbd2cSJim Jagielski
2082*b1cdbd2cSJim Jagielski ScDBFunc* pView = pViewData->GetView();
2083*b1cdbd2cSJim Jagielski ScDocument* pBrushDoc = pView->GetBrushDocument();
2084*b1cdbd2cSJim Jagielski if ( pBrushDoc )
2085*b1cdbd2cSJim Jagielski {
2086*b1cdbd2cSJim Jagielski pView->PasteFromClip( IDF_ATTRIB, pBrushDoc );
2087*b1cdbd2cSJim Jagielski if ( !pView->IsPaintBrushLocked() )
2088*b1cdbd2cSJim Jagielski pView->ResetBrushDocument(); // invalidates pBrushDoc pointer
2089*b1cdbd2cSJim Jagielski }
2090*b1cdbd2cSJim Jagielski
2091*b1cdbd2cSJim Jagielski //
2092*b1cdbd2cSJim Jagielski // double click (only left button)
2093*b1cdbd2cSJim Jagielski //
2094*b1cdbd2cSJim Jagielski
2095*b1cdbd2cSJim Jagielski sal_Bool bDouble = ( rMEvt.GetClicks() == 2 && rMEvt.IsLeft() );
2096*b1cdbd2cSJim Jagielski if ( bDouble && !bRefMode && nMouseStatus == SC_GM_DBLDOWN && !pScMod->IsRefDialogOpen() )
2097*b1cdbd2cSJim Jagielski {
2098*b1cdbd2cSJim Jagielski // data pilot table
2099*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
2100*b1cdbd2cSJim Jagielski SCsCOL nPosX;
2101*b1cdbd2cSJim Jagielski SCsROW nPosY;
2102*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
2103*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
2104*b1cdbd2cSJim Jagielski ScDPObject* pDPObj = pDoc->GetDPAtCursor( nPosX, nPosY, nTab );
2105*b1cdbd2cSJim Jagielski if ( pDPObj && pDPObj->GetSaveData()->GetDrillDown() )
2106*b1cdbd2cSJim Jagielski {
2107*b1cdbd2cSJim Jagielski ScAddress aCellPos( nPosX, nPosY, pViewData->GetTabNo() );
2108*b1cdbd2cSJim Jagielski
2109*b1cdbd2cSJim Jagielski // Check for header drill-down first.
2110*b1cdbd2cSJim Jagielski sheet::DataPilotTableHeaderData aData;
2111*b1cdbd2cSJim Jagielski pDPObj->GetHeaderPositionData(aCellPos, aData);
2112*b1cdbd2cSJim Jagielski
2113*b1cdbd2cSJim Jagielski if ( ( aData.Flags & sheet::MemberResultFlags::HASMEMBER ) &&
2114*b1cdbd2cSJim Jagielski ! ( aData.Flags & sheet::MemberResultFlags::SUBTOTAL ) )
2115*b1cdbd2cSJim Jagielski {
2116*b1cdbd2cSJim Jagielski sal_uInt16 nDummy;
2117*b1cdbd2cSJim Jagielski if ( pView->HasSelectionForDrillDown( nDummy ) )
2118*b1cdbd2cSJim Jagielski {
2119*b1cdbd2cSJim Jagielski // execute slot to show dialog
2120*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( SID_OUTLINE_SHOW, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD );
2121*b1cdbd2cSJim Jagielski }
2122*b1cdbd2cSJim Jagielski else
2123*b1cdbd2cSJim Jagielski {
2124*b1cdbd2cSJim Jagielski // toggle single entry
2125*b1cdbd2cSJim Jagielski ScDPObject aNewObj( *pDPObj );
2126*b1cdbd2cSJim Jagielski pDPObj->ToggleDetails( aData, &aNewObj );
2127*b1cdbd2cSJim Jagielski ScDBDocFunc aFunc( *pViewData->GetDocShell() );
2128*b1cdbd2cSJim Jagielski aFunc.DataPilotUpdate( pDPObj, &aNewObj, sal_True, sal_False );
2129*b1cdbd2cSJim Jagielski pViewData->GetView()->CursorPosChanged(); // shells may be switched
2130*b1cdbd2cSJim Jagielski }
2131*b1cdbd2cSJim Jagielski }
2132*b1cdbd2cSJim Jagielski else
2133*b1cdbd2cSJim Jagielski {
2134*b1cdbd2cSJim Jagielski // Check if the data area is double-clicked.
2135*b1cdbd2cSJim Jagielski
2136*b1cdbd2cSJim Jagielski Sequence<sheet::DataPilotFieldFilter> aFilters;
2137*b1cdbd2cSJim Jagielski if ( pDPObj->GetDataFieldPositionData(aCellPos, aFilters) )
2138*b1cdbd2cSJim Jagielski pViewData->GetView()->ShowDataPilotSourceData( *pDPObj, aFilters );
2139*b1cdbd2cSJim Jagielski else
2140*b1cdbd2cSJim Jagielski Sound::Beep(); // nothing to expand/collapse/show
2141*b1cdbd2cSJim Jagielski }
2142*b1cdbd2cSJim Jagielski
2143*b1cdbd2cSJim Jagielski return;
2144*b1cdbd2cSJim Jagielski }
2145*b1cdbd2cSJim Jagielski
2146*b1cdbd2cSJim Jagielski // Check for cell protection attribute.
2147*b1cdbd2cSJim Jagielski ScTableProtection* pProtect = pDoc->GetTabProtection( nTab );
2148*b1cdbd2cSJim Jagielski bool bEditAllowed = true;
2149*b1cdbd2cSJim Jagielski if ( pProtect && pProtect->isProtected() )
2150*b1cdbd2cSJim Jagielski {
2151*b1cdbd2cSJim Jagielski bool bCellProtected = pDoc->HasAttrib(nPosX, nPosY, nTab, nPosX, nPosY, nTab, HASATTR_PROTECTED);
2152*b1cdbd2cSJim Jagielski bool bSkipProtected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
2153*b1cdbd2cSJim Jagielski bool bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
2154*b1cdbd2cSJim Jagielski
2155*b1cdbd2cSJim Jagielski if ( bSkipProtected && bSkipUnprotected )
2156*b1cdbd2cSJim Jagielski bEditAllowed = false;
2157*b1cdbd2cSJim Jagielski else if ( (bCellProtected && bSkipProtected) || (!bCellProtected && bSkipUnprotected) )
2158*b1cdbd2cSJim Jagielski bEditAllowed = false;
2159*b1cdbd2cSJim Jagielski }
2160*b1cdbd2cSJim Jagielski
2161*b1cdbd2cSJim Jagielski if ( bEditAllowed )
2162*b1cdbd2cSJim Jagielski {
2163*b1cdbd2cSJim Jagielski // edit cell contents
2164*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->UpdateInputHandler();
2165*b1cdbd2cSJim Jagielski pScMod->SetInputMode( SC_INPUT_TABLE );
2166*b1cdbd2cSJim Jagielski if (pViewData->HasEditView(eWhich))
2167*b1cdbd2cSJim Jagielski {
2168*b1cdbd2cSJim Jagielski // Text-Cursor gleich an die geklickte Stelle setzen
2169*b1cdbd2cSJim Jagielski EditView* pEditView = pViewData->GetEditView( eWhich );
2170*b1cdbd2cSJim Jagielski MouseEvent aEditEvt( rMEvt.GetPosPixel(), 1, MOUSE_SYNTHETIC, MOUSE_LEFT, 0 );
2171*b1cdbd2cSJim Jagielski pEditView->MouseButtonDown( aEditEvt );
2172*b1cdbd2cSJim Jagielski pEditView->MouseButtonUp( aEditEvt );
2173*b1cdbd2cSJim Jagielski }
2174*b1cdbd2cSJim Jagielski }
2175*b1cdbd2cSJim Jagielski return;
2176*b1cdbd2cSJim Jagielski }
2177*b1cdbd2cSJim Jagielski
2178*b1cdbd2cSJim Jagielski //
2179*b1cdbd2cSJim Jagielski // Links in edit cells
2180*b1cdbd2cSJim Jagielski //
2181*b1cdbd2cSJim Jagielski
2182*b1cdbd2cSJim Jagielski sal_Bool bAlt = rMEvt.IsMod2();
2183*b1cdbd2cSJim Jagielski if ( !bAlt && !bRefMode && !bDouble && nMouseStatus == SC_GM_URLDOWN )
2184*b1cdbd2cSJim Jagielski {
2185*b1cdbd2cSJim Jagielski // beim ButtonUp nur ausfuehren, wenn ButtonDown auch ueber einer URL war
2186*b1cdbd2cSJim Jagielski
2187*b1cdbd2cSJim Jagielski String aName, aUrl, aTarget;
2188*b1cdbd2cSJim Jagielski if ( GetEditUrl( rMEvt.GetPosPixel(), &aName, &aUrl, &aTarget ) )
2189*b1cdbd2cSJim Jagielski {
2190*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE; // keinen Doppelklick anfangen
2191*b1cdbd2cSJim Jagielski ScGlobal::OpenURL( aUrl, aTarget );
2192*b1cdbd2cSJim Jagielski
2193*b1cdbd2cSJim Jagielski // fire worksheet_followhyperlink event
2194*b1cdbd2cSJim Jagielski uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents = pDoc->GetVbaEventProcessor();
2195*b1cdbd2cSJim Jagielski if( xVbaEvents.is() ) try
2196*b1cdbd2cSJim Jagielski {
2197*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
2198*b1cdbd2cSJim Jagielski SCsCOL nPosX;
2199*b1cdbd2cSJim Jagielski SCsROW nPosY;
2200*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
2201*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
2202*b1cdbd2cSJim Jagielski ScBaseCell* pCell = NULL;
2203*b1cdbd2cSJim Jagielski if( lcl_GetHyperlinkCell( pDoc, nPosX, nPosY, nTab, pCell ) )
2204*b1cdbd2cSJim Jagielski {
2205*b1cdbd2cSJim Jagielski ScAddress aCellPos( nPosX, nPosY, nTab );
2206*b1cdbd2cSJim Jagielski uno::Reference< table::XCell > xCell( new ScCellObj( pViewData->GetDocShell(), aCellPos ) );
2207*b1cdbd2cSJim Jagielski uno::Sequence< uno::Any > aArgs(1);
2208*b1cdbd2cSJim Jagielski aArgs[0] <<= xCell;
2209*b1cdbd2cSJim Jagielski xVbaEvents->processVbaEvent( script::vba::VBAEventId::WORKSHEET_FOLLOWHYPERLINK, aArgs );
2210*b1cdbd2cSJim Jagielski }
2211*b1cdbd2cSJim Jagielski }
2212*b1cdbd2cSJim Jagielski catch( uno::Exception& )
2213*b1cdbd2cSJim Jagielski {
2214*b1cdbd2cSJim Jagielski }
2215*b1cdbd2cSJim Jagielski
2216*b1cdbd2cSJim Jagielski return;
2217*b1cdbd2cSJim Jagielski }
2218*b1cdbd2cSJim Jagielski }
2219*b1cdbd2cSJim Jagielski
2220*b1cdbd2cSJim Jagielski //
2221*b1cdbd2cSJim Jagielski // Gridwin - SelectionEngine
2222*b1cdbd2cSJim Jagielski //
2223*b1cdbd2cSJim Jagielski
2224*b1cdbd2cSJim Jagielski // SelMouseButtonDown is called only for left button, but SelMouseButtonUp would return
2225*b1cdbd2cSJim Jagielski // sal_True for any call, so IsLeft must be checked here, too.
2226*b1cdbd2cSJim Jagielski
2227*b1cdbd2cSJim Jagielski if ( rMEvt.IsLeft() && pViewData->GetView()->GetSelEngine()->SelMouseButtonUp( rMEvt ) )
2228*b1cdbd2cSJim Jagielski {
2229*b1cdbd2cSJim Jagielski // rMark.MarkToSimple();
2230*b1cdbd2cSJim Jagielski pViewData->GetView()->UpdateAutoFillMark();
2231*b1cdbd2cSJim Jagielski
2232*b1cdbd2cSJim Jagielski SfxDispatcher* pDisp = pViewData->GetViewShell()->GetDispatcher();
2233*b1cdbd2cSJim Jagielski sal_Bool bFormulaMode = pScMod->IsFormulaMode();
2234*b1cdbd2cSJim Jagielski DBG_ASSERT( pDisp || bFormulaMode, "Cursor auf nicht aktiver View bewegen ?" );
2235*b1cdbd2cSJim Jagielski
2236*b1cdbd2cSJim Jagielski // #i14927# execute SID_CURRENTCELL (for macro recording) only if there is no
2237*b1cdbd2cSJim Jagielski // multiple selection, so the argument string completely describes the selection,
2238*b1cdbd2cSJim Jagielski // and executing the slot won't change the existing selection (executing the slot
2239*b1cdbd2cSJim Jagielski // here and from a recorded macro is treated equally)
2240*b1cdbd2cSJim Jagielski
2241*b1cdbd2cSJim Jagielski if ( pDisp && !bFormulaMode && !rMark.IsMultiMarked() )
2242*b1cdbd2cSJim Jagielski {
2243*b1cdbd2cSJim Jagielski String aAddr; // CurrentCell
2244*b1cdbd2cSJim Jagielski if( rMark.IsMarked() )
2245*b1cdbd2cSJim Jagielski {
2246*b1cdbd2cSJim Jagielski // sal_Bool bKeep = rMark.IsMultiMarked(); //! wohin damit ???
2247*b1cdbd2cSJim Jagielski
2248*b1cdbd2cSJim Jagielski ScRange aScRange;
2249*b1cdbd2cSJim Jagielski rMark.GetMarkArea( aScRange );
2250*b1cdbd2cSJim Jagielski aScRange.Format( aAddr, SCR_ABS );
2251*b1cdbd2cSJim Jagielski if ( aScRange.aStart == aScRange.aEnd )
2252*b1cdbd2cSJim Jagielski {
2253*b1cdbd2cSJim Jagielski // make sure there is a range selection string even for a single cell
2254*b1cdbd2cSJim Jagielski String aSingle = aAddr;
2255*b1cdbd2cSJim Jagielski aAddr.Append( (sal_Char) ':' );
2256*b1cdbd2cSJim Jagielski aAddr.Append( aSingle );
2257*b1cdbd2cSJim Jagielski }
2258*b1cdbd2cSJim Jagielski
2259*b1cdbd2cSJim Jagielski //! SID_MARKAREA gibts nicht mehr ???
2260*b1cdbd2cSJim Jagielski //! was passiert beim Markieren mit dem Cursor ???
2261*b1cdbd2cSJim Jagielski }
2262*b1cdbd2cSJim Jagielski else // nur Cursor bewegen
2263*b1cdbd2cSJim Jagielski {
2264*b1cdbd2cSJim Jagielski ScAddress aScAddress( pViewData->GetCurX(), pViewData->GetCurY(), 0 );
2265*b1cdbd2cSJim Jagielski aScAddress.Format( aAddr, SCA_ABS );
2266*b1cdbd2cSJim Jagielski }
2267*b1cdbd2cSJim Jagielski
2268*b1cdbd2cSJim Jagielski SfxStringItem aPosItem( SID_CURRENTCELL, aAddr );
2269*b1cdbd2cSJim Jagielski pDisp->Execute( SID_CURRENTCELL, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
2270*b1cdbd2cSJim Jagielski &aPosItem, (void*)0L );
2271*b1cdbd2cSJim Jagielski
2272*b1cdbd2cSJim Jagielski pViewData->GetView()->InvalidateAttribs();
2273*b1cdbd2cSJim Jagielski }
2274*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->SelectionChanged();
2275*b1cdbd2cSJim Jagielski return;
2276*b1cdbd2cSJim Jagielski }
2277*b1cdbd2cSJim Jagielski }
2278*b1cdbd2cSJim Jagielski
FakeButtonUp()2279*b1cdbd2cSJim Jagielski void ScGridWindow::FakeButtonUp()
2280*b1cdbd2cSJim Jagielski {
2281*b1cdbd2cSJim Jagielski if ( nButtonDown )
2282*b1cdbd2cSJim Jagielski {
2283*b1cdbd2cSJim Jagielski MouseEvent aEvent( aCurMousePos ); // nButtons = 0 -> ignore
2284*b1cdbd2cSJim Jagielski MouseButtonUp( aEvent );
2285*b1cdbd2cSJim Jagielski }
2286*b1cdbd2cSJim Jagielski }
2287*b1cdbd2cSJim Jagielski
MouseMove(const MouseEvent & rMEvt)2288*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::MouseMove( const MouseEvent& rMEvt )
2289*b1cdbd2cSJim Jagielski {
2290*b1cdbd2cSJim Jagielski aCurMousePos = rMEvt.GetPosPixel();
2291*b1cdbd2cSJim Jagielski
2292*b1cdbd2cSJim Jagielski if ( rMEvt.IsLeaveWindow() && pNoteMarker && !pNoteMarker->IsByKeyboard() )
2293*b1cdbd2cSJim Jagielski HideNoteMarker();
2294*b1cdbd2cSJim Jagielski
2295*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
2296*b1cdbd2cSJim Jagielski if (pScMod->IsModalMode(pViewData->GetSfxDocShell()))
2297*b1cdbd2cSJim Jagielski return;
2298*b1cdbd2cSJim Jagielski
2299*b1cdbd2cSJim Jagielski // Ob aus dem Edit-Modus Drag&Drop gestartet wurde, bekommt man leider
2300*b1cdbd2cSJim Jagielski // nicht anders mit:
2301*b1cdbd2cSJim Jagielski
2302*b1cdbd2cSJim Jagielski if (bEEMouse && nButtonDown && !rMEvt.GetButtons())
2303*b1cdbd2cSJim Jagielski {
2304*b1cdbd2cSJim Jagielski bEEMouse = sal_False;
2305*b1cdbd2cSJim Jagielski nButtonDown = 0;
2306*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
2307*b1cdbd2cSJim Jagielski return;
2308*b1cdbd2cSJim Jagielski }
2309*b1cdbd2cSJim Jagielski
2310*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_IGNORE)
2311*b1cdbd2cSJim Jagielski return;
2312*b1cdbd2cSJim Jagielski
2313*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_WATERUNDO) // Undo im Giesskannenmodus -> nur auf Up warten
2314*b1cdbd2cSJim Jagielski return;
2315*b1cdbd2cSJim Jagielski
2316*b1cdbd2cSJim Jagielski if ( pViewData->GetViewShell()->IsAuditShell() ) // Detektiv-Fuell-Modus
2317*b1cdbd2cSJim Jagielski {
2318*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_FILL ) );
2319*b1cdbd2cSJim Jagielski return;
2320*b1cdbd2cSJim Jagielski }
2321*b1cdbd2cSJim Jagielski
2322*b1cdbd2cSJim Jagielski if (nMouseStatus == SC_GM_FILTER && pFilterBox)
2323*b1cdbd2cSJim Jagielski {
2324*b1cdbd2cSJim Jagielski Point aRelPos = pFilterBox->ScreenToOutputPixel( OutputToScreenPixel( rMEvt.GetPosPixel() ) );
2325*b1cdbd2cSJim Jagielski if ( Rectangle(Point(),pFilterBox->GetOutputSizePixel()).IsInside(aRelPos) )
2326*b1cdbd2cSJim Jagielski {
2327*b1cdbd2cSJim Jagielski nButtonDown = 0;
2328*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_NONE;
2329*b1cdbd2cSJim Jagielski if ( pFilterBox->GetMode() == SC_FILTERBOX_FILTER )
2330*b1cdbd2cSJim Jagielski {
2331*b1cdbd2cSJim Jagielski if (mpFilterButton.get())
2332*b1cdbd2cSJim Jagielski {
2333*b1cdbd2cSJim Jagielski mpFilterButton->setHasHiddenMember(false);
2334*b1cdbd2cSJim Jagielski mpFilterButton->setPopupPressed(false);
2335*b1cdbd2cSJim Jagielski HideCursor();
2336*b1cdbd2cSJim Jagielski mpFilterButton->draw();
2337*b1cdbd2cSJim Jagielski ShowCursor();
2338*b1cdbd2cSJim Jagielski }
2339*b1cdbd2cSJim Jagielski }
2340*b1cdbd2cSJim Jagielski ReleaseMouse();
2341*b1cdbd2cSJim Jagielski pFilterBox->MouseButtonDown( MouseEvent( aRelPos, 1, MOUSE_SIMPLECLICK, MOUSE_LEFT ) );
2342*b1cdbd2cSJim Jagielski return;
2343*b1cdbd2cSJim Jagielski }
2344*b1cdbd2cSJim Jagielski }
2345*b1cdbd2cSJim Jagielski
2346*b1cdbd2cSJim Jagielski sal_Bool bFormulaMode = pScMod->IsFormulaMode(); // naechster Klick -> Referenz
2347*b1cdbd2cSJim Jagielski
2348*b1cdbd2cSJim Jagielski if (bEEMouse && pViewData->HasEditView( eWhich ))
2349*b1cdbd2cSJim Jagielski {
2350*b1cdbd2cSJim Jagielski EditView* pEditView;
2351*b1cdbd2cSJim Jagielski SCCOL nEditCol;
2352*b1cdbd2cSJim Jagielski SCROW nEditRow;
2353*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
2354*b1cdbd2cSJim Jagielski pEditView->MouseMove( rMEvt );
2355*b1cdbd2cSJim Jagielski return;
2356*b1cdbd2cSJim Jagielski }
2357*b1cdbd2cSJim Jagielski
2358*b1cdbd2cSJim Jagielski if (bDPMouse)
2359*b1cdbd2cSJim Jagielski {
2360*b1cdbd2cSJim Jagielski DPMouseMove( rMEvt );
2361*b1cdbd2cSJim Jagielski return;
2362*b1cdbd2cSJim Jagielski }
2363*b1cdbd2cSJim Jagielski
2364*b1cdbd2cSJim Jagielski if (bRFMouse)
2365*b1cdbd2cSJim Jagielski {
2366*b1cdbd2cSJim Jagielski RFMouseMove( rMEvt, sal_False );
2367*b1cdbd2cSJim Jagielski return;
2368*b1cdbd2cSJim Jagielski }
2369*b1cdbd2cSJim Jagielski
2370*b1cdbd2cSJim Jagielski if (nPagebreakMouse)
2371*b1cdbd2cSJim Jagielski {
2372*b1cdbd2cSJim Jagielski PagebreakMove( rMEvt, sal_False );
2373*b1cdbd2cSJim Jagielski return;
2374*b1cdbd2cSJim Jagielski }
2375*b1cdbd2cSJim Jagielski
2376*b1cdbd2cSJim Jagielski // anderen Mauszeiger anzeigen?
2377*b1cdbd2cSJim Jagielski
2378*b1cdbd2cSJim Jagielski sal_Bool bEditMode = pViewData->HasEditView(eWhich);
2379*b1cdbd2cSJim Jagielski
2380*b1cdbd2cSJim Jagielski //! Testen ob RefMode-Dragging !!!
2381*b1cdbd2cSJim Jagielski if ( bEditMode && (pViewData->GetRefTabNo() == pViewData->GetTabNo()) )
2382*b1cdbd2cSJim Jagielski {
2383*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
2384*b1cdbd2cSJim Jagielski SCsCOL nPosX;
2385*b1cdbd2cSJim Jagielski SCsROW nPosY;
2386*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
2387*b1cdbd2cSJim Jagielski
2388*b1cdbd2cSJim Jagielski EditView* pEditView;
2389*b1cdbd2cSJim Jagielski SCCOL nEditCol;
2390*b1cdbd2cSJim Jagielski SCROW nEditRow;
2391*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
2392*b1cdbd2cSJim Jagielski SCCOL nEndCol = pViewData->GetEditEndCol();
2393*b1cdbd2cSJim Jagielski SCROW nEndRow = pViewData->GetEditEndRow();
2394*b1cdbd2cSJim Jagielski
2395*b1cdbd2cSJim Jagielski if ( nPosX >= (SCsCOL) nEditCol && nPosX <= (SCsCOL) nEndCol &&
2396*b1cdbd2cSJim Jagielski nPosY >= (SCsROW) nEditRow && nPosY <= (SCsROW) nEndRow )
2397*b1cdbd2cSJim Jagielski {
2398*b1cdbd2cSJim Jagielski // Field can only be URL field
2399*b1cdbd2cSJim Jagielski sal_Bool bAlt = rMEvt.IsMod2();
2400*b1cdbd2cSJim Jagielski if ( !bAlt && !nButtonDown && pEditView && pEditView->GetFieldUnderMousePointer() )
2401*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_REFHAND ) );
2402*b1cdbd2cSJim Jagielski else if ( pEditView && pEditView->GetEditEngine()->IsVertical() )
2403*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_TEXT_VERTICAL ) );
2404*b1cdbd2cSJim Jagielski else
2405*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_TEXT ) );
2406*b1cdbd2cSJim Jagielski return;
2407*b1cdbd2cSJim Jagielski }
2408*b1cdbd2cSJim Jagielski }
2409*b1cdbd2cSJim Jagielski
2410*b1cdbd2cSJim Jagielski sal_Bool bWater = SC_MOD()->GetIsWaterCan() || pViewData->GetView()->HasPaintBrush();
2411*b1cdbd2cSJim Jagielski if (bWater)
2412*b1cdbd2cSJim Jagielski SetPointer( Pointer(POINTER_FILL) );
2413*b1cdbd2cSJim Jagielski
2414*b1cdbd2cSJim Jagielski if (!bWater)
2415*b1cdbd2cSJim Jagielski {
2416*b1cdbd2cSJim Jagielski sal_Bool bCross = sal_False;
2417*b1cdbd2cSJim Jagielski
2418*b1cdbd2cSJim Jagielski // Range-Finder
2419*b1cdbd2cSJim Jagielski
2420*b1cdbd2cSJim Jagielski sal_Bool bCorner;
2421*b1cdbd2cSJim Jagielski if ( HitRangeFinder( rMEvt.GetPosPixel(), bCorner ) )
2422*b1cdbd2cSJim Jagielski {
2423*b1cdbd2cSJim Jagielski if (bCorner)
2424*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_CROSS ) );
2425*b1cdbd2cSJim Jagielski else
2426*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_HAND ) );
2427*b1cdbd2cSJim Jagielski bCross = sal_True;
2428*b1cdbd2cSJim Jagielski }
2429*b1cdbd2cSJim Jagielski
2430*b1cdbd2cSJim Jagielski // Page-Break-Modus
2431*b1cdbd2cSJim Jagielski
2432*b1cdbd2cSJim Jagielski sal_uInt16 nBreakType;
2433*b1cdbd2cSJim Jagielski if ( !nButtonDown && pViewData->IsPagebreakMode() &&
2434*b1cdbd2cSJim Jagielski ( nBreakType = HitPageBreak( rMEvt.GetPosPixel() ) ) != 0 )
2435*b1cdbd2cSJim Jagielski {
2436*b1cdbd2cSJim Jagielski PointerStyle eNew = POINTER_ARROW;
2437*b1cdbd2cSJim Jagielski switch ( nBreakType )
2438*b1cdbd2cSJim Jagielski {
2439*b1cdbd2cSJim Jagielski case SC_PD_RANGE_L:
2440*b1cdbd2cSJim Jagielski case SC_PD_RANGE_R:
2441*b1cdbd2cSJim Jagielski case SC_PD_BREAK_H:
2442*b1cdbd2cSJim Jagielski eNew = POINTER_ESIZE;
2443*b1cdbd2cSJim Jagielski break;
2444*b1cdbd2cSJim Jagielski case SC_PD_RANGE_T:
2445*b1cdbd2cSJim Jagielski case SC_PD_RANGE_B:
2446*b1cdbd2cSJim Jagielski case SC_PD_BREAK_V:
2447*b1cdbd2cSJim Jagielski eNew = POINTER_SSIZE;
2448*b1cdbd2cSJim Jagielski break;
2449*b1cdbd2cSJim Jagielski case SC_PD_RANGE_TL:
2450*b1cdbd2cSJim Jagielski case SC_PD_RANGE_BR:
2451*b1cdbd2cSJim Jagielski eNew = POINTER_SESIZE;
2452*b1cdbd2cSJim Jagielski break;
2453*b1cdbd2cSJim Jagielski case SC_PD_RANGE_TR:
2454*b1cdbd2cSJim Jagielski case SC_PD_RANGE_BL:
2455*b1cdbd2cSJim Jagielski eNew = POINTER_NESIZE;
2456*b1cdbd2cSJim Jagielski break;
2457*b1cdbd2cSJim Jagielski }
2458*b1cdbd2cSJim Jagielski SetPointer( Pointer( eNew ) );
2459*b1cdbd2cSJim Jagielski bCross = sal_True;
2460*b1cdbd2cSJim Jagielski }
2461*b1cdbd2cSJim Jagielski
2462*b1cdbd2cSJim Jagielski // Fill-Cursor anzeigen ?
2463*b1cdbd2cSJim Jagielski
2464*b1cdbd2cSJim Jagielski if ( !bFormulaMode && !nButtonDown )
2465*b1cdbd2cSJim Jagielski if (TestMouse( rMEvt, sal_False ))
2466*b1cdbd2cSJim Jagielski bCross = sal_True;
2467*b1cdbd2cSJim Jagielski
2468*b1cdbd2cSJim Jagielski if ( nButtonDown && pViewData->IsAnyFillMode() )
2469*b1cdbd2cSJim Jagielski {
2470*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_CROSS ) );
2471*b1cdbd2cSJim Jagielski bCross = sal_True;
2472*b1cdbd2cSJim Jagielski nScFillModeMouseModifier = rMEvt.GetModifier(); // ausgewertet bei AutoFill und Matrix
2473*b1cdbd2cSJim Jagielski }
2474*b1cdbd2cSJim Jagielski
2475*b1cdbd2cSJim Jagielski if (!bCross)
2476*b1cdbd2cSJim Jagielski {
2477*b1cdbd2cSJim Jagielski sal_Bool bAlt = rMEvt.IsMod2();
2478*b1cdbd2cSJim Jagielski
2479*b1cdbd2cSJim Jagielski if (bEditMode) // Edit-Mode muss zuerst kommen!
2480*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_ARROW ) );
2481*b1cdbd2cSJim Jagielski else if ( !bAlt && !nButtonDown &&
2482*b1cdbd2cSJim Jagielski GetEditUrl(rMEvt.GetPosPixel()) )
2483*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_REFHAND ) );
2484*b1cdbd2cSJim Jagielski else if ( DrawMouseMove(rMEvt) ) // setzt Pointer um
2485*b1cdbd2cSJim Jagielski return;
2486*b1cdbd2cSJim Jagielski }
2487*b1cdbd2cSJim Jagielski }
2488*b1cdbd2cSJim Jagielski
2489*b1cdbd2cSJim Jagielski if ( pViewData->GetView()->GetSelEngine()->SelMouseMove( rMEvt ) )
2490*b1cdbd2cSJim Jagielski return;
2491*b1cdbd2cSJim Jagielski }
2492*b1cdbd2cSJim Jagielski
lcl_InitMouseEvent(::com::sun::star::awt::MouseEvent & rEvent,const MouseEvent & rEvt)2493*b1cdbd2cSJim Jagielski void lcl_InitMouseEvent( ::com::sun::star::awt::MouseEvent& rEvent, const MouseEvent& rEvt )
2494*b1cdbd2cSJim Jagielski {
2495*b1cdbd2cSJim Jagielski rEvent.Modifiers = 0;
2496*b1cdbd2cSJim Jagielski if ( rEvt.IsShift() )
2497*b1cdbd2cSJim Jagielski rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::SHIFT;
2498*b1cdbd2cSJim Jagielski if ( rEvt.IsMod1() )
2499*b1cdbd2cSJim Jagielski rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD1;
2500*b1cdbd2cSJim Jagielski if ( rEvt.IsMod2() )
2501*b1cdbd2cSJim Jagielski rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD2;
2502*b1cdbd2cSJim Jagielski if ( rEvt.IsMod3() )
2503*b1cdbd2cSJim Jagielski rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD3;
2504*b1cdbd2cSJim Jagielski
2505*b1cdbd2cSJim Jagielski rEvent.Buttons = 0;
2506*b1cdbd2cSJim Jagielski if ( rEvt.IsLeft() )
2507*b1cdbd2cSJim Jagielski rEvent.Buttons |= ::com::sun::star::awt::MouseButton::LEFT;
2508*b1cdbd2cSJim Jagielski if ( rEvt.IsRight() )
2509*b1cdbd2cSJim Jagielski rEvent.Buttons |= ::com::sun::star::awt::MouseButton::RIGHT;
2510*b1cdbd2cSJim Jagielski if ( rEvt.IsMiddle() )
2511*b1cdbd2cSJim Jagielski rEvent.Buttons |= ::com::sun::star::awt::MouseButton::MIDDLE;
2512*b1cdbd2cSJim Jagielski
2513*b1cdbd2cSJim Jagielski rEvent.X = rEvt.GetPosPixel().X();
2514*b1cdbd2cSJim Jagielski rEvent.Y = rEvt.GetPosPixel().Y();
2515*b1cdbd2cSJim Jagielski rEvent.ClickCount = rEvt.GetClicks();
2516*b1cdbd2cSJim Jagielski rEvent.PopupTrigger = sal_False;
2517*b1cdbd2cSJim Jagielski }
2518*b1cdbd2cSJim Jagielski
PreNotify(NotifyEvent & rNEvt)2519*b1cdbd2cSJim Jagielski long ScGridWindow::PreNotify( NotifyEvent& rNEvt )
2520*b1cdbd2cSJim Jagielski {
2521*b1cdbd2cSJim Jagielski bool bDone = false;
2522*b1cdbd2cSJim Jagielski sal_uInt16 nType = rNEvt.GetType();
2523*b1cdbd2cSJim Jagielski if ( nType == EVENT_MOUSEBUTTONUP || nType == EVENT_MOUSEBUTTONDOWN )
2524*b1cdbd2cSJim Jagielski {
2525*b1cdbd2cSJim Jagielski Window* pWindow = rNEvt.GetWindow();
2526*b1cdbd2cSJim Jagielski if (pWindow == this && pViewData)
2527*b1cdbd2cSJim Jagielski {
2528*b1cdbd2cSJim Jagielski SfxViewFrame* pViewFrame = pViewData->GetViewShell()->GetViewFrame();
2529*b1cdbd2cSJim Jagielski if (pViewFrame)
2530*b1cdbd2cSJim Jagielski {
2531*b1cdbd2cSJim Jagielski com::sun::star::uno::Reference<com::sun::star::frame::XController> xController = pViewFrame->GetFrame().GetController();
2532*b1cdbd2cSJim Jagielski if (xController.is())
2533*b1cdbd2cSJim Jagielski {
2534*b1cdbd2cSJim Jagielski ScTabViewObj* pImp = ScTabViewObj::getImplementation( xController );
2535*b1cdbd2cSJim Jagielski if (pImp && pImp->IsMouseListening())
2536*b1cdbd2cSJim Jagielski {
2537*b1cdbd2cSJim Jagielski ::com::sun::star::awt::MouseEvent aEvent;
2538*b1cdbd2cSJim Jagielski lcl_InitMouseEvent( aEvent, *rNEvt.GetMouseEvent() );
2539*b1cdbd2cSJim Jagielski if ( rNEvt.GetWindow() )
2540*b1cdbd2cSJim Jagielski aEvent.Source = rNEvt.GetWindow()->GetComponentInterface();
2541*b1cdbd2cSJim Jagielski if ( nType == EVENT_MOUSEBUTTONDOWN)
2542*b1cdbd2cSJim Jagielski bDone = pImp->MousePressed( aEvent );
2543*b1cdbd2cSJim Jagielski else
2544*b1cdbd2cSJim Jagielski bDone = pImp->MouseReleased( aEvent );
2545*b1cdbd2cSJim Jagielski }
2546*b1cdbd2cSJim Jagielski }
2547*b1cdbd2cSJim Jagielski }
2548*b1cdbd2cSJim Jagielski }
2549*b1cdbd2cSJim Jagielski }
2550*b1cdbd2cSJim Jagielski if (bDone) // event consumed by a listener
2551*b1cdbd2cSJim Jagielski {
2552*b1cdbd2cSJim Jagielski if ( nType == EVENT_MOUSEBUTTONDOWN )
2553*b1cdbd2cSJim Jagielski {
2554*b1cdbd2cSJim Jagielski const MouseEvent* pMouseEvent = rNEvt.GetMouseEvent();
2555*b1cdbd2cSJim Jagielski if ( pMouseEvent->IsRight() && pMouseEvent->GetClicks() == 1 )
2556*b1cdbd2cSJim Jagielski {
2557*b1cdbd2cSJim Jagielski // If a listener returned true for a right-click call, also prevent opening the context menu
2558*b1cdbd2cSJim Jagielski // (this works only if the context menu is opened on mouse-down)
2559*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_IGNORE;
2560*b1cdbd2cSJim Jagielski }
2561*b1cdbd2cSJim Jagielski }
2562*b1cdbd2cSJim Jagielski
2563*b1cdbd2cSJim Jagielski return 1;
2564*b1cdbd2cSJim Jagielski }
2565*b1cdbd2cSJim Jagielski else
2566*b1cdbd2cSJim Jagielski return Window::PreNotify( rNEvt );
2567*b1cdbd2cSJim Jagielski }
2568*b1cdbd2cSJim Jagielski
Tracking(const TrackingEvent & rTEvt)2569*b1cdbd2cSJim Jagielski void ScGridWindow::Tracking( const TrackingEvent& rTEvt )
2570*b1cdbd2cSJim Jagielski {
2571*b1cdbd2cSJim Jagielski // Weil die SelectionEngine kein Tracking kennt, die Events nur auf
2572*b1cdbd2cSJim Jagielski // die verschiedenen MouseHandler verteilen...
2573*b1cdbd2cSJim Jagielski
2574*b1cdbd2cSJim Jagielski const MouseEvent& rMEvt = rTEvt.GetMouseEvent();
2575*b1cdbd2cSJim Jagielski
2576*b1cdbd2cSJim Jagielski if ( rTEvt.IsTrackingCanceled() ) // alles abbrechen...
2577*b1cdbd2cSJim Jagielski {
2578*b1cdbd2cSJim Jagielski if (!pViewData->GetView()->IsInActivatePart())
2579*b1cdbd2cSJim Jagielski {
2580*b1cdbd2cSJim Jagielski if (bDPMouse)
2581*b1cdbd2cSJim Jagielski bDPMouse = sal_False; // gezeichnet wird per bDragRect
2582*b1cdbd2cSJim Jagielski if (bDragRect)
2583*b1cdbd2cSJim Jagielski {
2584*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
2585*b1cdbd2cSJim Jagielski bDragRect = sal_False;
2586*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
2587*b1cdbd2cSJim Jagielski }
2588*b1cdbd2cSJim Jagielski if (bRFMouse)
2589*b1cdbd2cSJim Jagielski {
2590*b1cdbd2cSJim Jagielski RFMouseMove( rMEvt, sal_True ); // richtig abbrechen geht dabei nicht...
2591*b1cdbd2cSJim Jagielski bRFMouse = sal_False;
2592*b1cdbd2cSJim Jagielski }
2593*b1cdbd2cSJim Jagielski if (nPagebreakMouse)
2594*b1cdbd2cSJim Jagielski {
2595*b1cdbd2cSJim Jagielski // if (bPagebreakDrawn)
2596*b1cdbd2cSJim Jagielski // DrawDragRect( aPagebreakDrag.aStart.Col(), aPagebreakDrag.aStart.Row(),
2597*b1cdbd2cSJim Jagielski // aPagebreakDrag.aEnd.Col(), aPagebreakDrag.aEnd.Row(), sal_False );
2598*b1cdbd2cSJim Jagielski bPagebreakDrawn = sal_False;
2599*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
2600*b1cdbd2cSJim Jagielski nPagebreakMouse = SC_PD_NONE;
2601*b1cdbd2cSJim Jagielski }
2602*b1cdbd2cSJim Jagielski
2603*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_ARROW ) );
2604*b1cdbd2cSJim Jagielski StopMarking();
2605*b1cdbd2cSJim Jagielski MouseButtonUp( rMEvt ); // mit Status SC_GM_IGNORE aus StopMarking
2606*b1cdbd2cSJim Jagielski
2607*b1cdbd2cSJim Jagielski sal_Bool bRefMode = pViewData->IsRefMode();
2608*b1cdbd2cSJim Jagielski if (bRefMode)
2609*b1cdbd2cSJim Jagielski SC_MOD()->EndReference(); // #63148# Dialog nicht verkleinert lassen
2610*b1cdbd2cSJim Jagielski }
2611*b1cdbd2cSJim Jagielski }
2612*b1cdbd2cSJim Jagielski else if ( rTEvt.IsTrackingEnded() )
2613*b1cdbd2cSJim Jagielski {
2614*b1cdbd2cSJim Jagielski // MouseButtonUp immer mit passenden Buttons (z.B. wegen Testtool, #63148#)
2615*b1cdbd2cSJim Jagielski // Schliesslich behauptet der Tracking-Event ja, dass normal beendet und nicht
2616*b1cdbd2cSJim Jagielski // abgebrochen wurde.
2617*b1cdbd2cSJim Jagielski
2618*b1cdbd2cSJim Jagielski MouseEvent aUpEvt( rMEvt.GetPosPixel(), rMEvt.GetClicks(),
2619*b1cdbd2cSJim Jagielski rMEvt.GetMode(), nButtonDown, rMEvt.GetModifier() );
2620*b1cdbd2cSJim Jagielski MouseButtonUp( aUpEvt );
2621*b1cdbd2cSJim Jagielski }
2622*b1cdbd2cSJim Jagielski else
2623*b1cdbd2cSJim Jagielski MouseMove( rMEvt );
2624*b1cdbd2cSJim Jagielski }
2625*b1cdbd2cSJim Jagielski
StartDrag(sal_Int8,const Point & rPosPixel)2626*b1cdbd2cSJim Jagielski void ScGridWindow::StartDrag( sal_Int8 /* nAction */, const Point& rPosPixel )
2627*b1cdbd2cSJim Jagielski {
2628*b1cdbd2cSJim Jagielski if ( pFilterBox || nPagebreakMouse )
2629*b1cdbd2cSJim Jagielski return;
2630*b1cdbd2cSJim Jagielski
2631*b1cdbd2cSJim Jagielski HideNoteMarker();
2632*b1cdbd2cSJim Jagielski
2633*b1cdbd2cSJim Jagielski CommandEvent aDragEvent( rPosPixel, COMMAND_STARTDRAG, sal_True );
2634*b1cdbd2cSJim Jagielski
2635*b1cdbd2cSJim Jagielski if (bEEMouse && pViewData->HasEditView( eWhich ))
2636*b1cdbd2cSJim Jagielski {
2637*b1cdbd2cSJim Jagielski EditView* pEditView;
2638*b1cdbd2cSJim Jagielski SCCOL nEditCol;
2639*b1cdbd2cSJim Jagielski SCROW nEditRow;
2640*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
2641*b1cdbd2cSJim Jagielski
2642*b1cdbd2cSJim Jagielski // #63263# don't remove the edit view while switching views
2643*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
2644*b1cdbd2cSJim Jagielski pScMod->SetInEditCommand( sal_True );
2645*b1cdbd2cSJim Jagielski
2646*b1cdbd2cSJim Jagielski pEditView->Command( aDragEvent );
2647*b1cdbd2cSJim Jagielski
2648*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = pScMod->GetInputHdl();
2649*b1cdbd2cSJim Jagielski if (pHdl)
2650*b1cdbd2cSJim Jagielski pHdl->DataChanged();
2651*b1cdbd2cSJim Jagielski
2652*b1cdbd2cSJim Jagielski pScMod->SetInEditCommand( sal_False );
2653*b1cdbd2cSJim Jagielski if (!pViewData->IsActive()) // dropped to different view?
2654*b1cdbd2cSJim Jagielski {
2655*b1cdbd2cSJim Jagielski ScInputHandler* pViewHdl = pScMod->GetInputHdl( pViewData->GetViewShell() );
2656*b1cdbd2cSJim Jagielski if ( pViewHdl && pViewData->HasEditView( eWhich ) )
2657*b1cdbd2cSJim Jagielski {
2658*b1cdbd2cSJim Jagielski pViewHdl->CancelHandler();
2659*b1cdbd2cSJim Jagielski ShowCursor(); // missing from KillEditView
2660*b1cdbd2cSJim Jagielski }
2661*b1cdbd2cSJim Jagielski }
2662*b1cdbd2cSJim Jagielski }
2663*b1cdbd2cSJim Jagielski else
2664*b1cdbd2cSJim Jagielski if ( !DrawCommand(aDragEvent) )
2665*b1cdbd2cSJim Jagielski pViewData->GetView()->GetSelEngine()->Command( aDragEvent );
2666*b1cdbd2cSJim Jagielski }
2667*b1cdbd2cSJim Jagielski
lcl_SetTextCursorPos(ScViewData * pViewData,ScSplitPos eWhich,Window * pWin)2668*b1cdbd2cSJim Jagielski void lcl_SetTextCursorPos( ScViewData* pViewData, ScSplitPos eWhich, Window* pWin )
2669*b1cdbd2cSJim Jagielski {
2670*b1cdbd2cSJim Jagielski SCCOL nCol = pViewData->GetCurX();
2671*b1cdbd2cSJim Jagielski SCROW nRow = pViewData->GetCurY();
2672*b1cdbd2cSJim Jagielski Rectangle aEditArea = pViewData->GetEditArea( eWhich, nCol, nRow, pWin, NULL, sal_True );
2673*b1cdbd2cSJim Jagielski aEditArea.Right() = aEditArea.Left();
2674*b1cdbd2cSJim Jagielski aEditArea = pWin->PixelToLogic( aEditArea );
2675*b1cdbd2cSJim Jagielski pWin->SetCursorRect( &aEditArea );
2676*b1cdbd2cSJim Jagielski }
2677*b1cdbd2cSJim Jagielski
Command(const CommandEvent & rCEvt)2678*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::Command( const CommandEvent& rCEvt )
2679*b1cdbd2cSJim Jagielski {
2680*b1cdbd2cSJim Jagielski // The command event is send to the window after a possible context
2681*b1cdbd2cSJim Jagielski // menu from an inplace client is closed. Now we have the chance to
2682*b1cdbd2cSJim Jagielski // deactivate the inplace client without any problem regarding parent
2683*b1cdbd2cSJim Jagielski // windows and code on the stack.
2684*b1cdbd2cSJim Jagielski // For more information, see #126086# and #128122#
2685*b1cdbd2cSJim Jagielski sal_uInt16 nCmd = rCEvt.GetCommand();
2686*b1cdbd2cSJim Jagielski ScTabViewShell* pTabViewSh = pViewData->GetViewShell();
2687*b1cdbd2cSJim Jagielski SfxInPlaceClient* pClient = pTabViewSh->GetIPClient();
2688*b1cdbd2cSJim Jagielski if ( pClient &&
2689*b1cdbd2cSJim Jagielski pClient->IsObjectInPlaceActive() &&
2690*b1cdbd2cSJim Jagielski nCmd == COMMAND_CONTEXTMENU )
2691*b1cdbd2cSJim Jagielski {
2692*b1cdbd2cSJim Jagielski pTabViewSh->DeactivateOle();
2693*b1cdbd2cSJim Jagielski return;
2694*b1cdbd2cSJim Jagielski }
2695*b1cdbd2cSJim Jagielski
2696*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
2697*b1cdbd2cSJim Jagielski DBG_ASSERT( nCmd != COMMAND_STARTDRAG, "ScGridWindow::Command called with COMMAND_STARTDRAG" );
2698*b1cdbd2cSJim Jagielski
2699*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_STARTEXTTEXTINPUT ||
2700*b1cdbd2cSJim Jagielski nCmd == COMMAND_ENDEXTTEXTINPUT ||
2701*b1cdbd2cSJim Jagielski nCmd == COMMAND_EXTTEXTINPUT ||
2702*b1cdbd2cSJim Jagielski nCmd == COMMAND_CURSORPOS )
2703*b1cdbd2cSJim Jagielski {
2704*b1cdbd2cSJim Jagielski sal_Bool bEditView = pViewData->HasEditView( eWhich );
2705*b1cdbd2cSJim Jagielski if (!bEditView)
2706*b1cdbd2cSJim Jagielski {
2707*b1cdbd2cSJim Jagielski // only if no cell editview is active, look at drawview
2708*b1cdbd2cSJim Jagielski SdrView* pSdrView = pViewData->GetView()->GetSdrView();
2709*b1cdbd2cSJim Jagielski if ( pSdrView )
2710*b1cdbd2cSJim Jagielski {
2711*b1cdbd2cSJim Jagielski OutlinerView* pOlView = pSdrView->GetTextEditOutlinerView();
2712*b1cdbd2cSJim Jagielski if ( pOlView && pOlView->GetWindow() == this )
2713*b1cdbd2cSJim Jagielski {
2714*b1cdbd2cSJim Jagielski pOlView->Command( rCEvt );
2715*b1cdbd2cSJim Jagielski return; // done
2716*b1cdbd2cSJim Jagielski }
2717*b1cdbd2cSJim Jagielski }
2718*b1cdbd2cSJim Jagielski }
2719*b1cdbd2cSJim Jagielski
2720*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_CURSORPOS && !bEditView )
2721*b1cdbd2cSJim Jagielski {
2722*b1cdbd2cSJim Jagielski // #88458# CURSORPOS may be called without following text input,
2723*b1cdbd2cSJim Jagielski // to set the input method window position
2724*b1cdbd2cSJim Jagielski // -> input mode must not be started,
2725*b1cdbd2cSJim Jagielski // manually calculate text insert position if not in input mode
2726*b1cdbd2cSJim Jagielski
2727*b1cdbd2cSJim Jagielski lcl_SetTextCursorPos( pViewData, eWhich, this );
2728*b1cdbd2cSJim Jagielski return;
2729*b1cdbd2cSJim Jagielski }
2730*b1cdbd2cSJim Jagielski
2731*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = pScMod->GetInputHdl( pViewData->GetViewShell() );
2732*b1cdbd2cSJim Jagielski if ( pHdl )
2733*b1cdbd2cSJim Jagielski {
2734*b1cdbd2cSJim Jagielski pHdl->InputCommand( rCEvt, sal_True );
2735*b1cdbd2cSJim Jagielski return; // done
2736*b1cdbd2cSJim Jagielski }
2737*b1cdbd2cSJim Jagielski
2738*b1cdbd2cSJim Jagielski Window::Command( rCEvt );
2739*b1cdbd2cSJim Jagielski return;
2740*b1cdbd2cSJim Jagielski }
2741*b1cdbd2cSJim Jagielski
2742*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_VOICE )
2743*b1cdbd2cSJim Jagielski {
2744*b1cdbd2cSJim Jagielski // Der Handler wird nur gerufen, wenn ein Text-Cursor aktiv ist,
2745*b1cdbd2cSJim Jagielski // also muss es eine EditView oder ein editiertes Zeichenobjekt geben
2746*b1cdbd2cSJim Jagielski
2747*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = pScMod->GetInputHdl( pViewData->GetViewShell() );
2748*b1cdbd2cSJim Jagielski if ( pHdl && pViewData->HasEditView( eWhich ) )
2749*b1cdbd2cSJim Jagielski {
2750*b1cdbd2cSJim Jagielski EditView* pEditView = pViewData->GetEditView( eWhich ); // ist dann nicht 0
2751*b1cdbd2cSJim Jagielski pHdl->DataChanging();
2752*b1cdbd2cSJim Jagielski pEditView->Command( rCEvt );
2753*b1cdbd2cSJim Jagielski pHdl->DataChanged();
2754*b1cdbd2cSJim Jagielski return; // erledigt
2755*b1cdbd2cSJim Jagielski }
2756*b1cdbd2cSJim Jagielski SdrView* pSdrView = pViewData->GetView()->GetSdrView();
2757*b1cdbd2cSJim Jagielski if ( pSdrView )
2758*b1cdbd2cSJim Jagielski {
2759*b1cdbd2cSJim Jagielski OutlinerView* pOlView = pSdrView->GetTextEditOutlinerView();
2760*b1cdbd2cSJim Jagielski if ( pOlView && pOlView->GetWindow() == this )
2761*b1cdbd2cSJim Jagielski {
2762*b1cdbd2cSJim Jagielski pOlView->Command( rCEvt );
2763*b1cdbd2cSJim Jagielski return; // erledigt
2764*b1cdbd2cSJim Jagielski }
2765*b1cdbd2cSJim Jagielski }
2766*b1cdbd2cSJim Jagielski Window::Command(rCEvt); // sonst soll sich die Basisklasse drum kuemmern...
2767*b1cdbd2cSJim Jagielski return;
2768*b1cdbd2cSJim Jagielski }
2769*b1cdbd2cSJim Jagielski
2770*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_PASTESELECTION )
2771*b1cdbd2cSJim Jagielski {
2772*b1cdbd2cSJim Jagielski if ( bEEMouse )
2773*b1cdbd2cSJim Jagielski {
2774*b1cdbd2cSJim Jagielski // EditEngine handles selection in MouseButtonUp - no action
2775*b1cdbd2cSJim Jagielski // needed in command handler
2776*b1cdbd2cSJim Jagielski }
2777*b1cdbd2cSJim Jagielski else
2778*b1cdbd2cSJim Jagielski {
2779*b1cdbd2cSJim Jagielski PasteSelection( rCEvt.GetMousePosPixel() );
2780*b1cdbd2cSJim Jagielski }
2781*b1cdbd2cSJim Jagielski return;
2782*b1cdbd2cSJim Jagielski }
2783*b1cdbd2cSJim Jagielski
2784*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_INPUTLANGUAGECHANGE )
2785*b1cdbd2cSJim Jagielski {
2786*b1cdbd2cSJim Jagielski // #i55929# Font and font size state depends on input language if nothing is selected,
2787*b1cdbd2cSJim Jagielski // so the slots have to be invalidated when the input language is changed.
2788*b1cdbd2cSJim Jagielski
2789*b1cdbd2cSJim Jagielski SfxBindings& rBindings = pViewData->GetBindings();
2790*b1cdbd2cSJim Jagielski rBindings.Invalidate( SID_ATTR_CHAR_FONT );
2791*b1cdbd2cSJim Jagielski rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
2792*b1cdbd2cSJim Jagielski return;
2793*b1cdbd2cSJim Jagielski }
2794*b1cdbd2cSJim Jagielski
2795*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_WHEEL || nCmd == COMMAND_STARTAUTOSCROLL || nCmd == COMMAND_AUTOSCROLL )
2796*b1cdbd2cSJim Jagielski {
2797*b1cdbd2cSJim Jagielski sal_Bool bDone = pViewData->GetView()->ScrollCommand( rCEvt, eWhich );
2798*b1cdbd2cSJim Jagielski if (!bDone)
2799*b1cdbd2cSJim Jagielski Window::Command(rCEvt);
2800*b1cdbd2cSJim Jagielski return;
2801*b1cdbd2cSJim Jagielski }
2802*b1cdbd2cSJim Jagielski // #i7560# FormulaMode check is below scrolling - scrolling is allowed during formula input
2803*b1cdbd2cSJim Jagielski sal_Bool bDisable = pScMod->IsFormulaMode() ||
2804*b1cdbd2cSJim Jagielski pScMod->IsModalMode(pViewData->GetSfxDocShell());
2805*b1cdbd2cSJim Jagielski if (bDisable)
2806*b1cdbd2cSJim Jagielski return;
2807*b1cdbd2cSJim Jagielski
2808*b1cdbd2cSJim Jagielski if ( nCmd == COMMAND_CONTEXTMENU && !SC_MOD()->GetIsWaterCan() )
2809*b1cdbd2cSJim Jagielski {
2810*b1cdbd2cSJim Jagielski sal_Bool bMouse = rCEvt.IsMouseEvent();
2811*b1cdbd2cSJim Jagielski if ( bMouse && nMouseStatus == SC_GM_IGNORE )
2812*b1cdbd2cSJim Jagielski return;
2813*b1cdbd2cSJim Jagielski
2814*b1cdbd2cSJim Jagielski if (pViewData->IsAnyFillMode())
2815*b1cdbd2cSJim Jagielski {
2816*b1cdbd2cSJim Jagielski pViewData->GetView()->StopRefMode();
2817*b1cdbd2cSJim Jagielski pViewData->ResetFillMode();
2818*b1cdbd2cSJim Jagielski }
2819*b1cdbd2cSJim Jagielski ReleaseMouse();
2820*b1cdbd2cSJim Jagielski StopMarking();
2821*b1cdbd2cSJim Jagielski
2822*b1cdbd2cSJim Jagielski Point aPosPixel = rCEvt.GetMousePosPixel();
2823*b1cdbd2cSJim Jagielski Point aMenuPos = aPosPixel;
2824*b1cdbd2cSJim Jagielski
2825*b1cdbd2cSJim Jagielski if ( bMouse )
2826*b1cdbd2cSJim Jagielski {
2827*b1cdbd2cSJim Jagielski SCsCOL nCellX = -1;
2828*b1cdbd2cSJim Jagielski SCsROW nCellY = -1;
2829*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel(aPosPixel.X(), aPosPixel.Y(), eWhich, nCellX, nCellY);
2830*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
2831*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
2832*b1cdbd2cSJim Jagielski const ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
2833*b1cdbd2cSJim Jagielski bool bSelectAllowed = true;
2834*b1cdbd2cSJim Jagielski if ( pProtect && pProtect->isProtected() )
2835*b1cdbd2cSJim Jagielski {
2836*b1cdbd2cSJim Jagielski // This sheet is protected. Check if a context menu is allowed on this cell.
2837*b1cdbd2cSJim Jagielski bool bCellProtected = pDoc->HasAttrib(nCellX, nCellY, nTab, nCellX, nCellY, nTab, HASATTR_PROTECTED);
2838*b1cdbd2cSJim Jagielski bool bSelProtected = pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
2839*b1cdbd2cSJim Jagielski bool bSelUnprotected = pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
2840*b1cdbd2cSJim Jagielski
2841*b1cdbd2cSJim Jagielski if (bCellProtected)
2842*b1cdbd2cSJim Jagielski bSelectAllowed = bSelProtected;
2843*b1cdbd2cSJim Jagielski else
2844*b1cdbd2cSJim Jagielski bSelectAllowed = bSelUnprotected;
2845*b1cdbd2cSJim Jagielski }
2846*b1cdbd2cSJim Jagielski if (!bSelectAllowed)
2847*b1cdbd2cSJim Jagielski // Selecting this cell is not allowed, neither is context menu.
2848*b1cdbd2cSJim Jagielski return;
2849*b1cdbd2cSJim Jagielski
2850*b1cdbd2cSJim Jagielski // #i18735# First select the item under the mouse pointer.
2851*b1cdbd2cSJim Jagielski // This can change the selection, and the view state (edit mode, etc).
2852*b1cdbd2cSJim Jagielski SelectForContextMenu( aPosPixel, nCellX, nCellY );
2853*b1cdbd2cSJim Jagielski }
2854*b1cdbd2cSJim Jagielski
2855*b1cdbd2cSJim Jagielski sal_Bool bDone = sal_False;
2856*b1cdbd2cSJim Jagielski sal_Bool bEdit = pViewData->HasEditView(eWhich);
2857*b1cdbd2cSJim Jagielski if ( !bEdit )
2858*b1cdbd2cSJim Jagielski {
2859*b1cdbd2cSJim Jagielski // Edit-Zelle mit Spelling-Errors ?
2860*b1cdbd2cSJim Jagielski if ( bMouse && GetEditUrlOrError( sal_True, aPosPixel ) )
2861*b1cdbd2cSJim Jagielski {
2862*b1cdbd2cSJim Jagielski // GetEditUrlOrError hat den Cursor schon bewegt
2863*b1cdbd2cSJim Jagielski
2864*b1cdbd2cSJim Jagielski pScMod->SetInputMode( SC_INPUT_TABLE );
2865*b1cdbd2cSJim Jagielski bEdit = pViewData->HasEditView(eWhich); // hat's geklappt ?
2866*b1cdbd2cSJim Jagielski
2867*b1cdbd2cSJim Jagielski DBG_ASSERT( bEdit, "kann nicht in Edit-Modus schalten" );
2868*b1cdbd2cSJim Jagielski }
2869*b1cdbd2cSJim Jagielski }
2870*b1cdbd2cSJim Jagielski if ( bEdit )
2871*b1cdbd2cSJim Jagielski {
2872*b1cdbd2cSJim Jagielski EditView* pEditView = pViewData->GetEditView( eWhich ); // ist dann nicht 0
2873*b1cdbd2cSJim Jagielski
2874*b1cdbd2cSJim Jagielski if ( !bMouse )
2875*b1cdbd2cSJim Jagielski {
2876*b1cdbd2cSJim Jagielski Cursor* pCur = pEditView->GetCursor();
2877*b1cdbd2cSJim Jagielski if ( pCur )
2878*b1cdbd2cSJim Jagielski {
2879*b1cdbd2cSJim Jagielski Point aLogicPos = pCur->GetPos();
2880*b1cdbd2cSJim Jagielski // use the position right of the cursor (spell popup is opened if
2881*b1cdbd2cSJim Jagielski // the cursor is before the word, but not if behind it)
2882*b1cdbd2cSJim Jagielski aLogicPos.X() += pCur->GetWidth();
2883*b1cdbd2cSJim Jagielski aLogicPos.Y() += pCur->GetHeight() / 2; // center vertically
2884*b1cdbd2cSJim Jagielski aMenuPos = LogicToPixel( aLogicPos );
2885*b1cdbd2cSJim Jagielski }
2886*b1cdbd2cSJim Jagielski }
2887*b1cdbd2cSJim Jagielski
2888*b1cdbd2cSJim Jagielski // if edit mode was just started above, online spelling may be incomplete
2889*b1cdbd2cSJim Jagielski pEditView->GetEditEngine()->CompleteOnlineSpelling();
2890*b1cdbd2cSJim Jagielski
2891*b1cdbd2cSJim Jagielski // IsCursorAtWrongSpelledWord could be used for !bMouse
2892*b1cdbd2cSJim Jagielski // if there was a corresponding ExecuteSpellPopup call
2893*b1cdbd2cSJim Jagielski
2894*b1cdbd2cSJim Jagielski if( pEditView->IsWrongSpelledWordAtPos( aMenuPos ) )
2895*b1cdbd2cSJim Jagielski {
2896*b1cdbd2cSJim Jagielski // Wenn man unter OS/2 neben das Popupmenue klickt, kommt MouseButtonDown
2897*b1cdbd2cSJim Jagielski // vor dem Ende des Menue-Execute, darum muss SetModified vorher kommen
2898*b1cdbd2cSJim Jagielski // (Bug #40968#)
2899*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = pScMod->GetInputHdl();
2900*b1cdbd2cSJim Jagielski if (pHdl)
2901*b1cdbd2cSJim Jagielski pHdl->SetModified();
2902*b1cdbd2cSJim Jagielski
2903*b1cdbd2cSJim Jagielski Link aLink = LINK( this, ScGridWindow, PopupSpellingHdl );
2904*b1cdbd2cSJim Jagielski pEditView->ExecuteSpellPopup( aMenuPos, &aLink );
2905*b1cdbd2cSJim Jagielski
2906*b1cdbd2cSJim Jagielski bDone = sal_True;
2907*b1cdbd2cSJim Jagielski }
2908*b1cdbd2cSJim Jagielski }
2909*b1cdbd2cSJim Jagielski else if ( !bMouse )
2910*b1cdbd2cSJim Jagielski {
2911*b1cdbd2cSJim Jagielski // non-edit menu by keyboard -> use lower right of cell cursor position
2912*b1cdbd2cSJim Jagielski
2913*b1cdbd2cSJim Jagielski SCCOL nCurX = pViewData->GetCurX();
2914*b1cdbd2cSJim Jagielski SCROW nCurY = pViewData->GetCurY();
2915*b1cdbd2cSJim Jagielski aMenuPos = pViewData->GetScrPos( nCurX, nCurY, eWhich, sal_True );
2916*b1cdbd2cSJim Jagielski long nSizeXPix;
2917*b1cdbd2cSJim Jagielski long nSizeYPix;
2918*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nCurX, nCurY, nSizeXPix, nSizeYPix );
2919*b1cdbd2cSJim Jagielski aMenuPos.X() += nSizeXPix;
2920*b1cdbd2cSJim Jagielski aMenuPos.Y() += nSizeYPix;
2921*b1cdbd2cSJim Jagielski
2922*b1cdbd2cSJim Jagielski if (pViewData)
2923*b1cdbd2cSJim Jagielski {
2924*b1cdbd2cSJim Jagielski ScTabViewShell* pViewSh = pViewData->GetViewShell();
2925*b1cdbd2cSJim Jagielski if (pViewSh)
2926*b1cdbd2cSJim Jagielski {
2927*b1cdbd2cSJim Jagielski // Is a draw object selected?
2928*b1cdbd2cSJim Jagielski
2929*b1cdbd2cSJim Jagielski SdrView* pDrawView = pViewSh->GetSdrView();
2930*b1cdbd2cSJim Jagielski if (pDrawView && pDrawView->AreObjectsMarked())
2931*b1cdbd2cSJim Jagielski {
2932*b1cdbd2cSJim Jagielski // #100442#; the conext menu should open in the middle of the selected objects
2933*b1cdbd2cSJim Jagielski Rectangle aSelectRect(LogicToPixel(pDrawView->GetAllMarkedBoundRect()));
2934*b1cdbd2cSJim Jagielski aMenuPos = aSelectRect.Center();
2935*b1cdbd2cSJim Jagielski }
2936*b1cdbd2cSJim Jagielski }
2937*b1cdbd2cSJim Jagielski }
2938*b1cdbd2cSJim Jagielski }
2939*b1cdbd2cSJim Jagielski
2940*b1cdbd2cSJim Jagielski if (!bDone)
2941*b1cdbd2cSJim Jagielski {
2942*b1cdbd2cSJim Jagielski SfxDispatcher::ExecutePopup( 0, this, &aMenuPos );
2943*b1cdbd2cSJim Jagielski }
2944*b1cdbd2cSJim Jagielski }
2945*b1cdbd2cSJim Jagielski }
2946*b1cdbd2cSJim Jagielski
SelectForContextMenu(const Point & rPosPixel,SCsCOL nCellX,SCsROW nCellY)2947*b1cdbd2cSJim Jagielski void ScGridWindow::SelectForContextMenu( const Point& rPosPixel, SCsCOL nCellX, SCsROW nCellY )
2948*b1cdbd2cSJim Jagielski {
2949*b1cdbd2cSJim Jagielski // #i18735# if the click was outside of the current selection,
2950*b1cdbd2cSJim Jagielski // the cursor is moved or an object at the click position selected.
2951*b1cdbd2cSJim Jagielski // (see SwEditWin::SelectMenuPosition in Writer)
2952*b1cdbd2cSJim Jagielski
2953*b1cdbd2cSJim Jagielski ScTabView* pView = pViewData->GetView();
2954*b1cdbd2cSJim Jagielski ScDrawView* pDrawView = pView->GetScDrawView();
2955*b1cdbd2cSJim Jagielski
2956*b1cdbd2cSJim Jagielski // check cell edit mode
2957*b1cdbd2cSJim Jagielski
2958*b1cdbd2cSJim Jagielski if ( pViewData->HasEditView(eWhich) )
2959*b1cdbd2cSJim Jagielski {
2960*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
2961*b1cdbd2cSJim Jagielski SCCOL nEditStartCol = pViewData->GetEditViewCol(); //! change to GetEditStartCol after calcrtl is integrated
2962*b1cdbd2cSJim Jagielski SCROW nEditStartRow = pViewData->GetEditViewRow();
2963*b1cdbd2cSJim Jagielski SCCOL nEditEndCol = pViewData->GetEditEndCol();
2964*b1cdbd2cSJim Jagielski SCROW nEditEndRow = pViewData->GetEditEndRow();
2965*b1cdbd2cSJim Jagielski
2966*b1cdbd2cSJim Jagielski if ( nCellX >= (SCsCOL) nEditStartCol && nCellX <= (SCsCOL) nEditEndCol &&
2967*b1cdbd2cSJim Jagielski nCellY >= (SCsROW) nEditStartRow && nCellY <= (SCsROW) nEditEndRow )
2968*b1cdbd2cSJim Jagielski {
2969*b1cdbd2cSJim Jagielski // handle selection within the EditView
2970*b1cdbd2cSJim Jagielski
2971*b1cdbd2cSJim Jagielski EditView* pEditView = pViewData->GetEditView( eWhich ); // not NULL (HasEditView)
2972*b1cdbd2cSJim Jagielski EditEngine* pEditEngine = pEditView->GetEditEngine();
2973*b1cdbd2cSJim Jagielski Rectangle aOutputArea = pEditView->GetOutputArea();
2974*b1cdbd2cSJim Jagielski Rectangle aVisArea = pEditView->GetVisArea();
2975*b1cdbd2cSJim Jagielski
2976*b1cdbd2cSJim Jagielski Point aTextPos = PixelToLogic( rPosPixel );
2977*b1cdbd2cSJim Jagielski if ( pEditEngine->IsVertical() ) // have to manually transform position
2978*b1cdbd2cSJim Jagielski {
2979*b1cdbd2cSJim Jagielski aTextPos -= aOutputArea.TopRight();
2980*b1cdbd2cSJim Jagielski long nTemp = -aTextPos.X();
2981*b1cdbd2cSJim Jagielski aTextPos.X() = aTextPos.Y();
2982*b1cdbd2cSJim Jagielski aTextPos.Y() = nTemp;
2983*b1cdbd2cSJim Jagielski }
2984*b1cdbd2cSJim Jagielski else
2985*b1cdbd2cSJim Jagielski aTextPos -= aOutputArea.TopLeft();
2986*b1cdbd2cSJim Jagielski aTextPos += aVisArea.TopLeft(); // position in the edit document
2987*b1cdbd2cSJim Jagielski
2988*b1cdbd2cSJim Jagielski EPosition aDocPosition = pEditEngine->FindDocPosition(aTextPos);
2989*b1cdbd2cSJim Jagielski ESelection aCompare(aDocPosition.nPara, aDocPosition.nIndex);
2990*b1cdbd2cSJim Jagielski ESelection aSelection = pEditView->GetSelection();
2991*b1cdbd2cSJim Jagielski aSelection.Adjust(); // needed for IsLess/IsGreater
2992*b1cdbd2cSJim Jagielski if ( aCompare.IsLess(aSelection) || aCompare.IsGreater(aSelection) )
2993*b1cdbd2cSJim Jagielski {
2994*b1cdbd2cSJim Jagielski // clicked outside the selected text - deselect and move text cursor
2995*b1cdbd2cSJim Jagielski MouseEvent aEvent( rPosPixel );
2996*b1cdbd2cSJim Jagielski pEditView->MouseButtonDown( aEvent );
2997*b1cdbd2cSJim Jagielski pEditView->MouseButtonUp( aEvent );
2998*b1cdbd2cSJim Jagielski pScMod->InputSelection( pEditView );
2999*b1cdbd2cSJim Jagielski }
3000*b1cdbd2cSJim Jagielski
3001*b1cdbd2cSJim Jagielski return; // clicked within the edit view - keep edit mode
3002*b1cdbd2cSJim Jagielski }
3003*b1cdbd2cSJim Jagielski else
3004*b1cdbd2cSJim Jagielski {
3005*b1cdbd2cSJim Jagielski // outside of the edit view - end edit mode, regardless of cell selection, then continue
3006*b1cdbd2cSJim Jagielski pScMod->InputEnterHandler();
3007*b1cdbd2cSJim Jagielski }
3008*b1cdbd2cSJim Jagielski }
3009*b1cdbd2cSJim Jagielski
3010*b1cdbd2cSJim Jagielski // check draw text edit mode
3011*b1cdbd2cSJim Jagielski
3012*b1cdbd2cSJim Jagielski Point aLogicPos = PixelToLogic( rPosPixel ); // after cell edit mode is ended
3013*b1cdbd2cSJim Jagielski if ( pDrawView && pDrawView->GetTextEditObject() && pDrawView->GetTextEditOutlinerView() )
3014*b1cdbd2cSJim Jagielski {
3015*b1cdbd2cSJim Jagielski OutlinerView* pOlView = pDrawView->GetTextEditOutlinerView();
3016*b1cdbd2cSJim Jagielski Rectangle aOutputArea = pOlView->GetOutputArea();
3017*b1cdbd2cSJim Jagielski if ( aOutputArea.IsInside( aLogicPos ) )
3018*b1cdbd2cSJim Jagielski {
3019*b1cdbd2cSJim Jagielski // handle selection within the OutlinerView
3020*b1cdbd2cSJim Jagielski
3021*b1cdbd2cSJim Jagielski Outliner* pOutliner = pOlView->GetOutliner();
3022*b1cdbd2cSJim Jagielski const EditEngine& rEditEngine = pOutliner->GetEditEngine();
3023*b1cdbd2cSJim Jagielski Rectangle aVisArea = pOlView->GetVisArea();
3024*b1cdbd2cSJim Jagielski
3025*b1cdbd2cSJim Jagielski Point aTextPos = aLogicPos;
3026*b1cdbd2cSJim Jagielski if ( pOutliner->IsVertical() ) // have to manually transform position
3027*b1cdbd2cSJim Jagielski {
3028*b1cdbd2cSJim Jagielski aTextPos -= aOutputArea.TopRight();
3029*b1cdbd2cSJim Jagielski long nTemp = -aTextPos.X();
3030*b1cdbd2cSJim Jagielski aTextPos.X() = aTextPos.Y();
3031*b1cdbd2cSJim Jagielski aTextPos.Y() = nTemp;
3032*b1cdbd2cSJim Jagielski }
3033*b1cdbd2cSJim Jagielski else
3034*b1cdbd2cSJim Jagielski aTextPos -= aOutputArea.TopLeft();
3035*b1cdbd2cSJim Jagielski aTextPos += aVisArea.TopLeft(); // position in the edit document
3036*b1cdbd2cSJim Jagielski
3037*b1cdbd2cSJim Jagielski EPosition aDocPosition = rEditEngine.FindDocPosition(aTextPos);
3038*b1cdbd2cSJim Jagielski ESelection aCompare(aDocPosition.nPara, aDocPosition.nIndex);
3039*b1cdbd2cSJim Jagielski ESelection aSelection = pOlView->GetSelection();
3040*b1cdbd2cSJim Jagielski aSelection.Adjust(); // needed for IsLess/IsGreater
3041*b1cdbd2cSJim Jagielski if ( aCompare.IsLess(aSelection) || aCompare.IsGreater(aSelection) )
3042*b1cdbd2cSJim Jagielski {
3043*b1cdbd2cSJim Jagielski // clicked outside the selected text - deselect and move text cursor
3044*b1cdbd2cSJim Jagielski // use DrawView to allow extra handling there (none currently)
3045*b1cdbd2cSJim Jagielski MouseEvent aEvent( rPosPixel );
3046*b1cdbd2cSJim Jagielski pDrawView->MouseButtonDown( aEvent, this );
3047*b1cdbd2cSJim Jagielski pDrawView->MouseButtonUp( aEvent, this );
3048*b1cdbd2cSJim Jagielski }
3049*b1cdbd2cSJim Jagielski
3050*b1cdbd2cSJim Jagielski return; // clicked within the edit area - keep edit mode
3051*b1cdbd2cSJim Jagielski }
3052*b1cdbd2cSJim Jagielski else
3053*b1cdbd2cSJim Jagielski {
3054*b1cdbd2cSJim Jagielski // Outside of the edit area - end text edit mode, then continue.
3055*b1cdbd2cSJim Jagielski // DrawDeselectAll also ends text edit mode and updates the shells.
3056*b1cdbd2cSJim Jagielski // If the click was on the edited object, it will be selected again below.
3057*b1cdbd2cSJim Jagielski pView->DrawDeselectAll();
3058*b1cdbd2cSJim Jagielski }
3059*b1cdbd2cSJim Jagielski }
3060*b1cdbd2cSJim Jagielski
3061*b1cdbd2cSJim Jagielski // look for existing selection
3062*b1cdbd2cSJim Jagielski
3063*b1cdbd2cSJim Jagielski sal_Bool bHitSelected = sal_False;
3064*b1cdbd2cSJim Jagielski if ( pDrawView && pDrawView->IsMarkedObjHit( aLogicPos ) )
3065*b1cdbd2cSJim Jagielski {
3066*b1cdbd2cSJim Jagielski // clicked on selected object -> don't change anything
3067*b1cdbd2cSJim Jagielski bHitSelected = sal_True;
3068*b1cdbd2cSJim Jagielski }
3069*b1cdbd2cSJim Jagielski else if ( pViewData->GetMarkData().IsCellMarked(nCellX, nCellY) )
3070*b1cdbd2cSJim Jagielski {
3071*b1cdbd2cSJim Jagielski // clicked on selected cell -> don't change anything
3072*b1cdbd2cSJim Jagielski bHitSelected = sal_True;
3073*b1cdbd2cSJim Jagielski }
3074*b1cdbd2cSJim Jagielski
3075*b1cdbd2cSJim Jagielski // select drawing object or move cell cursor
3076*b1cdbd2cSJim Jagielski
3077*b1cdbd2cSJim Jagielski if ( !bHitSelected )
3078*b1cdbd2cSJim Jagielski {
3079*b1cdbd2cSJim Jagielski sal_Bool bWasDraw = ( pDrawView && pDrawView->AreObjectsMarked() );
3080*b1cdbd2cSJim Jagielski sal_Bool bHitDraw = sal_False;
3081*b1cdbd2cSJim Jagielski if ( pDrawView )
3082*b1cdbd2cSJim Jagielski {
3083*b1cdbd2cSJim Jagielski pDrawView->UnmarkAllObj();
3084*b1cdbd2cSJim Jagielski // Unlock the Internal Layer in order to activate the context menu.
3085*b1cdbd2cSJim Jagielski // re-lock in ScDrawView::MarkListHasChanged()
3086*b1cdbd2cSJim Jagielski lcl_UnLockComment( pDrawView, pDrawView->GetSdrPageView(), pDrawView->GetModel(), aLogicPos ,pViewData);
3087*b1cdbd2cSJim Jagielski bHitDraw = pDrawView->MarkObj( aLogicPos );
3088*b1cdbd2cSJim Jagielski // draw shell is activated in MarkListHasChanged
3089*b1cdbd2cSJim Jagielski }
3090*b1cdbd2cSJim Jagielski if ( !bHitDraw )
3091*b1cdbd2cSJim Jagielski {
3092*b1cdbd2cSJim Jagielski pView->Unmark();
3093*b1cdbd2cSJim Jagielski pView->SetCursor(nCellX, nCellY);
3094*b1cdbd2cSJim Jagielski if ( bWasDraw )
3095*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->SetDrawShell( sal_False ); // switch shells
3096*b1cdbd2cSJim Jagielski }
3097*b1cdbd2cSJim Jagielski }
3098*b1cdbd2cSJim Jagielski }
3099*b1cdbd2cSJim Jagielski
KeyInput(const KeyEvent & rKEvt)3100*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::KeyInput(const KeyEvent& rKEvt)
3101*b1cdbd2cSJim Jagielski {
3102*b1cdbd2cSJim Jagielski // #96965# Cursor control for ref input dialog
3103*b1cdbd2cSJim Jagielski if( SC_MOD()->IsRefDialogOpen() )
3104*b1cdbd2cSJim Jagielski {
3105*b1cdbd2cSJim Jagielski const KeyCode& rKeyCode = rKEvt.GetKeyCode();
3106*b1cdbd2cSJim Jagielski if( !rKeyCode.GetModifier() && (rKeyCode.GetCode() == KEY_F2) )
3107*b1cdbd2cSJim Jagielski {
3108*b1cdbd2cSJim Jagielski SC_MOD()->EndReference();
3109*b1cdbd2cSJim Jagielski }
3110*b1cdbd2cSJim Jagielski else if( pViewData->GetViewShell()->MoveCursorKeyInput( rKEvt ) )
3111*b1cdbd2cSJim Jagielski {
3112*b1cdbd2cSJim Jagielski ScRange aRef(
3113*b1cdbd2cSJim Jagielski pViewData->GetRefStartX(), pViewData->GetRefStartY(), pViewData->GetRefStartZ(),
3114*b1cdbd2cSJim Jagielski pViewData->GetRefEndX(), pViewData->GetRefEndY(), pViewData->GetRefEndZ() );
3115*b1cdbd2cSJim Jagielski SC_MOD()->SetReference( aRef, pViewData->GetDocument() );
3116*b1cdbd2cSJim Jagielski }
3117*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->SelectionChanged();
3118*b1cdbd2cSJim Jagielski return ;
3119*b1cdbd2cSJim Jagielski }
3120*b1cdbd2cSJim Jagielski // wenn semi-Modeless-SfxChildWindow-Dialog oben, keine KeyInputs:
3121*b1cdbd2cSJim Jagielski else if( !pViewData->IsAnyFillMode() )
3122*b1cdbd2cSJim Jagielski {
3123*b1cdbd2cSJim Jagielski // query for existing note marker before calling ViewShell's keyboard handling
3124*b1cdbd2cSJim Jagielski // which may remove the marker
3125*b1cdbd2cSJim Jagielski sal_Bool bHadKeyMarker = ( pNoteMarker && pNoteMarker->IsByKeyboard() );
3126*b1cdbd2cSJim Jagielski ScTabViewShell* pViewSh = pViewData->GetViewShell();
3127*b1cdbd2cSJim Jagielski
3128*b1cdbd2cSJim Jagielski if (pViewData->GetDocShell()->GetProgress())
3129*b1cdbd2cSJim Jagielski return;
3130*b1cdbd2cSJim Jagielski
3131*b1cdbd2cSJim Jagielski if (DrawKeyInput(rKEvt))
3132*b1cdbd2cSJim Jagielski {
3133*b1cdbd2cSJim Jagielski const KeyCode& rKeyCode = rKEvt.GetKeyCode();
3134*b1cdbd2cSJim Jagielski if (rKeyCode.GetCode() == KEY_DOWN
3135*b1cdbd2cSJim Jagielski || rKeyCode.GetCode() == KEY_UP
3136*b1cdbd2cSJim Jagielski || rKeyCode.GetCode() == KEY_LEFT
3137*b1cdbd2cSJim Jagielski || rKeyCode.GetCode() == KEY_RIGHT)
3138*b1cdbd2cSJim Jagielski {
3139*b1cdbd2cSJim Jagielski ScTabViewShell* pViewShell = pViewData->GetViewShell();
3140*b1cdbd2cSJim Jagielski SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings();
3141*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_X);
3142*b1cdbd2cSJim Jagielski rBindings.Invalidate(SID_ATTR_TRANSFORM_POS_Y);
3143*b1cdbd2cSJim Jagielski }
3144*b1cdbd2cSJim Jagielski return;
3145*b1cdbd2cSJim Jagielski }
3146*b1cdbd2cSJim Jagielski
3147*b1cdbd2cSJim Jagielski if (!pViewData->GetView()->IsDrawSelMode() && !DrawHasMarkedObj()) // keine Eingaben im Zeichenmodus
3148*b1cdbd2cSJim Jagielski { //! DrawShell abfragen !!!
3149*b1cdbd2cSJim Jagielski if (pViewSh->TabKeyInput(rKEvt))
3150*b1cdbd2cSJim Jagielski return;
3151*b1cdbd2cSJim Jagielski }
3152*b1cdbd2cSJim Jagielski else
3153*b1cdbd2cSJim Jagielski if (pViewSh->SfxViewShell::KeyInput(rKEvt)) // von SfxViewShell
3154*b1cdbd2cSJim Jagielski return;
3155*b1cdbd2cSJim Jagielski
3156*b1cdbd2cSJim Jagielski KeyCode aCode = rKEvt.GetKeyCode();
3157*b1cdbd2cSJim Jagielski if ( aCode.GetCode() == KEY_ESCAPE && aCode.GetModifier() == 0 )
3158*b1cdbd2cSJim Jagielski {
3159*b1cdbd2cSJim Jagielski if ( bHadKeyMarker )
3160*b1cdbd2cSJim Jagielski HideNoteMarker();
3161*b1cdbd2cSJim Jagielski else
3162*b1cdbd2cSJim Jagielski pViewSh->Escape();
3163*b1cdbd2cSJim Jagielski return;
3164*b1cdbd2cSJim Jagielski }
3165*b1cdbd2cSJim Jagielski if ( aCode.GetCode() == KEY_F1 && aCode.GetModifier() == KEY_MOD1 )
3166*b1cdbd2cSJim Jagielski {
3167*b1cdbd2cSJim Jagielski // ctrl-F1 shows or hides the note or redlining info for the cursor position
3168*b1cdbd2cSJim Jagielski // (hard-coded because F1 can't be configured)
3169*b1cdbd2cSJim Jagielski
3170*b1cdbd2cSJim Jagielski if ( bHadKeyMarker )
3171*b1cdbd2cSJim Jagielski HideNoteMarker(); // hide when previously visible
3172*b1cdbd2cSJim Jagielski else
3173*b1cdbd2cSJim Jagielski ShowNoteMarker( pViewData->GetCurX(), pViewData->GetCurY(), sal_True );
3174*b1cdbd2cSJim Jagielski return;
3175*b1cdbd2cSJim Jagielski }
3176*b1cdbd2cSJim Jagielski }
3177*b1cdbd2cSJim Jagielski
3178*b1cdbd2cSJim Jagielski Window::KeyInput(rKEvt);
3179*b1cdbd2cSJim Jagielski }
3180*b1cdbd2cSJim Jagielski
StopMarking()3181*b1cdbd2cSJim Jagielski void ScGridWindow::StopMarking()
3182*b1cdbd2cSJim Jagielski {
3183*b1cdbd2cSJim Jagielski DrawEndAction(); // Markieren/Verschieben auf Drawing-Layer abbrechen
3184*b1cdbd2cSJim Jagielski
3185*b1cdbd2cSJim Jagielski if (nButtonDown)
3186*b1cdbd2cSJim Jagielski {
3187*b1cdbd2cSJim Jagielski pViewData->GetMarkData().SetMarking(sal_False);
3188*b1cdbd2cSJim Jagielski nMouseStatus = SC_GM_IGNORE;
3189*b1cdbd2cSJim Jagielski }
3190*b1cdbd2cSJim Jagielski }
3191*b1cdbd2cSJim Jagielski
UpdateInputContext()3192*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateInputContext()
3193*b1cdbd2cSJim Jagielski {
3194*b1cdbd2cSJim Jagielski sal_Bool bReadOnly = pViewData->GetDocShell()->IsReadOnly();
3195*b1cdbd2cSJim Jagielski sal_uLong nOptions = bReadOnly ? 0 : ( INPUTCONTEXT_TEXT | INPUTCONTEXT_EXTTEXTINPUT );
3196*b1cdbd2cSJim Jagielski
3197*b1cdbd2cSJim Jagielski // when font from InputContext is used,
3198*b1cdbd2cSJim Jagielski // it must be taken from the cursor position's cell attributes
3199*b1cdbd2cSJim Jagielski
3200*b1cdbd2cSJim Jagielski InputContext aContext;
3201*b1cdbd2cSJim Jagielski aContext.SetOptions( nOptions );
3202*b1cdbd2cSJim Jagielski SetInputContext( aContext );
3203*b1cdbd2cSJim Jagielski }
3204*b1cdbd2cSJim Jagielski
3205*b1cdbd2cSJim Jagielski //--------------------------------------------------------
3206*b1cdbd2cSJim Jagielski
3207*b1cdbd2cSJim Jagielski // sensitiver Bereich (Pixel)
3208*b1cdbd2cSJim Jagielski #define SCROLL_SENSITIVE 20
3209*b1cdbd2cSJim Jagielski
DropScroll(const Point & rMousePos)3210*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::DropScroll( const Point& rMousePos )
3211*b1cdbd2cSJim Jagielski {
3212*b1cdbd2cSJim Jagielski /* doch auch auf nicht aktiven Views...
3213*b1cdbd2cSJim Jagielski if ( !pViewData->IsActive() )
3214*b1cdbd2cSJim Jagielski return sal_False;
3215*b1cdbd2cSJim Jagielski */
3216*b1cdbd2cSJim Jagielski SCsCOL nDx = 0;
3217*b1cdbd2cSJim Jagielski SCsROW nDy = 0;
3218*b1cdbd2cSJim Jagielski Size aSize = GetOutputSizePixel();
3219*b1cdbd2cSJim Jagielski
3220*b1cdbd2cSJim Jagielski if (aSize.Width() > SCROLL_SENSITIVE * 3)
3221*b1cdbd2cSJim Jagielski {
3222*b1cdbd2cSJim Jagielski if ( rMousePos.X() < SCROLL_SENSITIVE && pViewData->GetPosX(WhichH(eWhich)) > 0 )
3223*b1cdbd2cSJim Jagielski nDx = -1;
3224*b1cdbd2cSJim Jagielski if ( rMousePos.X() >= aSize.Width() - SCROLL_SENSITIVE
3225*b1cdbd2cSJim Jagielski && pViewData->GetPosX(WhichH(eWhich)) < MAXCOL )
3226*b1cdbd2cSJim Jagielski nDx = 1;
3227*b1cdbd2cSJim Jagielski }
3228*b1cdbd2cSJim Jagielski if (aSize.Height() > SCROLL_SENSITIVE * 3)
3229*b1cdbd2cSJim Jagielski {
3230*b1cdbd2cSJim Jagielski if ( rMousePos.Y() < SCROLL_SENSITIVE && pViewData->GetPosY(WhichV(eWhich)) > 0 )
3231*b1cdbd2cSJim Jagielski nDy = -1;
3232*b1cdbd2cSJim Jagielski if ( rMousePos.Y() >= aSize.Height() - SCROLL_SENSITIVE
3233*b1cdbd2cSJim Jagielski && pViewData->GetPosY(WhichV(eWhich)) < MAXROW )
3234*b1cdbd2cSJim Jagielski nDy = 1;
3235*b1cdbd2cSJim Jagielski }
3236*b1cdbd2cSJim Jagielski
3237*b1cdbd2cSJim Jagielski if ( nDx != 0 || nDy != 0 )
3238*b1cdbd2cSJim Jagielski {
3239*b1cdbd2cSJim Jagielski // if (bDragRect)
3240*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3241*b1cdbd2cSJim Jagielski
3242*b1cdbd2cSJim Jagielski if ( nDx != 0 )
3243*b1cdbd2cSJim Jagielski pViewData->GetView()->ScrollX( nDx, WhichH(eWhich) );
3244*b1cdbd2cSJim Jagielski if ( nDy != 0 )
3245*b1cdbd2cSJim Jagielski pViewData->GetView()->ScrollY( nDy, WhichV(eWhich) );
3246*b1cdbd2cSJim Jagielski
3247*b1cdbd2cSJim Jagielski // if (bDragRect)
3248*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3249*b1cdbd2cSJim Jagielski }
3250*b1cdbd2cSJim Jagielski
3251*b1cdbd2cSJim Jagielski return sal_False;
3252*b1cdbd2cSJim Jagielski }
3253*b1cdbd2cSJim Jagielski
lcl_TestScenarioRedliningDrop(ScDocument * pDoc,const ScRange & aDragRange)3254*b1cdbd2cSJim Jagielski sal_Bool lcl_TestScenarioRedliningDrop( ScDocument* pDoc, const ScRange& aDragRange)
3255*b1cdbd2cSJim Jagielski {
3256*b1cdbd2cSJim Jagielski // Testet, ob bei eingeschalteten RedLining,
3257*b1cdbd2cSJim Jagielski // bei einem Drop ein Scenario betroffen ist.
3258*b1cdbd2cSJim Jagielski
3259*b1cdbd2cSJim Jagielski sal_Bool bReturn = sal_False;
3260*b1cdbd2cSJim Jagielski SCTAB nTab = aDragRange.aStart.Tab();
3261*b1cdbd2cSJim Jagielski SCTAB nTabCount = pDoc->GetTableCount();
3262*b1cdbd2cSJim Jagielski
3263*b1cdbd2cSJim Jagielski if(pDoc->GetChangeTrack()!=NULL)
3264*b1cdbd2cSJim Jagielski {
3265*b1cdbd2cSJim Jagielski if( pDoc->IsScenario(nTab) && pDoc->HasScenarioRange(nTab, aDragRange))
3266*b1cdbd2cSJim Jagielski {
3267*b1cdbd2cSJim Jagielski bReturn = sal_True;
3268*b1cdbd2cSJim Jagielski }
3269*b1cdbd2cSJim Jagielski else
3270*b1cdbd2cSJim Jagielski {
3271*b1cdbd2cSJim Jagielski for(SCTAB i=nTab+1; i<nTabCount && pDoc->IsScenario(i); i++)
3272*b1cdbd2cSJim Jagielski {
3273*b1cdbd2cSJim Jagielski if(pDoc->HasScenarioRange(i, aDragRange))
3274*b1cdbd2cSJim Jagielski {
3275*b1cdbd2cSJim Jagielski bReturn = sal_True;
3276*b1cdbd2cSJim Jagielski break;
3277*b1cdbd2cSJim Jagielski }
3278*b1cdbd2cSJim Jagielski }
3279*b1cdbd2cSJim Jagielski }
3280*b1cdbd2cSJim Jagielski }
3281*b1cdbd2cSJim Jagielski return bReturn;
3282*b1cdbd2cSJim Jagielski }
3283*b1cdbd2cSJim Jagielski
lcl_MakeDropRange(SCCOL nPosX,SCROW nPosY,SCTAB nTab,const ScRange & rSource)3284*b1cdbd2cSJim Jagielski ScRange lcl_MakeDropRange( SCCOL nPosX, SCROW nPosY, SCTAB nTab, const ScRange& rSource )
3285*b1cdbd2cSJim Jagielski {
3286*b1cdbd2cSJim Jagielski SCCOL nCol1 = nPosX;
3287*b1cdbd2cSJim Jagielski SCCOL nCol2 = nCol1 + ( rSource.aEnd.Col() - rSource.aStart.Col() );
3288*b1cdbd2cSJim Jagielski if ( nCol2 > MAXCOL )
3289*b1cdbd2cSJim Jagielski {
3290*b1cdbd2cSJim Jagielski nCol1 -= nCol2 - MAXCOL;
3291*b1cdbd2cSJim Jagielski nCol2 = MAXCOL;
3292*b1cdbd2cSJim Jagielski }
3293*b1cdbd2cSJim Jagielski SCROW nRow1 = nPosY;
3294*b1cdbd2cSJim Jagielski SCROW nRow2 = nRow1 + ( rSource.aEnd.Row() - rSource.aStart.Row() );
3295*b1cdbd2cSJim Jagielski if ( nRow2 > MAXROW )
3296*b1cdbd2cSJim Jagielski {
3297*b1cdbd2cSJim Jagielski nRow1 -= nRow2 - MAXROW;
3298*b1cdbd2cSJim Jagielski nRow2 = MAXROW;
3299*b1cdbd2cSJim Jagielski }
3300*b1cdbd2cSJim Jagielski
3301*b1cdbd2cSJim Jagielski return ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
3302*b1cdbd2cSJim Jagielski }
3303*b1cdbd2cSJim Jagielski
3304*b1cdbd2cSJim Jagielski //--------------------------------------------------------
3305*b1cdbd2cSJim Jagielski
3306*b1cdbd2cSJim Jagielski extern sal_Bool bPasteIsDrop; // viewfun4 -> move to header
3307*b1cdbd2cSJim Jagielski extern sal_Bool bPasteIsMove; // viewfun7 -> move to header
3308*b1cdbd2cSJim Jagielski
3309*b1cdbd2cSJim Jagielski //--------------------------------------------------------
3310*b1cdbd2cSJim Jagielski
AcceptPrivateDrop(const AcceptDropEvent & rEvt)3311*b1cdbd2cSJim Jagielski sal_Int8 ScGridWindow::AcceptPrivateDrop( const AcceptDropEvent& rEvt )
3312*b1cdbd2cSJim Jagielski {
3313*b1cdbd2cSJim Jagielski if ( rEvt.mbLeaving )
3314*b1cdbd2cSJim Jagielski {
3315*b1cdbd2cSJim Jagielski // if (bDragRect)
3316*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3317*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3318*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3319*b1cdbd2cSJim Jagielski return rEvt.mnAction;
3320*b1cdbd2cSJim Jagielski }
3321*b1cdbd2cSJim Jagielski
3322*b1cdbd2cSJim Jagielski const ScDragData& rData = SC_MOD()->GetDragData();
3323*b1cdbd2cSJim Jagielski if ( rData.pCellTransfer )
3324*b1cdbd2cSJim Jagielski {
3325*b1cdbd2cSJim Jagielski // Don't move source that would include filtered rows.
3326*b1cdbd2cSJim Jagielski if ((rEvt.mnAction & DND_ACTION_MOVE) && rData.pCellTransfer->HasFilteredRows())
3327*b1cdbd2cSJim Jagielski {
3328*b1cdbd2cSJim Jagielski if (bDragRect)
3329*b1cdbd2cSJim Jagielski {
3330*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3331*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3332*b1cdbd2cSJim Jagielski }
3333*b1cdbd2cSJim Jagielski return DND_ACTION_NONE;
3334*b1cdbd2cSJim Jagielski }
3335*b1cdbd2cSJim Jagielski
3336*b1cdbd2cSJim Jagielski Point aPos = rEvt.maPosPixel;
3337*b1cdbd2cSJim Jagielski
3338*b1cdbd2cSJim Jagielski ScDocument* pSourceDoc = rData.pCellTransfer->GetSourceDocument();
3339*b1cdbd2cSJim Jagielski ScDocument* pThisDoc = pViewData->GetDocument();
3340*b1cdbd2cSJim Jagielski if (pSourceDoc == pThisDoc)
3341*b1cdbd2cSJim Jagielski {
3342*b1cdbd2cSJim Jagielski if ( pThisDoc->HasChartAtPoint(pViewData->GetTabNo(), PixelToLogic(aPos)) )
3343*b1cdbd2cSJim Jagielski {
3344*b1cdbd2cSJim Jagielski if (bDragRect) // Rechteck loeschen
3345*b1cdbd2cSJim Jagielski {
3346*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3347*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3348*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3349*b1cdbd2cSJim Jagielski }
3350*b1cdbd2cSJim Jagielski
3351*b1cdbd2cSJim Jagielski //! highlight chart? (selection border?)
3352*b1cdbd2cSJim Jagielski
3353*b1cdbd2cSJim Jagielski sal_Int8 nRet = rEvt.mnAction;
3354*b1cdbd2cSJim Jagielski //! if ( rEvt.GetAction() == DROP_LINK )
3355*b1cdbd2cSJim Jagielski //! bOk = rEvt.SetAction( DROP_COPY ); // can't link onto chart
3356*b1cdbd2cSJim Jagielski return nRet;
3357*b1cdbd2cSJim Jagielski }
3358*b1cdbd2cSJim Jagielski }
3359*b1cdbd2cSJim Jagielski //! else
3360*b1cdbd2cSJim Jagielski //! if ( rEvt.GetAction() == DROP_MOVE )
3361*b1cdbd2cSJim Jagielski //! rEvt.SetAction( DROP_COPY ); // different doc: default=COPY
3362*b1cdbd2cSJim Jagielski
3363*b1cdbd2cSJim Jagielski
3364*b1cdbd2cSJim Jagielski if ( rData.pCellTransfer->GetDragSourceFlags() & SC_DROP_TABLE ) // whole sheet?
3365*b1cdbd2cSJim Jagielski {
3366*b1cdbd2cSJim Jagielski sal_Bool bOk = pThisDoc->IsDocEditable();
3367*b1cdbd2cSJim Jagielski return bOk ? rEvt.mnAction : 0; // don't draw selection frame
3368*b1cdbd2cSJim Jagielski }
3369*b1cdbd2cSJim Jagielski
3370*b1cdbd2cSJim Jagielski SCsCOL nPosX;
3371*b1cdbd2cSJim Jagielski SCsROW nPosY;
3372*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
3373*b1cdbd2cSJim Jagielski
3374*b1cdbd2cSJim Jagielski ScRange aSourceRange = rData.pCellTransfer->GetRange();
3375*b1cdbd2cSJim Jagielski SCCOL nSourceStartX = aSourceRange.aStart.Col();
3376*b1cdbd2cSJim Jagielski SCROW nSourceStartY = aSourceRange.aStart.Row();
3377*b1cdbd2cSJim Jagielski SCCOL nSourceEndX = aSourceRange.aEnd.Col();
3378*b1cdbd2cSJim Jagielski SCROW nSourceEndY = aSourceRange.aEnd.Row();
3379*b1cdbd2cSJim Jagielski SCCOL nSizeX = nSourceEndX - nSourceStartX + 1;
3380*b1cdbd2cSJim Jagielski SCROW nSizeY = nSourceEndY - nSourceStartY + 1;
3381*b1cdbd2cSJim Jagielski
3382*b1cdbd2cSJim Jagielski if ( rEvt.mnAction != DND_ACTION_MOVE )
3383*b1cdbd2cSJim Jagielski nSizeY = rData.pCellTransfer->GetNonFilteredRows(); // copy/link: no filtered rows
3384*b1cdbd2cSJim Jagielski
3385*b1cdbd2cSJim Jagielski SCsCOL nNewDragX = nPosX - rData.pCellTransfer->GetDragHandleX();
3386*b1cdbd2cSJim Jagielski if (nNewDragX<0) nNewDragX=0;
3387*b1cdbd2cSJim Jagielski if (nNewDragX+(nSizeX-1) > MAXCOL)
3388*b1cdbd2cSJim Jagielski nNewDragX = MAXCOL-(nSizeX-1);
3389*b1cdbd2cSJim Jagielski SCsROW nNewDragY = nPosY - rData.pCellTransfer->GetDragHandleY();
3390*b1cdbd2cSJim Jagielski if (nNewDragY<0) nNewDragY=0;
3391*b1cdbd2cSJim Jagielski if (nNewDragY+(nSizeY-1) > MAXROW)
3392*b1cdbd2cSJim Jagielski nNewDragY = MAXROW-(nSizeY-1);
3393*b1cdbd2cSJim Jagielski
3394*b1cdbd2cSJim Jagielski // don't break scenario ranges, don't drop on filtered
3395*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
3396*b1cdbd2cSJim Jagielski ScRange aDropRange = lcl_MakeDropRange( nNewDragX, nNewDragY, nTab, aSourceRange );
3397*b1cdbd2cSJim Jagielski if ( lcl_TestScenarioRedliningDrop( pThisDoc, aDropRange ) ||
3398*b1cdbd2cSJim Jagielski lcl_TestScenarioRedliningDrop( pSourceDoc, aSourceRange ) ||
3399*b1cdbd2cSJim Jagielski ScViewUtil::HasFiltered( aDropRange, pThisDoc) )
3400*b1cdbd2cSJim Jagielski {
3401*b1cdbd2cSJim Jagielski if (bDragRect)
3402*b1cdbd2cSJim Jagielski {
3403*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3404*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3405*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3406*b1cdbd2cSJim Jagielski }
3407*b1cdbd2cSJim Jagielski return DND_ACTION_NONE;
3408*b1cdbd2cSJim Jagielski }
3409*b1cdbd2cSJim Jagielski
3410*b1cdbd2cSJim Jagielski InsCellCmd eDragInsertMode = INS_NONE;
3411*b1cdbd2cSJim Jagielski Window::PointerState aState = GetPointerState();
3412*b1cdbd2cSJim Jagielski
3413*b1cdbd2cSJim Jagielski // check for datapilot item sorting
3414*b1cdbd2cSJim Jagielski ScDPObject* pDPObj = NULL;
3415*b1cdbd2cSJim Jagielski if ( pThisDoc == pSourceDoc && ( pDPObj = pThisDoc->GetDPAtCursor( nNewDragX, nNewDragY, nTab ) ) != NULL )
3416*b1cdbd2cSJim Jagielski {
3417*b1cdbd2cSJim Jagielski // drop on DataPilot table: sort or nothing
3418*b1cdbd2cSJim Jagielski
3419*b1cdbd2cSJim Jagielski bool bDPSort = false;
3420*b1cdbd2cSJim Jagielski if ( pThisDoc->GetDPAtCursor( nSourceStartX, nSourceStartY, aSourceRange.aStart.Tab() ) == pDPObj )
3421*b1cdbd2cSJim Jagielski {
3422*b1cdbd2cSJim Jagielski sheet::DataPilotTableHeaderData aDestData;
3423*b1cdbd2cSJim Jagielski pDPObj->GetHeaderPositionData( ScAddress(nNewDragX, nNewDragY, nTab), aDestData );
3424*b1cdbd2cSJim Jagielski bool bValid = ( aDestData.Dimension >= 0 ); // dropping onto a field
3425*b1cdbd2cSJim Jagielski
3426*b1cdbd2cSJim Jagielski // look through the source range
3427*b1cdbd2cSJim Jagielski for (SCROW nRow = aSourceRange.aStart.Row(); bValid && nRow <= aSourceRange.aEnd.Row(); ++nRow )
3428*b1cdbd2cSJim Jagielski for (SCCOL nCol = aSourceRange.aStart.Col(); bValid && nCol <= aSourceRange.aEnd.Col(); ++nCol )
3429*b1cdbd2cSJim Jagielski {
3430*b1cdbd2cSJim Jagielski sheet::DataPilotTableHeaderData aSourceData;
3431*b1cdbd2cSJim Jagielski pDPObj->GetHeaderPositionData( ScAddress( nCol, nRow, aSourceRange.aStart.Tab() ), aSourceData );
3432*b1cdbd2cSJim Jagielski if ( aSourceData.Dimension != aDestData.Dimension || !aSourceData.MemberName.getLength() )
3433*b1cdbd2cSJim Jagielski bValid = false; // empty (subtotal) or different field
3434*b1cdbd2cSJim Jagielski }
3435*b1cdbd2cSJim Jagielski
3436*b1cdbd2cSJim Jagielski if ( bValid )
3437*b1cdbd2cSJim Jagielski {
3438*b1cdbd2cSJim Jagielski sal_Bool bIsDataLayout;
3439*b1cdbd2cSJim Jagielski String aDimName = pDPObj->GetDimName( aDestData.Dimension, bIsDataLayout );
3440*b1cdbd2cSJim Jagielski const ScDPSaveDimension* pDim = pDPObj->GetSaveData()->GetExistingDimensionByName( aDimName );
3441*b1cdbd2cSJim Jagielski if ( pDim )
3442*b1cdbd2cSJim Jagielski {
3443*b1cdbd2cSJim Jagielski ScRange aOutRange = pDPObj->GetOutRange();
3444*b1cdbd2cSJim Jagielski
3445*b1cdbd2cSJim Jagielski sal_uInt16 nOrient = pDim->GetOrientation();
3446*b1cdbd2cSJim Jagielski if ( nOrient == sheet::DataPilotFieldOrientation_COLUMN )
3447*b1cdbd2cSJim Jagielski {
3448*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSRIGHT;
3449*b1cdbd2cSJim Jagielski nSizeY = aOutRange.aEnd.Row() - nNewDragY + 1;
3450*b1cdbd2cSJim Jagielski bDPSort = true;
3451*b1cdbd2cSJim Jagielski }
3452*b1cdbd2cSJim Jagielski else if ( nOrient == sheet::DataPilotFieldOrientation_ROW )
3453*b1cdbd2cSJim Jagielski {
3454*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSDOWN;
3455*b1cdbd2cSJim Jagielski nSizeX = aOutRange.aEnd.Col() - nNewDragX + 1;
3456*b1cdbd2cSJim Jagielski bDPSort = true;
3457*b1cdbd2cSJim Jagielski }
3458*b1cdbd2cSJim Jagielski }
3459*b1cdbd2cSJim Jagielski }
3460*b1cdbd2cSJim Jagielski }
3461*b1cdbd2cSJim Jagielski
3462*b1cdbd2cSJim Jagielski if ( !bDPSort )
3463*b1cdbd2cSJim Jagielski {
3464*b1cdbd2cSJim Jagielski // no valid sorting in a DataPilot table -> disallow
3465*b1cdbd2cSJim Jagielski if ( bDragRect )
3466*b1cdbd2cSJim Jagielski {
3467*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3468*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3469*b1cdbd2cSJim Jagielski }
3470*b1cdbd2cSJim Jagielski return DND_ACTION_NONE;
3471*b1cdbd2cSJim Jagielski }
3472*b1cdbd2cSJim Jagielski }
3473*b1cdbd2cSJim Jagielski else if ( aState.mnState & KEY_MOD2 )
3474*b1cdbd2cSJim Jagielski {
3475*b1cdbd2cSJim Jagielski if ( pThisDoc == pSourceDoc && nTab == aSourceRange.aStart.Tab() )
3476*b1cdbd2cSJim Jagielski {
3477*b1cdbd2cSJim Jagielski long nDeltaX = labs( static_cast< long >( nNewDragX - nSourceStartX ) );
3478*b1cdbd2cSJim Jagielski long nDeltaY = labs( static_cast< long >( nNewDragY - nSourceStartY ) );
3479*b1cdbd2cSJim Jagielski if ( nDeltaX <= nDeltaY )
3480*b1cdbd2cSJim Jagielski {
3481*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSDOWN;
3482*b1cdbd2cSJim Jagielski }
3483*b1cdbd2cSJim Jagielski else
3484*b1cdbd2cSJim Jagielski {
3485*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSRIGHT;
3486*b1cdbd2cSJim Jagielski }
3487*b1cdbd2cSJim Jagielski
3488*b1cdbd2cSJim Jagielski if ( ( eDragInsertMode == INS_CELLSDOWN && nNewDragY <= nSourceEndY &&
3489*b1cdbd2cSJim Jagielski ( nNewDragX + nSizeX - 1 ) >= nSourceStartX && nNewDragX <= nSourceEndX &&
3490*b1cdbd2cSJim Jagielski ( nNewDragX != nSourceStartX || nNewDragY >= nSourceStartY ) ) ||
3491*b1cdbd2cSJim Jagielski ( eDragInsertMode == INS_CELLSRIGHT && nNewDragX <= nSourceEndX &&
3492*b1cdbd2cSJim Jagielski ( nNewDragY + nSizeY - 1 ) >= nSourceStartY && nNewDragY <= nSourceEndY &&
3493*b1cdbd2cSJim Jagielski ( nNewDragY != nSourceStartY || nNewDragX >= nSourceStartX ) ) )
3494*b1cdbd2cSJim Jagielski {
3495*b1cdbd2cSJim Jagielski if ( bDragRect )
3496*b1cdbd2cSJim Jagielski {
3497*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3498*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3499*b1cdbd2cSJim Jagielski }
3500*b1cdbd2cSJim Jagielski return DND_ACTION_NONE;
3501*b1cdbd2cSJim Jagielski }
3502*b1cdbd2cSJim Jagielski }
3503*b1cdbd2cSJim Jagielski else
3504*b1cdbd2cSJim Jagielski {
3505*b1cdbd2cSJim Jagielski if ( static_cast< long >( nSizeX ) >= static_cast< long >( nSizeY ) )
3506*b1cdbd2cSJim Jagielski {
3507*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSDOWN;
3508*b1cdbd2cSJim Jagielski
3509*b1cdbd2cSJim Jagielski }
3510*b1cdbd2cSJim Jagielski else
3511*b1cdbd2cSJim Jagielski {
3512*b1cdbd2cSJim Jagielski eDragInsertMode = INS_CELLSRIGHT;
3513*b1cdbd2cSJim Jagielski }
3514*b1cdbd2cSJim Jagielski }
3515*b1cdbd2cSJim Jagielski }
3516*b1cdbd2cSJim Jagielski
3517*b1cdbd2cSJim Jagielski if ( nNewDragX != (SCsCOL) nDragStartX || nNewDragY != (SCsROW) nDragStartY ||
3518*b1cdbd2cSJim Jagielski nDragStartX+nSizeX-1 != nDragEndX || nDragStartY+nSizeY-1 != nDragEndY ||
3519*b1cdbd2cSJim Jagielski !bDragRect || eDragInsertMode != meDragInsertMode )
3520*b1cdbd2cSJim Jagielski {
3521*b1cdbd2cSJim Jagielski // if (bDragRect)
3522*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3523*b1cdbd2cSJim Jagielski
3524*b1cdbd2cSJim Jagielski nDragStartX = nNewDragX;
3525*b1cdbd2cSJim Jagielski nDragStartY = nNewDragY;
3526*b1cdbd2cSJim Jagielski nDragEndX = nDragStartX+nSizeX-1;
3527*b1cdbd2cSJim Jagielski nDragEndY = nDragStartY+nSizeY-1;
3528*b1cdbd2cSJim Jagielski bDragRect = sal_True;
3529*b1cdbd2cSJim Jagielski meDragInsertMode = eDragInsertMode;
3530*b1cdbd2cSJim Jagielski
3531*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3532*b1cdbd2cSJim Jagielski
3533*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3534*b1cdbd2cSJim Jagielski
3535*b1cdbd2cSJim Jagielski // show target position as tip help
3536*b1cdbd2cSJim Jagielski #if 0
3537*b1cdbd2cSJim Jagielski if (Help::IsQuickHelpEnabled())
3538*b1cdbd2cSJim Jagielski {
3539*b1cdbd2cSJim Jagielski ScRange aRange( nDragStartX, nDragStartY, nTab, nDragEndX, nDragEndY, nTab );
3540*b1cdbd2cSJim Jagielski String aHelpStr;
3541*b1cdbd2cSJim Jagielski aRange.Format( aHelpStr, SCA_VALID ); // non-3D
3542*b1cdbd2cSJim Jagielski
3543*b1cdbd2cSJim Jagielski Point aPos = Pointer::GetPosPixel();
3544*b1cdbd2cSJim Jagielski sal_uInt16 nAlign = QUICKHELP_BOTTOM|QUICKHELP_RIGHT;
3545*b1cdbd2cSJim Jagielski Rectangle aRect( aPos, aPos );
3546*b1cdbd2cSJim Jagielski Help::ShowQuickHelp(aRect, aHelpStr, nAlign);
3547*b1cdbd2cSJim Jagielski }
3548*b1cdbd2cSJim Jagielski #endif
3549*b1cdbd2cSJim Jagielski }
3550*b1cdbd2cSJim Jagielski }
3551*b1cdbd2cSJim Jagielski
3552*b1cdbd2cSJim Jagielski return rEvt.mnAction;
3553*b1cdbd2cSJim Jagielski }
3554*b1cdbd2cSJim Jagielski
AcceptDrop(const AcceptDropEvent & rEvt)3555*b1cdbd2cSJim Jagielski sal_Int8 ScGridWindow::AcceptDrop( const AcceptDropEvent& rEvt )
3556*b1cdbd2cSJim Jagielski {
3557*b1cdbd2cSJim Jagielski const ScDragData& rData = SC_MOD()->GetDragData();
3558*b1cdbd2cSJim Jagielski if ( rEvt.mbLeaving )
3559*b1cdbd2cSJim Jagielski {
3560*b1cdbd2cSJim Jagielski DrawMarkDropObj( NULL );
3561*b1cdbd2cSJim Jagielski if ( rData.pCellTransfer )
3562*b1cdbd2cSJim Jagielski return AcceptPrivateDrop( rEvt ); // hide drop marker for internal D&D
3563*b1cdbd2cSJim Jagielski else
3564*b1cdbd2cSJim Jagielski return rEvt.mnAction;
3565*b1cdbd2cSJim Jagielski }
3566*b1cdbd2cSJim Jagielski
3567*b1cdbd2cSJim Jagielski if ( pViewData->GetDocShell()->IsReadOnly() )
3568*b1cdbd2cSJim Jagielski return DND_ACTION_NONE;
3569*b1cdbd2cSJim Jagielski
3570*b1cdbd2cSJim Jagielski
3571*b1cdbd2cSJim Jagielski sal_Int8 nRet = DND_ACTION_NONE;
3572*b1cdbd2cSJim Jagielski
3573*b1cdbd2cSJim Jagielski if (rData.pCellTransfer)
3574*b1cdbd2cSJim Jagielski {
3575*b1cdbd2cSJim Jagielski ScRange aSource = rData.pCellTransfer->GetRange();
3576*b1cdbd2cSJim Jagielski if ( aSource.aStart.Col() != 0 || aSource.aEnd.Col() != MAXCOL ||
3577*b1cdbd2cSJim Jagielski aSource.aStart.Row() != 0 || aSource.aEnd.Row() != MAXROW )
3578*b1cdbd2cSJim Jagielski DropScroll( rEvt.maPosPixel );
3579*b1cdbd2cSJim Jagielski
3580*b1cdbd2cSJim Jagielski nRet = AcceptPrivateDrop( rEvt );
3581*b1cdbd2cSJim Jagielski }
3582*b1cdbd2cSJim Jagielski else
3583*b1cdbd2cSJim Jagielski {
3584*b1cdbd2cSJim Jagielski if ( rData.aLinkDoc.Len() )
3585*b1cdbd2cSJim Jagielski {
3586*b1cdbd2cSJim Jagielski String aThisName;
3587*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
3588*b1cdbd2cSJim Jagielski if (pDocSh && pDocSh->HasName())
3589*b1cdbd2cSJim Jagielski aThisName = pDocSh->GetMedium()->GetName();
3590*b1cdbd2cSJim Jagielski
3591*b1cdbd2cSJim Jagielski if ( rData.aLinkDoc != aThisName )
3592*b1cdbd2cSJim Jagielski nRet = rEvt.mnAction;
3593*b1cdbd2cSJim Jagielski }
3594*b1cdbd2cSJim Jagielski else if (rData.aJumpTarget.Len())
3595*b1cdbd2cSJim Jagielski {
3596*b1cdbd2cSJim Jagielski // internal bookmarks (from Navigator)
3597*b1cdbd2cSJim Jagielski // local jumps from an unnamed document are possible only within a document
3598*b1cdbd2cSJim Jagielski
3599*b1cdbd2cSJim Jagielski if ( !rData.pJumpLocalDoc || rData.pJumpLocalDoc == pViewData->GetDocument() )
3600*b1cdbd2cSJim Jagielski nRet = rEvt.mnAction;
3601*b1cdbd2cSJim Jagielski }
3602*b1cdbd2cSJim Jagielski else
3603*b1cdbd2cSJim Jagielski {
3604*b1cdbd2cSJim Jagielski sal_Int8 nMyAction = rEvt.mnAction;
3605*b1cdbd2cSJim Jagielski
3606*b1cdbd2cSJim Jagielski // clear DND_ACTION_LINK when other actions are set. The usage below cannot handle
3607*b1cdbd2cSJim Jagielski // multiple set values
3608*b1cdbd2cSJim Jagielski if((nMyAction & DND_ACTION_LINK) && (nMyAction & (DND_ACTION_COPYMOVE)))
3609*b1cdbd2cSJim Jagielski {
3610*b1cdbd2cSJim Jagielski nMyAction &= ~DND_ACTION_LINK;
3611*b1cdbd2cSJim Jagielski }
3612*b1cdbd2cSJim Jagielski
3613*b1cdbd2cSJim Jagielski if ( !rData.pDrawTransfer ||
3614*b1cdbd2cSJim Jagielski !IsMyModel(rData.pDrawTransfer->GetDragSourceView()) ) // drawing within the document
3615*b1cdbd2cSJim Jagielski if ( rEvt.mbDefault && nMyAction == DND_ACTION_MOVE )
3616*b1cdbd2cSJim Jagielski nMyAction = DND_ACTION_COPY;
3617*b1cdbd2cSJim Jagielski
3618*b1cdbd2cSJim Jagielski ScDocument* pThisDoc = pViewData->GetDocument();
3619*b1cdbd2cSJim Jagielski SdrObject* pHitObj = pThisDoc->GetObjectAtPoint(
3620*b1cdbd2cSJim Jagielski pViewData->GetTabNo(), PixelToLogic(rEvt.maPosPixel) );
3621*b1cdbd2cSJim Jagielski if ( pHitObj && nMyAction == DND_ACTION_LINK ) // && !rData.pDrawTransfer )
3622*b1cdbd2cSJim Jagielski {
3623*b1cdbd2cSJim Jagielski if ( IsDropFormatSupported(SOT_FORMATSTR_ID_SVXB)
3624*b1cdbd2cSJim Jagielski || IsDropFormatSupported(SOT_FORMAT_GDIMETAFILE)
3625*b1cdbd2cSJim Jagielski || IsDropFormatSupported(SOT_FORMATSTR_ID_PNG)
3626*b1cdbd2cSJim Jagielski || IsDropFormatSupported(SOT_FORMAT_BITMAP) )
3627*b1cdbd2cSJim Jagielski {
3628*b1cdbd2cSJim Jagielski // graphic dragged onto drawing object
3629*b1cdbd2cSJim Jagielski DrawMarkDropObj( pHitObj );
3630*b1cdbd2cSJim Jagielski nRet = nMyAction;
3631*b1cdbd2cSJim Jagielski }
3632*b1cdbd2cSJim Jagielski }
3633*b1cdbd2cSJim Jagielski if (!nRet)
3634*b1cdbd2cSJim Jagielski DrawMarkDropObj( NULL );
3635*b1cdbd2cSJim Jagielski
3636*b1cdbd2cSJim Jagielski if (!nRet)
3637*b1cdbd2cSJim Jagielski {
3638*b1cdbd2cSJim Jagielski switch ( nMyAction )
3639*b1cdbd2cSJim Jagielski {
3640*b1cdbd2cSJim Jagielski case DND_ACTION_COPY:
3641*b1cdbd2cSJim Jagielski case DND_ACTION_MOVE:
3642*b1cdbd2cSJim Jagielski case DND_ACTION_COPYMOVE:
3643*b1cdbd2cSJim Jagielski {
3644*b1cdbd2cSJim Jagielski sal_Bool bMove = ( nMyAction == DND_ACTION_MOVE );
3645*b1cdbd2cSJim Jagielski if ( IsDropFormatSupported( SOT_FORMATSTR_ID_EMBED_SOURCE ) ||
3646*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_LINK_SOURCE ) ||
3647*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ) ||
3648*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ) ||
3649*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ) ||
3650*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_STRING ) ||
3651*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SYLK ) ||
3652*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_LINK ) ||
3653*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_HTML ) ||
3654*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_HTML_SIMPLE ) ||
3655*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_DIF ) ||
3656*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_DRAWING ) ||
3657*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SVXB ) ||
3658*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_RTF ) ||
3659*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_GDIMETAFILE ) ||
3660*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_PNG ) ||
3661*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_BITMAP ) ||
3662*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SBA_DATAEXCHANGE ) ||
3663*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE ) ||
3664*b1cdbd2cSJim Jagielski ( !bMove && (
3665*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_FILE_LIST ) ||
3666*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_FILE ) ||
3667*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SOLK ) ||
3668*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) ||
3669*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) ||
3670*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) ) ) )
3671*b1cdbd2cSJim Jagielski {
3672*b1cdbd2cSJim Jagielski nRet = nMyAction;
3673*b1cdbd2cSJim Jagielski }
3674*b1cdbd2cSJim Jagielski }
3675*b1cdbd2cSJim Jagielski break;
3676*b1cdbd2cSJim Jagielski case DND_ACTION_LINK:
3677*b1cdbd2cSJim Jagielski if ( IsDropFormatSupported( SOT_FORMATSTR_ID_LINK_SOURCE ) ||
3678*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ) ||
3679*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_LINK ) ||
3680*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_FILE_LIST ) ||
3681*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMAT_FILE ) ||
3682*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_SOLK ) ||
3683*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) ||
3684*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) ||
3685*b1cdbd2cSJim Jagielski IsDropFormatSupported( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) )
3686*b1cdbd2cSJim Jagielski {
3687*b1cdbd2cSJim Jagielski nRet = nMyAction;
3688*b1cdbd2cSJim Jagielski }
3689*b1cdbd2cSJim Jagielski break;
3690*b1cdbd2cSJim Jagielski }
3691*b1cdbd2cSJim Jagielski
3692*b1cdbd2cSJim Jagielski if ( nRet )
3693*b1cdbd2cSJim Jagielski {
3694*b1cdbd2cSJim Jagielski // Simple check for protection: It's not known here if the drop will result
3695*b1cdbd2cSJim Jagielski // in cells or drawing objects (some formats can be both) and how many cells
3696*b1cdbd2cSJim Jagielski // the result will be. But if IsFormatEditable for the drop cell position
3697*b1cdbd2cSJim Jagielski // is sal_False (ignores matrix formulas), nothing can be pasted, so the drop
3698*b1cdbd2cSJim Jagielski // can already be rejected here.
3699*b1cdbd2cSJim Jagielski
3700*b1cdbd2cSJim Jagielski Point aPos = rEvt.maPosPixel;
3701*b1cdbd2cSJim Jagielski SCsCOL nPosX;
3702*b1cdbd2cSJim Jagielski SCsROW nPosY;
3703*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
3704*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
3705*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
3706*b1cdbd2cSJim Jagielski
3707*b1cdbd2cSJim Jagielski ScEditableTester aTester( pDoc, nTab, nPosX,nPosY, nPosX,nPosY );
3708*b1cdbd2cSJim Jagielski if ( !aTester.IsFormatEditable() )
3709*b1cdbd2cSJim Jagielski nRet = DND_ACTION_NONE; // forbidden
3710*b1cdbd2cSJim Jagielski }
3711*b1cdbd2cSJim Jagielski }
3712*b1cdbd2cSJim Jagielski }
3713*b1cdbd2cSJim Jagielski
3714*b1cdbd2cSJim Jagielski // scroll only for accepted formats
3715*b1cdbd2cSJim Jagielski if (nRet)
3716*b1cdbd2cSJim Jagielski DropScroll( rEvt.maPosPixel );
3717*b1cdbd2cSJim Jagielski }
3718*b1cdbd2cSJim Jagielski
3719*b1cdbd2cSJim Jagielski return nRet;
3720*b1cdbd2cSJim Jagielski }
3721*b1cdbd2cSJim Jagielski
lcl_GetDropFormatId(const uno::Reference<datatransfer::XTransferable> & xTransfer,bool bPreferText=false)3722*b1cdbd2cSJim Jagielski sal_uLong lcl_GetDropFormatId( const uno::Reference<datatransfer::XTransferable>& xTransfer, bool bPreferText = false )
3723*b1cdbd2cSJim Jagielski {
3724*b1cdbd2cSJim Jagielski TransferableDataHelper aDataHelper( xTransfer );
3725*b1cdbd2cSJim Jagielski
3726*b1cdbd2cSJim Jagielski if ( !aDataHelper.HasFormat( SOT_FORMATSTR_ID_SBA_DATAEXCHANGE ) )
3727*b1cdbd2cSJim Jagielski {
3728*b1cdbd2cSJim Jagielski // use bookmark formats if no sba is present
3729*b1cdbd2cSJim Jagielski
3730*b1cdbd2cSJim Jagielski if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SOLK ) )
3731*b1cdbd2cSJim Jagielski return SOT_FORMATSTR_ID_SOLK;
3732*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) )
3733*b1cdbd2cSJim Jagielski return SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR;
3734*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) )
3735*b1cdbd2cSJim Jagielski return SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK;
3736*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) )
3737*b1cdbd2cSJim Jagielski return SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR;
3738*b1cdbd2cSJim Jagielski }
3739*b1cdbd2cSJim Jagielski
3740*b1cdbd2cSJim Jagielski sal_uLong nFormatId = 0;
3741*b1cdbd2cSJim Jagielski if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ) )
3742*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_DRAWING;
3743*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) )
3744*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_SVXB;
3745*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ) )
3746*b1cdbd2cSJim Jagielski {
3747*b1cdbd2cSJim Jagielski // If it's a Writer object, insert RTF instead of OLE
3748*b1cdbd2cSJim Jagielski
3749*b1cdbd2cSJim Jagielski sal_Bool bDoRtf = sal_False;
3750*b1cdbd2cSJim Jagielski SotStorageStreamRef xStm;
3751*b1cdbd2cSJim Jagielski TransferableObjectDescriptor aObjDesc;
3752*b1cdbd2cSJim Jagielski if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) &&
3753*b1cdbd2cSJim Jagielski aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_EMBED_SOURCE, xStm ) )
3754*b1cdbd2cSJim Jagielski {
3755*b1cdbd2cSJim Jagielski SotStorageRef xStore( new SotStorage( *xStm ) );
3756*b1cdbd2cSJim Jagielski bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||
3757*b1cdbd2cSJim Jagielski aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )
3758*b1cdbd2cSJim Jagielski && aDataHelper.HasFormat( SOT_FORMAT_RTF ) );
3759*b1cdbd2cSJim Jagielski }
3760*b1cdbd2cSJim Jagielski if ( bDoRtf )
3761*b1cdbd2cSJim Jagielski nFormatId = FORMAT_RTF;
3762*b1cdbd2cSJim Jagielski else
3763*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE;
3764*b1cdbd2cSJim Jagielski }
3765*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE ) )
3766*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE;
3767*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SBA_DATAEXCHANGE ) )
3768*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_SBA_DATAEXCHANGE;
3769*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE ) )
3770*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE;
3771*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_BIFF_8 ) )
3772*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_BIFF_8;
3773*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_BIFF_5 ) )
3774*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_BIFF_5;
3775*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ) )
3776*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_EMBED_SOURCE_OLE;
3777*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ) )
3778*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE;
3779*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ) )
3780*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE_OLE;
3781*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_RTF ) )
3782*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_RTF;
3783*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_HTML ) )
3784*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_HTML;
3785*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_HTML_SIMPLE ) )
3786*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_HTML_SIMPLE;
3787*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SYLK ) )
3788*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_SYLK;
3789*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK ) )
3790*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK;
3791*b1cdbd2cSJim Jagielski else if ( bPreferText && aDataHelper.HasFormat( SOT_FORMAT_STRING ) ) // #i86734# the behaviour introduced in #i62773# is wrong when pasting
3792*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_STRING;
3793*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_FILE_LIST ) )
3794*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_FILE_LIST;
3795*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_FILE ) ) // #i62773# FILE_LIST/FILE before STRING (Unix file managers)
3796*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_FILE;
3797*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_STRING ) )
3798*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_STRING;
3799*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_GDIMETAFILE ) )
3800*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_GDIMETAFILE;
3801*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_PNG ) )
3802*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_PNG;
3803*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_BITMAP ) )
3804*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_BITMAP;
3805*b1cdbd2cSJim Jagielski
3806*b1cdbd2cSJim Jagielski return nFormatId;
3807*b1cdbd2cSJim Jagielski }
3808*b1cdbd2cSJim Jagielski
lcl_GetDropLinkId(const uno::Reference<datatransfer::XTransferable> & xTransfer)3809*b1cdbd2cSJim Jagielski sal_uLong lcl_GetDropLinkId( const uno::Reference<datatransfer::XTransferable>& xTransfer )
3810*b1cdbd2cSJim Jagielski {
3811*b1cdbd2cSJim Jagielski TransferableDataHelper aDataHelper( xTransfer );
3812*b1cdbd2cSJim Jagielski
3813*b1cdbd2cSJim Jagielski sal_uLong nFormatId = 0;
3814*b1cdbd2cSJim Jagielski if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE ) )
3815*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE;
3816*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK_SOURCE_OLE ) )
3817*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK_SOURCE_OLE;
3818*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_LINK ) )
3819*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_LINK;
3820*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_FILE_LIST ) )
3821*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_FILE_LIST;
3822*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMAT_FILE ) )
3823*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMAT_FILE;
3824*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_SOLK ) )
3825*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_SOLK;
3826*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) )
3827*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR;
3828*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) )
3829*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK;
3830*b1cdbd2cSJim Jagielski else if ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) )
3831*b1cdbd2cSJim Jagielski nFormatId = SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR;
3832*b1cdbd2cSJim Jagielski
3833*b1cdbd2cSJim Jagielski return nFormatId;
3834*b1cdbd2cSJim Jagielski }
3835*b1cdbd2cSJim Jagielski
3836*b1cdbd2cSJim Jagielski
ExecutePrivateDrop(const ExecuteDropEvent & rEvt)3837*b1cdbd2cSJim Jagielski sal_Int8 ScGridWindow::ExecutePrivateDrop( const ExecuteDropEvent& rEvt )
3838*b1cdbd2cSJim Jagielski {
3839*b1cdbd2cSJim Jagielski // hide drop marker
3840*b1cdbd2cSJim Jagielski // if (bDragRect)
3841*b1cdbd2cSJim Jagielski // pViewData->GetView()->DrawDragRect( nDragStartX, nDragStartY, nDragEndX, nDragEndY, eWhich );
3842*b1cdbd2cSJim Jagielski bDragRect = sal_False;
3843*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
3844*b1cdbd2cSJim Jagielski
3845*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
3846*b1cdbd2cSJim Jagielski const ScDragData& rData = pScMod->GetDragData();
3847*b1cdbd2cSJim Jagielski
3848*b1cdbd2cSJim Jagielski return DropTransferObj( rData.pCellTransfer, nDragStartX, nDragStartY,
3849*b1cdbd2cSJim Jagielski PixelToLogic(rEvt.maPosPixel), rEvt.mnAction );
3850*b1cdbd2cSJim Jagielski }
3851*b1cdbd2cSJim Jagielski
DropTransferObj(ScTransferObj * pTransObj,SCCOL nDestPosX,SCROW nDestPosY,const Point & rLogicPos,sal_Int8 nDndAction)3852*b1cdbd2cSJim Jagielski sal_Int8 ScGridWindow::DropTransferObj( ScTransferObj* pTransObj, SCCOL nDestPosX, SCROW nDestPosY,
3853*b1cdbd2cSJim Jagielski const Point& rLogicPos, sal_Int8 nDndAction )
3854*b1cdbd2cSJim Jagielski {
3855*b1cdbd2cSJim Jagielski if ( !pTransObj )
3856*b1cdbd2cSJim Jagielski return 0;
3857*b1cdbd2cSJim Jagielski
3858*b1cdbd2cSJim Jagielski ScDocument* pSourceDoc = pTransObj->GetSourceDocument();
3859*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
3860*b1cdbd2cSJim Jagielski ScDocument* pThisDoc = pViewData->GetDocument();
3861*b1cdbd2cSJim Jagielski ScViewFunc* pView = pViewData->GetView();
3862*b1cdbd2cSJim Jagielski SCTAB nThisTab = pViewData->GetTabNo();
3863*b1cdbd2cSJim Jagielski sal_uInt16 nFlags = pTransObj->GetDragSourceFlags();
3864*b1cdbd2cSJim Jagielski
3865*b1cdbd2cSJim Jagielski sal_Bool bIsNavi = ( nFlags & SC_DROP_NAVIGATOR ) != 0;
3866*b1cdbd2cSJim Jagielski sal_Bool bIsMove = ( nDndAction == DND_ACTION_MOVE && !bIsNavi );
3867*b1cdbd2cSJim Jagielski
3868*b1cdbd2cSJim Jagielski // workaround for wrong nDndAction on Windows when pressing solely
3869*b1cdbd2cSJim Jagielski // the Alt key during drag and drop;
3870*b1cdbd2cSJim Jagielski // can be removed after #i79215# has been fixed
3871*b1cdbd2cSJim Jagielski if ( meDragInsertMode != INS_NONE )
3872*b1cdbd2cSJim Jagielski {
3873*b1cdbd2cSJim Jagielski bIsMove = ( nDndAction & DND_ACTION_MOVE && !bIsNavi );
3874*b1cdbd2cSJim Jagielski }
3875*b1cdbd2cSJim Jagielski
3876*b1cdbd2cSJim Jagielski sal_Bool bIsLink = ( nDndAction == DND_ACTION_LINK );
3877*b1cdbd2cSJim Jagielski
3878*b1cdbd2cSJim Jagielski ScRange aSource = pTransObj->GetRange();
3879*b1cdbd2cSJim Jagielski
3880*b1cdbd2cSJim Jagielski // only use visible tab from source range - when dragging within one table,
3881*b1cdbd2cSJim Jagielski // all selected tables at the time of dropping are used (handled in MoveBlockTo)
3882*b1cdbd2cSJim Jagielski SCTAB nSourceTab = pTransObj->GetVisibleTab();
3883*b1cdbd2cSJim Jagielski aSource.aStart.SetTab( nSourceTab );
3884*b1cdbd2cSJim Jagielski aSource.aEnd.SetTab( nSourceTab );
3885*b1cdbd2cSJim Jagielski
3886*b1cdbd2cSJim Jagielski SCCOL nSizeX = aSource.aEnd.Col() - aSource.aStart.Col() + 1;
3887*b1cdbd2cSJim Jagielski SCROW nSizeY = (bIsMove ? (aSource.aEnd.Row() - aSource.aStart.Row() + 1) :
3888*b1cdbd2cSJim Jagielski pTransObj->GetNonFilteredRows()); // copy/link: no filtered rows
3889*b1cdbd2cSJim Jagielski ScRange aDest( nDestPosX, nDestPosY, nThisTab,
3890*b1cdbd2cSJim Jagielski nDestPosX + nSizeX - 1, nDestPosY + nSizeY - 1, nThisTab );
3891*b1cdbd2cSJim Jagielski
3892*b1cdbd2cSJim Jagielski
3893*b1cdbd2cSJim Jagielski /* NOTE: AcceptPrivateDrop() already checked for filtered conditions during
3894*b1cdbd2cSJim Jagielski * dragging and adapted drawing of the selection frame. We check here
3895*b1cdbd2cSJim Jagielski * (again) because this may actually also be called from PasteSelection(),
3896*b1cdbd2cSJim Jagielski * we would have to duplicate determination of flags and destination range
3897*b1cdbd2cSJim Jagielski * and would lose the context of the "filtered destination is OK" cases
3898*b1cdbd2cSJim Jagielski * below, which is already awkward enough as is. */
3899*b1cdbd2cSJim Jagielski
3900*b1cdbd2cSJim Jagielski // Don't move filtered source.
3901*b1cdbd2cSJim Jagielski bool bFiltered = (bIsMove && pTransObj->HasFilteredRows());
3902*b1cdbd2cSJim Jagielski if (!bFiltered)
3903*b1cdbd2cSJim Jagielski {
3904*b1cdbd2cSJim Jagielski if (pSourceDoc != pThisDoc && ((nFlags & SC_DROP_TABLE) ||
3905*b1cdbd2cSJim Jagielski (!bIsLink && meDragInsertMode == INS_NONE)))
3906*b1cdbd2cSJim Jagielski {
3907*b1cdbd2cSJim Jagielski // Nothing. Either entire sheet to be dropped, or the one case
3908*b1cdbd2cSJim Jagielski // where PasteFromClip() is to be called that handles a filtered
3909*b1cdbd2cSJim Jagielski // destination itself. Drag-copy from another document without
3910*b1cdbd2cSJim Jagielski // inserting cells.
3911*b1cdbd2cSJim Jagielski }
3912*b1cdbd2cSJim Jagielski else
3913*b1cdbd2cSJim Jagielski // Don't copy or move to filtered destination.
3914*b1cdbd2cSJim Jagielski bFiltered = ScViewUtil::HasFiltered( aDest, pThisDoc);
3915*b1cdbd2cSJim Jagielski }
3916*b1cdbd2cSJim Jagielski
3917*b1cdbd2cSJim Jagielski sal_Bool bDone = sal_False;
3918*b1cdbd2cSJim Jagielski
3919*b1cdbd2cSJim Jagielski if (!bFiltered && pSourceDoc == pThisDoc)
3920*b1cdbd2cSJim Jagielski {
3921*b1cdbd2cSJim Jagielski if ( nFlags & SC_DROP_TABLE ) // whole sheet?
3922*b1cdbd2cSJim Jagielski {
3923*b1cdbd2cSJim Jagielski if ( pThisDoc->IsDocEditable() )
3924*b1cdbd2cSJim Jagielski {
3925*b1cdbd2cSJim Jagielski SCTAB nSrcTab = aSource.aStart.Tab();
3926*b1cdbd2cSJim Jagielski pViewData->GetDocShell()->MoveTable( nSrcTab, nThisTab, !bIsMove, sal_True ); // with Undo
3927*b1cdbd2cSJim Jagielski pView->SetTabNo( nThisTab, sal_True );
3928*b1cdbd2cSJim Jagielski bDone = sal_True;
3929*b1cdbd2cSJim Jagielski }
3930*b1cdbd2cSJim Jagielski }
3931*b1cdbd2cSJim Jagielski else // move/copy block
3932*b1cdbd2cSJim Jagielski {
3933*b1cdbd2cSJim Jagielski String aChartName;
3934*b1cdbd2cSJim Jagielski if (pThisDoc->HasChartAtPoint( nThisTab, rLogicPos, &aChartName ))
3935*b1cdbd2cSJim Jagielski {
3936*b1cdbd2cSJim Jagielski String aRangeName;
3937*b1cdbd2cSJim Jagielski aSource.Format( aRangeName, SCR_ABS_3D, pThisDoc );
3938*b1cdbd2cSJim Jagielski SfxStringItem aNameItem( SID_CHART_NAME, aChartName );
3939*b1cdbd2cSJim Jagielski SfxStringItem aRangeItem( SID_CHART_SOURCE, aRangeName );
3940*b1cdbd2cSJim Jagielski sal_uInt16 nId = bIsMove ? SID_CHART_SOURCE : SID_CHART_ADDSOURCE;
3941*b1cdbd2cSJim Jagielski pViewData->GetDispatcher().Execute( nId, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
3942*b1cdbd2cSJim Jagielski &aRangeItem, &aNameItem, (void*) NULL );
3943*b1cdbd2cSJim Jagielski bDone = sal_True;
3944*b1cdbd2cSJim Jagielski }
3945*b1cdbd2cSJim Jagielski else if ( pThisDoc->GetDPAtCursor( nDestPosX, nDestPosY, nThisTab ) )
3946*b1cdbd2cSJim Jagielski {
3947*b1cdbd2cSJim Jagielski // drop on DataPilot table: try to sort, fail if that isn't possible
3948*b1cdbd2cSJim Jagielski
3949*b1cdbd2cSJim Jagielski ScAddress aDestPos( nDestPosX, nDestPosY, nThisTab );
3950*b1cdbd2cSJim Jagielski if ( aDestPos != aSource.aStart )
3951*b1cdbd2cSJim Jagielski bDone = pViewData->GetView()->DataPilotMove( aSource, aDestPos );
3952*b1cdbd2cSJim Jagielski else
3953*b1cdbd2cSJim Jagielski bDone = sal_True; // same position: nothing
3954*b1cdbd2cSJim Jagielski }
3955*b1cdbd2cSJim Jagielski else if ( nDestPosX != aSource.aStart.Col() || nDestPosY != aSource.aStart.Row() ||
3956*b1cdbd2cSJim Jagielski nSourceTab != nThisTab )
3957*b1cdbd2cSJim Jagielski {
3958*b1cdbd2cSJim Jagielski String aUndo = ScGlobal::GetRscString( bIsMove ? STR_UNDO_MOVE : STR_UNDO_COPY );
3959*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
3960*b1cdbd2cSJim Jagielski
3961*b1cdbd2cSJim Jagielski bDone = sal_True;
3962*b1cdbd2cSJim Jagielski if ( meDragInsertMode != INS_NONE )
3963*b1cdbd2cSJim Jagielski {
3964*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
3965*b1cdbd2cSJim Jagielski bDone = pDocSh->GetDocFunc().InsertCells( aDest, NULL, meDragInsertMode, sal_True /*bRecord*/, sal_True /*bApi*/, sal_True /*bPartOfPaste*/ );
3966*b1cdbd2cSJim Jagielski if ( bDone )
3967*b1cdbd2cSJim Jagielski {
3968*b1cdbd2cSJim Jagielski if ( nThisTab == nSourceTab )
3969*b1cdbd2cSJim Jagielski {
3970*b1cdbd2cSJim Jagielski if ( meDragInsertMode == INS_CELLSDOWN &&
3971*b1cdbd2cSJim Jagielski nDestPosX == aSource.aStart.Col() && nDestPosY < aSource.aStart.Row() )
3972*b1cdbd2cSJim Jagielski {
3973*b1cdbd2cSJim Jagielski bDone = aSource.Move( 0, nSizeY, 0, pSourceDoc );
3974*b1cdbd2cSJim Jagielski }
3975*b1cdbd2cSJim Jagielski else if ( meDragInsertMode == INS_CELLSRIGHT &&
3976*b1cdbd2cSJim Jagielski nDestPosY == aSource.aStart.Row() && nDestPosX < aSource.aStart.Col() )
3977*b1cdbd2cSJim Jagielski {
3978*b1cdbd2cSJim Jagielski bDone = aSource.Move( nSizeX, 0, 0, pSourceDoc );
3979*b1cdbd2cSJim Jagielski }
3980*b1cdbd2cSJim Jagielski }
3981*b1cdbd2cSJim Jagielski pDocSh->UpdateOle( pViewData );
3982*b1cdbd2cSJim Jagielski pView->CellContentChanged();
3983*b1cdbd2cSJim Jagielski }
3984*b1cdbd2cSJim Jagielski }
3985*b1cdbd2cSJim Jagielski
3986*b1cdbd2cSJim Jagielski if ( bDone )
3987*b1cdbd2cSJim Jagielski {
3988*b1cdbd2cSJim Jagielski if ( bIsLink )
3989*b1cdbd2cSJim Jagielski {
3990*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
3991*b1cdbd2cSJim Jagielski bDone = pView->LinkBlock( aSource, aDest.aStart, sal_True /*bApi*/ );
3992*b1cdbd2cSJim Jagielski }
3993*b1cdbd2cSJim Jagielski else
3994*b1cdbd2cSJim Jagielski {
3995*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
3996*b1cdbd2cSJim Jagielski bDone = pView->MoveBlockTo( aSource, aDest.aStart, bIsMove, sal_True /*bRecord*/, sal_True /*bPaint*/, sal_True /*bApi*/ );
3997*b1cdbd2cSJim Jagielski }
3998*b1cdbd2cSJim Jagielski }
3999*b1cdbd2cSJim Jagielski
4000*b1cdbd2cSJim Jagielski if ( bDone && meDragInsertMode != INS_NONE && bIsMove && nThisTab == nSourceTab )
4001*b1cdbd2cSJim Jagielski {
4002*b1cdbd2cSJim Jagielski DelCellCmd eCmd = DEL_NONE;
4003*b1cdbd2cSJim Jagielski if ( meDragInsertMode == INS_CELLSDOWN )
4004*b1cdbd2cSJim Jagielski {
4005*b1cdbd2cSJim Jagielski eCmd = DEL_CELLSUP;
4006*b1cdbd2cSJim Jagielski }
4007*b1cdbd2cSJim Jagielski else if ( meDragInsertMode == INS_CELLSRIGHT )
4008*b1cdbd2cSJim Jagielski {
4009*b1cdbd2cSJim Jagielski eCmd = DEL_CELLSLEFT;
4010*b1cdbd2cSJim Jagielski }
4011*b1cdbd2cSJim Jagielski
4012*b1cdbd2cSJim Jagielski if ( ( eCmd == DEL_CELLSUP && nDestPosX == aSource.aStart.Col() ) ||
4013*b1cdbd2cSJim Jagielski ( eCmd == DEL_CELLSLEFT && nDestPosY == aSource.aStart.Row() ) )
4014*b1cdbd2cSJim Jagielski {
4015*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
4016*b1cdbd2cSJim Jagielski bDone = pDocSh->GetDocFunc().DeleteCells( aSource, NULL, eCmd, sal_True /*bRecord*/, sal_True /*bApi*/ );
4017*b1cdbd2cSJim Jagielski if ( bDone )
4018*b1cdbd2cSJim Jagielski {
4019*b1cdbd2cSJim Jagielski if ( eCmd == DEL_CELLSUP && nDestPosY > aSource.aEnd.Row() )
4020*b1cdbd2cSJim Jagielski {
4021*b1cdbd2cSJim Jagielski bDone = aDest.Move( 0, -nSizeY, 0, pThisDoc );
4022*b1cdbd2cSJim Jagielski }
4023*b1cdbd2cSJim Jagielski else if ( eCmd == DEL_CELLSLEFT && nDestPosX > aSource.aEnd.Col() )
4024*b1cdbd2cSJim Jagielski {
4025*b1cdbd2cSJim Jagielski bDone = aDest.Move( -nSizeX, 0, 0, pThisDoc );
4026*b1cdbd2cSJim Jagielski }
4027*b1cdbd2cSJim Jagielski pDocSh->UpdateOle( pViewData );
4028*b1cdbd2cSJim Jagielski pView->CellContentChanged();
4029*b1cdbd2cSJim Jagielski }
4030*b1cdbd2cSJim Jagielski }
4031*b1cdbd2cSJim Jagielski }
4032*b1cdbd2cSJim Jagielski
4033*b1cdbd2cSJim Jagielski if ( bDone )
4034*b1cdbd2cSJim Jagielski {
4035*b1cdbd2cSJim Jagielski pView->MarkRange( aDest, sal_False, sal_False );
4036*b1cdbd2cSJim Jagielski pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );
4037*b1cdbd2cSJim Jagielski }
4038*b1cdbd2cSJim Jagielski
4039*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->LeaveListAction();
4040*b1cdbd2cSJim Jagielski
4041*b1cdbd2cSJim Jagielski if (!bDone)
4042*b1cdbd2cSJim Jagielski Sound::Beep(); // instead of error message in drop handler
4043*b1cdbd2cSJim Jagielski }
4044*b1cdbd2cSJim Jagielski else
4045*b1cdbd2cSJim Jagielski bDone = sal_True; // nothing to do
4046*b1cdbd2cSJim Jagielski }
4047*b1cdbd2cSJim Jagielski
4048*b1cdbd2cSJim Jagielski if (bDone)
4049*b1cdbd2cSJim Jagielski pTransObj->SetDragWasInternal(); // don't delete source in DragFinished
4050*b1cdbd2cSJim Jagielski }
4051*b1cdbd2cSJim Jagielski else if ( !bFiltered && pSourceDoc ) // between documents
4052*b1cdbd2cSJim Jagielski {
4053*b1cdbd2cSJim Jagielski if ( nFlags & SC_DROP_TABLE ) // copy/link sheets between documents
4054*b1cdbd2cSJim Jagielski {
4055*b1cdbd2cSJim Jagielski if ( pThisDoc->IsDocEditable() )
4056*b1cdbd2cSJim Jagielski {
4057*b1cdbd2cSJim Jagielski ScDocShell* pSrcShell = pTransObj->GetSourceDocShell();
4058*b1cdbd2cSJim Jagielski
4059*b1cdbd2cSJim Jagielski SCTAB nTabs[MAXTABCOUNT];
4060*b1cdbd2cSJim Jagielski
4061*b1cdbd2cSJim Jagielski ScMarkData aMark = pTransObj->GetSourceMarkData();
4062*b1cdbd2cSJim Jagielski SCTAB nTabCount = pSourceDoc->GetTableCount();
4063*b1cdbd2cSJim Jagielski SCTAB nTabSelCount = 0;
4064*b1cdbd2cSJim Jagielski
4065*b1cdbd2cSJim Jagielski for(SCTAB i=0; i<nTabCount; i++)
4066*b1cdbd2cSJim Jagielski {
4067*b1cdbd2cSJim Jagielski if(aMark.GetTableSelect(i))
4068*b1cdbd2cSJim Jagielski {
4069*b1cdbd2cSJim Jagielski nTabs[nTabSelCount++]=i;
4070*b1cdbd2cSJim Jagielski for(SCTAB j=i+1;j<nTabCount;j++)
4071*b1cdbd2cSJim Jagielski {
4072*b1cdbd2cSJim Jagielski if((!pSourceDoc->IsVisible(j))&&(pSourceDoc->IsScenario(j)))
4073*b1cdbd2cSJim Jagielski {
4074*b1cdbd2cSJim Jagielski nTabs[nTabSelCount++]=j;
4075*b1cdbd2cSJim Jagielski i=j;
4076*b1cdbd2cSJim Jagielski }
4077*b1cdbd2cSJim Jagielski else break;
4078*b1cdbd2cSJim Jagielski }
4079*b1cdbd2cSJim Jagielski }
4080*b1cdbd2cSJim Jagielski }
4081*b1cdbd2cSJim Jagielski
4082*b1cdbd2cSJim Jagielski pView->ImportTables( pSrcShell,nTabSelCount, nTabs, bIsLink, nThisTab );
4083*b1cdbd2cSJim Jagielski bDone = sal_True;
4084*b1cdbd2cSJim Jagielski }
4085*b1cdbd2cSJim Jagielski }
4086*b1cdbd2cSJim Jagielski else if ( bIsLink )
4087*b1cdbd2cSJim Jagielski {
4088*b1cdbd2cSJim Jagielski // as in PasteDDE
4089*b1cdbd2cSJim Jagielski // (external references might be used instead?)
4090*b1cdbd2cSJim Jagielski
4091*b1cdbd2cSJim Jagielski SfxObjectShell* pSourceSh = pSourceDoc->GetDocumentShell();
4092*b1cdbd2cSJim Jagielski DBG_ASSERT(pSourceSh, "drag document has no shell");
4093*b1cdbd2cSJim Jagielski if (pSourceSh)
4094*b1cdbd2cSJim Jagielski {
4095*b1cdbd2cSJim Jagielski String aUndo = ScGlobal::GetRscString( STR_UNDO_COPY );
4096*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
4097*b1cdbd2cSJim Jagielski
4098*b1cdbd2cSJim Jagielski bDone = sal_True;
4099*b1cdbd2cSJim Jagielski if ( meDragInsertMode != INS_NONE )
4100*b1cdbd2cSJim Jagielski {
4101*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
4102*b1cdbd2cSJim Jagielski bDone = pDocSh->GetDocFunc().InsertCells( aDest, NULL, meDragInsertMode, sal_True /*bRecord*/, sal_True /*bApi*/, sal_True /*bPartOfPaste*/ );
4103*b1cdbd2cSJim Jagielski if ( bDone )
4104*b1cdbd2cSJim Jagielski {
4105*b1cdbd2cSJim Jagielski pDocSh->UpdateOle( pViewData );
4106*b1cdbd2cSJim Jagielski pView->CellContentChanged();
4107*b1cdbd2cSJim Jagielski }
4108*b1cdbd2cSJim Jagielski }
4109*b1cdbd2cSJim Jagielski
4110*b1cdbd2cSJim Jagielski if ( bDone )
4111*b1cdbd2cSJim Jagielski {
4112*b1cdbd2cSJim Jagielski String aApp = Application::GetAppName();
4113*b1cdbd2cSJim Jagielski String aTopic = pSourceSh->GetTitle( SFX_TITLE_FULLNAME );
4114*b1cdbd2cSJim Jagielski String aItem;
4115*b1cdbd2cSJim Jagielski aSource.Format( aItem, SCA_VALID | SCA_TAB_3D, pSourceDoc );
4116*b1cdbd2cSJim Jagielski
4117*b1cdbd2cSJim Jagielski // TODO: we could define ocQuote for "
4118*b1cdbd2cSJim Jagielski const String aQuote( '"' );
4119*b1cdbd2cSJim Jagielski const String& sSep = ScCompiler::GetNativeSymbol( ocSep);
4120*b1cdbd2cSJim Jagielski String aFormula( '=' );
4121*b1cdbd2cSJim Jagielski aFormula += ScCompiler::GetNativeSymbol( ocDde);
4122*b1cdbd2cSJim Jagielski aFormula += ScCompiler::GetNativeSymbol( ocOpen);
4123*b1cdbd2cSJim Jagielski aFormula += aQuote;
4124*b1cdbd2cSJim Jagielski aFormula += aApp;
4125*b1cdbd2cSJim Jagielski aFormula += aQuote;
4126*b1cdbd2cSJim Jagielski aFormula += sSep;
4127*b1cdbd2cSJim Jagielski aFormula += aQuote;
4128*b1cdbd2cSJim Jagielski aFormula += aTopic;
4129*b1cdbd2cSJim Jagielski aFormula += aQuote;
4130*b1cdbd2cSJim Jagielski aFormula += sSep;
4131*b1cdbd2cSJim Jagielski aFormula += aQuote;
4132*b1cdbd2cSJim Jagielski aFormula += aItem;
4133*b1cdbd2cSJim Jagielski aFormula += aQuote;
4134*b1cdbd2cSJim Jagielski aFormula += ScCompiler::GetNativeSymbol( ocClose);
4135*b1cdbd2cSJim Jagielski
4136*b1cdbd2cSJim Jagielski pView->DoneBlockMode();
4137*b1cdbd2cSJim Jagielski pView->InitBlockMode( nDestPosX, nDestPosY, nThisTab );
4138*b1cdbd2cSJim Jagielski pView->MarkCursor( nDestPosX + nSizeX - 1,
4139*b1cdbd2cSJim Jagielski nDestPosY + nSizeY - 1, nThisTab );
4140*b1cdbd2cSJim Jagielski
4141*b1cdbd2cSJim Jagielski pView->EnterMatrix( aFormula );
4142*b1cdbd2cSJim Jagielski
4143*b1cdbd2cSJim Jagielski pView->MarkRange( aDest, sal_False, sal_False );
4144*b1cdbd2cSJim Jagielski pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );
4145*b1cdbd2cSJim Jagielski }
4146*b1cdbd2cSJim Jagielski
4147*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->LeaveListAction();
4148*b1cdbd2cSJim Jagielski }
4149*b1cdbd2cSJim Jagielski }
4150*b1cdbd2cSJim Jagielski else
4151*b1cdbd2cSJim Jagielski {
4152*b1cdbd2cSJim Jagielski //! HasSelectedBlockMatrixFragment without selected sheet?
4153*b1cdbd2cSJim Jagielski //! or don't start dragging on a part of a matrix
4154*b1cdbd2cSJim Jagielski
4155*b1cdbd2cSJim Jagielski String aUndo = ScGlobal::GetRscString( bIsMove ? STR_UNDO_MOVE : STR_UNDO_COPY );
4156*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo );
4157*b1cdbd2cSJim Jagielski
4158*b1cdbd2cSJim Jagielski bDone = sal_True;
4159*b1cdbd2cSJim Jagielski if ( meDragInsertMode != INS_NONE )
4160*b1cdbd2cSJim Jagielski {
4161*b1cdbd2cSJim Jagielski // call with bApi = sal_True to avoid error messages in drop handler
4162*b1cdbd2cSJim Jagielski bDone = pDocSh->GetDocFunc().InsertCells( aDest, NULL, meDragInsertMode, sal_True /*bRecord*/, sal_True /*bApi*/, sal_True /*bPartOfPaste*/ );
4163*b1cdbd2cSJim Jagielski if ( bDone )
4164*b1cdbd2cSJim Jagielski {
4165*b1cdbd2cSJim Jagielski pDocSh->UpdateOle( pViewData );
4166*b1cdbd2cSJim Jagielski pView->CellContentChanged();
4167*b1cdbd2cSJim Jagielski }
4168*b1cdbd2cSJim Jagielski }
4169*b1cdbd2cSJim Jagielski
4170*b1cdbd2cSJim Jagielski if ( bDone )
4171*b1cdbd2cSJim Jagielski {
4172*b1cdbd2cSJim Jagielski pView->Unmark(); // before SetCursor, so CheckSelectionTransfer isn't called with a selection
4173*b1cdbd2cSJim Jagielski pView->SetCursor( nDestPosX, nDestPosY );
4174*b1cdbd2cSJim Jagielski bDone = pView->PasteFromClip( IDF_ALL, pTransObj->GetDocument() ); // clip-doc
4175*b1cdbd2cSJim Jagielski if ( bDone )
4176*b1cdbd2cSJim Jagielski {
4177*b1cdbd2cSJim Jagielski pView->MarkRange( aDest, sal_False, sal_False );
4178*b1cdbd2cSJim Jagielski pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );
4179*b1cdbd2cSJim Jagielski }
4180*b1cdbd2cSJim Jagielski }
4181*b1cdbd2cSJim Jagielski
4182*b1cdbd2cSJim Jagielski pDocSh->GetUndoManager()->LeaveListAction();
4183*b1cdbd2cSJim Jagielski
4184*b1cdbd2cSJim Jagielski // no longer call ResetMark here - the inserted block has been selected
4185*b1cdbd2cSJim Jagielski // and may have been copied to primary selection
4186*b1cdbd2cSJim Jagielski }
4187*b1cdbd2cSJim Jagielski }
4188*b1cdbd2cSJim Jagielski
4189*b1cdbd2cSJim Jagielski sal_Int8 nRet = bDone ? nDndAction : DND_ACTION_NONE;
4190*b1cdbd2cSJim Jagielski return nRet;
4191*b1cdbd2cSJim Jagielski }
4192*b1cdbd2cSJim Jagielski
ExecuteDrop(const ExecuteDropEvent & rEvt)4193*b1cdbd2cSJim Jagielski sal_Int8 ScGridWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
4194*b1cdbd2cSJim Jagielski {
4195*b1cdbd2cSJim Jagielski DrawMarkDropObj( NULL ); // drawing layer
4196*b1cdbd2cSJim Jagielski
4197*b1cdbd2cSJim Jagielski ScModule* pScMod = SC_MOD();
4198*b1cdbd2cSJim Jagielski const ScDragData& rData = pScMod->GetDragData();
4199*b1cdbd2cSJim Jagielski if (rData.pCellTransfer)
4200*b1cdbd2cSJim Jagielski return ExecutePrivateDrop( rEvt );
4201*b1cdbd2cSJim Jagielski
4202*b1cdbd2cSJim Jagielski Point aPos = rEvt.maPosPixel;
4203*b1cdbd2cSJim Jagielski
4204*b1cdbd2cSJim Jagielski if ( rData.aLinkDoc.Len() )
4205*b1cdbd2cSJim Jagielski {
4206*b1cdbd2cSJim Jagielski // try to insert a link
4207*b1cdbd2cSJim Jagielski
4208*b1cdbd2cSJim Jagielski sal_Bool bOk = sal_True;
4209*b1cdbd2cSJim Jagielski String aThisName;
4210*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
4211*b1cdbd2cSJim Jagielski if (pDocSh && pDocSh->HasName())
4212*b1cdbd2cSJim Jagielski aThisName = pDocSh->GetMedium()->GetName();
4213*b1cdbd2cSJim Jagielski
4214*b1cdbd2cSJim Jagielski if ( rData.aLinkDoc == aThisName ) // error - no link within a document
4215*b1cdbd2cSJim Jagielski bOk = sal_False;
4216*b1cdbd2cSJim Jagielski else
4217*b1cdbd2cSJim Jagielski {
4218*b1cdbd2cSJim Jagielski ScViewFunc* pView = pViewData->GetView();
4219*b1cdbd2cSJim Jagielski if ( rData.aLinkTable.Len() )
4220*b1cdbd2cSJim Jagielski pView->InsertTableLink( rData.aLinkDoc, EMPTY_STRING, EMPTY_STRING,
4221*b1cdbd2cSJim Jagielski rData.aLinkTable );
4222*b1cdbd2cSJim Jagielski else if ( rData.aLinkArea.Len() )
4223*b1cdbd2cSJim Jagielski {
4224*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4225*b1cdbd2cSJim Jagielski SCsROW nPosY;
4226*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
4227*b1cdbd2cSJim Jagielski pView->MoveCursorAbs( nPosX, nPosY, SC_FOLLOW_NONE, sal_False, sal_False );
4228*b1cdbd2cSJim Jagielski
4229*b1cdbd2cSJim Jagielski pView->InsertAreaLink( rData.aLinkDoc, EMPTY_STRING, EMPTY_STRING,
4230*b1cdbd2cSJim Jagielski rData.aLinkArea, 0 );
4231*b1cdbd2cSJim Jagielski }
4232*b1cdbd2cSJim Jagielski else
4233*b1cdbd2cSJim Jagielski {
4234*b1cdbd2cSJim Jagielski DBG_ERROR("drop with link: no sheet nor area");
4235*b1cdbd2cSJim Jagielski bOk = sal_False;
4236*b1cdbd2cSJim Jagielski }
4237*b1cdbd2cSJim Jagielski }
4238*b1cdbd2cSJim Jagielski
4239*b1cdbd2cSJim Jagielski return bOk ? rEvt.mnAction : DND_ACTION_NONE; // don't try anything else
4240*b1cdbd2cSJim Jagielski }
4241*b1cdbd2cSJim Jagielski
4242*b1cdbd2cSJim Jagielski Point aLogicPos = PixelToLogic(aPos);
4243*b1cdbd2cSJim Jagielski sal_Bool bIsLink = ( rEvt.mnAction == DND_ACTION_LINK );
4244*b1cdbd2cSJim Jagielski
4245*b1cdbd2cSJim Jagielski if (!bIsLink && rData.pDrawTransfer)
4246*b1cdbd2cSJim Jagielski {
4247*b1cdbd2cSJim Jagielski sal_uInt16 nFlags = rData.pDrawTransfer->GetDragSourceFlags();
4248*b1cdbd2cSJim Jagielski
4249*b1cdbd2cSJim Jagielski sal_Bool bIsNavi = ( nFlags & SC_DROP_NAVIGATOR ) != 0;
4250*b1cdbd2cSJim Jagielski sal_Bool bIsMove = ( rEvt.mnAction == DND_ACTION_MOVE && !bIsNavi );
4251*b1cdbd2cSJim Jagielski
4252*b1cdbd2cSJim Jagielski bPasteIsMove = bIsMove;
4253*b1cdbd2cSJim Jagielski
4254*b1cdbd2cSJim Jagielski pViewData->GetView()->PasteDraw( aLogicPos, rData.pDrawTransfer->GetModel() );
4255*b1cdbd2cSJim Jagielski
4256*b1cdbd2cSJim Jagielski if (bPasteIsMove)
4257*b1cdbd2cSJim Jagielski rData.pDrawTransfer->SetDragWasInternal();
4258*b1cdbd2cSJim Jagielski bPasteIsMove = sal_False;
4259*b1cdbd2cSJim Jagielski
4260*b1cdbd2cSJim Jagielski return rEvt.mnAction;
4261*b1cdbd2cSJim Jagielski }
4262*b1cdbd2cSJim Jagielski
4263*b1cdbd2cSJim Jagielski
4264*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4265*b1cdbd2cSJim Jagielski SCsROW nPosY;
4266*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
4267*b1cdbd2cSJim Jagielski
4268*b1cdbd2cSJim Jagielski if (rData.aJumpTarget.Len())
4269*b1cdbd2cSJim Jagielski {
4270*b1cdbd2cSJim Jagielski // internal bookmark (from Navigator)
4271*b1cdbd2cSJim Jagielski // bookmark clipboard formats are in PasteScDataObject
4272*b1cdbd2cSJim Jagielski
4273*b1cdbd2cSJim Jagielski if ( !rData.pJumpLocalDoc || rData.pJumpLocalDoc == pViewData->GetDocument() )
4274*b1cdbd2cSJim Jagielski {
4275*b1cdbd2cSJim Jagielski pViewData->GetViewShell()->InsertBookmark( rData.aJumpText, rData.aJumpTarget,
4276*b1cdbd2cSJim Jagielski nPosX, nPosY );
4277*b1cdbd2cSJim Jagielski return rEvt.mnAction;
4278*b1cdbd2cSJim Jagielski }
4279*b1cdbd2cSJim Jagielski }
4280*b1cdbd2cSJim Jagielski
4281*b1cdbd2cSJim Jagielski ScDocument* pThisDoc = pViewData->GetDocument();
4282*b1cdbd2cSJim Jagielski SdrObject* pHitObj = pThisDoc->GetObjectAtPoint( pViewData->GetTabNo(), PixelToLogic(aPos) );
4283*b1cdbd2cSJim Jagielski if ( pHitObj && bIsLink )
4284*b1cdbd2cSJim Jagielski {
4285*b1cdbd2cSJim Jagielski // dropped on drawing object
4286*b1cdbd2cSJim Jagielski // PasteOnDrawObjectLinked checks for valid formats
4287*b1cdbd2cSJim Jagielski if ( pViewData->GetView()->PasteOnDrawObjectLinked( rEvt.maDropEvent.Transferable, *pHitObj ) )
4288*b1cdbd2cSJim Jagielski return rEvt.mnAction;
4289*b1cdbd2cSJim Jagielski }
4290*b1cdbd2cSJim Jagielski
4291*b1cdbd2cSJim Jagielski sal_Bool bDone = sal_False;
4292*b1cdbd2cSJim Jagielski
4293*b1cdbd2cSJim Jagielski sal_uLong nFormatId = bIsLink ?
4294*b1cdbd2cSJim Jagielski lcl_GetDropLinkId( rEvt.maDropEvent.Transferable ) :
4295*b1cdbd2cSJim Jagielski lcl_GetDropFormatId( rEvt.maDropEvent.Transferable );
4296*b1cdbd2cSJim Jagielski if ( nFormatId )
4297*b1cdbd2cSJim Jagielski {
4298*b1cdbd2cSJim Jagielski pScMod->SetInExecuteDrop( sal_True ); // #i28468# prevent error messages from PasteDataFormat
4299*b1cdbd2cSJim Jagielski bPasteIsDrop = sal_True;
4300*b1cdbd2cSJim Jagielski bDone = pViewData->GetView()->PasteDataFormat(
4301*b1cdbd2cSJim Jagielski nFormatId, rEvt.maDropEvent.Transferable, nPosX, nPosY, &aLogicPos, bIsLink );
4302*b1cdbd2cSJim Jagielski bPasteIsDrop = sal_False;
4303*b1cdbd2cSJim Jagielski pScMod->SetInExecuteDrop( sal_False );
4304*b1cdbd2cSJim Jagielski }
4305*b1cdbd2cSJim Jagielski
4306*b1cdbd2cSJim Jagielski sal_Int8 nRet = bDone ? rEvt.mnAction : DND_ACTION_NONE;
4307*b1cdbd2cSJim Jagielski return nRet;
4308*b1cdbd2cSJim Jagielski }
4309*b1cdbd2cSJim Jagielski
4310*b1cdbd2cSJim Jagielski //--------------------------------------------------------
4311*b1cdbd2cSJim Jagielski
PasteSelection(const Point & rPosPixel)4312*b1cdbd2cSJim Jagielski void ScGridWindow::PasteSelection( const Point& rPosPixel )
4313*b1cdbd2cSJim Jagielski {
4314*b1cdbd2cSJim Jagielski Point aLogicPos = PixelToLogic( rPosPixel );
4315*b1cdbd2cSJim Jagielski
4316*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4317*b1cdbd2cSJim Jagielski SCsROW nPosY;
4318*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( rPosPixel.X(), rPosPixel.Y(), eWhich, nPosX, nPosY );
4319*b1cdbd2cSJim Jagielski
4320*b1cdbd2cSJim Jagielski ScSelectionTransferObj* pOwnSelection = SC_MOD()->GetSelectionTransfer();
4321*b1cdbd2cSJim Jagielski if ( pOwnSelection )
4322*b1cdbd2cSJim Jagielski {
4323*b1cdbd2cSJim Jagielski // within Calc
4324*b1cdbd2cSJim Jagielski
4325*b1cdbd2cSJim Jagielski ScTransferObj* pCellTransfer = pOwnSelection->GetCellData();
4326*b1cdbd2cSJim Jagielski if ( pCellTransfer )
4327*b1cdbd2cSJim Jagielski {
4328*b1cdbd2cSJim Jagielski // keep a reference to the data in case the selection is changed during paste
4329*b1cdbd2cSJim Jagielski uno::Reference<datatransfer::XTransferable> xRef( pCellTransfer );
4330*b1cdbd2cSJim Jagielski DropTransferObj( pCellTransfer, nPosX, nPosY, aLogicPos, DND_ACTION_COPY );
4331*b1cdbd2cSJim Jagielski }
4332*b1cdbd2cSJim Jagielski else
4333*b1cdbd2cSJim Jagielski {
4334*b1cdbd2cSJim Jagielski ScDrawTransferObj* pDrawTransfer = pOwnSelection->GetDrawData();
4335*b1cdbd2cSJim Jagielski if ( pDrawTransfer )
4336*b1cdbd2cSJim Jagielski {
4337*b1cdbd2cSJim Jagielski // keep a reference to the data in case the selection is changed during paste
4338*b1cdbd2cSJim Jagielski uno::Reference<datatransfer::XTransferable> xRef( pDrawTransfer );
4339*b1cdbd2cSJim Jagielski
4340*b1cdbd2cSJim Jagielski // #96821# bSameDocClipboard argument for PasteDraw is needed
4341*b1cdbd2cSJim Jagielski // because only DragData is checked directly inside PasteDraw
4342*b1cdbd2cSJim Jagielski pViewData->GetView()->PasteDraw( aLogicPos, pDrawTransfer->GetModel(), sal_False,
4343*b1cdbd2cSJim Jagielski pDrawTransfer->GetSourceDocID() == pViewData->GetDocument()->GetDocumentID() );
4344*b1cdbd2cSJim Jagielski }
4345*b1cdbd2cSJim Jagielski }
4346*b1cdbd2cSJim Jagielski }
4347*b1cdbd2cSJim Jagielski else
4348*b1cdbd2cSJim Jagielski {
4349*b1cdbd2cSJim Jagielski // get selection from system
4350*b1cdbd2cSJim Jagielski
4351*b1cdbd2cSJim Jagielski TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSelection( this ) );
4352*b1cdbd2cSJim Jagielski uno::Reference<datatransfer::XTransferable> xTransferable = aDataHelper.GetTransferable();
4353*b1cdbd2cSJim Jagielski if ( xTransferable.is() )
4354*b1cdbd2cSJim Jagielski {
4355*b1cdbd2cSJim Jagielski sal_uLong nFormatId = lcl_GetDropFormatId( xTransferable, true );
4356*b1cdbd2cSJim Jagielski if ( nFormatId )
4357*b1cdbd2cSJim Jagielski {
4358*b1cdbd2cSJim Jagielski bPasteIsDrop = sal_True;
4359*b1cdbd2cSJim Jagielski pViewData->GetView()->PasteDataFormat( nFormatId, xTransferable, nPosX, nPosY, &aLogicPos );
4360*b1cdbd2cSJim Jagielski bPasteIsDrop = sal_False;
4361*b1cdbd2cSJim Jagielski }
4362*b1cdbd2cSJim Jagielski }
4363*b1cdbd2cSJim Jagielski }
4364*b1cdbd2cSJim Jagielski }
4365*b1cdbd2cSJim Jagielski
4366*b1cdbd2cSJim Jagielski //--------------------------------------------------------
4367*b1cdbd2cSJim Jagielski
UpdateEditViewPos()4368*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateEditViewPos()
4369*b1cdbd2cSJim Jagielski {
4370*b1cdbd2cSJim Jagielski if (pViewData->HasEditView(eWhich))
4371*b1cdbd2cSJim Jagielski {
4372*b1cdbd2cSJim Jagielski EditView* pView;
4373*b1cdbd2cSJim Jagielski SCCOL nCol;
4374*b1cdbd2cSJim Jagielski SCROW nRow;
4375*b1cdbd2cSJim Jagielski pViewData->GetEditView( eWhich, pView, nCol, nRow );
4376*b1cdbd2cSJim Jagielski SCCOL nEndCol = pViewData->GetEditEndCol();
4377*b1cdbd2cSJim Jagielski SCROW nEndRow = pViewData->GetEditEndRow();
4378*b1cdbd2cSJim Jagielski
4379*b1cdbd2cSJim Jagielski // hide EditView?
4380*b1cdbd2cSJim Jagielski
4381*b1cdbd2cSJim Jagielski sal_Bool bHide = ( nEndCol<pViewData->GetPosX(eHWhich) || nEndRow<pViewData->GetPosY(eVWhich) );
4382*b1cdbd2cSJim Jagielski if ( SC_MOD()->IsFormulaMode() )
4383*b1cdbd2cSJim Jagielski if ( pViewData->GetTabNo() != pViewData->GetRefTabNo() )
4384*b1cdbd2cSJim Jagielski bHide = sal_True;
4385*b1cdbd2cSJim Jagielski
4386*b1cdbd2cSJim Jagielski if (bHide)
4387*b1cdbd2cSJim Jagielski {
4388*b1cdbd2cSJim Jagielski Rectangle aRect = pView->GetOutputArea();
4389*b1cdbd2cSJim Jagielski long nHeight = aRect.Bottom() - aRect.Top();
4390*b1cdbd2cSJim Jagielski aRect.Top() = PixelToLogic(GetOutputSizePixel(), pViewData->GetLogicMode()).
4391*b1cdbd2cSJim Jagielski Height() * 2;
4392*b1cdbd2cSJim Jagielski aRect.Bottom() = aRect.Top() + nHeight;
4393*b1cdbd2cSJim Jagielski pView->SetOutputArea( aRect );
4394*b1cdbd2cSJim Jagielski pView->HideCursor();
4395*b1cdbd2cSJim Jagielski }
4396*b1cdbd2cSJim Jagielski else
4397*b1cdbd2cSJim Jagielski {
4398*b1cdbd2cSJim Jagielski // bForceToTop = sal_True for editing
4399*b1cdbd2cSJim Jagielski Rectangle aPixRect = pViewData->GetEditArea( eWhich, nCol, nRow, this, NULL, sal_True );
4400*b1cdbd2cSJim Jagielski Point aScrPos = PixelToLogic( aPixRect.TopLeft(), pViewData->GetLogicMode() );
4401*b1cdbd2cSJim Jagielski
4402*b1cdbd2cSJim Jagielski Rectangle aRect = pView->GetOutputArea();
4403*b1cdbd2cSJim Jagielski aRect.SetPos( aScrPos );
4404*b1cdbd2cSJim Jagielski pView->SetOutputArea( aRect );
4405*b1cdbd2cSJim Jagielski pView->ShowCursor();
4406*b1cdbd2cSJim Jagielski }
4407*b1cdbd2cSJim Jagielski }
4408*b1cdbd2cSJim Jagielski }
4409*b1cdbd2cSJim Jagielski
ScrollPixel(long nDifX,long nDifY)4410*b1cdbd2cSJim Jagielski void ScGridWindow::ScrollPixel( long nDifX, long nDifY )
4411*b1cdbd2cSJim Jagielski {
4412*b1cdbd2cSJim Jagielski ClickExtern();
4413*b1cdbd2cSJim Jagielski HideNoteMarker();
4414*b1cdbd2cSJim Jagielski
4415*b1cdbd2cSJim Jagielski bIsInScroll = sal_True;
4416*b1cdbd2cSJim Jagielski //sal_Bool bXor=DrawBeforeScroll();
4417*b1cdbd2cSJim Jagielski
4418*b1cdbd2cSJim Jagielski SetMapMode(MAP_PIXEL);
4419*b1cdbd2cSJim Jagielski Scroll( nDifX, nDifY, SCROLL_CHILDREN );
4420*b1cdbd2cSJim Jagielski SetMapMode( GetDrawMapMode() ); // verschobenen MapMode erzeugen
4421*b1cdbd2cSJim Jagielski
4422*b1cdbd2cSJim Jagielski UpdateEditViewPos();
4423*b1cdbd2cSJim Jagielski
4424*b1cdbd2cSJim Jagielski DrawAfterScroll(); //bXor);
4425*b1cdbd2cSJim Jagielski bIsInScroll = sal_False;
4426*b1cdbd2cSJim Jagielski }
4427*b1cdbd2cSJim Jagielski
4428*b1cdbd2cSJim Jagielski // Formeln neu zeichnen -------------------------------------------------
4429*b1cdbd2cSJim Jagielski
UpdateFormulas()4430*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateFormulas()
4431*b1cdbd2cSJim Jagielski {
4432*b1cdbd2cSJim Jagielski if (pViewData->GetView()->IsMinimized())
4433*b1cdbd2cSJim Jagielski return;
4434*b1cdbd2cSJim Jagielski
4435*b1cdbd2cSJim Jagielski if ( nPaintCount )
4436*b1cdbd2cSJim Jagielski {
4437*b1cdbd2cSJim Jagielski // nicht anfangen, verschachtelt zu painten
4438*b1cdbd2cSJim Jagielski // (dann wuerde zumindest der MapMode nicht mehr stimmen)
4439*b1cdbd2cSJim Jagielski
4440*b1cdbd2cSJim Jagielski bNeedsRepaint = sal_True; // -> am Ende vom Paint nochmal Invalidate auf alles
4441*b1cdbd2cSJim Jagielski aRepaintPixel = Rectangle(); // alles
4442*b1cdbd2cSJim Jagielski return;
4443*b1cdbd2cSJim Jagielski }
4444*b1cdbd2cSJim Jagielski
4445*b1cdbd2cSJim Jagielski SCCOL nX1 = pViewData->GetPosX( eHWhich );
4446*b1cdbd2cSJim Jagielski SCROW nY1 = pViewData->GetPosY( eVWhich );
4447*b1cdbd2cSJim Jagielski SCCOL nX2 = nX1 + pViewData->VisibleCellsX( eHWhich );
4448*b1cdbd2cSJim Jagielski SCROW nY2 = nY1 + pViewData->VisibleCellsY( eVWhich );
4449*b1cdbd2cSJim Jagielski
4450*b1cdbd2cSJim Jagielski if (nX2 > MAXCOL) nX2 = MAXCOL;
4451*b1cdbd2cSJim Jagielski if (nY2 > MAXROW) nY2 = MAXROW;
4452*b1cdbd2cSJim Jagielski
4453*b1cdbd2cSJim Jagielski // Draw( nX1, nY1, nX2, nY2, SC_UPDATE_CHANGED );
4454*b1cdbd2cSJim Jagielski
4455*b1cdbd2cSJim Jagielski // don't draw directly - instead use OutputData to find changed area and invalidate
4456*b1cdbd2cSJim Jagielski
4457*b1cdbd2cSJim Jagielski SCROW nPosY = nY1;
4458*b1cdbd2cSJim Jagielski
4459*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
4460*b1cdbd2cSJim Jagielski ScDocument* pDoc = pDocSh->GetDocument();
4461*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
4462*b1cdbd2cSJim Jagielski
4463*b1cdbd2cSJim Jagielski pDoc->ExtendHidden( nX1, nY1, nX2, nY2, nTab );
4464*b1cdbd2cSJim Jagielski
4465*b1cdbd2cSJim Jagielski Point aScrPos = pViewData->GetScrPos( nX1, nY1, eWhich );
4466*b1cdbd2cSJim Jagielski long nMirrorWidth = GetSizePixel().Width();
4467*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
4468*b1cdbd2cSJim Jagielski // unused variable long nLayoutSign = bLayoutRTL ? -1 : 1;
4469*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
4470*b1cdbd2cSJim Jagielski {
4471*b1cdbd2cSJim Jagielski long nEndPixel = pViewData->GetScrPos( nX2+1, nPosY, eWhich ).X();
4472*b1cdbd2cSJim Jagielski nMirrorWidth = aScrPos.X() - nEndPixel;
4473*b1cdbd2cSJim Jagielski aScrPos.X() = nEndPixel + 1;
4474*b1cdbd2cSJim Jagielski }
4475*b1cdbd2cSJim Jagielski
4476*b1cdbd2cSJim Jagielski long nScrX = aScrPos.X();
4477*b1cdbd2cSJim Jagielski long nScrY = aScrPos.Y();
4478*b1cdbd2cSJim Jagielski
4479*b1cdbd2cSJim Jagielski double nPPTX = pViewData->GetPPTX();
4480*b1cdbd2cSJim Jagielski double nPPTY = pViewData->GetPPTY();
4481*b1cdbd2cSJim Jagielski
4482*b1cdbd2cSJim Jagielski ScTableInfo aTabInfo;
4483*b1cdbd2cSJim Jagielski pDoc->FillInfo( aTabInfo, nX1, nY1, nX2, nY2, nTab, nPPTX, nPPTY, sal_False, sal_False );
4484*b1cdbd2cSJim Jagielski
4485*b1cdbd2cSJim Jagielski Fraction aZoomX = pViewData->GetZoomX();
4486*b1cdbd2cSJim Jagielski Fraction aZoomY = pViewData->GetZoomY();
4487*b1cdbd2cSJim Jagielski ScOutputData aOutputData( this, OUTTYPE_WINDOW, aTabInfo, pDoc, nTab,
4488*b1cdbd2cSJim Jagielski nScrX, nScrY, nX1, nY1, nX2, nY2, nPPTX, nPPTY,
4489*b1cdbd2cSJim Jagielski &aZoomX, &aZoomY );
4490*b1cdbd2cSJim Jagielski aOutputData.SetMirrorWidth( nMirrorWidth );
4491*b1cdbd2cSJim Jagielski
4492*b1cdbd2cSJim Jagielski aOutputData.FindChanged();
4493*b1cdbd2cSJim Jagielski
4494*b1cdbd2cSJim Jagielski // #122149# do not use old GetChangedArea() which used polygon-based Regions, but use
4495*b1cdbd2cSJim Jagielski // the region-band based new version; anyways, only rectangles are added
4496*b1cdbd2cSJim Jagielski Region aChangedRegion( aOutputData.GetChangedAreaRegion() ); // logic (PixelToLogic)
4497*b1cdbd2cSJim Jagielski if(!aChangedRegion.IsEmpty())
4498*b1cdbd2cSJim Jagielski {
4499*b1cdbd2cSJim Jagielski Invalidate(aChangedRegion);
4500*b1cdbd2cSJim Jagielski }
4501*b1cdbd2cSJim Jagielski
4502*b1cdbd2cSJim Jagielski CheckNeedsRepaint(); // #i90362# used to be called via Draw() - still needed here
4503*b1cdbd2cSJim Jagielski }
4504*b1cdbd2cSJim Jagielski
UpdateAutoFillMark(sal_Bool bMarked,const ScRange & rMarkRange)4505*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateAutoFillMark(sal_Bool bMarked, const ScRange& rMarkRange)
4506*b1cdbd2cSJim Jagielski {
4507*b1cdbd2cSJim Jagielski if ( bMarked != bAutoMarkVisible || ( bMarked && rMarkRange.aEnd != aAutoMarkPos ) )
4508*b1cdbd2cSJim Jagielski {
4509*b1cdbd2cSJim Jagielski HideCursor();
4510*b1cdbd2cSJim Jagielski bAutoMarkVisible = bMarked;
4511*b1cdbd2cSJim Jagielski if ( bMarked )
4512*b1cdbd2cSJim Jagielski aAutoMarkPos = rMarkRange.aEnd;
4513*b1cdbd2cSJim Jagielski ShowCursor();
4514*b1cdbd2cSJim Jagielski
4515*b1cdbd2cSJim Jagielski UpdateAutoFillOverlay();
4516*b1cdbd2cSJim Jagielski }
4517*b1cdbd2cSJim Jagielski }
4518*b1cdbd2cSJim Jagielski
UpdateListValPos(sal_Bool bVisible,const ScAddress & rPos)4519*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateListValPos( sal_Bool bVisible, const ScAddress& rPos )
4520*b1cdbd2cSJim Jagielski {
4521*b1cdbd2cSJim Jagielski sal_Bool bOldButton = bListValButton;
4522*b1cdbd2cSJim Jagielski ScAddress aOldPos = aListValPos;
4523*b1cdbd2cSJim Jagielski
4524*b1cdbd2cSJim Jagielski bListValButton = bVisible;
4525*b1cdbd2cSJim Jagielski aListValPos = rPos;
4526*b1cdbd2cSJim Jagielski
4527*b1cdbd2cSJim Jagielski if ( bListValButton )
4528*b1cdbd2cSJim Jagielski {
4529*b1cdbd2cSJim Jagielski if ( !bOldButton || aListValPos != aOldPos )
4530*b1cdbd2cSJim Jagielski {
4531*b1cdbd2cSJim Jagielski // paint area of new button
4532*b1cdbd2cSJim Jagielski Invalidate( PixelToLogic( GetListValButtonRect( aListValPos ) ) );
4533*b1cdbd2cSJim Jagielski }
4534*b1cdbd2cSJim Jagielski }
4535*b1cdbd2cSJim Jagielski if ( bOldButton )
4536*b1cdbd2cSJim Jagielski {
4537*b1cdbd2cSJim Jagielski if ( !bListValButton || aListValPos != aOldPos )
4538*b1cdbd2cSJim Jagielski {
4539*b1cdbd2cSJim Jagielski // paint area of old button
4540*b1cdbd2cSJim Jagielski Invalidate( PixelToLogic( GetListValButtonRect( aOldPos ) ) );
4541*b1cdbd2cSJim Jagielski }
4542*b1cdbd2cSJim Jagielski }
4543*b1cdbd2cSJim Jagielski }
4544*b1cdbd2cSJim Jagielski
HideCursor()4545*b1cdbd2cSJim Jagielski void ScGridWindow::HideCursor()
4546*b1cdbd2cSJim Jagielski {
4547*b1cdbd2cSJim Jagielski ++nCursorHideCount;
4548*b1cdbd2cSJim Jagielski if (nCursorHideCount==1)
4549*b1cdbd2cSJim Jagielski {
4550*b1cdbd2cSJim Jagielski DrawCursor();
4551*b1cdbd2cSJim Jagielski DrawAutoFillMark();
4552*b1cdbd2cSJim Jagielski }
4553*b1cdbd2cSJim Jagielski }
4554*b1cdbd2cSJim Jagielski
ShowCursor()4555*b1cdbd2cSJim Jagielski void ScGridWindow::ShowCursor()
4556*b1cdbd2cSJim Jagielski {
4557*b1cdbd2cSJim Jagielski if (nCursorHideCount==0)
4558*b1cdbd2cSJim Jagielski {
4559*b1cdbd2cSJim Jagielski DBG_ERROR("zuviel ShowCursor");
4560*b1cdbd2cSJim Jagielski return;
4561*b1cdbd2cSJim Jagielski }
4562*b1cdbd2cSJim Jagielski
4563*b1cdbd2cSJim Jagielski if (nCursorHideCount==1)
4564*b1cdbd2cSJim Jagielski {
4565*b1cdbd2cSJim Jagielski // #i57745# Draw the cursor before setting the variable, in case the
4566*b1cdbd2cSJim Jagielski // GetSizePixel call from drawing causes a repaint (resize handler is called)
4567*b1cdbd2cSJim Jagielski DrawAutoFillMark();
4568*b1cdbd2cSJim Jagielski DrawCursor();
4569*b1cdbd2cSJim Jagielski }
4570*b1cdbd2cSJim Jagielski
4571*b1cdbd2cSJim Jagielski --nCursorHideCount;
4572*b1cdbd2cSJim Jagielski }
4573*b1cdbd2cSJim Jagielski
GetFocus()4574*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::GetFocus()
4575*b1cdbd2cSJim Jagielski {
4576*b1cdbd2cSJim Jagielski ScTabViewShell* pViewShell = pViewData->GetViewShell();
4577*b1cdbd2cSJim Jagielski pViewShell->GotFocus();
4578*b1cdbd2cSJim Jagielski pViewShell->SetFormShellAtTop( sal_False ); // focus in GridWindow -> FormShell no longer on top
4579*b1cdbd2cSJim Jagielski
4580*b1cdbd2cSJim Jagielski if (pViewShell->HasAccessibilityObjects())
4581*b1cdbd2cSJim Jagielski pViewShell->BroadcastAccessibility(ScAccGridWinFocusGotHint(eWhich, GetAccessible()));
4582*b1cdbd2cSJim Jagielski
4583*b1cdbd2cSJim Jagielski
4584*b1cdbd2cSJim Jagielski if ( !SC_MOD()->IsFormulaMode() )
4585*b1cdbd2cSJim Jagielski {
4586*b1cdbd2cSJim Jagielski pViewShell->UpdateInputHandler();
4587*b1cdbd2cSJim Jagielski // StopMarking(); // falls Dialog (Fehler), weil dann kein ButtonUp
4588*b1cdbd2cSJim Jagielski // MO: nur wenn nicht im RefInput-Modus
4589*b1cdbd2cSJim Jagielski // -> GetFocus/MouseButtonDown-Reihenfolge
4590*b1cdbd2cSJim Jagielski // auf dem Mac
4591*b1cdbd2cSJim Jagielski }
4592*b1cdbd2cSJim Jagielski
4593*b1cdbd2cSJim Jagielski Window::GetFocus();
4594*b1cdbd2cSJim Jagielski }
4595*b1cdbd2cSJim Jagielski
LoseFocus()4596*b1cdbd2cSJim Jagielski void __EXPORT ScGridWindow::LoseFocus()
4597*b1cdbd2cSJim Jagielski {
4598*b1cdbd2cSJim Jagielski ScTabViewShell* pViewShell = pViewData->GetViewShell();
4599*b1cdbd2cSJim Jagielski pViewShell->LostFocus();
4600*b1cdbd2cSJim Jagielski
4601*b1cdbd2cSJim Jagielski if (pViewShell->HasAccessibilityObjects())
4602*b1cdbd2cSJim Jagielski pViewShell->BroadcastAccessibility(ScAccGridWinFocusLostHint(eWhich, GetAccessible()));
4603*b1cdbd2cSJim Jagielski
4604*b1cdbd2cSJim Jagielski Window::LoseFocus();
4605*b1cdbd2cSJim Jagielski }
4606*b1cdbd2cSJim Jagielski
GetMousePosPixel() const4607*b1cdbd2cSJim Jagielski Point ScGridWindow::GetMousePosPixel() const { return aCurMousePos; }
4608*b1cdbd2cSJim Jagielski
4609*b1cdbd2cSJim Jagielski //------------------------------------------------------------------------
4610*b1cdbd2cSJim Jagielski
HitRangeFinder(const Point & rMouse,sal_Bool & rCorner,sal_uInt16 * pIndex,SCsCOL * pAddX,SCsROW * pAddY)4611*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::HitRangeFinder( const Point& rMouse, sal_Bool& rCorner,
4612*b1cdbd2cSJim Jagielski sal_uInt16* pIndex, SCsCOL* pAddX, SCsROW* pAddY )
4613*b1cdbd2cSJim Jagielski {
4614*b1cdbd2cSJim Jagielski sal_Bool bFound = sal_False;
4615*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = SC_MOD()->GetInputHdl( pViewData->GetViewShell() );
4616*b1cdbd2cSJim Jagielski if (pHdl)
4617*b1cdbd2cSJim Jagielski {
4618*b1cdbd2cSJim Jagielski ScRangeFindList* pRangeFinder = pHdl->GetRangeFindList();
4619*b1cdbd2cSJim Jagielski if ( pRangeFinder && !pRangeFinder->IsHidden() &&
4620*b1cdbd2cSJim Jagielski pRangeFinder->GetDocName() == pViewData->GetDocShell()->GetTitle() )
4621*b1cdbd2cSJim Jagielski {
4622*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
4623*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
4624*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
4625*b1cdbd2cSJim Jagielski long nLayoutSign = bLayoutRTL ? -1 : 1;
4626*b1cdbd2cSJim Jagielski
4627*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4628*b1cdbd2cSJim Jagielski SCsROW nPosY;
4629*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( rMouse.X(), rMouse.Y(), eWhich, nPosX, nPosY );
4630*b1cdbd2cSJim Jagielski // zusammengefasste (einzeln/Bereich) ???
4631*b1cdbd2cSJim Jagielski ScAddress aAddr( nPosX, nPosY, nTab );
4632*b1cdbd2cSJim Jagielski
4633*b1cdbd2cSJim Jagielski // Point aNext = pViewData->GetScrPos( nPosX+1, nPosY+1, eWhich );
4634*b1cdbd2cSJim Jagielski
4635*b1cdbd2cSJim Jagielski Point aNext = pViewData->GetScrPos( nPosX, nPosY, eWhich, sal_True );
4636*b1cdbd2cSJim Jagielski long nSizeXPix;
4637*b1cdbd2cSJim Jagielski long nSizeYPix;
4638*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nPosX, nPosY, nSizeXPix, nSizeYPix );
4639*b1cdbd2cSJim Jagielski aNext.X() += nSizeXPix * nLayoutSign;
4640*b1cdbd2cSJim Jagielski aNext.Y() += nSizeYPix;
4641*b1cdbd2cSJim Jagielski
4642*b1cdbd2cSJim Jagielski sal_Bool bCornerHor;
4643*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
4644*b1cdbd2cSJim Jagielski bCornerHor = ( rMouse.X() >= aNext.X() && rMouse.X() <= aNext.X() + 8 );
4645*b1cdbd2cSJim Jagielski else
4646*b1cdbd2cSJim Jagielski bCornerHor = ( rMouse.X() >= aNext.X() - 8 && rMouse.X() <= aNext.X() );
4647*b1cdbd2cSJim Jagielski
4648*b1cdbd2cSJim Jagielski sal_Bool bCellCorner = ( bCornerHor &&
4649*b1cdbd2cSJim Jagielski rMouse.Y() >= aNext.Y() - 8 && rMouse.Y() <= aNext.Y() );
4650*b1cdbd2cSJim Jagielski // corner is hit only if the mouse is within the cell
4651*b1cdbd2cSJim Jagielski
4652*b1cdbd2cSJim Jagielski sal_uInt16 nCount = (sal_uInt16)pRangeFinder->Count();
4653*b1cdbd2cSJim Jagielski for (sal_uInt16 i=nCount; i;)
4654*b1cdbd2cSJim Jagielski {
4655*b1cdbd2cSJim Jagielski // rueckwaerts suchen, damit der zuletzt gepaintete Rahmen gefunden wird
4656*b1cdbd2cSJim Jagielski --i;
4657*b1cdbd2cSJim Jagielski ScRangeFindData* pData = pRangeFinder->GetObject(i);
4658*b1cdbd2cSJim Jagielski if ( pData && pData->aRef.In(aAddr) )
4659*b1cdbd2cSJim Jagielski {
4660*b1cdbd2cSJim Jagielski if (pIndex) *pIndex = i;
4661*b1cdbd2cSJim Jagielski if (pAddX) *pAddX = nPosX - pData->aRef.aStart.Col();
4662*b1cdbd2cSJim Jagielski if (pAddY) *pAddY = nPosY - pData->aRef.aStart.Row();
4663*b1cdbd2cSJim Jagielski bFound = sal_True;
4664*b1cdbd2cSJim Jagielski rCorner = ( bCellCorner && aAddr == pData->aRef.aEnd );
4665*b1cdbd2cSJim Jagielski break;
4666*b1cdbd2cSJim Jagielski }
4667*b1cdbd2cSJim Jagielski }
4668*b1cdbd2cSJim Jagielski }
4669*b1cdbd2cSJim Jagielski }
4670*b1cdbd2cSJim Jagielski return bFound;
4671*b1cdbd2cSJim Jagielski }
4672*b1cdbd2cSJim Jagielski
4673*b1cdbd2cSJim Jagielski #define SCE_TOP 1
4674*b1cdbd2cSJim Jagielski #define SCE_BOTTOM 2
4675*b1cdbd2cSJim Jagielski #define SCE_LEFT 4
4676*b1cdbd2cSJim Jagielski #define SCE_RIGHT 8
4677*b1cdbd2cSJim Jagielski #define SCE_ALL 15
4678*b1cdbd2cSJim Jagielski
lcl_PaintOneRange(ScDocShell * pDocSh,const ScRange & rRange,sal_uInt16 nEdges)4679*b1cdbd2cSJim Jagielski void lcl_PaintOneRange( ScDocShell* pDocSh, const ScRange& rRange, sal_uInt16 nEdges )
4680*b1cdbd2cSJim Jagielski {
4681*b1cdbd2cSJim Jagielski // der Range ist immer richtigherum
4682*b1cdbd2cSJim Jagielski
4683*b1cdbd2cSJim Jagielski SCCOL nCol1 = rRange.aStart.Col();
4684*b1cdbd2cSJim Jagielski SCROW nRow1 = rRange.aStart.Row();
4685*b1cdbd2cSJim Jagielski SCTAB nTab1 = rRange.aStart.Tab();
4686*b1cdbd2cSJim Jagielski SCCOL nCol2 = rRange.aEnd.Col();
4687*b1cdbd2cSJim Jagielski SCROW nRow2 = rRange.aEnd.Row();
4688*b1cdbd2cSJim Jagielski SCTAB nTab2 = rRange.aEnd.Tab();
4689*b1cdbd2cSJim Jagielski sal_Bool bHiddenEdge = sal_False;
4690*b1cdbd2cSJim Jagielski SCROW nTmp;
4691*b1cdbd2cSJim Jagielski
4692*b1cdbd2cSJim Jagielski ScDocument* pDoc = pDocSh->GetDocument();
4693*b1cdbd2cSJim Jagielski while ( nCol1 > 0 && pDoc->ColHidden(nCol1, nTab1) )
4694*b1cdbd2cSJim Jagielski {
4695*b1cdbd2cSJim Jagielski --nCol1;
4696*b1cdbd2cSJim Jagielski bHiddenEdge = sal_True;
4697*b1cdbd2cSJim Jagielski }
4698*b1cdbd2cSJim Jagielski while ( nCol2 < MAXCOL && pDoc->ColHidden(nCol2, nTab1) )
4699*b1cdbd2cSJim Jagielski {
4700*b1cdbd2cSJim Jagielski ++nCol2;
4701*b1cdbd2cSJim Jagielski bHiddenEdge = sal_True;
4702*b1cdbd2cSJim Jagielski }
4703*b1cdbd2cSJim Jagielski nTmp = pDoc->FirstVisibleRow(0, nRow1, nTab1);
4704*b1cdbd2cSJim Jagielski if (!ValidRow(nTmp))
4705*b1cdbd2cSJim Jagielski nTmp = 0;
4706*b1cdbd2cSJim Jagielski if (nTmp < nRow1)
4707*b1cdbd2cSJim Jagielski {
4708*b1cdbd2cSJim Jagielski nRow1 = nTmp;
4709*b1cdbd2cSJim Jagielski bHiddenEdge = sal_True;
4710*b1cdbd2cSJim Jagielski }
4711*b1cdbd2cSJim Jagielski nTmp = pDoc->FirstVisibleRow(nRow2, MAXROW, nTab1);
4712*b1cdbd2cSJim Jagielski if (!ValidRow(nTmp))
4713*b1cdbd2cSJim Jagielski nTmp = MAXROW;
4714*b1cdbd2cSJim Jagielski if (nTmp > nRow2)
4715*b1cdbd2cSJim Jagielski {
4716*b1cdbd2cSJim Jagielski nRow2 = nTmp;
4717*b1cdbd2cSJim Jagielski bHiddenEdge = sal_True;
4718*b1cdbd2cSJim Jagielski }
4719*b1cdbd2cSJim Jagielski
4720*b1cdbd2cSJim Jagielski if ( nCol2 > nCol1 + 1 && nRow2 > nRow1 + 1 && !bHiddenEdge )
4721*b1cdbd2cSJim Jagielski {
4722*b1cdbd2cSJim Jagielski // nur an den Raendern entlang
4723*b1cdbd2cSJim Jagielski // (die Ecken werden evtl. zweimal getroffen)
4724*b1cdbd2cSJim Jagielski
4725*b1cdbd2cSJim Jagielski if ( nEdges & SCE_TOP )
4726*b1cdbd2cSJim Jagielski pDocSh->PostPaint( nCol1, nRow1, nTab1, nCol2, nRow1, nTab2, PAINT_MARKS );
4727*b1cdbd2cSJim Jagielski if ( nEdges & SCE_LEFT )
4728*b1cdbd2cSJim Jagielski pDocSh->PostPaint( nCol1, nRow1, nTab1, nCol1, nRow2, nTab2, PAINT_MARKS );
4729*b1cdbd2cSJim Jagielski if ( nEdges & SCE_RIGHT )
4730*b1cdbd2cSJim Jagielski pDocSh->PostPaint( nCol2, nRow1, nTab1, nCol2, nRow2, nTab2, PAINT_MARKS );
4731*b1cdbd2cSJim Jagielski if ( nEdges & SCE_BOTTOM )
4732*b1cdbd2cSJim Jagielski pDocSh->PostPaint( nCol1, nRow2, nTab1, nCol2, nRow2, nTab2, PAINT_MARKS );
4733*b1cdbd2cSJim Jagielski }
4734*b1cdbd2cSJim Jagielski else // everything in one call
4735*b1cdbd2cSJim Jagielski pDocSh->PostPaint( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, PAINT_MARKS );
4736*b1cdbd2cSJim Jagielski }
4737*b1cdbd2cSJim Jagielski
lcl_PaintRefChanged(ScDocShell * pDocSh,const ScRange & rOldUn,const ScRange & rNewUn)4738*b1cdbd2cSJim Jagielski void lcl_PaintRefChanged( ScDocShell* pDocSh, const ScRange& rOldUn, const ScRange& rNewUn )
4739*b1cdbd2cSJim Jagielski {
4740*b1cdbd2cSJim Jagielski // Repaint fuer die Teile des Rahmens in Old, die bei New nicht mehr da sind
4741*b1cdbd2cSJim Jagielski
4742*b1cdbd2cSJim Jagielski ScRange aOld = rOldUn;
4743*b1cdbd2cSJim Jagielski ScRange aNew = rNewUn;
4744*b1cdbd2cSJim Jagielski aOld.Justify();
4745*b1cdbd2cSJim Jagielski aNew.Justify();
4746*b1cdbd2cSJim Jagielski
4747*b1cdbd2cSJim Jagielski if ( aOld.aStart == aOld.aEnd ) //! Tab ignorieren?
4748*b1cdbd2cSJim Jagielski pDocSh->GetDocument()->ExtendMerge(aOld);
4749*b1cdbd2cSJim Jagielski if ( aNew.aStart == aNew.aEnd ) //! Tab ignorieren?
4750*b1cdbd2cSJim Jagielski pDocSh->GetDocument()->ExtendMerge(aNew);
4751*b1cdbd2cSJim Jagielski
4752*b1cdbd2cSJim Jagielski SCCOL nOldCol1 = aOld.aStart.Col();
4753*b1cdbd2cSJim Jagielski SCROW nOldRow1 = aOld.aStart.Row();
4754*b1cdbd2cSJim Jagielski SCCOL nOldCol2 = aOld.aEnd.Col();
4755*b1cdbd2cSJim Jagielski SCROW nOldRow2 = aOld.aEnd.Row();
4756*b1cdbd2cSJim Jagielski SCCOL nNewCol1 = aNew.aStart.Col();
4757*b1cdbd2cSJim Jagielski SCROW nNewRow1 = aNew.aStart.Row();
4758*b1cdbd2cSJim Jagielski SCCOL nNewCol2 = aNew.aEnd.Col();
4759*b1cdbd2cSJim Jagielski SCROW nNewRow2 = aNew.aEnd.Row();
4760*b1cdbd2cSJim Jagielski SCTAB nTab1 = aOld.aStart.Tab(); // Tab aendert sich nicht
4761*b1cdbd2cSJim Jagielski SCTAB nTab2 = aOld.aEnd.Tab();
4762*b1cdbd2cSJim Jagielski
4763*b1cdbd2cSJim Jagielski if ( nNewRow2 < nOldRow1 || nNewRow1 > nOldRow2 ||
4764*b1cdbd2cSJim Jagielski nNewCol2 < nOldCol1 || nNewCol1 > nOldCol2 ||
4765*b1cdbd2cSJim Jagielski ( nNewCol1 != nOldCol1 && nNewRow1 != nOldRow1 &&
4766*b1cdbd2cSJim Jagielski nNewCol2 != nOldCol2 && nNewRow2 != nOldRow2 ) )
4767*b1cdbd2cSJim Jagielski {
4768*b1cdbd2cSJim Jagielski // komplett weggeschoben oder alle Seiten veraendert
4769*b1cdbd2cSJim Jagielski // (Abfrage <= statt < geht schief bei einzelnen Zeilen/Spalten)
4770*b1cdbd2cSJim Jagielski
4771*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, aOld, SCE_ALL );
4772*b1cdbd2cSJim Jagielski }
4773*b1cdbd2cSJim Jagielski else // alle vier Kanten einzeln testen
4774*b1cdbd2cSJim Jagielski {
4775*b1cdbd2cSJim Jagielski // oberer Teil
4776*b1cdbd2cSJim Jagielski if ( nNewRow1 < nOldRow1 ) // nur obere Linie loeschen
4777*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4778*b1cdbd2cSJim Jagielski nOldCol1, nOldRow1, nTab1, nOldCol2, nOldRow1, nTab2 ), SCE_ALL );
4779*b1cdbd2cSJim Jagielski else if ( nNewRow1 > nOldRow1 ) // den Teil, der oben wegkommt
4780*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4781*b1cdbd2cSJim Jagielski nOldCol1, nOldRow1, nTab1, nOldCol2, nNewRow1-1, nTab2 ),
4782*b1cdbd2cSJim Jagielski SCE_ALL &~ SCE_BOTTOM );
4783*b1cdbd2cSJim Jagielski
4784*b1cdbd2cSJim Jagielski // unterer Teil
4785*b1cdbd2cSJim Jagielski if ( nNewRow2 > nOldRow2 ) // nur untere Linie loeschen
4786*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4787*b1cdbd2cSJim Jagielski nOldCol1, nOldRow2, nTab1, nOldCol2, nOldRow2, nTab2 ), SCE_ALL );
4788*b1cdbd2cSJim Jagielski else if ( nNewRow2 < nOldRow2 ) // den Teil, der unten wegkommt
4789*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4790*b1cdbd2cSJim Jagielski nOldCol1, nNewRow2+1, nTab1, nOldCol2, nOldRow2, nTab2 ),
4791*b1cdbd2cSJim Jagielski SCE_ALL &~ SCE_TOP );
4792*b1cdbd2cSJim Jagielski
4793*b1cdbd2cSJim Jagielski // linker Teil
4794*b1cdbd2cSJim Jagielski if ( nNewCol1 < nOldCol1 ) // nur linke Linie loeschen
4795*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4796*b1cdbd2cSJim Jagielski nOldCol1, nOldRow1, nTab1, nOldCol1, nOldRow2, nTab2 ), SCE_ALL );
4797*b1cdbd2cSJim Jagielski else if ( nNewCol1 > nOldCol1 ) // den Teil, der links wegkommt
4798*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4799*b1cdbd2cSJim Jagielski nOldCol1, nOldRow1, nTab1, nNewCol1-1, nOldRow2, nTab2 ),
4800*b1cdbd2cSJim Jagielski SCE_ALL &~ SCE_RIGHT );
4801*b1cdbd2cSJim Jagielski
4802*b1cdbd2cSJim Jagielski // rechter Teil
4803*b1cdbd2cSJim Jagielski if ( nNewCol2 > nOldCol2 ) // nur rechte Linie loeschen
4804*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4805*b1cdbd2cSJim Jagielski nOldCol2, nOldRow1, nTab1, nOldCol2, nOldRow2, nTab2 ), SCE_ALL );
4806*b1cdbd2cSJim Jagielski else if ( nNewCol2 < nOldCol2 ) // den Teil, der rechts wegkommt
4807*b1cdbd2cSJim Jagielski lcl_PaintOneRange( pDocSh, ScRange(
4808*b1cdbd2cSJim Jagielski nNewCol2+1, nOldRow1, nTab1, nOldCol2, nOldRow2, nTab2 ),
4809*b1cdbd2cSJim Jagielski SCE_ALL &~ SCE_LEFT );
4810*b1cdbd2cSJim Jagielski }
4811*b1cdbd2cSJim Jagielski }
4812*b1cdbd2cSJim Jagielski
RFMouseMove(const MouseEvent & rMEvt,sal_Bool bUp)4813*b1cdbd2cSJim Jagielski void ScGridWindow::RFMouseMove( const MouseEvent& rMEvt, sal_Bool bUp )
4814*b1cdbd2cSJim Jagielski {
4815*b1cdbd2cSJim Jagielski ScInputHandler* pHdl = SC_MOD()->GetInputHdl( pViewData->GetViewShell() );
4816*b1cdbd2cSJim Jagielski if (!pHdl)
4817*b1cdbd2cSJim Jagielski return;
4818*b1cdbd2cSJim Jagielski ScRangeFindList* pRangeFinder = pHdl->GetRangeFindList();
4819*b1cdbd2cSJim Jagielski if (!pRangeFinder || nRFIndex >= pRangeFinder->Count())
4820*b1cdbd2cSJim Jagielski return;
4821*b1cdbd2cSJim Jagielski ScRangeFindData* pData = pRangeFinder->GetObject( nRFIndex );
4822*b1cdbd2cSJim Jagielski if (!pData)
4823*b1cdbd2cSJim Jagielski return;
4824*b1cdbd2cSJim Jagielski
4825*b1cdbd2cSJim Jagielski // Mauszeiger
4826*b1cdbd2cSJim Jagielski
4827*b1cdbd2cSJim Jagielski if (bRFSize)
4828*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_CROSS ) );
4829*b1cdbd2cSJim Jagielski else
4830*b1cdbd2cSJim Jagielski SetPointer( Pointer( POINTER_HAND ) );
4831*b1cdbd2cSJim Jagielski
4832*b1cdbd2cSJim Jagielski // Scrolling
4833*b1cdbd2cSJim Jagielski
4834*b1cdbd2cSJim Jagielski sal_Bool bTimer = sal_False;
4835*b1cdbd2cSJim Jagielski Point aPos = rMEvt.GetPosPixel();
4836*b1cdbd2cSJim Jagielski SCsCOL nDx = 0;
4837*b1cdbd2cSJim Jagielski SCsROW nDy = 0;
4838*b1cdbd2cSJim Jagielski if ( aPos.X() < 0 ) nDx = -1;
4839*b1cdbd2cSJim Jagielski if ( aPos.Y() < 0 ) nDy = -1;
4840*b1cdbd2cSJim Jagielski Size aSize = GetOutputSizePixel();
4841*b1cdbd2cSJim Jagielski if ( aPos.X() >= aSize.Width() )
4842*b1cdbd2cSJim Jagielski nDx = 1;
4843*b1cdbd2cSJim Jagielski if ( aPos.Y() >= aSize.Height() )
4844*b1cdbd2cSJim Jagielski nDy = 1;
4845*b1cdbd2cSJim Jagielski if ( nDx != 0 || nDy != 0 )
4846*b1cdbd2cSJim Jagielski {
4847*b1cdbd2cSJim Jagielski if ( nDx != 0) pViewData->GetView()->ScrollX( nDx, WhichH(eWhich) );
4848*b1cdbd2cSJim Jagielski if ( nDy != 0 ) pViewData->GetView()->ScrollY( nDy, WhichV(eWhich) );
4849*b1cdbd2cSJim Jagielski bTimer = sal_True;
4850*b1cdbd2cSJim Jagielski }
4851*b1cdbd2cSJim Jagielski
4852*b1cdbd2cSJim Jagielski // Umschalten bei Fixierung (damit Scrolling funktioniert)
4853*b1cdbd2cSJim Jagielski
4854*b1cdbd2cSJim Jagielski if ( eWhich == pViewData->GetActivePart() ) //??
4855*b1cdbd2cSJim Jagielski {
4856*b1cdbd2cSJim Jagielski if ( pViewData->GetHSplitMode() == SC_SPLIT_FIX )
4857*b1cdbd2cSJim Jagielski if ( nDx > 0 )
4858*b1cdbd2cSJim Jagielski {
4859*b1cdbd2cSJim Jagielski if ( eWhich == SC_SPLIT_TOPLEFT )
4860*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( SC_SPLIT_TOPRIGHT );
4861*b1cdbd2cSJim Jagielski else if ( eWhich == SC_SPLIT_BOTTOMLEFT )
4862*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT );
4863*b1cdbd2cSJim Jagielski }
4864*b1cdbd2cSJim Jagielski
4865*b1cdbd2cSJim Jagielski if ( pViewData->GetVSplitMode() == SC_SPLIT_FIX )
4866*b1cdbd2cSJim Jagielski if ( nDy > 0 )
4867*b1cdbd2cSJim Jagielski {
4868*b1cdbd2cSJim Jagielski if ( eWhich == SC_SPLIT_TOPLEFT )
4869*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMLEFT );
4870*b1cdbd2cSJim Jagielski else if ( eWhich == SC_SPLIT_TOPRIGHT )
4871*b1cdbd2cSJim Jagielski pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT );
4872*b1cdbd2cSJim Jagielski }
4873*b1cdbd2cSJim Jagielski }
4874*b1cdbd2cSJim Jagielski
4875*b1cdbd2cSJim Jagielski // Verschieben
4876*b1cdbd2cSJim Jagielski
4877*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4878*b1cdbd2cSJim Jagielski SCsROW nPosY;
4879*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( aPos.X(), aPos.Y(), eWhich, nPosX, nPosY );
4880*b1cdbd2cSJim Jagielski
4881*b1cdbd2cSJim Jagielski ScRange aOld = pData->aRef;
4882*b1cdbd2cSJim Jagielski ScRange aNew = aOld;
4883*b1cdbd2cSJim Jagielski if ( bRFSize )
4884*b1cdbd2cSJim Jagielski {
4885*b1cdbd2cSJim Jagielski aNew.aEnd.SetCol((SCCOL)nPosX);
4886*b1cdbd2cSJim Jagielski aNew.aEnd.SetRow((SCROW)nPosY);
4887*b1cdbd2cSJim Jagielski }
4888*b1cdbd2cSJim Jagielski else
4889*b1cdbd2cSJim Jagielski {
4890*b1cdbd2cSJim Jagielski long nStartX = nPosX - nRFAddX;
4891*b1cdbd2cSJim Jagielski if ( nStartX < 0 ) nStartX = 0;
4892*b1cdbd2cSJim Jagielski long nStartY = nPosY - nRFAddY;
4893*b1cdbd2cSJim Jagielski if ( nStartY < 0 ) nStartY = 0;
4894*b1cdbd2cSJim Jagielski long nEndX = nStartX + aOld.aEnd.Col() - aOld.aStart.Col();
4895*b1cdbd2cSJim Jagielski if ( nEndX > MAXCOL )
4896*b1cdbd2cSJim Jagielski {
4897*b1cdbd2cSJim Jagielski nStartX -= ( nEndX - MAXROW );
4898*b1cdbd2cSJim Jagielski nEndX = MAXCOL;
4899*b1cdbd2cSJim Jagielski }
4900*b1cdbd2cSJim Jagielski long nEndY = nStartY + aOld.aEnd.Row() - aOld.aStart.Row();
4901*b1cdbd2cSJim Jagielski if ( nEndY > MAXROW )
4902*b1cdbd2cSJim Jagielski {
4903*b1cdbd2cSJim Jagielski nStartY -= ( nEndY - MAXROW );
4904*b1cdbd2cSJim Jagielski nEndY = MAXROW;
4905*b1cdbd2cSJim Jagielski }
4906*b1cdbd2cSJim Jagielski
4907*b1cdbd2cSJim Jagielski aNew.aStart.SetCol((SCCOL)nStartX);
4908*b1cdbd2cSJim Jagielski aNew.aStart.SetRow((SCROW)nStartY);
4909*b1cdbd2cSJim Jagielski aNew.aEnd.SetCol((SCCOL)nEndX);
4910*b1cdbd2cSJim Jagielski aNew.aEnd.SetRow((SCROW)nEndY);
4911*b1cdbd2cSJim Jagielski }
4912*b1cdbd2cSJim Jagielski
4913*b1cdbd2cSJim Jagielski if ( bUp )
4914*b1cdbd2cSJim Jagielski aNew.Justify(); // beim ButtonUp wieder richtigherum
4915*b1cdbd2cSJim Jagielski
4916*b1cdbd2cSJim Jagielski if ( aNew != aOld )
4917*b1cdbd2cSJim Jagielski {
4918*b1cdbd2cSJim Jagielski pHdl->UpdateRange( nRFIndex, aNew );
4919*b1cdbd2cSJim Jagielski
4920*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
4921*b1cdbd2cSJim Jagielski
4922*b1cdbd2cSJim Jagielski // nur das neuzeichnen, was sich veraendert hat...
4923*b1cdbd2cSJim Jagielski lcl_PaintRefChanged( pDocSh, aOld, aNew );
4924*b1cdbd2cSJim Jagielski
4925*b1cdbd2cSJim Jagielski // neuen Rahmen nur drueberzeichnen (synchron)
4926*b1cdbd2cSJim Jagielski pDocSh->Broadcast( ScIndexHint( SC_HINT_SHOWRANGEFINDER, nRFIndex ) );
4927*b1cdbd2cSJim Jagielski
4928*b1cdbd2cSJim Jagielski Update(); // was man bewegt, will man auch sofort sehen
4929*b1cdbd2cSJim Jagielski }
4930*b1cdbd2cSJim Jagielski
4931*b1cdbd2cSJim Jagielski // Timer fuer Scrolling
4932*b1cdbd2cSJim Jagielski
4933*b1cdbd2cSJim Jagielski if (bTimer)
4934*b1cdbd2cSJim Jagielski pViewData->GetView()->SetTimer( this, rMEvt ); // Event wiederholen
4935*b1cdbd2cSJim Jagielski else
4936*b1cdbd2cSJim Jagielski pViewData->GetView()->ResetTimer();
4937*b1cdbd2cSJim Jagielski }
4938*b1cdbd2cSJim Jagielski
4939*b1cdbd2cSJim Jagielski //------------------------------------------------------------------------
4940*b1cdbd2cSJim Jagielski
GetEditUrl(const Point & rPos,String * pName,String * pUrl,String * pTarget)4941*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::GetEditUrl( const Point& rPos,
4942*b1cdbd2cSJim Jagielski String* pName, String* pUrl, String* pTarget )
4943*b1cdbd2cSJim Jagielski {
4944*b1cdbd2cSJim Jagielski return GetEditUrlOrError( sal_False, rPos, pName, pUrl, pTarget );
4945*b1cdbd2cSJim Jagielski }
4946*b1cdbd2cSJim Jagielski
GetEditUrlOrError(sal_Bool bSpellErr,const Point & rPos,String * pName,String * pUrl,String * pTarget)4947*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::GetEditUrlOrError( sal_Bool bSpellErr, const Point& rPos,
4948*b1cdbd2cSJim Jagielski String* pName, String* pUrl, String* pTarget )
4949*b1cdbd2cSJim Jagielski {
4950*b1cdbd2cSJim Jagielski //! nPosX/Y mit uebergeben?
4951*b1cdbd2cSJim Jagielski SCsCOL nPosX;
4952*b1cdbd2cSJim Jagielski SCsROW nPosY;
4953*b1cdbd2cSJim Jagielski pViewData->GetPosFromPixel( rPos.X(), rPos.Y(), eWhich, nPosX, nPosY );
4954*b1cdbd2cSJim Jagielski
4955*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
4956*b1cdbd2cSJim Jagielski ScDocShell* pDocSh = pViewData->GetDocShell();
4957*b1cdbd2cSJim Jagielski ScDocument* pDoc = pDocSh->GetDocument();
4958*b1cdbd2cSJim Jagielski ScBaseCell* pCell = NULL;
4959*b1cdbd2cSJim Jagielski
4960*b1cdbd2cSJim Jagielski sal_Bool bFound = lcl_GetHyperlinkCell( pDoc, nPosX, nPosY, nTab, pCell );
4961*b1cdbd2cSJim Jagielski if( !bFound )
4962*b1cdbd2cSJim Jagielski return sal_False;
4963*b1cdbd2cSJim Jagielski
4964*b1cdbd2cSJim Jagielski ScHideTextCursor aHideCursor( pViewData, eWhich ); // before GetEditArea (MapMode is changed)
4965*b1cdbd2cSJim Jagielski
4966*b1cdbd2cSJim Jagielski const ScPatternAttr* pPattern = pDoc->GetPattern( nPosX, nPosY, nTab );
4967*b1cdbd2cSJim Jagielski // bForceToTop = sal_False, use the cell's real position
4968*b1cdbd2cSJim Jagielski Rectangle aEditRect = pViewData->GetEditArea( eWhich, nPosX, nPosY, this, pPattern, sal_False );
4969*b1cdbd2cSJim Jagielski if (rPos.Y() < aEditRect.Top())
4970*b1cdbd2cSJim Jagielski return sal_False;
4971*b1cdbd2cSJim Jagielski
4972*b1cdbd2cSJim Jagielski // vertikal kann (noch) nicht angeklickt werden:
4973*b1cdbd2cSJim Jagielski
4974*b1cdbd2cSJim Jagielski if (pPattern->GetCellOrientation() != SVX_ORIENTATION_STANDARD)
4975*b1cdbd2cSJim Jagielski return sal_False;
4976*b1cdbd2cSJim Jagielski
4977*b1cdbd2cSJim Jagielski sal_Bool bBreak = ((SfxBoolItem&)pPattern->GetItem(ATTR_LINEBREAK)).GetValue() ||
4978*b1cdbd2cSJim Jagielski ((SvxCellHorJustify)((const SvxHorJustifyItem&)pPattern->
4979*b1cdbd2cSJim Jagielski GetItem( ATTR_HOR_JUSTIFY )).GetValue() == SVX_HOR_JUSTIFY_BLOCK);
4980*b1cdbd2cSJim Jagielski SvxCellHorJustify eHorJust = (SvxCellHorJustify)((SvxHorJustifyItem&)pPattern->
4981*b1cdbd2cSJim Jagielski GetItem(ATTR_HOR_JUSTIFY)).GetValue();
4982*b1cdbd2cSJim Jagielski
4983*b1cdbd2cSJim Jagielski // EditEngine
4984*b1cdbd2cSJim Jagielski
4985*b1cdbd2cSJim Jagielski ScFieldEditEngine aEngine( pDoc->GetEditPool() );
4986*b1cdbd2cSJim Jagielski ScSizeDeviceProvider aProv(pDocSh);
4987*b1cdbd2cSJim Jagielski aEngine.SetRefDevice( aProv.GetDevice() );
4988*b1cdbd2cSJim Jagielski aEngine.SetRefMapMode( MAP_100TH_MM );
4989*b1cdbd2cSJim Jagielski SfxItemSet aDefault( aEngine.GetEmptyItemSet() );
4990*b1cdbd2cSJim Jagielski pPattern->FillEditItemSet( &aDefault );
4991*b1cdbd2cSJim Jagielski SvxAdjust eSvxAdjust = SVX_ADJUST_LEFT;
4992*b1cdbd2cSJim Jagielski switch (eHorJust)
4993*b1cdbd2cSJim Jagielski {
4994*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_LEFT:
4995*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_REPEAT: // nicht implementiert
4996*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_STANDARD: // always Text if an EditCell type
4997*b1cdbd2cSJim Jagielski eSvxAdjust = SVX_ADJUST_LEFT;
4998*b1cdbd2cSJim Jagielski break;
4999*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_RIGHT:
5000*b1cdbd2cSJim Jagielski eSvxAdjust = SVX_ADJUST_RIGHT;
5001*b1cdbd2cSJim Jagielski break;
5002*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_CENTER:
5003*b1cdbd2cSJim Jagielski eSvxAdjust = SVX_ADJUST_CENTER;
5004*b1cdbd2cSJim Jagielski break;
5005*b1cdbd2cSJim Jagielski case SVX_HOR_JUSTIFY_BLOCK:
5006*b1cdbd2cSJim Jagielski eSvxAdjust = SVX_ADJUST_BLOCK;
5007*b1cdbd2cSJim Jagielski break;
5008*b1cdbd2cSJim Jagielski }
5009*b1cdbd2cSJim Jagielski aDefault.Put( SvxAdjustItem( eSvxAdjust, EE_PARA_JUST ) );
5010*b1cdbd2cSJim Jagielski aEngine.SetDefaults( aDefault );
5011*b1cdbd2cSJim Jagielski if (bSpellErr)
5012*b1cdbd2cSJim Jagielski aEngine.SetControlWord( aEngine.GetControlWord() | EE_CNTRL_ONLINESPELLING );
5013*b1cdbd2cSJim Jagielski
5014*b1cdbd2cSJim Jagielski MapMode aEditMode = pViewData->GetLogicMode(eWhich); // ohne Drawing-Skalierung
5015*b1cdbd2cSJim Jagielski Rectangle aLogicEdit = PixelToLogic( aEditRect, aEditMode );
5016*b1cdbd2cSJim Jagielski long nThisColLogic = aLogicEdit.Right() - aLogicEdit.Left() + 1;
5017*b1cdbd2cSJim Jagielski Size aPaperSize = Size( 1000000, 1000000 );
5018*b1cdbd2cSJim Jagielski if(pCell->GetCellType() == CELLTYPE_FORMULA)
5019*b1cdbd2cSJim Jagielski {
5020*b1cdbd2cSJim Jagielski long nSizeX = 0;
5021*b1cdbd2cSJim Jagielski long nSizeY = 0;
5022*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nPosX, nPosY, nSizeX, nSizeY );
5023*b1cdbd2cSJim Jagielski aPaperSize = Size(nSizeX, nSizeY );
5024*b1cdbd2cSJim Jagielski aPaperSize = PixelToLogic(aPaperSize);
5025*b1cdbd2cSJim Jagielski }
5026*b1cdbd2cSJim Jagielski
5027*b1cdbd2cSJim Jagielski if (bBreak)
5028*b1cdbd2cSJim Jagielski aPaperSize.Width() = nThisColLogic;
5029*b1cdbd2cSJim Jagielski aEngine.SetPaperSize( aPaperSize );
5030*b1cdbd2cSJim Jagielski
5031*b1cdbd2cSJim Jagielski ::std::auto_ptr< EditTextObject > pTextObj;
5032*b1cdbd2cSJim Jagielski const EditTextObject* pData;
5033*b1cdbd2cSJim Jagielski if(pCell->GetCellType() == CELLTYPE_EDIT)
5034*b1cdbd2cSJim Jagielski {
5035*b1cdbd2cSJim Jagielski ((ScEditCell*)pCell)->GetData(pData);
5036*b1cdbd2cSJim Jagielski if (pData)
5037*b1cdbd2cSJim Jagielski aEngine.SetText(*pData);
5038*b1cdbd2cSJim Jagielski }
5039*b1cdbd2cSJim Jagielski else // HyperLink Formula cell
5040*b1cdbd2cSJim Jagielski {
5041*b1cdbd2cSJim Jagielski pTextObj.reset((static_cast<ScFormulaCell*>(pCell))->CreateURLObject());
5042*b1cdbd2cSJim Jagielski if (pTextObj.get())
5043*b1cdbd2cSJim Jagielski aEngine.SetText(*pTextObj);
5044*b1cdbd2cSJim Jagielski }
5045*b1cdbd2cSJim Jagielski
5046*b1cdbd2cSJim Jagielski long nStartX = aLogicEdit.Left();
5047*b1cdbd2cSJim Jagielski
5048*b1cdbd2cSJim Jagielski long nTextWidth = aEngine.CalcTextWidth();
5049*b1cdbd2cSJim Jagielski long nTextHeight = aEngine.GetTextHeight();
5050*b1cdbd2cSJim Jagielski if ( nTextWidth < nThisColLogic )
5051*b1cdbd2cSJim Jagielski {
5052*b1cdbd2cSJim Jagielski if (eHorJust == SVX_HOR_JUSTIFY_RIGHT)
5053*b1cdbd2cSJim Jagielski nStartX += nThisColLogic - nTextWidth;
5054*b1cdbd2cSJim Jagielski else if (eHorJust == SVX_HOR_JUSTIFY_CENTER)
5055*b1cdbd2cSJim Jagielski nStartX += (nThisColLogic - nTextWidth) / 2;
5056*b1cdbd2cSJim Jagielski }
5057*b1cdbd2cSJim Jagielski
5058*b1cdbd2cSJim Jagielski aLogicEdit.Left() = nStartX;
5059*b1cdbd2cSJim Jagielski if (!bBreak)
5060*b1cdbd2cSJim Jagielski aLogicEdit.Right() = nStartX + nTextWidth;
5061*b1cdbd2cSJim Jagielski
5062*b1cdbd2cSJim Jagielski // There is one glitch when dealing with a hyperlink cell and
5063*b1cdbd2cSJim Jagielski // the cell content is NUMERIC. This defaults to right aligned and
5064*b1cdbd2cSJim Jagielski // we need to adjust accordingly.
5065*b1cdbd2cSJim Jagielski if(pCell->GetCellType() == CELLTYPE_FORMULA &&
5066*b1cdbd2cSJim Jagielski static_cast<ScFormulaCell*>(pCell)->IsValue() &&
5067*b1cdbd2cSJim Jagielski eHorJust == SVX_HOR_JUSTIFY_STANDARD)
5068*b1cdbd2cSJim Jagielski {
5069*b1cdbd2cSJim Jagielski aLogicEdit.Right() = aLogicEdit.Left() + nThisColLogic - 1;
5070*b1cdbd2cSJim Jagielski aLogicEdit.Left() = aLogicEdit.Right() - nTextWidth;
5071*b1cdbd2cSJim Jagielski }
5072*b1cdbd2cSJim Jagielski aLogicEdit.Bottom() = aLogicEdit.Top() + nTextHeight;
5073*b1cdbd2cSJim Jagielski
5074*b1cdbd2cSJim Jagielski
5075*b1cdbd2cSJim Jagielski Point aLogicClick = PixelToLogic(rPos,aEditMode);
5076*b1cdbd2cSJim Jagielski if ( aLogicEdit.IsInside(aLogicClick) )
5077*b1cdbd2cSJim Jagielski {
5078*b1cdbd2cSJim Jagielski // aEngine.SetUpdateMode(sal_False);
5079*b1cdbd2cSJim Jagielski EditView aTempView( &aEngine, this );
5080*b1cdbd2cSJim Jagielski aTempView.SetOutputArea( aLogicEdit );
5081*b1cdbd2cSJim Jagielski
5082*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
5083*b1cdbd2cSJim Jagielski MapMode aOld = GetMapMode();
5084*b1cdbd2cSJim Jagielski SetMapMode(aEditMode); // kein return mehr
5085*b1cdbd2cSJim Jagielski
5086*b1cdbd2cSJim Jagielski if (bSpellErr) // Spelling-Fehler suchen
5087*b1cdbd2cSJim Jagielski {
5088*b1cdbd2cSJim Jagielski bRet = aTempView.IsWrongSpelledWordAtPos( rPos );
5089*b1cdbd2cSJim Jagielski if ( bRet )
5090*b1cdbd2cSJim Jagielski pViewData->GetView()->SetCursor( nPosX, nPosY ); // Cursor setzen
5091*b1cdbd2cSJim Jagielski }
5092*b1cdbd2cSJim Jagielski else // URL suchen
5093*b1cdbd2cSJim Jagielski {
5094*b1cdbd2cSJim Jagielski const SvxFieldItem* pFieldItem = aTempView.GetFieldUnderMousePointer();
5095*b1cdbd2cSJim Jagielski
5096*b1cdbd2cSJim Jagielski if (pFieldItem)
5097*b1cdbd2cSJim Jagielski {
5098*b1cdbd2cSJim Jagielski const SvxFieldData* pField = pFieldItem->GetField();
5099*b1cdbd2cSJim Jagielski if ( pField && pField->ISA(SvxURLField) )
5100*b1cdbd2cSJim Jagielski {
5101*b1cdbd2cSJim Jagielski if ( pName || pUrl || pTarget )
5102*b1cdbd2cSJim Jagielski {
5103*b1cdbd2cSJim Jagielski const SvxURLField* pURLField = (const SvxURLField*)pField;
5104*b1cdbd2cSJim Jagielski if (pName)
5105*b1cdbd2cSJim Jagielski *pName = pURLField->GetRepresentation();
5106*b1cdbd2cSJim Jagielski if (pUrl)
5107*b1cdbd2cSJim Jagielski *pUrl = pURLField->GetURL();
5108*b1cdbd2cSJim Jagielski if (pTarget)
5109*b1cdbd2cSJim Jagielski *pTarget = pURLField->GetTargetFrame();
5110*b1cdbd2cSJim Jagielski }
5111*b1cdbd2cSJim Jagielski bRet = sal_True;
5112*b1cdbd2cSJim Jagielski }
5113*b1cdbd2cSJim Jagielski }
5114*b1cdbd2cSJim Jagielski }
5115*b1cdbd2cSJim Jagielski
5116*b1cdbd2cSJim Jagielski SetMapMode(aOld);
5117*b1cdbd2cSJim Jagielski
5118*b1cdbd2cSJim Jagielski // text cursor is restored in ScHideTextCursor dtor
5119*b1cdbd2cSJim Jagielski
5120*b1cdbd2cSJim Jagielski return bRet;
5121*b1cdbd2cSJim Jagielski }
5122*b1cdbd2cSJim Jagielski return sal_False;
5123*b1cdbd2cSJim Jagielski }
5124*b1cdbd2cSJim Jagielski
HasScenarioButton(const Point & rPosPixel,ScRange & rScenRange)5125*b1cdbd2cSJim Jagielski sal_Bool ScGridWindow::HasScenarioButton( const Point& rPosPixel, ScRange& rScenRange )
5126*b1cdbd2cSJim Jagielski {
5127*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
5128*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
5129*b1cdbd2cSJim Jagielski SCTAB nTabCount = pDoc->GetTableCount();
5130*b1cdbd2cSJim Jagielski if ( nTab+1<nTabCount && pDoc->IsScenario(nTab+1) && !pDoc->IsScenario(nTab) )
5131*b1cdbd2cSJim Jagielski {
5132*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
5133*b1cdbd2cSJim Jagielski
5134*b1cdbd2cSJim Jagielski Size aButSize = pViewData->GetScenButSize();
5135*b1cdbd2cSJim Jagielski long nBWidth = aButSize.Width();
5136*b1cdbd2cSJim Jagielski if (!nBWidth)
5137*b1cdbd2cSJim Jagielski return sal_False; // noch kein Button gezeichnet -> da ist auch keiner
5138*b1cdbd2cSJim Jagielski long nBHeight = aButSize.Height();
5139*b1cdbd2cSJim Jagielski long nHSpace = (long)( SC_SCENARIO_HSPACE * pViewData->GetPPTX() );
5140*b1cdbd2cSJim Jagielski
5141*b1cdbd2cSJim Jagielski //! Ranges an der Table cachen!!!!
5142*b1cdbd2cSJim Jagielski
5143*b1cdbd2cSJim Jagielski ScMarkData aMarks;
5144*b1cdbd2cSJim Jagielski for (SCTAB i=nTab+1; i<nTabCount && pDoc->IsScenario(i); i++)
5145*b1cdbd2cSJim Jagielski pDoc->MarkScenario( i, nTab, aMarks, sal_False, SC_SCENARIO_SHOWFRAME );
5146*b1cdbd2cSJim Jagielski ScRangeList aRanges;
5147*b1cdbd2cSJim Jagielski aMarks.FillRangeListWithMarks( &aRanges, sal_False );
5148*b1cdbd2cSJim Jagielski
5149*b1cdbd2cSJim Jagielski
5150*b1cdbd2cSJim Jagielski sal_uLong nRangeCount = aRanges.Count();
5151*b1cdbd2cSJim Jagielski for (sal_uLong j=0; j<nRangeCount; j++)
5152*b1cdbd2cSJim Jagielski {
5153*b1cdbd2cSJim Jagielski ScRange aRange = *aRanges.GetObject(j);
5154*b1cdbd2cSJim Jagielski // Szenario-Rahmen immer dann auf zusammengefasste Zellen erweitern, wenn
5155*b1cdbd2cSJim Jagielski // dadurch keine neuen nicht-ueberdeckten Zellen mit umrandet werden
5156*b1cdbd2cSJim Jagielski pDoc->ExtendTotalMerge( aRange );
5157*b1cdbd2cSJim Jagielski
5158*b1cdbd2cSJim Jagielski sal_Bool bTextBelow = ( aRange.aStart.Row() == 0 );
5159*b1cdbd2cSJim Jagielski
5160*b1cdbd2cSJim Jagielski Point aButtonPos;
5161*b1cdbd2cSJim Jagielski if ( bTextBelow )
5162*b1cdbd2cSJim Jagielski {
5163*b1cdbd2cSJim Jagielski aButtonPos = pViewData->GetScrPos( aRange.aEnd.Col()+1, aRange.aEnd.Row()+1,
5164*b1cdbd2cSJim Jagielski eWhich, sal_True );
5165*b1cdbd2cSJim Jagielski }
5166*b1cdbd2cSJim Jagielski else
5167*b1cdbd2cSJim Jagielski {
5168*b1cdbd2cSJim Jagielski aButtonPos = pViewData->GetScrPos( aRange.aEnd.Col()+1, aRange.aStart.Row(),
5169*b1cdbd2cSJim Jagielski eWhich, sal_True );
5170*b1cdbd2cSJim Jagielski aButtonPos.Y() -= nBHeight;
5171*b1cdbd2cSJim Jagielski }
5172*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
5173*b1cdbd2cSJim Jagielski aButtonPos.X() -= nHSpace - 1;
5174*b1cdbd2cSJim Jagielski else
5175*b1cdbd2cSJim Jagielski aButtonPos.X() -= nBWidth - nHSpace; // same for top or bottom
5176*b1cdbd2cSJim Jagielski
5177*b1cdbd2cSJim Jagielski Rectangle aButRect( aButtonPos, Size(nBWidth,nBHeight) );
5178*b1cdbd2cSJim Jagielski if ( aButRect.IsInside( rPosPixel ) )
5179*b1cdbd2cSJim Jagielski {
5180*b1cdbd2cSJim Jagielski rScenRange = aRange;
5181*b1cdbd2cSJim Jagielski return sal_True;
5182*b1cdbd2cSJim Jagielski }
5183*b1cdbd2cSJim Jagielski }
5184*b1cdbd2cSJim Jagielski }
5185*b1cdbd2cSJim Jagielski
5186*b1cdbd2cSJim Jagielski return sal_False;
5187*b1cdbd2cSJim Jagielski }
5188*b1cdbd2cSJim Jagielski
UpdateVisibleRange()5189*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateVisibleRange()
5190*b1cdbd2cSJim Jagielski {
5191*b1cdbd2cSJim Jagielski // #163911# Update the visible range outside of paint (called when switching sheets).
5192*b1cdbd2cSJim Jagielski // Use the same logic here as in ScGridWindow::Draw.
5193*b1cdbd2cSJim Jagielski
5194*b1cdbd2cSJim Jagielski SCCOL nPosX = pViewData->GetPosX( eHWhich );
5195*b1cdbd2cSJim Jagielski SCROW nPosY = pViewData->GetPosY( eVWhich );
5196*b1cdbd2cSJim Jagielski
5197*b1cdbd2cSJim Jagielski SCCOL nXRight = nPosX + pViewData->VisibleCellsX(eHWhich);
5198*b1cdbd2cSJim Jagielski if (nXRight > MAXCOL) nXRight = MAXCOL;
5199*b1cdbd2cSJim Jagielski SCROW nYBottom = nPosY + pViewData->VisibleCellsY(eVWhich);
5200*b1cdbd2cSJim Jagielski if (nYBottom > MAXROW) nYBottom = MAXROW;
5201*b1cdbd2cSJim Jagielski
5202*b1cdbd2cSJim Jagielski // Store the current visible range.
5203*b1cdbd2cSJim Jagielski maVisibleRange.mnCol1 = nPosX;
5204*b1cdbd2cSJim Jagielski maVisibleRange.mnCol2 = nXRight;
5205*b1cdbd2cSJim Jagielski maVisibleRange.mnRow1 = nPosY;
5206*b1cdbd2cSJim Jagielski maVisibleRange.mnRow2 = nYBottom;
5207*b1cdbd2cSJim Jagielski }
5208*b1cdbd2cSJim Jagielski
5209*b1cdbd2cSJim Jagielski // #114409#
DrawLayerCreated()5210*b1cdbd2cSJim Jagielski void ScGridWindow::DrawLayerCreated()
5211*b1cdbd2cSJim Jagielski {
5212*b1cdbd2cSJim Jagielski SetMapMode( GetDrawMapMode() );
5213*b1cdbd2cSJim Jagielski
5214*b1cdbd2cSJim Jagielski // initially create overlay objects
5215*b1cdbd2cSJim Jagielski ImpCreateOverlayObjects();
5216*b1cdbd2cSJim Jagielski }
5217*b1cdbd2cSJim Jagielski
5218*b1cdbd2cSJim Jagielski // #114409#
CursorChanged()5219*b1cdbd2cSJim Jagielski void ScGridWindow::CursorChanged()
5220*b1cdbd2cSJim Jagielski {
5221*b1cdbd2cSJim Jagielski // here the created OverlayObjects may be transformed in later versions. For
5222*b1cdbd2cSJim Jagielski // now, just re-create them
5223*b1cdbd2cSJim Jagielski
5224*b1cdbd2cSJim Jagielski UpdateCursorOverlay();
5225*b1cdbd2cSJim Jagielski }
5226*b1cdbd2cSJim Jagielski
5227*b1cdbd2cSJim Jagielski // #114409#
ImpCreateOverlayObjects()5228*b1cdbd2cSJim Jagielski void ScGridWindow::ImpCreateOverlayObjects()
5229*b1cdbd2cSJim Jagielski {
5230*b1cdbd2cSJim Jagielski UpdateCursorOverlay();
5231*b1cdbd2cSJim Jagielski UpdateSelectionOverlay();
5232*b1cdbd2cSJim Jagielski UpdateAutoFillOverlay();
5233*b1cdbd2cSJim Jagielski UpdateDragRectOverlay();
5234*b1cdbd2cSJim Jagielski UpdateHeaderOverlay();
5235*b1cdbd2cSJim Jagielski UpdateShrinkOverlay();
5236*b1cdbd2cSJim Jagielski }
5237*b1cdbd2cSJim Jagielski
5238*b1cdbd2cSJim Jagielski // #114409#
ImpDestroyOverlayObjects()5239*b1cdbd2cSJim Jagielski void ScGridWindow::ImpDestroyOverlayObjects()
5240*b1cdbd2cSJim Jagielski {
5241*b1cdbd2cSJim Jagielski DeleteCursorOverlay();
5242*b1cdbd2cSJim Jagielski DeleteSelectionOverlay();
5243*b1cdbd2cSJim Jagielski DeleteAutoFillOverlay();
5244*b1cdbd2cSJim Jagielski DeleteDragRectOverlay();
5245*b1cdbd2cSJim Jagielski DeleteHeaderOverlay();
5246*b1cdbd2cSJim Jagielski DeleteShrinkOverlay();
5247*b1cdbd2cSJim Jagielski }
5248*b1cdbd2cSJim Jagielski
UpdateAllOverlays()5249*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateAllOverlays()
5250*b1cdbd2cSJim Jagielski {
5251*b1cdbd2cSJim Jagielski // delete and re-allocate all overlay objects
5252*b1cdbd2cSJim Jagielski
5253*b1cdbd2cSJim Jagielski ImpDestroyOverlayObjects();
5254*b1cdbd2cSJim Jagielski ImpCreateOverlayObjects();
5255*b1cdbd2cSJim Jagielski }
5256*b1cdbd2cSJim Jagielski
DeleteCursorOverlay()5257*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteCursorOverlay()
5258*b1cdbd2cSJim Jagielski {
5259*b1cdbd2cSJim Jagielski DELETEZ( mpOOCursors );
5260*b1cdbd2cSJim Jagielski }
5261*b1cdbd2cSJim Jagielski
UpdateCursorOverlay()5262*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateCursorOverlay()
5263*b1cdbd2cSJim Jagielski {
5264*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5265*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5266*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5267*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5268*b1cdbd2cSJim Jagielski
5269*b1cdbd2cSJim Jagielski // Existing OverlayObjects may be transformed in later versions.
5270*b1cdbd2cSJim Jagielski // For now, just re-create them.
5271*b1cdbd2cSJim Jagielski
5272*b1cdbd2cSJim Jagielski DeleteCursorOverlay();
5273*b1cdbd2cSJim Jagielski
5274*b1cdbd2cSJim Jagielski std::vector<Rectangle> aPixelRects;
5275*b1cdbd2cSJim Jagielski
5276*b1cdbd2cSJim Jagielski //
5277*b1cdbd2cSJim Jagielski // determine the cursor rectangles in pixels (moved from ScGridWindow::DrawCursor)
5278*b1cdbd2cSJim Jagielski //
5279*b1cdbd2cSJim Jagielski
5280*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
5281*b1cdbd2cSJim Jagielski SCCOL nX = pViewData->GetCurX();
5282*b1cdbd2cSJim Jagielski SCROW nY = pViewData->GetCurY();
5283*b1cdbd2cSJim Jagielski
5284*b1cdbd2cSJim Jagielski if (!maVisibleRange.isInside(nX, nY))
5285*b1cdbd2cSJim Jagielski return;
5286*b1cdbd2cSJim Jagielski
5287*b1cdbd2cSJim Jagielski // don't show the cursor in overlapped cells
5288*b1cdbd2cSJim Jagielski
5289*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
5290*b1cdbd2cSJim Jagielski const ScPatternAttr* pPattern = pDoc->GetPattern(nX,nY,nTab);
5291*b1cdbd2cSJim Jagielski const ScMergeFlagAttr& rMergeFlag = (const ScMergeFlagAttr&) pPattern->GetItem(ATTR_MERGE_FLAG);
5292*b1cdbd2cSJim Jagielski sal_Bool bOverlapped = rMergeFlag.IsOverlapped();
5293*b1cdbd2cSJim Jagielski
5294*b1cdbd2cSJim Jagielski // left or above of the screen?
5295*b1cdbd2cSJim Jagielski
5296*b1cdbd2cSJim Jagielski sal_Bool bVis = ( nX>=pViewData->GetPosX(eHWhich) && nY>=pViewData->GetPosY(eVWhich) );
5297*b1cdbd2cSJim Jagielski if (!bVis)
5298*b1cdbd2cSJim Jagielski {
5299*b1cdbd2cSJim Jagielski SCCOL nEndX = nX;
5300*b1cdbd2cSJim Jagielski SCROW nEndY = nY;
5301*b1cdbd2cSJim Jagielski const ScMergeAttr& rMerge = (const ScMergeAttr&) pPattern->GetItem(ATTR_MERGE);
5302*b1cdbd2cSJim Jagielski if (rMerge.GetColMerge() > 1)
5303*b1cdbd2cSJim Jagielski nEndX += rMerge.GetColMerge()-1;
5304*b1cdbd2cSJim Jagielski if (rMerge.GetRowMerge() > 1)
5305*b1cdbd2cSJim Jagielski nEndY += rMerge.GetRowMerge()-1;
5306*b1cdbd2cSJim Jagielski bVis = ( nEndX>=pViewData->GetPosX(eHWhich) && nEndY>=pViewData->GetPosY(eVWhich) );
5307*b1cdbd2cSJim Jagielski }
5308*b1cdbd2cSJim Jagielski
5309*b1cdbd2cSJim Jagielski if ( bVis && !bOverlapped && !pViewData->HasEditView(eWhich) && pViewData->IsActive() )
5310*b1cdbd2cSJim Jagielski {
5311*b1cdbd2cSJim Jagielski Point aScrPos = pViewData->GetScrPos( nX, nY, eWhich, sal_True );
5312*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
5313*b1cdbd2cSJim Jagielski
5314*b1cdbd2cSJim Jagielski // completely right of/below the screen?
5315*b1cdbd2cSJim Jagielski // (test with logical start position in aScrPos)
5316*b1cdbd2cSJim Jagielski sal_Bool bMaybeVisible;
5317*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
5318*b1cdbd2cSJim Jagielski bMaybeVisible = ( aScrPos.X() >= -2 && aScrPos.Y() >= -2 );
5319*b1cdbd2cSJim Jagielski else
5320*b1cdbd2cSJim Jagielski {
5321*b1cdbd2cSJim Jagielski Size aOutSize = GetOutputSizePixel();
5322*b1cdbd2cSJim Jagielski bMaybeVisible = ( aScrPos.X() <= aOutSize.Width() + 2 && aScrPos.Y() <= aOutSize.Height() + 2 );
5323*b1cdbd2cSJim Jagielski }
5324*b1cdbd2cSJim Jagielski if ( bMaybeVisible )
5325*b1cdbd2cSJim Jagielski {
5326*b1cdbd2cSJim Jagielski long nSizeXPix;
5327*b1cdbd2cSJim Jagielski long nSizeYPix;
5328*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nX, nY, nSizeXPix, nSizeYPix );
5329*b1cdbd2cSJim Jagielski
5330*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
5331*b1cdbd2cSJim Jagielski aScrPos.X() -= nSizeXPix - 2; // move instead of mirroring
5332*b1cdbd2cSJim Jagielski
5333*b1cdbd2cSJim Jagielski sal_Bool bFix = ( pViewData->GetHSplitMode() == SC_SPLIT_FIX ||
5334*b1cdbd2cSJim Jagielski pViewData->GetVSplitMode() == SC_SPLIT_FIX );
5335*b1cdbd2cSJim Jagielski if ( pViewData->GetActivePart()==eWhich || bFix )
5336*b1cdbd2cSJim Jagielski {
5337*b1cdbd2cSJim Jagielski aScrPos.X() -= 2;
5338*b1cdbd2cSJim Jagielski aScrPos.Y() -= 2;
5339*b1cdbd2cSJim Jagielski Rectangle aRect( aScrPos, Size( nSizeXPix + 3, nSizeYPix + 3 ) );
5340*b1cdbd2cSJim Jagielski
5341*b1cdbd2cSJim Jagielski aPixelRects.push_back(Rectangle( aRect.Left(), aRect.Top(), aRect.Left()+2, aRect.Bottom() ));
5342*b1cdbd2cSJim Jagielski aPixelRects.push_back(Rectangle( aRect.Right()-2, aRect.Top(), aRect.Right(), aRect.Bottom() ));
5343*b1cdbd2cSJim Jagielski aPixelRects.push_back(Rectangle( aRect.Left()+3, aRect.Top(), aRect.Right()-3, aRect.Top()+2 ));
5344*b1cdbd2cSJim Jagielski aPixelRects.push_back(Rectangle( aRect.Left()+3, aRect.Bottom()-2, aRect.Right()-3, aRect.Bottom() ));
5345*b1cdbd2cSJim Jagielski }
5346*b1cdbd2cSJim Jagielski else
5347*b1cdbd2cSJim Jagielski {
5348*b1cdbd2cSJim Jagielski Rectangle aRect( aScrPos, Size( nSizeXPix - 1, nSizeYPix - 1 ) );
5349*b1cdbd2cSJim Jagielski aPixelRects.push_back( aRect );
5350*b1cdbd2cSJim Jagielski }
5351*b1cdbd2cSJim Jagielski }
5352*b1cdbd2cSJim Jagielski }
5353*b1cdbd2cSJim Jagielski
5354*b1cdbd2cSJim Jagielski if ( aPixelRects.size() )
5355*b1cdbd2cSJim Jagielski {
5356*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5357*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5358*b1cdbd2cSJim Jagielski
5359*b1cdbd2cSJim Jagielski if(pOverlayManager)
5360*b1cdbd2cSJim Jagielski {
5361*b1cdbd2cSJim Jagielski const Color aCursorColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor );
5362*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5363*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5364*b1cdbd2cSJim Jagielski
5365*b1cdbd2cSJim Jagielski for(sal_uInt32 a(0); a < aPixelRects.size(); a++)
5366*b1cdbd2cSJim Jagielski {
5367*b1cdbd2cSJim Jagielski const Rectangle aRA(aPixelRects[a]);
5368*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(aRA.Left(), aRA.Top(), aRA.Right() + 1, aRA.Bottom() + 1);
5369*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5370*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5371*b1cdbd2cSJim Jagielski }
5372*b1cdbd2cSJim Jagielski
5373*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5374*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_SOLID,
5375*b1cdbd2cSJim Jagielski aCursorColor,
5376*b1cdbd2cSJim Jagielski aRanges,
5377*b1cdbd2cSJim Jagielski false);
5378*b1cdbd2cSJim Jagielski
5379*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5380*b1cdbd2cSJim Jagielski mpOOCursors = new ::sdr::overlay::OverlayObjectList;
5381*b1cdbd2cSJim Jagielski mpOOCursors->append(*pOverlay);
5382*b1cdbd2cSJim Jagielski }
5383*b1cdbd2cSJim Jagielski }
5384*b1cdbd2cSJim Jagielski
5385*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5386*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5387*b1cdbd2cSJim Jagielski }
5388*b1cdbd2cSJim Jagielski
DeleteSelectionOverlay()5389*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteSelectionOverlay()
5390*b1cdbd2cSJim Jagielski {
5391*b1cdbd2cSJim Jagielski DELETEZ( mpOOSelection );
5392*b1cdbd2cSJim Jagielski }
5393*b1cdbd2cSJim Jagielski
UpdateSelectionOverlay()5394*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateSelectionOverlay()
5395*b1cdbd2cSJim Jagielski {
5396*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5397*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5398*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5399*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5400*b1cdbd2cSJim Jagielski
5401*b1cdbd2cSJim Jagielski DeleteSelectionOverlay();
5402*b1cdbd2cSJim Jagielski std::vector<Rectangle> aPixelRects;
5403*b1cdbd2cSJim Jagielski GetSelectionRects( aPixelRects );
5404*b1cdbd2cSJim Jagielski
5405*b1cdbd2cSJim Jagielski if ( aPixelRects.size() && pViewData->IsActive() )
5406*b1cdbd2cSJim Jagielski {
5407*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5408*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5409*b1cdbd2cSJim Jagielski
5410*b1cdbd2cSJim Jagielski if(pOverlayManager)
5411*b1cdbd2cSJim Jagielski {
5412*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5413*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5414*b1cdbd2cSJim Jagielski
5415*b1cdbd2cSJim Jagielski for(sal_uInt32 a(0); a < aPixelRects.size(); a++)
5416*b1cdbd2cSJim Jagielski {
5417*b1cdbd2cSJim Jagielski const Rectangle aRA(aPixelRects[a]);
5418*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(aRA.Left() - 1, aRA.Top() - 1, aRA.Right(), aRA.Bottom());
5419*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5420*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5421*b1cdbd2cSJim Jagielski }
5422*b1cdbd2cSJim Jagielski
5423*b1cdbd2cSJim Jagielski // get the system's hilight color
5424*b1cdbd2cSJim Jagielski const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
5425*b1cdbd2cSJim Jagielski const Color aHighlight(aSvtOptionsDrawinglayer.getHilightColor());
5426*b1cdbd2cSJim Jagielski
5427*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5428*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_TRANSPARENT,
5429*b1cdbd2cSJim Jagielski aHighlight,
5430*b1cdbd2cSJim Jagielski aRanges,
5431*b1cdbd2cSJim Jagielski true);
5432*b1cdbd2cSJim Jagielski
5433*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5434*b1cdbd2cSJim Jagielski mpOOSelection = new ::sdr::overlay::OverlayObjectList;
5435*b1cdbd2cSJim Jagielski mpOOSelection->append(*pOverlay);
5436*b1cdbd2cSJim Jagielski }
5437*b1cdbd2cSJim Jagielski }
5438*b1cdbd2cSJim Jagielski
5439*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5440*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5441*b1cdbd2cSJim Jagielski }
5442*b1cdbd2cSJim Jagielski
DeleteAutoFillOverlay()5443*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteAutoFillOverlay()
5444*b1cdbd2cSJim Jagielski {
5445*b1cdbd2cSJim Jagielski DELETEZ( mpOOAutoFill );
5446*b1cdbd2cSJim Jagielski mpAutoFillRect.reset();
5447*b1cdbd2cSJim Jagielski }
5448*b1cdbd2cSJim Jagielski
UpdateAutoFillOverlay()5449*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateAutoFillOverlay()
5450*b1cdbd2cSJim Jagielski {
5451*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5452*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5453*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5454*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5455*b1cdbd2cSJim Jagielski
5456*b1cdbd2cSJim Jagielski DeleteAutoFillOverlay();
5457*b1cdbd2cSJim Jagielski
5458*b1cdbd2cSJim Jagielski //
5459*b1cdbd2cSJim Jagielski // get the AutoFill handle rectangle in pixels (moved from ScGridWindow::DrawAutoFillMark)
5460*b1cdbd2cSJim Jagielski //
5461*b1cdbd2cSJim Jagielski
5462*b1cdbd2cSJim Jagielski if ( bAutoMarkVisible && aAutoMarkPos.Tab() == pViewData->GetTabNo() &&
5463*b1cdbd2cSJim Jagielski !pViewData->HasEditView(eWhich) && pViewData->IsActive() )
5464*b1cdbd2cSJim Jagielski {
5465*b1cdbd2cSJim Jagielski SCCOL nX = aAutoMarkPos.Col();
5466*b1cdbd2cSJim Jagielski SCROW nY = aAutoMarkPos.Row();
5467*b1cdbd2cSJim Jagielski
5468*b1cdbd2cSJim Jagielski if (!maVisibleRange.isInside(nX, nY))
5469*b1cdbd2cSJim Jagielski // Autofill mark is not visible. Bail out.
5470*b1cdbd2cSJim Jagielski return;
5471*b1cdbd2cSJim Jagielski
5472*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
5473*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
5474*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
5475*b1cdbd2cSJim Jagielski
5476*b1cdbd2cSJim Jagielski Point aFillPos = pViewData->GetScrPos( nX, nY, eWhich, sal_True );
5477*b1cdbd2cSJim Jagielski long nSizeXPix;
5478*b1cdbd2cSJim Jagielski long nSizeYPix;
5479*b1cdbd2cSJim Jagielski pViewData->GetMergeSizePixel( nX, nY, nSizeXPix, nSizeYPix );
5480*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
5481*b1cdbd2cSJim Jagielski aFillPos.X() -= nSizeXPix + 3;
5482*b1cdbd2cSJim Jagielski else
5483*b1cdbd2cSJim Jagielski aFillPos.X() += nSizeXPix - 2;
5484*b1cdbd2cSJim Jagielski
5485*b1cdbd2cSJim Jagielski aFillPos.Y() += nSizeYPix;
5486*b1cdbd2cSJim Jagielski aFillPos.Y() -= 2;
5487*b1cdbd2cSJim Jagielski mpAutoFillRect.reset(new Rectangle(aFillPos, Size(6, 6)));
5488*b1cdbd2cSJim Jagielski
5489*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5490*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5491*b1cdbd2cSJim Jagielski
5492*b1cdbd2cSJim Jagielski if(pOverlayManager)
5493*b1cdbd2cSJim Jagielski {
5494*b1cdbd2cSJim Jagielski const Color aHandleColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::FONTCOLOR).nColor );
5495*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5496*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5497*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(mpAutoFillRect->Left(), mpAutoFillRect->Top(), mpAutoFillRect->Right() + 1, mpAutoFillRect->Bottom() + 1);
5498*b1cdbd2cSJim Jagielski
5499*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5500*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5501*b1cdbd2cSJim Jagielski
5502*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5503*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_SOLID,
5504*b1cdbd2cSJim Jagielski aHandleColor,
5505*b1cdbd2cSJim Jagielski aRanges,
5506*b1cdbd2cSJim Jagielski false);
5507*b1cdbd2cSJim Jagielski
5508*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5509*b1cdbd2cSJim Jagielski mpOOAutoFill = new ::sdr::overlay::OverlayObjectList;
5510*b1cdbd2cSJim Jagielski mpOOAutoFill->append(*pOverlay);
5511*b1cdbd2cSJim Jagielski }
5512*b1cdbd2cSJim Jagielski
5513*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5514*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5515*b1cdbd2cSJim Jagielski }
5516*b1cdbd2cSJim Jagielski }
5517*b1cdbd2cSJim Jagielski
DeleteDragRectOverlay()5518*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteDragRectOverlay()
5519*b1cdbd2cSJim Jagielski {
5520*b1cdbd2cSJim Jagielski DELETEZ( mpOODragRect );
5521*b1cdbd2cSJim Jagielski }
5522*b1cdbd2cSJim Jagielski
UpdateDragRectOverlay()5523*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateDragRectOverlay()
5524*b1cdbd2cSJim Jagielski {
5525*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5526*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5527*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5528*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5529*b1cdbd2cSJim Jagielski
5530*b1cdbd2cSJim Jagielski DeleteDragRectOverlay();
5531*b1cdbd2cSJim Jagielski
5532*b1cdbd2cSJim Jagielski //
5533*b1cdbd2cSJim Jagielski // get the rectangles in pixels (moved from DrawDragRect)
5534*b1cdbd2cSJim Jagielski //
5535*b1cdbd2cSJim Jagielski
5536*b1cdbd2cSJim Jagielski if ( bDragRect || bPagebreakDrawn )
5537*b1cdbd2cSJim Jagielski {
5538*b1cdbd2cSJim Jagielski std::vector<Rectangle> aPixelRects;
5539*b1cdbd2cSJim Jagielski
5540*b1cdbd2cSJim Jagielski SCCOL nX1 = bDragRect ? nDragStartX : aPagebreakDrag.aStart.Col();
5541*b1cdbd2cSJim Jagielski SCROW nY1 = bDragRect ? nDragStartY : aPagebreakDrag.aStart.Row();
5542*b1cdbd2cSJim Jagielski SCCOL nX2 = bDragRect ? nDragEndX : aPagebreakDrag.aEnd.Col();
5543*b1cdbd2cSJim Jagielski SCROW nY2 = bDragRect ? nDragEndY : aPagebreakDrag.aEnd.Row();
5544*b1cdbd2cSJim Jagielski
5545*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
5546*b1cdbd2cSJim Jagielski
5547*b1cdbd2cSJim Jagielski SCCOL nPosX = pViewData->GetPosX(WhichH(eWhich));
5548*b1cdbd2cSJim Jagielski SCROW nPosY = pViewData->GetPosY(WhichV(eWhich));
5549*b1cdbd2cSJim Jagielski if (nX1 < nPosX) nX1 = nPosX;
5550*b1cdbd2cSJim Jagielski if (nX2 < nPosX) nX2 = nPosX;
5551*b1cdbd2cSJim Jagielski if (nY1 < nPosY) nY1 = nPosY;
5552*b1cdbd2cSJim Jagielski if (nY2 < nPosY) nY2 = nPosY;
5553*b1cdbd2cSJim Jagielski
5554*b1cdbd2cSJim Jagielski Point aScrPos( pViewData->GetScrPos( nX1, nY1, eWhich ) );
5555*b1cdbd2cSJim Jagielski
5556*b1cdbd2cSJim Jagielski long nSizeXPix=0;
5557*b1cdbd2cSJim Jagielski long nSizeYPix=0;
5558*b1cdbd2cSJim Jagielski ScDocument* pDoc = pViewData->GetDocument();
5559*b1cdbd2cSJim Jagielski double nPPTX = pViewData->GetPPTX();
5560*b1cdbd2cSJim Jagielski double nPPTY = pViewData->GetPPTY();
5561*b1cdbd2cSJim Jagielski SCCOLROW i;
5562*b1cdbd2cSJim Jagielski
5563*b1cdbd2cSJim Jagielski sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
5564*b1cdbd2cSJim Jagielski long nLayoutSign = bLayoutRTL ? -1 : 1;
5565*b1cdbd2cSJim Jagielski
5566*b1cdbd2cSJim Jagielski if (ValidCol(nX2) && nX2>=nX1)
5567*b1cdbd2cSJim Jagielski for (i=nX1; i<=nX2; i++)
5568*b1cdbd2cSJim Jagielski nSizeXPix += ScViewData::ToPixel( pDoc->GetColWidth( static_cast<SCCOL>(i), nTab ), nPPTX );
5569*b1cdbd2cSJim Jagielski else
5570*b1cdbd2cSJim Jagielski {
5571*b1cdbd2cSJim Jagielski aScrPos.X() -= nLayoutSign;
5572*b1cdbd2cSJim Jagielski nSizeXPix += 2;
5573*b1cdbd2cSJim Jagielski }
5574*b1cdbd2cSJim Jagielski
5575*b1cdbd2cSJim Jagielski if (ValidRow(nY2) && nY2>=nY1)
5576*b1cdbd2cSJim Jagielski for (i=nY1; i<=nY2; i++)
5577*b1cdbd2cSJim Jagielski nSizeYPix += ScViewData::ToPixel( pDoc->GetRowHeight( i, nTab ), nPPTY );
5578*b1cdbd2cSJim Jagielski else
5579*b1cdbd2cSJim Jagielski {
5580*b1cdbd2cSJim Jagielski aScrPos.Y() -= 1;
5581*b1cdbd2cSJim Jagielski nSizeYPix += 2;
5582*b1cdbd2cSJim Jagielski }
5583*b1cdbd2cSJim Jagielski
5584*b1cdbd2cSJim Jagielski aScrPos.X() -= 2 * nLayoutSign;
5585*b1cdbd2cSJim Jagielski aScrPos.Y() -= 2;
5586*b1cdbd2cSJim Jagielski // Rectangle aRect( aScrPos, Size( nSizeXPix + 3, nSizeYPix + 3 ) );
5587*b1cdbd2cSJim Jagielski Rectangle aRect( aScrPos.X(), aScrPos.Y(),
5588*b1cdbd2cSJim Jagielski aScrPos.X() + ( nSizeXPix + 2 ) * nLayoutSign, aScrPos.Y() + nSizeYPix + 2 );
5589*b1cdbd2cSJim Jagielski if ( bLayoutRTL )
5590*b1cdbd2cSJim Jagielski {
5591*b1cdbd2cSJim Jagielski aRect.Left() = aRect.Right(); // end position is left
5592*b1cdbd2cSJim Jagielski aRect.Right() = aScrPos.X();
5593*b1cdbd2cSJim Jagielski }
5594*b1cdbd2cSJim Jagielski
5595*b1cdbd2cSJim Jagielski if ( meDragInsertMode == INS_CELLSDOWN )
5596*b1cdbd2cSJim Jagielski {
5597*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+1, aRect.Top()+3, aRect.Left()+1, aRect.Bottom()-2 ) );
5598*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Right()-1, aRect.Top()+3, aRect.Right()-1, aRect.Bottom()-2 ) );
5599*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+1, aRect.Top(), aRect.Right()-1, aRect.Top()+2 ) );
5600*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+1, aRect.Bottom()-1, aRect.Right()-1, aRect.Bottom()-1 ) );
5601*b1cdbd2cSJim Jagielski }
5602*b1cdbd2cSJim Jagielski else if ( meDragInsertMode == INS_CELLSRIGHT )
5603*b1cdbd2cSJim Jagielski {
5604*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left(), aRect.Top()+1, aRect.Left()+2, aRect.Bottom()-1 ) );
5605*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Right()-1, aRect.Top()+1, aRect.Right()-1, aRect.Bottom()-1 ) );
5606*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+3, aRect.Top()+1, aRect.Right()-2, aRect.Top()+1 ) );
5607*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+3, aRect.Bottom()-1, aRect.Right()-2, aRect.Bottom()-1 ) );
5608*b1cdbd2cSJim Jagielski }
5609*b1cdbd2cSJim Jagielski else
5610*b1cdbd2cSJim Jagielski {
5611*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left(), aRect.Top(), aRect.Left()+2, aRect.Bottom() ) );
5612*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Right()-2, aRect.Top(), aRect.Right(), aRect.Bottom() ) );
5613*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+3, aRect.Top(), aRect.Right()-3, aRect.Top()+2 ) );
5614*b1cdbd2cSJim Jagielski aPixelRects.push_back( Rectangle( aRect.Left()+3, aRect.Bottom()-2, aRect.Right()-3, aRect.Bottom() ) );
5615*b1cdbd2cSJim Jagielski }
5616*b1cdbd2cSJim Jagielski
5617*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5618*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5619*b1cdbd2cSJim Jagielski
5620*b1cdbd2cSJim Jagielski if(pOverlayManager)
5621*b1cdbd2cSJim Jagielski {
5622*b1cdbd2cSJim Jagielski // Color aHighlight = GetSettings().GetStyleSettings().GetHighlightColor();
5623*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5624*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5625*b1cdbd2cSJim Jagielski
5626*b1cdbd2cSJim Jagielski for(sal_uInt32 a(0); a < aPixelRects.size(); a++)
5627*b1cdbd2cSJim Jagielski {
5628*b1cdbd2cSJim Jagielski const Rectangle aRA(aPixelRects[a]);
5629*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(aRA.Left(), aRA.Top(), aRA.Right() + 1, aRA.Bottom() + 1);
5630*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5631*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5632*b1cdbd2cSJim Jagielski }
5633*b1cdbd2cSJim Jagielski
5634*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5635*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_INVERT,
5636*b1cdbd2cSJim Jagielski Color(COL_BLACK),
5637*b1cdbd2cSJim Jagielski aRanges,
5638*b1cdbd2cSJim Jagielski false);
5639*b1cdbd2cSJim Jagielski
5640*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5641*b1cdbd2cSJim Jagielski mpOODragRect = new ::sdr::overlay::OverlayObjectList;
5642*b1cdbd2cSJim Jagielski mpOODragRect->append(*pOverlay);
5643*b1cdbd2cSJim Jagielski }
5644*b1cdbd2cSJim Jagielski }
5645*b1cdbd2cSJim Jagielski
5646*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5647*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5648*b1cdbd2cSJim Jagielski }
5649*b1cdbd2cSJim Jagielski
DeleteHeaderOverlay()5650*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteHeaderOverlay()
5651*b1cdbd2cSJim Jagielski {
5652*b1cdbd2cSJim Jagielski DELETEZ( mpOOHeader );
5653*b1cdbd2cSJim Jagielski }
5654*b1cdbd2cSJim Jagielski
UpdateHeaderOverlay()5655*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateHeaderOverlay()
5656*b1cdbd2cSJim Jagielski {
5657*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5658*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5659*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5660*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5661*b1cdbd2cSJim Jagielski
5662*b1cdbd2cSJim Jagielski DeleteHeaderOverlay();
5663*b1cdbd2cSJim Jagielski
5664*b1cdbd2cSJim Jagielski // Pixel rectangle is in aInvertRect
5665*b1cdbd2cSJim Jagielski if ( !aInvertRect.IsEmpty() )
5666*b1cdbd2cSJim Jagielski {
5667*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5668*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5669*b1cdbd2cSJim Jagielski
5670*b1cdbd2cSJim Jagielski if(pOverlayManager)
5671*b1cdbd2cSJim Jagielski {
5672*b1cdbd2cSJim Jagielski // Color aHighlight = GetSettings().GetStyleSettings().GetHighlightColor();
5673*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5674*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5675*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(aInvertRect.Left(), aInvertRect.Top(), aInvertRect.Right() + 1, aInvertRect.Bottom() + 1);
5676*b1cdbd2cSJim Jagielski
5677*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5678*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5679*b1cdbd2cSJim Jagielski
5680*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5681*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_INVERT,
5682*b1cdbd2cSJim Jagielski Color(COL_BLACK),
5683*b1cdbd2cSJim Jagielski aRanges,
5684*b1cdbd2cSJim Jagielski false);
5685*b1cdbd2cSJim Jagielski
5686*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5687*b1cdbd2cSJim Jagielski mpOOHeader = new ::sdr::overlay::OverlayObjectList;
5688*b1cdbd2cSJim Jagielski mpOOHeader->append(*pOverlay);
5689*b1cdbd2cSJim Jagielski }
5690*b1cdbd2cSJim Jagielski }
5691*b1cdbd2cSJim Jagielski
5692*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5693*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5694*b1cdbd2cSJim Jagielski }
5695*b1cdbd2cSJim Jagielski
DeleteShrinkOverlay()5696*b1cdbd2cSJim Jagielski void ScGridWindow::DeleteShrinkOverlay()
5697*b1cdbd2cSJim Jagielski {
5698*b1cdbd2cSJim Jagielski DELETEZ( mpOOShrink );
5699*b1cdbd2cSJim Jagielski }
5700*b1cdbd2cSJim Jagielski
UpdateShrinkOverlay()5701*b1cdbd2cSJim Jagielski void ScGridWindow::UpdateShrinkOverlay()
5702*b1cdbd2cSJim Jagielski {
5703*b1cdbd2cSJim Jagielski MapMode aDrawMode = GetDrawMapMode();
5704*b1cdbd2cSJim Jagielski MapMode aOldMode = GetMapMode();
5705*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5706*b1cdbd2cSJim Jagielski SetMapMode( aDrawMode );
5707*b1cdbd2cSJim Jagielski
5708*b1cdbd2cSJim Jagielski DeleteShrinkOverlay();
5709*b1cdbd2cSJim Jagielski
5710*b1cdbd2cSJim Jagielski //
5711*b1cdbd2cSJim Jagielski // get the rectangle in pixels
5712*b1cdbd2cSJim Jagielski //
5713*b1cdbd2cSJim Jagielski
5714*b1cdbd2cSJim Jagielski Rectangle aPixRect;
5715*b1cdbd2cSJim Jagielski ScRange aRange;
5716*b1cdbd2cSJim Jagielski SCTAB nTab = pViewData->GetTabNo();
5717*b1cdbd2cSJim Jagielski if ( pViewData->IsRefMode() && nTab >= pViewData->GetRefStartZ() && nTab <= pViewData->GetRefEndZ() &&
5718*b1cdbd2cSJim Jagielski pViewData->GetDelMark( aRange ) )
5719*b1cdbd2cSJim Jagielski {
5720*b1cdbd2cSJim Jagielski //! limit to visible area
5721*b1cdbd2cSJim Jagielski if ( aRange.aStart.Col() <= aRange.aEnd.Col() &&
5722*b1cdbd2cSJim Jagielski aRange.aStart.Row() <= aRange.aEnd.Row() )
5723*b1cdbd2cSJim Jagielski {
5724*b1cdbd2cSJim Jagielski Point aStart = pViewData->GetScrPos( aRange.aStart.Col(),
5725*b1cdbd2cSJim Jagielski aRange.aStart.Row(), eWhich );
5726*b1cdbd2cSJim Jagielski Point aEnd = pViewData->GetScrPos( aRange.aEnd.Col()+1,
5727*b1cdbd2cSJim Jagielski aRange.aEnd.Row()+1, eWhich );
5728*b1cdbd2cSJim Jagielski aEnd.X() -= 1;
5729*b1cdbd2cSJim Jagielski aEnd.Y() -= 1;
5730*b1cdbd2cSJim Jagielski
5731*b1cdbd2cSJim Jagielski aPixRect = Rectangle( aStart,aEnd );
5732*b1cdbd2cSJim Jagielski }
5733*b1cdbd2cSJim Jagielski }
5734*b1cdbd2cSJim Jagielski
5735*b1cdbd2cSJim Jagielski if ( !aPixRect.IsEmpty() )
5736*b1cdbd2cSJim Jagielski {
5737*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5738*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5739*b1cdbd2cSJim Jagielski
5740*b1cdbd2cSJim Jagielski if(pOverlayManager)
5741*b1cdbd2cSJim Jagielski {
5742*b1cdbd2cSJim Jagielski // Color aHighlight = GetSettings().GetStyleSettings().GetHighlightColor();
5743*b1cdbd2cSJim Jagielski std::vector< basegfx::B2DRange > aRanges;
5744*b1cdbd2cSJim Jagielski const basegfx::B2DHomMatrix aTransform(GetInverseViewTransformation());
5745*b1cdbd2cSJim Jagielski basegfx::B2DRange aRB(aPixRect.Left(), aPixRect.Top(), aPixRect.Right() + 1, aPixRect.Bottom() + 1);
5746*b1cdbd2cSJim Jagielski
5747*b1cdbd2cSJim Jagielski aRB.transform(aTransform);
5748*b1cdbd2cSJim Jagielski aRanges.push_back(aRB);
5749*b1cdbd2cSJim Jagielski
5750*b1cdbd2cSJim Jagielski sdr::overlay::OverlayObject* pOverlay = new sdr::overlay::OverlaySelection(
5751*b1cdbd2cSJim Jagielski sdr::overlay::OVERLAY_INVERT,
5752*b1cdbd2cSJim Jagielski Color(COL_BLACK),
5753*b1cdbd2cSJim Jagielski aRanges,
5754*b1cdbd2cSJim Jagielski false);
5755*b1cdbd2cSJim Jagielski
5756*b1cdbd2cSJim Jagielski pOverlayManager->add(*pOverlay);
5757*b1cdbd2cSJim Jagielski mpOOShrink = new ::sdr::overlay::OverlayObjectList;
5758*b1cdbd2cSJim Jagielski mpOOShrink->append(*pOverlay);
5759*b1cdbd2cSJim Jagielski }
5760*b1cdbd2cSJim Jagielski }
5761*b1cdbd2cSJim Jagielski
5762*b1cdbd2cSJim Jagielski if ( aOldMode != aDrawMode )
5763*b1cdbd2cSJim Jagielski SetMapMode( aOldMode );
5764*b1cdbd2cSJim Jagielski }
5765*b1cdbd2cSJim Jagielski
5766*b1cdbd2cSJim Jagielski // #i70788# central method to get the OverlayManager safely
getOverlayManager()5767*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* ScGridWindow::getOverlayManager()
5768*b1cdbd2cSJim Jagielski {
5769*b1cdbd2cSJim Jagielski SdrPageView* pPV = pViewData->GetView()->GetScDrawView()->GetSdrPageView();
5770*b1cdbd2cSJim Jagielski
5771*b1cdbd2cSJim Jagielski if(pPV)
5772*b1cdbd2cSJim Jagielski {
5773*b1cdbd2cSJim Jagielski SdrPageWindow* pPageWin = pPV->FindPageWindow( *this );
5774*b1cdbd2cSJim Jagielski
5775*b1cdbd2cSJim Jagielski if ( pPageWin )
5776*b1cdbd2cSJim Jagielski {
5777*b1cdbd2cSJim Jagielski return (pPageWin->GetOverlayManager());
5778*b1cdbd2cSJim Jagielski }
5779*b1cdbd2cSJim Jagielski }
5780*b1cdbd2cSJim Jagielski
5781*b1cdbd2cSJim Jagielski return 0L;
5782*b1cdbd2cSJim Jagielski }
5783*b1cdbd2cSJim Jagielski
flushOverlayManager()5784*b1cdbd2cSJim Jagielski void ScGridWindow::flushOverlayManager()
5785*b1cdbd2cSJim Jagielski {
5786*b1cdbd2cSJim Jagielski // #i70788# get the OverlayManager safely
5787*b1cdbd2cSJim Jagielski ::sdr::overlay::OverlayManager* pOverlayManager = getOverlayManager();
5788*b1cdbd2cSJim Jagielski
5789*b1cdbd2cSJim Jagielski if(pOverlayManager)
5790*b1cdbd2cSJim Jagielski {
5791*b1cdbd2cSJim Jagielski pOverlayManager->flush();
5792*b1cdbd2cSJim Jagielski }
5793*b1cdbd2cSJim Jagielski }
5794*b1cdbd2cSJim Jagielski
5795*b1cdbd2cSJim Jagielski // ---------------------------------------------------------------------------
5796*b1cdbd2cSJim Jagielski // eof
5797