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_svx.hxx"
26*b1cdbd2cSJim Jagielski
27*b1cdbd2cSJim Jagielski // INCLUDE ---------------------------------------------------------------
28*b1cdbd2cSJim Jagielski
29*b1cdbd2cSJim Jagielski #include <string.h>
30*b1cdbd2cSJim Jagielski #include <limits.h>
31*b1cdbd2cSJim Jagielski #include <tools/shl.hxx>
32*b1cdbd2cSJim Jagielski #include <vcl/image.hxx>
33*b1cdbd2cSJim Jagielski #include <svl/eitem.hxx>
34*b1cdbd2cSJim Jagielski #include <svl/rectitem.hxx>
35*b1cdbd2cSJim Jagielski #include <sfx2/dispatch.hxx>
36*b1cdbd2cSJim Jagielski
37*b1cdbd2cSJim Jagielski #include <svl/smplhint.hxx>
38*b1cdbd2cSJim Jagielski
39*b1cdbd2cSJim Jagielski
40*b1cdbd2cSJim Jagielski
41*b1cdbd2cSJim Jagielski
42*b1cdbd2cSJim Jagielski
43*b1cdbd2cSJim Jagielski #include <svx/dialogs.hrc>
44*b1cdbd2cSJim Jagielski #include <svx/dialmgr.hxx>
45*b1cdbd2cSJim Jagielski #include <svx/ruler.hxx>
46*b1cdbd2cSJim Jagielski #include "rlrcitem.hxx"
47*b1cdbd2cSJim Jagielski #include "svx/rulritem.hxx"
48*b1cdbd2cSJim Jagielski #include <editeng/tstpitem.hxx>
49*b1cdbd2cSJim Jagielski #include <editeng/lrspitem.hxx>
50*b1cdbd2cSJim Jagielski #include "editeng/protitem.hxx"
51*b1cdbd2cSJim Jagielski #ifndef _APP_HXX
52*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
53*b1cdbd2cSJim Jagielski #endif
54*b1cdbd2cSJim Jagielski #ifndef RULER_TAB_RTL
55*b1cdbd2cSJim Jagielski #define RULER_TAB_RTL ((sal_uInt16)0x0010)
56*b1cdbd2cSJim Jagielski #endif
57*b1cdbd2cSJim Jagielski
58*b1cdbd2cSJim Jagielski #include <comphelper/uieventslogger.hxx>
59*b1cdbd2cSJim Jagielski
60*b1cdbd2cSJim Jagielski namespace
61*b1cdbd2cSJim Jagielski {
lcl_logRulerUse(const::rtl::OUString & sURL)62*b1cdbd2cSJim Jagielski void lcl_logRulerUse(const ::rtl::OUString& sURL) //#i99729#
63*b1cdbd2cSJim Jagielski {
64*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
65*b1cdbd2cSJim Jagielski util::URL aTargetURL;
66*b1cdbd2cSJim Jagielski aTargetURL.Complete = sURL;
67*b1cdbd2cSJim Jagielski aTargetURL.Main = sURL;
68*b1cdbd2cSJim Jagielski if(::comphelper::UiEventsLogger::isEnabled()) //#i88653#
69*b1cdbd2cSJim Jagielski {
70*b1cdbd2cSJim Jagielski ::rtl::OUString sAppName;
71*b1cdbd2cSJim Jagielski uno::Sequence<beans::PropertyValue> source;
72*b1cdbd2cSJim Jagielski ::comphelper::UiEventsLogger::appendDispatchOrigin(source, sAppName, ::rtl::OUString::createFromAscii("SfxRuler"));
73*b1cdbd2cSJim Jagielski ::comphelper::UiEventsLogger::logDispatch(aTargetURL, source);
74*b1cdbd2cSJim Jagielski }
75*b1cdbd2cSJim Jagielski }
76*b1cdbd2cSJim Jagielski }
77*b1cdbd2cSJim Jagielski
78*b1cdbd2cSJim Jagielski
79*b1cdbd2cSJim Jagielski
80*b1cdbd2cSJim Jagielski // STATIC DATA -----------------------------------------------------------
81*b1cdbd2cSJim Jagielski
82*b1cdbd2cSJim Jagielski #define CTRL_ITEM_COUNT 14
83*b1cdbd2cSJim Jagielski #define GAP 10
84*b1cdbd2cSJim Jagielski #define OBJECT_BORDER_COUNT 4
85*b1cdbd2cSJim Jagielski #define TAB_GAP 1
86*b1cdbd2cSJim Jagielski #define INDENT_GAP 2
87*b1cdbd2cSJim Jagielski #define INDENT_FIRST_LINE 4
88*b1cdbd2cSJim Jagielski #define INDENT_LEFT_MARGIN 5
89*b1cdbd2cSJim Jagielski #define INDENT_RIGHT_MARGIN 6
90*b1cdbd2cSJim Jagielski #define INDENT_LEFT_BORDER 2
91*b1cdbd2cSJim Jagielski #define INDENT_RIGHT_BORDER 3
92*b1cdbd2cSJim Jagielski #define INDENT_COUNT 5 //without the first two old values
93*b1cdbd2cSJim Jagielski
94*b1cdbd2cSJim Jagielski #define PIXEL_H_ADJUST( l1, l2 ) PixelHAdjust(l1,l2)
95*b1cdbd2cSJim Jagielski
96*b1cdbd2cSJim Jagielski #ifdef DEBUGLIN
97*b1cdbd2cSJim Jagielski
ToMM(Window * pWin,long lVal)98*b1cdbd2cSJim Jagielski inline long ToMM(Window *pWin, long lVal)
99*b1cdbd2cSJim Jagielski {
100*b1cdbd2cSJim Jagielski return pWin->PixelToLogic(Size(lVal, 0), MapMode(MAP_MM)).Width();
101*b1cdbd2cSJim Jagielski }
102*b1cdbd2cSJim Jagielski
Debug_Impl(Window * pWin,SvxColumnItem & rColItem)103*b1cdbd2cSJim Jagielski void Debug_Impl(Window *pWin, SvxColumnItem& rColItem)
104*b1cdbd2cSJim Jagielski {
105*b1cdbd2cSJim Jagielski String aTmp("Aktuell: ");
106*b1cdbd2cSJim Jagielski aTmp += rColItem.GetActColumn();
107*b1cdbd2cSJim Jagielski aTmp += " ColLeft: ";
108*b1cdbd2cSJim Jagielski aTmp += String(ToMM(pWin, rColItem.GetLeft()));
109*b1cdbd2cSJim Jagielski aTmp += " ColRight: ";
110*b1cdbd2cSJim Jagielski aTmp += String(ToMM(pWin, rColItem.GetRight()));
111*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < rColItem.Count(); ++i) {
112*b1cdbd2cSJim Jagielski aTmp += " Start: ";
113*b1cdbd2cSJim Jagielski aTmp += String(ToMM(pWin, rColItem[i].nStart));
114*b1cdbd2cSJim Jagielski aTmp += " End: ";
115*b1cdbd2cSJim Jagielski aTmp += String(ToMM(pWin, rColItem[i].nEnd));
116*b1cdbd2cSJim Jagielski }
117*b1cdbd2cSJim Jagielski
118*b1cdbd2cSJim Jagielski InfoBox(0, aTmp).Execute();
119*b1cdbd2cSJim Jagielski }
120*b1cdbd2cSJim Jagielski
Debug_Impl(Window * pWin,const SvxLongLRSpaceItem & rLRSpace)121*b1cdbd2cSJim Jagielski void Debug_Impl(Window *pWin, const SvxLongLRSpaceItem& rLRSpace)
122*b1cdbd2cSJim Jagielski {
123*b1cdbd2cSJim Jagielski String aTmp("Left: ");
124*b1cdbd2cSJim Jagielski aTmp += pWin->PixelToLogic(Size(rLRSpace.GetLeft(), 0), MapMode(MAP_MM)).Width();
125*b1cdbd2cSJim Jagielski aTmp += " Right: ";
126*b1cdbd2cSJim Jagielski aTmp +=pWin->PixelToLogic(Size(rLRSpace.GetRight(), 0), MapMode(MAP_MM)).Width();
127*b1cdbd2cSJim Jagielski InfoBox(0, aTmp).Execute();
128*b1cdbd2cSJim Jagielski }
129*b1cdbd2cSJim Jagielski
Debug_Impl(Window * pWin,const SvxLongULSpaceItem & rULSpace)130*b1cdbd2cSJim Jagielski void Debug_Impl(Window *pWin, const SvxLongULSpaceItem& rULSpace)
131*b1cdbd2cSJim Jagielski {
132*b1cdbd2cSJim Jagielski String aTmp("Upper: ");
133*b1cdbd2cSJim Jagielski aTmp += pWin->PixelToLogic(Size(rULSpace.GetUpper(), 0), MapMode(MAP_MM)).Width();
134*b1cdbd2cSJim Jagielski aTmp += " Lower: ";
135*b1cdbd2cSJim Jagielski aTmp += pWin->PixelToLogic(Size(rULSpace.GetLower(), 0), MapMode(MAP_MM)).Width();
136*b1cdbd2cSJim Jagielski
137*b1cdbd2cSJim Jagielski InfoBox(0, aTmp).Execute();
138*b1cdbd2cSJim Jagielski }
139*b1cdbd2cSJim Jagielski
DebugTabStops_Impl(const SvxTabStopItem & rTabs)140*b1cdbd2cSJim Jagielski void DebugTabStops_Impl(const SvxTabStopItem& rTabs)
141*b1cdbd2cSJim Jagielski {
142*b1cdbd2cSJim Jagielski String aTmp("Tabs: ");
143*b1cdbd2cSJim Jagielski
144*b1cdbd2cSJim Jagielski // Def Tabs loeschen
145*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < rTabs.Count(); ++i)
146*b1cdbd2cSJim Jagielski {
147*b1cdbd2cSJim Jagielski aTmp += String(rTabs[i].GetTabPos() / 56);
148*b1cdbd2cSJim Jagielski aTmp += " : ";
149*b1cdbd2cSJim Jagielski }
150*b1cdbd2cSJim Jagielski InfoBox(0, aTmp).Execute();
151*b1cdbd2cSJim Jagielski }
152*b1cdbd2cSJim Jagielski
DebugParaMargin_Impl(const SvxLRSpaceItem & rLRSpace)153*b1cdbd2cSJim Jagielski void DebugParaMargin_Impl(const SvxLRSpaceItem& rLRSpace)
154*b1cdbd2cSJim Jagielski {
155*b1cdbd2cSJim Jagielski String aTmp("ParaLeft: ");
156*b1cdbd2cSJim Jagielski aTmp += rLRSpace.GetTxtLeft() / 56;
157*b1cdbd2cSJim Jagielski aTmp += " ParaRight: ";
158*b1cdbd2cSJim Jagielski aTmp += rLRSpace.GetRight() / 56;
159*b1cdbd2cSJim Jagielski aTmp += " FLI: ";
160*b1cdbd2cSJim Jagielski aTmp += rLRSpace.GetTxtFirstLineOfst() / 56;
161*b1cdbd2cSJim Jagielski InfoBox(0, aTmp).Execute();
162*b1cdbd2cSJim Jagielski }
163*b1cdbd2cSJim Jagielski
164*b1cdbd2cSJim Jagielski #endif // DEBUGLIN
165*b1cdbd2cSJim Jagielski #ifdef DEBUG_RULER
166*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
167*b1cdbd2cSJim Jagielski #include <vcl/lstbox.hxx>
168*b1cdbd2cSJim Jagielski class RulerDebugWindow : public Window
169*b1cdbd2cSJim Jagielski {
170*b1cdbd2cSJim Jagielski ListBox aBox;
171*b1cdbd2cSJim Jagielski public:
RulerDebugWindow(Window * pParent)172*b1cdbd2cSJim Jagielski RulerDebugWindow(Window* pParent) :
173*b1cdbd2cSJim Jagielski Window(pParent, WB_BORDER|WB_SIZEMOVE|WB_DIALOGCONTROL|WB_CLIPCHILDREN|WB_SYSTEMWINDOW),
174*b1cdbd2cSJim Jagielski aBox(this, WB_BORDER)
175*b1cdbd2cSJim Jagielski {
176*b1cdbd2cSJim Jagielski Size aOutput(200, 400);
177*b1cdbd2cSJim Jagielski SetOutputSizePixel(aOutput);
178*b1cdbd2cSJim Jagielski aBox.SetSizePixel(aOutput);
179*b1cdbd2cSJim Jagielski aBox.Show();
180*b1cdbd2cSJim Jagielski Show();
181*b1cdbd2cSJim Jagielski Size aParentSize(pParent->GetOutputSizePixel());
182*b1cdbd2cSJim Jagielski Size aOwnSize(GetSizePixel());
183*b1cdbd2cSJim Jagielski aParentSize.Width() -= aOwnSize.Width();
184*b1cdbd2cSJim Jagielski aParentSize.Height() -= aOwnSize.Height();
185*b1cdbd2cSJim Jagielski SetPosPixel(Point(aParentSize.Width(), aParentSize.Height()));
186*b1cdbd2cSJim Jagielski }
187*b1cdbd2cSJim Jagielski ~RulerDebugWindow();
188*b1cdbd2cSJim Jagielski
GetLBox()189*b1cdbd2cSJim Jagielski ListBox& GetLBox() {return aBox;}
190*b1cdbd2cSJim Jagielski static void AddDebugText(const sal_Char* pDescription, const String& rText );
191*b1cdbd2cSJim Jagielski };
192*b1cdbd2cSJim Jagielski static RulerDebugWindow* pDebugWindow = 0;
193*b1cdbd2cSJim Jagielski
~RulerDebugWindow()194*b1cdbd2cSJim Jagielski RulerDebugWindow::~RulerDebugWindow()
195*b1cdbd2cSJim Jagielski {
196*b1cdbd2cSJim Jagielski pDebugWindow = 0;
197*b1cdbd2cSJim Jagielski }
AddDebugText(const sal_Char * pDescription,const String & rText)198*b1cdbd2cSJim Jagielski void RulerDebugWindow::AddDebugText(const sal_Char* pDescription, const String& rText )
199*b1cdbd2cSJim Jagielski {
200*b1cdbd2cSJim Jagielski if(!pDebugWindow)
201*b1cdbd2cSJim Jagielski {
202*b1cdbd2cSJim Jagielski Window* pParent = Application::GetFocusWindow();
203*b1cdbd2cSJim Jagielski while(pParent->GetParent())
204*b1cdbd2cSJim Jagielski pParent = pParent->GetParent();
205*b1cdbd2cSJim Jagielski pDebugWindow = new RulerDebugWindow(pParent);
206*b1cdbd2cSJim Jagielski }
207*b1cdbd2cSJim Jagielski String sContent(String::CreateFromAscii(pDescription));
208*b1cdbd2cSJim Jagielski sContent += rText;
209*b1cdbd2cSJim Jagielski sal_uInt16 nPos = pDebugWindow->GetLBox().InsertEntry(sContent);
210*b1cdbd2cSJim Jagielski pDebugWindow->GetLBox().SelectEntryPos(nPos);
211*b1cdbd2cSJim Jagielski pDebugWindow->GrabFocus();
212*b1cdbd2cSJim Jagielski }
213*b1cdbd2cSJim Jagielski
214*b1cdbd2cSJim Jagielski #define ADD_DEBUG_TEXT(cDescription, sValue) \
215*b1cdbd2cSJim Jagielski RulerDebugWindow::AddDebugText(cDescription, sValue);
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski #define REMOVE_DEBUG_WINDOW \
218*b1cdbd2cSJim Jagielski delete pDebugWindow; \
219*b1cdbd2cSJim Jagielski pDebugWindow = 0;
220*b1cdbd2cSJim Jagielski
221*b1cdbd2cSJim Jagielski #else
222*b1cdbd2cSJim Jagielski #define ADD_DEBUG_TEXT(cDescription, sValue)
223*b1cdbd2cSJim Jagielski #define REMOVE_DEBUG_WINDOW
224*b1cdbd2cSJim Jagielski #endif
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski struct SvxRuler_Impl {
227*b1cdbd2cSJim Jagielski sal_uInt16 *pPercBuf;
228*b1cdbd2cSJim Jagielski sal_uInt16 *pBlockBuf;
229*b1cdbd2cSJim Jagielski sal_uInt16 nPercSize;
230*b1cdbd2cSJim Jagielski long nTotalDist;
231*b1cdbd2cSJim Jagielski long lOldWinPos;
232*b1cdbd2cSJim Jagielski long lMaxLeftLogic;
233*b1cdbd2cSJim Jagielski long lMaxRightLogic;
234*b1cdbd2cSJim Jagielski long lLastLMargin;
235*b1cdbd2cSJim Jagielski long lLastRMargin;
236*b1cdbd2cSJim Jagielski SvxProtectItem aProtectItem;
237*b1cdbd2cSJim Jagielski SfxBoolItem* pTextRTLItem;
238*b1cdbd2cSJim Jagielski sal_uInt16 nControlerItems;
239*b1cdbd2cSJim Jagielski sal_uInt16 nIdx;
240*b1cdbd2cSJim Jagielski sal_uInt16 nColLeftPix, nColRightPix; // Pixelwerte fuer linken / rechten Rand
241*b1cdbd2cSJim Jagielski // bei Spalten; gepuffert, um Umrechenfehler
242*b1cdbd2cSJim Jagielski // zu vermeiden.
243*b1cdbd2cSJim Jagielski // Muesste vielleicht fuer weitere Werte
244*b1cdbd2cSJim Jagielski // aufgebohrt werden
245*b1cdbd2cSJim Jagielski sal_Bool bIsTableRows : 1; // pColumnItem contains table rows instead of columns
246*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
247*b1cdbd2cSJim Jagielski sal_Bool bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent?
SvxRuler_ImplSvxRuler_Impl248*b1cdbd2cSJim Jagielski SvxRuler_Impl() :
249*b1cdbd2cSJim Jagielski pPercBuf(0), pBlockBuf(0),
250*b1cdbd2cSJim Jagielski nPercSize(0), nTotalDist(0),
251*b1cdbd2cSJim Jagielski lOldWinPos(0),
252*b1cdbd2cSJim Jagielski lMaxLeftLogic(0), lMaxRightLogic(0),
253*b1cdbd2cSJim Jagielski lLastLMargin(0), lLastRMargin(0),
254*b1cdbd2cSJim Jagielski aProtectItem(SID_RULER_PROTECT),
255*b1cdbd2cSJim Jagielski pTextRTLItem(0), nControlerItems(0),
256*b1cdbd2cSJim Jagielski nIdx(0),
257*b1cdbd2cSJim Jagielski nColLeftPix(0), nColRightPix(0),
258*b1cdbd2cSJim Jagielski
259*b1cdbd2cSJim Jagielski bIsTableRows(sal_False),
260*b1cdbd2cSJim Jagielski bIsTabsRelativeToIndent(sal_True)
261*b1cdbd2cSJim Jagielski {
262*b1cdbd2cSJim Jagielski }
~SvxRuler_ImplSvxRuler_Impl263*b1cdbd2cSJim Jagielski ~SvxRuler_Impl()
264*b1cdbd2cSJim Jagielski {
265*b1cdbd2cSJim Jagielski nPercSize = 0; nTotalDist = 0;
266*b1cdbd2cSJim Jagielski delete[] pPercBuf; delete[] pBlockBuf; pPercBuf = 0;
267*b1cdbd2cSJim Jagielski delete pTextRTLItem;
268*b1cdbd2cSJim Jagielski }
269*b1cdbd2cSJim Jagielski void SetPercSize(sal_uInt16 nSize);
270*b1cdbd2cSJim Jagielski
271*b1cdbd2cSJim Jagielski };
272*b1cdbd2cSJim Jagielski
273*b1cdbd2cSJim Jagielski
274*b1cdbd2cSJim Jagielski
SetPercSize(sal_uInt16 nSize)275*b1cdbd2cSJim Jagielski void SvxRuler_Impl::SetPercSize(sal_uInt16 nSize)
276*b1cdbd2cSJim Jagielski {
277*b1cdbd2cSJim Jagielski if(nSize > nPercSize)
278*b1cdbd2cSJim Jagielski {
279*b1cdbd2cSJim Jagielski delete[] pPercBuf;
280*b1cdbd2cSJim Jagielski delete[] pBlockBuf;
281*b1cdbd2cSJim Jagielski pPercBuf = new sal_uInt16[nPercSize = nSize];
282*b1cdbd2cSJim Jagielski pBlockBuf = new sal_uInt16[nPercSize = nSize];
283*b1cdbd2cSJim Jagielski }
284*b1cdbd2cSJim Jagielski size_t nSize2 = sizeof(sal_uInt16) * nPercSize;
285*b1cdbd2cSJim Jagielski memset(pPercBuf, 0, nSize2);
286*b1cdbd2cSJim Jagielski memset(pBlockBuf, 0, nSize2);
287*b1cdbd2cSJim Jagielski }
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski
290*b1cdbd2cSJim Jagielski // Konstruktor des Lineals
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski // SID_ATTR_ULSPACE, SID_ATTR_LRSPACE
293*b1cdbd2cSJim Jagielski // erwartet als Parameter SvxULSpaceItem f"ur Seitenr"ander
294*b1cdbd2cSJim Jagielski // (entweder links/rechts oder oben/unten)
295*b1cdbd2cSJim Jagielski // Lineal: SetMargin1, SetMargin2
296*b1cdbd2cSJim Jagielski
297*b1cdbd2cSJim Jagielski // SID_RULER_PAGE_POS
298*b1cdbd2cSJim Jagielski // erwartet als Parameter Anfangswert der Seite sowie Seitenbreite
299*b1cdbd2cSJim Jagielski // Lineal: SetPagePos
300*b1cdbd2cSJim Jagielski
301*b1cdbd2cSJim Jagielski // SID_ATTR_TABSTOP
302*b1cdbd2cSJim Jagielski // erwartet: SvxTabStopItem
303*b1cdbd2cSJim Jagielski // Lineal: SetTabs
304*b1cdbd2cSJim Jagielski
305*b1cdbd2cSJim Jagielski // SID_ATTR_PARA_LRSPACE
306*b1cdbd2cSJim Jagielski // linker, rechter Absatzrand bei H-Lineal
307*b1cdbd2cSJim Jagielski // Lineal: SetIndents
308*b1cdbd2cSJim Jagielski
309*b1cdbd2cSJim Jagielski // SID_RULER_BORDERS
310*b1cdbd2cSJim Jagielski // Tabellenraender, Spalten
311*b1cdbd2cSJim Jagielski // erwartet: so etwas wie SwTabCols
312*b1cdbd2cSJim Jagielski // Lineal: SetBorders
313*b1cdbd2cSJim Jagielski
314*b1cdbd2cSJim Jagielski
SvxRuler(Window * pParent,Window * pWin,sal_uInt16 flags,SfxBindings & rBindings,WinBits nWinStyle)315*b1cdbd2cSJim Jagielski SvxRuler::SvxRuler
316*b1cdbd2cSJim Jagielski (
317*b1cdbd2cSJim Jagielski Window* pParent, // StarView Parent
318*b1cdbd2cSJim Jagielski Window* pWin, // Ausgabefenster; wird fuer Umrechnung logische
319*b1cdbd2cSJim Jagielski // Einheiten <-> Pixel verwendet
320*b1cdbd2cSJim Jagielski sal_uInt16 flags, // Anzeige Flags, siehe ruler.hxx
321*b1cdbd2cSJim Jagielski SfxBindings &rBindings, // zugeordnete Bindings
322*b1cdbd2cSJim Jagielski WinBits nWinStyle // StarView WinBits
323*b1cdbd2cSJim Jagielski )
324*b1cdbd2cSJim Jagielski : Ruler(pParent, nWinStyle),
325*b1cdbd2cSJim Jagielski pCtrlItem(new SvxRulerItem *[CTRL_ITEM_COUNT]),
326*b1cdbd2cSJim Jagielski pLRSpaceItem(0),
327*b1cdbd2cSJim Jagielski pMinMaxItem(0),
328*b1cdbd2cSJim Jagielski pULSpaceItem(0),
329*b1cdbd2cSJim Jagielski pTabStopItem(0),
330*b1cdbd2cSJim Jagielski pParaItem(0),
331*b1cdbd2cSJim Jagielski pParaBorderItem(0),
332*b1cdbd2cSJim Jagielski pPagePosItem(0),
333*b1cdbd2cSJim Jagielski pColumnItem(0),
334*b1cdbd2cSJim Jagielski pObjectItem(0),
335*b1cdbd2cSJim Jagielski pEditWin(pWin),
336*b1cdbd2cSJim Jagielski pRuler_Imp(new SvxRuler_Impl),
337*b1cdbd2cSJim Jagielski bAppSetNullOffset(sal_False), //Wird der 0-Offset des Lineals
338*b1cdbd2cSJim Jagielski //durch die appl. gesetzt?
339*b1cdbd2cSJim Jagielski lLogicNullOffset(0),
340*b1cdbd2cSJim Jagielski lAppNullOffset(LONG_MAX),
341*b1cdbd2cSJim Jagielski lMinFrame(5),
342*b1cdbd2cSJim Jagielski lInitialDragPos(0),
343*b1cdbd2cSJim Jagielski nFlags(flags),
344*b1cdbd2cSJim Jagielski nDragType(NONE),
345*b1cdbd2cSJim Jagielski nDefTabType(RULER_TAB_LEFT),
346*b1cdbd2cSJim Jagielski nTabCount(0),
347*b1cdbd2cSJim Jagielski nTabBufSize(0),
348*b1cdbd2cSJim Jagielski lDefTabDist(50),
349*b1cdbd2cSJim Jagielski lTabPos(-1),
350*b1cdbd2cSJim Jagielski pTabs(0),
351*b1cdbd2cSJim Jagielski pIndents(0),
352*b1cdbd2cSJim Jagielski pBorders(new RulerBorder[1]), //wg 1 Spaltiger Tabellen
353*b1cdbd2cSJim Jagielski nBorderCount(0),
354*b1cdbd2cSJim Jagielski pObjectBorders(0),
355*b1cdbd2cSJim Jagielski pBindings(&rBindings),
356*b1cdbd2cSJim Jagielski nDragOffset(0),
357*b1cdbd2cSJim Jagielski nMaxLeft(0),
358*b1cdbd2cSJim Jagielski nMaxRight(0),
359*b1cdbd2cSJim Jagielski bValid(sal_False),
360*b1cdbd2cSJim Jagielski bListening(sal_False),
361*b1cdbd2cSJim Jagielski bActive(sal_True)
362*b1cdbd2cSJim Jagielski
363*b1cdbd2cSJim Jagielski /*
364*b1cdbd2cSJim Jagielski [Beschreibung]
365*b1cdbd2cSJim Jagielski
366*b1cdbd2cSJim Jagielski ctor;
367*b1cdbd2cSJim Jagielski Datenpuffer initialisieren; ControllerItems werden erzeugt
368*b1cdbd2cSJim Jagielski
369*b1cdbd2cSJim Jagielski */
370*b1cdbd2cSJim Jagielski {
371*b1cdbd2cSJim Jagielski memset(pCtrlItem, 0, sizeof(SvxRulerItem *) * CTRL_ITEM_COUNT);
372*b1cdbd2cSJim Jagielski
373*b1cdbd2cSJim Jagielski rBindings.EnterRegistrations();
374*b1cdbd2cSJim Jagielski
375*b1cdbd2cSJim Jagielski // Unterstuetzte Items anlegen
376*b1cdbd2cSJim Jagielski sal_uInt16 i = 0;
377*b1cdbd2cSJim Jagielski // Seitenraender
378*b1cdbd2cSJim Jagielski
379*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings);
380*b1cdbd2cSJim Jagielski if((nWinStyle & WB_VSCROLL) == WB_VSCROLL)
381*b1cdbd2cSJim Jagielski {
382*b1cdbd2cSJim Jagielski bHorz = sal_False;
383*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_LONG_ULSPACE, *this, rBindings);
384*b1cdbd2cSJim Jagielski }
385*b1cdbd2cSJim Jagielski else
386*b1cdbd2cSJim Jagielski {
387*b1cdbd2cSJim Jagielski bHorz = sal_True;
388*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings);
389*b1cdbd2cSJim Jagielski }
390*b1cdbd2cSJim Jagielski
391*b1cdbd2cSJim Jagielski // Seitenposition
392*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings);
393*b1cdbd2cSJim Jagielski
394*b1cdbd2cSJim Jagielski if((nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS)
395*b1cdbd2cSJim Jagielski {
396*b1cdbd2cSJim Jagielski sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
397*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(nTabStopId, *this, rBindings);
398*b1cdbd2cSJim Jagielski SetExtraType(RULER_EXTRA_TAB, nDefTabType);
399*b1cdbd2cSJim Jagielski }
400*b1cdbd2cSJim Jagielski
401*b1cdbd2cSJim Jagielski
402*b1cdbd2cSJim Jagielski if(0 != (nFlags & (SVXRULER_SUPPORT_PARAGRAPH_MARGINS |SVXRULER_SUPPORT_PARAGRAPH_MARGINS_VERTICAL)))
403*b1cdbd2cSJim Jagielski {
404*b1cdbd2cSJim Jagielski if(bHorz)
405*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_PARA_LRSPACE, *this, rBindings);
406*b1cdbd2cSJim Jagielski else
407*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_PARA_LRSPACE_VERTICAL, *this, rBindings);
408*b1cdbd2cSJim Jagielski pIndents = new RulerIndent[5+INDENT_GAP];
409*b1cdbd2cSJim Jagielski memset(pIndents, 0, sizeof(RulerIndent)*(3+INDENT_GAP));
410*b1cdbd2cSJim Jagielski pIndents[0].nStyle = RULER_STYLE_DONTKNOW;
411*b1cdbd2cSJim Jagielski pIndents[1].nStyle = RULER_STYLE_DONTKNOW;
412*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nStyle = RULER_INDENT_TOP;
413*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
414*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
415*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_BORDER].nStyle = RULER_INDENT_BORDER;
416*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_BORDER].nStyle = RULER_INDENT_BORDER;
417*b1cdbd2cSJim Jagielski for(sal_uInt16 nIn = 0; nIn < 7; nIn++)
418*b1cdbd2cSJim Jagielski pIndents[nIn].nPos = 0;
419*b1cdbd2cSJim Jagielski }
420*b1cdbd2cSJim Jagielski
421*b1cdbd2cSJim Jagielski if((nFlags & SVXRULER_SUPPORT_BORDERS) == SVXRULER_SUPPORT_BORDERS)
422*b1cdbd2cSJim Jagielski {
423*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL, *this, rBindings);
424*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL, *this, rBindings);
425*b1cdbd2cSJim Jagielski }
426*b1cdbd2cSJim Jagielski
427*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_RULER_TEXT_RIGHT_TO_LEFT, *this, rBindings);
428*b1cdbd2cSJim Jagielski
429*b1cdbd2cSJim Jagielski if((nFlags & SVXRULER_SUPPORT_OBJECT) == SVXRULER_SUPPORT_OBJECT)
430*b1cdbd2cSJim Jagielski {
431*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_RULER_OBJECT, *this, rBindings );
432*b1cdbd2cSJim Jagielski pObjectBorders = new RulerBorder[OBJECT_BORDER_COUNT];
433*b1cdbd2cSJim Jagielski size_t nSize = sizeof( RulerBorder ) * OBJECT_BORDER_COUNT;
434*b1cdbd2cSJim Jagielski memset(pObjectBorders, 0, nSize);
435*b1cdbd2cSJim Jagielski for(sal_uInt16 nBorder = 0; nBorder < OBJECT_BORDER_COUNT; ++nBorder)
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski pObjectBorders[nBorder].nPos = 0;
438*b1cdbd2cSJim Jagielski pObjectBorders[nBorder].nWidth = 0;
439*b1cdbd2cSJim Jagielski pObjectBorders[nBorder].nStyle = RULER_BORDER_MOVEABLE;
440*b1cdbd2cSJim Jagielski }
441*b1cdbd2cSJim Jagielski }
442*b1cdbd2cSJim Jagielski
443*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem( SID_RULER_PROTECT, *this, rBindings );
444*b1cdbd2cSJim Jagielski pCtrlItem[i++] = new SvxRulerItem(SID_RULER_BORDER_DISTANCE, *this, rBindings);
445*b1cdbd2cSJim Jagielski pRuler_Imp->nControlerItems=i;
446*b1cdbd2cSJim Jagielski
447*b1cdbd2cSJim Jagielski if((nFlags & SVXRULER_SUPPORT_SET_NULLOFFSET) ==
448*b1cdbd2cSJim Jagielski SVXRULER_SUPPORT_SET_NULLOFFSET)
449*b1cdbd2cSJim Jagielski SetExtraType(RULER_EXTRA_NULLOFFSET, 0);
450*b1cdbd2cSJim Jagielski
451*b1cdbd2cSJim Jagielski rBindings.LeaveRegistrations();
452*b1cdbd2cSJim Jagielski }
453*b1cdbd2cSJim Jagielski
454*b1cdbd2cSJim Jagielski
~SvxRuler()455*b1cdbd2cSJim Jagielski __EXPORT SvxRuler::~SvxRuler()
456*b1cdbd2cSJim Jagielski /*
457*b1cdbd2cSJim Jagielski [Beschreibung]
458*b1cdbd2cSJim Jagielski
459*b1cdbd2cSJim Jagielski Destruktor Lineal
460*b1cdbd2cSJim Jagielski Freigabe interner Puffer
461*b1cdbd2cSJim Jagielski
462*b1cdbd2cSJim Jagielski
463*b1cdbd2cSJim Jagielski */
464*b1cdbd2cSJim Jagielski {
465*b1cdbd2cSJim Jagielski REMOVE_DEBUG_WINDOW
466*b1cdbd2cSJim Jagielski if(bListening)
467*b1cdbd2cSJim Jagielski EndListening(*pBindings);
468*b1cdbd2cSJim Jagielski
469*b1cdbd2cSJim Jagielski pBindings->EnterRegistrations();
470*b1cdbd2cSJim Jagielski
471*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < CTRL_ITEM_COUNT && pCtrlItem[i]; ++i)
472*b1cdbd2cSJim Jagielski delete pCtrlItem[i];
473*b1cdbd2cSJim Jagielski delete[] pCtrlItem;
474*b1cdbd2cSJim Jagielski
475*b1cdbd2cSJim Jagielski delete pLRSpaceItem;
476*b1cdbd2cSJim Jagielski delete pMinMaxItem;
477*b1cdbd2cSJim Jagielski delete pULSpaceItem;
478*b1cdbd2cSJim Jagielski delete pTabStopItem;
479*b1cdbd2cSJim Jagielski delete pParaItem;
480*b1cdbd2cSJim Jagielski delete pParaBorderItem;
481*b1cdbd2cSJim Jagielski delete pPagePosItem;
482*b1cdbd2cSJim Jagielski delete pColumnItem;
483*b1cdbd2cSJim Jagielski delete pObjectItem;
484*b1cdbd2cSJim Jagielski delete[] pIndents;
485*b1cdbd2cSJim Jagielski delete[] pBorders;
486*b1cdbd2cSJim Jagielski delete[] pObjectBorders;
487*b1cdbd2cSJim Jagielski delete[] pTabs;
488*b1cdbd2cSJim Jagielski delete pRuler_Imp;
489*b1cdbd2cSJim Jagielski
490*b1cdbd2cSJim Jagielski pBindings->LeaveRegistrations();
491*b1cdbd2cSJim Jagielski }
492*b1cdbd2cSJim Jagielski
493*b1cdbd2cSJim Jagielski /*
494*b1cdbd2cSJim Jagielski
495*b1cdbd2cSJim Jagielski [Beschreibung]
496*b1cdbd2cSJim Jagielski
497*b1cdbd2cSJim Jagielski Interne Umrechenroutinen
498*b1cdbd2cSJim Jagielski
499*b1cdbd2cSJim Jagielski */
500*b1cdbd2cSJim Jagielski
ConvertHPosPixel(long nVal) const501*b1cdbd2cSJim Jagielski long SvxRuler::ConvertHPosPixel(long nVal) const
502*b1cdbd2cSJim Jagielski {
503*b1cdbd2cSJim Jagielski return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
504*b1cdbd2cSJim Jagielski }
505*b1cdbd2cSJim Jagielski
ConvertVPosPixel(long nVal) const506*b1cdbd2cSJim Jagielski long SvxRuler::ConvertVPosPixel(long nVal) const
507*b1cdbd2cSJim Jagielski {
508*b1cdbd2cSJim Jagielski return pEditWin->LogicToPixel(Size(0, nVal)).Height();
509*b1cdbd2cSJim Jagielski }
510*b1cdbd2cSJim Jagielski
ConvertHSizePixel(long nVal) const511*b1cdbd2cSJim Jagielski long SvxRuler::ConvertHSizePixel(long nVal) const
512*b1cdbd2cSJim Jagielski {
513*b1cdbd2cSJim Jagielski return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
514*b1cdbd2cSJim Jagielski }
515*b1cdbd2cSJim Jagielski
ConvertVSizePixel(long nVal) const516*b1cdbd2cSJim Jagielski long SvxRuler::ConvertVSizePixel(long nVal) const
517*b1cdbd2cSJim Jagielski {
518*b1cdbd2cSJim Jagielski return pEditWin->LogicToPixel(Size(0, nVal)).Height();
519*b1cdbd2cSJim Jagielski }
520*b1cdbd2cSJim Jagielski
ConvertPosPixel(long nVal) const521*b1cdbd2cSJim Jagielski long SvxRuler::ConvertPosPixel(long nVal) const
522*b1cdbd2cSJim Jagielski {
523*b1cdbd2cSJim Jagielski return bHorz ? ConvertHPosPixel(nVal): ConvertVPosPixel(nVal);
524*b1cdbd2cSJim Jagielski }
525*b1cdbd2cSJim Jagielski
ConvertSizePixel(long nVal) const526*b1cdbd2cSJim Jagielski long SvxRuler::ConvertSizePixel(long nVal) const
527*b1cdbd2cSJim Jagielski {
528*b1cdbd2cSJim Jagielski return bHorz? ConvertHSizePixel(nVal): ConvertVSizePixel(nVal);
529*b1cdbd2cSJim Jagielski }
530*b1cdbd2cSJim Jagielski
531*b1cdbd2cSJim Jagielski
ConvertHPosLogic(long nVal) const532*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertHPosLogic(long nVal) const
533*b1cdbd2cSJim Jagielski {
534*b1cdbd2cSJim Jagielski return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
535*b1cdbd2cSJim Jagielski }
536*b1cdbd2cSJim Jagielski
ConvertVPosLogic(long nVal) const537*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertVPosLogic(long nVal) const
538*b1cdbd2cSJim Jagielski {
539*b1cdbd2cSJim Jagielski return pEditWin->PixelToLogic(Size(0, nVal)).Height();
540*b1cdbd2cSJim Jagielski }
541*b1cdbd2cSJim Jagielski
ConvertHSizeLogic(long nVal) const542*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertHSizeLogic(long nVal) const
543*b1cdbd2cSJim Jagielski {
544*b1cdbd2cSJim Jagielski return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
545*b1cdbd2cSJim Jagielski }
546*b1cdbd2cSJim Jagielski
ConvertVSizeLogic(long nVal) const547*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertVSizeLogic(long nVal) const
548*b1cdbd2cSJim Jagielski {
549*b1cdbd2cSJim Jagielski return pEditWin->PixelToLogic(Size(0, nVal)).Height();
550*b1cdbd2cSJim Jagielski }
551*b1cdbd2cSJim Jagielski
ConvertPosLogic(long nVal) const552*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertPosLogic(long nVal) const
553*b1cdbd2cSJim Jagielski {
554*b1cdbd2cSJim Jagielski return bHorz? ConvertHPosLogic(nVal): ConvertVPosLogic(nVal);
555*b1cdbd2cSJim Jagielski }
556*b1cdbd2cSJim Jagielski
ConvertSizeLogic(long nVal) const557*b1cdbd2cSJim Jagielski inline long SvxRuler::ConvertSizeLogic(long nVal) const
558*b1cdbd2cSJim Jagielski {
559*b1cdbd2cSJim Jagielski return bHorz? ConvertHSizeLogic(nVal): ConvertVSizeLogic(nVal);
560*b1cdbd2cSJim Jagielski }
561*b1cdbd2cSJim Jagielski
PixelHAdjust(long nVal,long nValOld) const562*b1cdbd2cSJim Jagielski long SvxRuler::PixelHAdjust(long nVal, long nValOld) const
563*b1cdbd2cSJim Jagielski {
564*b1cdbd2cSJim Jagielski if(ConvertHSizePixel(nVal)!=ConvertHSizePixel(nValOld))
565*b1cdbd2cSJim Jagielski return nVal;
566*b1cdbd2cSJim Jagielski else
567*b1cdbd2cSJim Jagielski return nValOld;
568*b1cdbd2cSJim Jagielski }
569*b1cdbd2cSJim Jagielski
PixelVAdjust(long nVal,long nValOld) const570*b1cdbd2cSJim Jagielski long SvxRuler::PixelVAdjust(long nVal, long nValOld) const
571*b1cdbd2cSJim Jagielski {
572*b1cdbd2cSJim Jagielski if(ConvertVSizePixel(nVal)!=ConvertVSizePixel(nValOld))
573*b1cdbd2cSJim Jagielski return nVal;
574*b1cdbd2cSJim Jagielski else
575*b1cdbd2cSJim Jagielski return nValOld;
576*b1cdbd2cSJim Jagielski }
577*b1cdbd2cSJim Jagielski
PixelAdjust(long nVal,long nValOld) const578*b1cdbd2cSJim Jagielski long SvxRuler::PixelAdjust(long nVal, long nValOld) const
579*b1cdbd2cSJim Jagielski {
580*b1cdbd2cSJim Jagielski if(ConvertSizePixel(nVal)!=ConvertSizePixel(nValOld))
581*b1cdbd2cSJim Jagielski return nVal;
582*b1cdbd2cSJim Jagielski else
583*b1cdbd2cSJim Jagielski return nValOld;
584*b1cdbd2cSJim Jagielski }
585*b1cdbd2cSJim Jagielski
586*b1cdbd2cSJim Jagielski
GetObjectBordersOff(sal_uInt16 nIdx) const587*b1cdbd2cSJim Jagielski inline sal_uInt16 SvxRuler::GetObjectBordersOff(sal_uInt16 nIdx) const
588*b1cdbd2cSJim Jagielski {
589*b1cdbd2cSJim Jagielski return bHorz? nIdx: nIdx + 2;
590*b1cdbd2cSJim Jagielski }
591*b1cdbd2cSJim Jagielski
592*b1cdbd2cSJim Jagielski
593*b1cdbd2cSJim Jagielski
UpdateFrame()594*b1cdbd2cSJim Jagielski void SvxRuler::UpdateFrame()
595*b1cdbd2cSJim Jagielski
596*b1cdbd2cSJim Jagielski /*
597*b1cdbd2cSJim Jagielski [Beschreibung]
598*b1cdbd2cSJim Jagielski
599*b1cdbd2cSJim Jagielski Linken, oberen Rand aktualisieren
600*b1cdbd2cSJim Jagielski Items werden in die Darstellung des Lineals uebersetzt.
601*b1cdbd2cSJim Jagielski
602*b1cdbd2cSJim Jagielski */
603*b1cdbd2cSJim Jagielski
604*b1cdbd2cSJim Jagielski {
605*b1cdbd2cSJim Jagielski const sal_uInt16 nMarginStyle =
606*b1cdbd2cSJim Jagielski ( pRuler_Imp->aProtectItem.IsSizeProtected() ||
607*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsPosProtected() ) ?
608*b1cdbd2cSJim Jagielski 0 : RULER_MARGIN_SIZEABLE;
609*b1cdbd2cSJim Jagielski
610*b1cdbd2cSJim Jagielski if(pLRSpaceItem && pPagePosItem)
611*b1cdbd2cSJim Jagielski {
612*b1cdbd2cSJim Jagielski // wenn keine Initialisierung durch App Defaultverhalten
613*b1cdbd2cSJim Jagielski const long nOld = lLogicNullOffset;
614*b1cdbd2cSJim Jagielski lLogicNullOffset = pColumnItem?
615*b1cdbd2cSJim Jagielski pColumnItem->GetLeft(): pLRSpaceItem->GetLeft();
616*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
617*b1cdbd2cSJim Jagielski lAppNullOffset += lLogicNullOffset - nOld;
618*b1cdbd2cSJim Jagielski if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
619*b1cdbd2cSJim Jagielski {
620*b1cdbd2cSJim Jagielski Ruler::SetNullOffset(ConvertHPosPixel(lLogicNullOffset));
621*b1cdbd2cSJim Jagielski SetMargin1( 0, nMarginStyle );
622*b1cdbd2cSJim Jagielski lAppNullOffset = 0;
623*b1cdbd2cSJim Jagielski }
624*b1cdbd2cSJim Jagielski else
625*b1cdbd2cSJim Jagielski SetMargin1( ConvertHPosPixel( lAppNullOffset ), nMarginStyle );
626*b1cdbd2cSJim Jagielski long lRight = 0;
627*b1cdbd2cSJim Jagielski // bei Tabelle rechten Rand der Tabelle auswerten
628*b1cdbd2cSJim Jagielski if(pColumnItem && pColumnItem->IsTable())
629*b1cdbd2cSJim Jagielski lRight = pColumnItem->GetRight();
630*b1cdbd2cSJim Jagielski else
631*b1cdbd2cSJim Jagielski lRight = pLRSpaceItem->GetRight();
632*b1cdbd2cSJim Jagielski
633*b1cdbd2cSJim Jagielski sal_uIntPtr aWidth=
634*b1cdbd2cSJim Jagielski ConvertHPosPixel(pPagePosItem->GetWidth() - lRight -
635*b1cdbd2cSJim Jagielski lLogicNullOffset + lAppNullOffset);
636*b1cdbd2cSJim Jagielski SetMargin2( aWidth, nMarginStyle );
637*b1cdbd2cSJim Jagielski }
638*b1cdbd2cSJim Jagielski else
639*b1cdbd2cSJim Jagielski if(pULSpaceItem && pPagePosItem)
640*b1cdbd2cSJim Jagielski {
641*b1cdbd2cSJim Jagielski // Nullpunkt aus oberem Rand des umgebenden Rahmens
642*b1cdbd2cSJim Jagielski const long nOld = lLogicNullOffset;
643*b1cdbd2cSJim Jagielski lLogicNullOffset = pColumnItem?
644*b1cdbd2cSJim Jagielski pColumnItem->GetLeft(): pULSpaceItem->GetUpper();
645*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
646*b1cdbd2cSJim Jagielski lAppNullOffset += lLogicNullOffset - nOld;
647*b1cdbd2cSJim Jagielski if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX) {
648*b1cdbd2cSJim Jagielski Ruler::SetNullOffset(ConvertVPosPixel(lLogicNullOffset));
649*b1cdbd2cSJim Jagielski lAppNullOffset = 0;
650*b1cdbd2cSJim Jagielski SetMargin1( 0, nMarginStyle );
651*b1cdbd2cSJim Jagielski }
652*b1cdbd2cSJim Jagielski else
653*b1cdbd2cSJim Jagielski SetMargin1( ConvertVPosPixel( lAppNullOffset ),nMarginStyle );
654*b1cdbd2cSJim Jagielski
655*b1cdbd2cSJim Jagielski long lLower = pColumnItem ?
656*b1cdbd2cSJim Jagielski pColumnItem->GetRight() : pULSpaceItem->GetLower();
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski SetMargin2(ConvertVPosPixel(pPagePosItem->GetHeight() - lLower -
659*b1cdbd2cSJim Jagielski lLogicNullOffset + lAppNullOffset),
660*b1cdbd2cSJim Jagielski nMarginStyle );
661*b1cdbd2cSJim Jagielski }
662*b1cdbd2cSJim Jagielski else
663*b1cdbd2cSJim Jagielski {
664*b1cdbd2cSJim Jagielski // schaltet die Anzeige aus
665*b1cdbd2cSJim Jagielski SetMargin1();
666*b1cdbd2cSJim Jagielski SetMargin2();
667*b1cdbd2cSJim Jagielski }
668*b1cdbd2cSJim Jagielski if(pColumnItem)
669*b1cdbd2cSJim Jagielski {
670*b1cdbd2cSJim Jagielski pRuler_Imp->nColLeftPix = (sal_uInt16) ConvertSizePixel(pColumnItem->GetLeft());
671*b1cdbd2cSJim Jagielski pRuler_Imp->nColRightPix = (sal_uInt16) ConvertSizePixel(pColumnItem->GetRight());
672*b1cdbd2cSJim Jagielski }
673*b1cdbd2cSJim Jagielski
674*b1cdbd2cSJim Jagielski }
675*b1cdbd2cSJim Jagielski
MouseMove(const MouseEvent & rMEvt)676*b1cdbd2cSJim Jagielski void SvxRuler::MouseMove( const MouseEvent& rMEvt )
677*b1cdbd2cSJim Jagielski {
678*b1cdbd2cSJim Jagielski if( bActive )
679*b1cdbd2cSJim Jagielski {
680*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_LR_MIN_MAX );
681*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_ULSPACE );
682*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_LRSPACE );
683*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PAGE_POS );
684*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
685*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
686*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
687*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
688*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_OBJECT );
689*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PROTECT );
690*b1cdbd2cSJim Jagielski }
691*b1cdbd2cSJim Jagielski Ruler::MouseMove( rMEvt );
692*b1cdbd2cSJim Jagielski }
StartListening_Impl()693*b1cdbd2cSJim Jagielski void SvxRuler::StartListening_Impl()
694*b1cdbd2cSJim Jagielski {
695*b1cdbd2cSJim Jagielski if(!bListening)
696*b1cdbd2cSJim Jagielski {
697*b1cdbd2cSJim Jagielski bValid = sal_False;
698*b1cdbd2cSJim Jagielski StartListening(*pBindings);
699*b1cdbd2cSJim Jagielski bListening = sal_True;
700*b1cdbd2cSJim Jagielski }
701*b1cdbd2cSJim Jagielski }
702*b1cdbd2cSJim Jagielski
UpdateFrame(const SvxLongLRSpaceItem * pItem)703*b1cdbd2cSJim Jagielski void SvxRuler::UpdateFrame
704*b1cdbd2cSJim Jagielski (
705*b1cdbd2cSJim Jagielski const SvxLongLRSpaceItem *pItem // neuer Wert LRSpace
706*b1cdbd2cSJim Jagielski )
707*b1cdbd2cSJim Jagielski
708*b1cdbd2cSJim Jagielski /*
709*b1cdbd2cSJim Jagielski [Beschreibung]
710*b1cdbd2cSJim Jagielski
711*b1cdbd2cSJim Jagielski Neuen Wert fuer LRSpace merken; alten gfs. loeschen
712*b1cdbd2cSJim Jagielski
713*b1cdbd2cSJim Jagielski */
714*b1cdbd2cSJim Jagielski
715*b1cdbd2cSJim Jagielski {
716*b1cdbd2cSJim Jagielski if(bActive)
717*b1cdbd2cSJim Jagielski {
718*b1cdbd2cSJim Jagielski delete pLRSpaceItem; pLRSpaceItem = 0;
719*b1cdbd2cSJim Jagielski if(pItem)
720*b1cdbd2cSJim Jagielski pLRSpaceItem = new SvxLongLRSpaceItem(*pItem);
721*b1cdbd2cSJim Jagielski StartListening_Impl();
722*b1cdbd2cSJim Jagielski }
723*b1cdbd2cSJim Jagielski }
724*b1cdbd2cSJim Jagielski
725*b1cdbd2cSJim Jagielski
UpdateFrameMinMax(const SfxRectangleItem * pItem)726*b1cdbd2cSJim Jagielski void SvxRuler::UpdateFrameMinMax
727*b1cdbd2cSJim Jagielski (
728*b1cdbd2cSJim Jagielski const SfxRectangleItem *pItem // Werte fuer MinMax
729*b1cdbd2cSJim Jagielski )
730*b1cdbd2cSJim Jagielski
731*b1cdbd2cSJim Jagielski /*
732*b1cdbd2cSJim Jagielski [Beschreibung]
733*b1cdbd2cSJim Jagielski
734*b1cdbd2cSJim Jagielski Neuen Wert fuer MinMax setzen; alten gfs. loeschen
735*b1cdbd2cSJim Jagielski
736*b1cdbd2cSJim Jagielski */
737*b1cdbd2cSJim Jagielski
738*b1cdbd2cSJim Jagielski {
739*b1cdbd2cSJim Jagielski if(bActive)
740*b1cdbd2cSJim Jagielski {
741*b1cdbd2cSJim Jagielski delete pMinMaxItem; pMinMaxItem = 0;
742*b1cdbd2cSJim Jagielski if(pItem)
743*b1cdbd2cSJim Jagielski pMinMaxItem = new SfxRectangleItem(*pItem);
744*b1cdbd2cSJim Jagielski }
745*b1cdbd2cSJim Jagielski }
746*b1cdbd2cSJim Jagielski
747*b1cdbd2cSJim Jagielski
UpdateFrame(const SvxLongULSpaceItem * pItem)748*b1cdbd2cSJim Jagielski void SvxRuler::UpdateFrame
749*b1cdbd2cSJim Jagielski (
750*b1cdbd2cSJim Jagielski const SvxLongULSpaceItem *pItem // neuer Wert
751*b1cdbd2cSJim Jagielski )
752*b1cdbd2cSJim Jagielski
753*b1cdbd2cSJim Jagielski /*
754*b1cdbd2cSJim Jagielski [Beschreibung]
755*b1cdbd2cSJim Jagielski
756*b1cdbd2cSJim Jagielski Rechten / unteren Rand aktualisieren
757*b1cdbd2cSJim Jagielski
758*b1cdbd2cSJim Jagielski */
759*b1cdbd2cSJim Jagielski
760*b1cdbd2cSJim Jagielski
761*b1cdbd2cSJim Jagielski {
762*b1cdbd2cSJim Jagielski if(bActive && !bHorz)
763*b1cdbd2cSJim Jagielski {
764*b1cdbd2cSJim Jagielski delete pULSpaceItem; pULSpaceItem = 0;
765*b1cdbd2cSJim Jagielski if(pItem)
766*b1cdbd2cSJim Jagielski pULSpaceItem = new SvxLongULSpaceItem(*pItem);
767*b1cdbd2cSJim Jagielski StartListening_Impl();
768*b1cdbd2cSJim Jagielski }
769*b1cdbd2cSJim Jagielski }
770*b1cdbd2cSJim Jagielski
Update(const SvxProtectItem * pItem)771*b1cdbd2cSJim Jagielski void SvxRuler::Update( const SvxProtectItem* pItem )
772*b1cdbd2cSJim Jagielski {
773*b1cdbd2cSJim Jagielski if( pItem ) pRuler_Imp->aProtectItem = *pItem;
774*b1cdbd2cSJim Jagielski }
775*b1cdbd2cSJim Jagielski /* -----------------------------22.08.2002 13:10------------------------------
776*b1cdbd2cSJim Jagielski
777*b1cdbd2cSJim Jagielski ---------------------------------------------------------------------------*/
UpdateTextRTL(const SfxBoolItem * pItem)778*b1cdbd2cSJim Jagielski void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem)
779*b1cdbd2cSJim Jagielski {
780*b1cdbd2cSJim Jagielski if(bActive && bHorz)
781*b1cdbd2cSJim Jagielski {
782*b1cdbd2cSJim Jagielski delete pRuler_Imp->pTextRTLItem; pRuler_Imp->pTextRTLItem = 0;
783*b1cdbd2cSJim Jagielski if(pItem)
784*b1cdbd2cSJim Jagielski pRuler_Imp->pTextRTLItem = new SfxBoolItem(*pItem);
785*b1cdbd2cSJim Jagielski SetTextRTL(pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue());
786*b1cdbd2cSJim Jagielski StartListening_Impl();
787*b1cdbd2cSJim Jagielski }
788*b1cdbd2cSJim Jagielski }
789*b1cdbd2cSJim Jagielski
Update(const SvxColumnItem * pItem,sal_uInt16 nSID)790*b1cdbd2cSJim Jagielski void SvxRuler::Update
791*b1cdbd2cSJim Jagielski (
792*b1cdbd2cSJim Jagielski const SvxColumnItem *pItem, // neuer Wert
793*b1cdbd2cSJim Jagielski sal_uInt16 nSID //Slot Id to identify NULL items
794*b1cdbd2cSJim Jagielski )
795*b1cdbd2cSJim Jagielski
796*b1cdbd2cSJim Jagielski /*
797*b1cdbd2cSJim Jagielski [Beschreibung]
798*b1cdbd2cSJim Jagielski
799*b1cdbd2cSJim Jagielski Neuen Wert fuer Spaltendarstellung setzen
800*b1cdbd2cSJim Jagielski
801*b1cdbd2cSJim Jagielski */
802*b1cdbd2cSJim Jagielski
803*b1cdbd2cSJim Jagielski {
804*b1cdbd2cSJim Jagielski if(bActive)
805*b1cdbd2cSJim Jagielski {
806*b1cdbd2cSJim Jagielski if(pItem)
807*b1cdbd2cSJim Jagielski {
808*b1cdbd2cSJim Jagielski delete pColumnItem; pColumnItem = 0;
809*b1cdbd2cSJim Jagielski pRuler_Imp->bIsTableRows = (pItem->Which() == SID_RULER_ROWS || pItem->Which() == SID_RULER_ROWS_VERTICAL);
810*b1cdbd2cSJim Jagielski pColumnItem = new SvxColumnItem(*pItem);
811*b1cdbd2cSJim Jagielski if(!bHorz && !pRuler_Imp->bIsTableRows)
812*b1cdbd2cSJim Jagielski pColumnItem->SetWhich(SID_RULER_BORDERS_VERTICAL);
813*b1cdbd2cSJim Jagielski }
814*b1cdbd2cSJim Jagielski else if(pColumnItem && pColumnItem->Which() == nSID)
815*b1cdbd2cSJim Jagielski //there are two groups of column items table/frame columns and table rows
816*b1cdbd2cSJim Jagielski //both can occur in vertical or horizontal mode
817*b1cdbd2cSJim Jagielski //the horizontal ruler handles the SID_RULER_BORDERS and SID_RULER_ROWS_VERTICAL
818*b1cdbd2cSJim Jagielski //and the vertical handles SID_RULER_BORDERS_VERTICAL and SID_RULER_ROWS
819*b1cdbd2cSJim Jagielski //if pColumnItem is already set with one of the ids then a NULL pItem argument
820*b1cdbd2cSJim Jagielski //must not delete it
821*b1cdbd2cSJim Jagielski {
822*b1cdbd2cSJim Jagielski delete pColumnItem; pColumnItem = 0;
823*b1cdbd2cSJim Jagielski pRuler_Imp->bIsTableRows = sal_False;
824*b1cdbd2cSJim Jagielski }
825*b1cdbd2cSJim Jagielski StartListening_Impl();
826*b1cdbd2cSJim Jagielski }
827*b1cdbd2cSJim Jagielski }
828*b1cdbd2cSJim Jagielski
829*b1cdbd2cSJim Jagielski
UpdateColumns()830*b1cdbd2cSJim Jagielski void SvxRuler::UpdateColumns()
831*b1cdbd2cSJim Jagielski /*
832*b1cdbd2cSJim Jagielski [Beschreibung]
833*b1cdbd2cSJim Jagielski
834*b1cdbd2cSJim Jagielski Anzeige der Spaltendarstellung aktualisieren
835*b1cdbd2cSJim Jagielski
836*b1cdbd2cSJim Jagielski */
837*b1cdbd2cSJim Jagielski {
838*b1cdbd2cSJim Jagielski if(pColumnItem && pColumnItem->Count() > 1)
839*b1cdbd2cSJim Jagielski {
840*b1cdbd2cSJim Jagielski if( nBorderCount < pColumnItem->Count())
841*b1cdbd2cSJim Jagielski {
842*b1cdbd2cSJim Jagielski delete[] pBorders;
843*b1cdbd2cSJim Jagielski nBorderCount = pColumnItem->Count();
844*b1cdbd2cSJim Jagielski pBorders = new RulerBorder[nBorderCount];
845*b1cdbd2cSJim Jagielski }
846*b1cdbd2cSJim Jagielski sal_uInt16 _nFlags = RULER_BORDER_VARIABLE;
847*b1cdbd2cSJim Jagielski sal_Bool bProtectColumns =
848*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsSizeProtected() ||
849*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsPosProtected();
850*b1cdbd2cSJim Jagielski if( !bProtectColumns )
851*b1cdbd2cSJim Jagielski _nFlags |= RULER_BORDER_MOVEABLE;
852*b1cdbd2cSJim Jagielski if( pColumnItem->IsTable() )
853*b1cdbd2cSJim Jagielski _nFlags |= RULER_BORDER_TABLE;
854*b1cdbd2cSJim Jagielski else
855*b1cdbd2cSJim Jagielski if ( !bProtectColumns )
856*b1cdbd2cSJim Jagielski _nFlags |= RULER_BORDER_SIZEABLE;
857*b1cdbd2cSJim Jagielski
858*b1cdbd2cSJim Jagielski sal_uInt16 nBorders = pColumnItem->Count();
859*b1cdbd2cSJim Jagielski if(!pRuler_Imp->bIsTableRows)
860*b1cdbd2cSJim Jagielski --nBorders;
861*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < nBorders; ++i)
862*b1cdbd2cSJim Jagielski {
863*b1cdbd2cSJim Jagielski pBorders[i].nStyle = _nFlags;
864*b1cdbd2cSJim Jagielski if(!(*pColumnItem)[i].bVisible)
865*b1cdbd2cSJim Jagielski pBorders[i].nStyle |= RULER_STYLE_INVISIBLE;
866*b1cdbd2cSJim Jagielski pBorders[i].nPos =
867*b1cdbd2cSJim Jagielski ConvertPosPixel((*pColumnItem)[i].nEnd + lAppNullOffset);
868*b1cdbd2cSJim Jagielski if(pColumnItem->Count() == i + 1)
869*b1cdbd2cSJim Jagielski {
870*b1cdbd2cSJim Jagielski //with table rows the end of the table is contained in the
871*b1cdbd2cSJim Jagielski //column item but it has no width!
872*b1cdbd2cSJim Jagielski pBorders[i].nWidth = 0;
873*b1cdbd2cSJim Jagielski }
874*b1cdbd2cSJim Jagielski else
875*b1cdbd2cSJim Jagielski {
876*b1cdbd2cSJim Jagielski pBorders[i].nWidth =
877*b1cdbd2cSJim Jagielski ConvertSizePixel((*pColumnItem)[i+1].nStart -
878*b1cdbd2cSJim Jagielski (*pColumnItem)[i].nEnd);
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski pBorders[i].nMinPos =
881*b1cdbd2cSJim Jagielski ConvertPosPixel((*pColumnItem)[i].nEndMin + lAppNullOffset);
882*b1cdbd2cSJim Jagielski pBorders[i].nMaxPos =
883*b1cdbd2cSJim Jagielski ConvertPosPixel((*pColumnItem)[i].nEndMax + lAppNullOffset);
884*b1cdbd2cSJim Jagielski }
885*b1cdbd2cSJim Jagielski SetBorders(pColumnItem->Count()-1, pBorders);
886*b1cdbd2cSJim Jagielski }
887*b1cdbd2cSJim Jagielski else
888*b1cdbd2cSJim Jagielski {
889*b1cdbd2cSJim Jagielski SetBorders();
890*b1cdbd2cSJim Jagielski }
891*b1cdbd2cSJim Jagielski }
892*b1cdbd2cSJim Jagielski
893*b1cdbd2cSJim Jagielski
UpdateObject()894*b1cdbd2cSJim Jagielski void SvxRuler::UpdateObject()
895*b1cdbd2cSJim Jagielski
896*b1cdbd2cSJim Jagielski /*
897*b1cdbd2cSJim Jagielski [Beschreibung]
898*b1cdbd2cSJim Jagielski
899*b1cdbd2cSJim Jagielski Anzeige der Objektdarstellung aktualisieren
900*b1cdbd2cSJim Jagielski
901*b1cdbd2cSJim Jagielski */
902*b1cdbd2cSJim Jagielski
903*b1cdbd2cSJim Jagielski {
904*b1cdbd2cSJim Jagielski if(pObjectItem)
905*b1cdbd2cSJim Jagielski {
906*b1cdbd2cSJim Jagielski DBG_ASSERT(pObjectBorders, "kein Buffer");
907*b1cdbd2cSJim Jagielski // !! zum Seitenrand
908*b1cdbd2cSJim Jagielski long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
909*b1cdbd2cSJim Jagielski pObjectBorders[0].nPos =
910*b1cdbd2cSJim Jagielski ConvertPosPixel(pObjectItem->GetStartX() -
911*b1cdbd2cSJim Jagielski nMargin + lAppNullOffset);
912*b1cdbd2cSJim Jagielski pObjectBorders[1].nPos =
913*b1cdbd2cSJim Jagielski ConvertPosPixel(pObjectItem->GetEndX() - nMargin + lAppNullOffset);
914*b1cdbd2cSJim Jagielski nMargin = pULSpaceItem? pULSpaceItem->GetUpper(): 0;
915*b1cdbd2cSJim Jagielski pObjectBorders[2].nPos =
916*b1cdbd2cSJim Jagielski ConvertPosPixel(pObjectItem->GetStartY() -
917*b1cdbd2cSJim Jagielski nMargin + lAppNullOffset);
918*b1cdbd2cSJim Jagielski pObjectBorders[3].nPos =
919*b1cdbd2cSJim Jagielski ConvertPosPixel(pObjectItem->GetEndY() - nMargin + lAppNullOffset);
920*b1cdbd2cSJim Jagielski
921*b1cdbd2cSJim Jagielski const sal_uInt16 nOff = GetObjectBordersOff(0);
922*b1cdbd2cSJim Jagielski SetBorders(2, pObjectBorders + nOff);
923*b1cdbd2cSJim Jagielski }
924*b1cdbd2cSJim Jagielski else
925*b1cdbd2cSJim Jagielski {
926*b1cdbd2cSJim Jagielski SetBorders();
927*b1cdbd2cSJim Jagielski }
928*b1cdbd2cSJim Jagielski }
929*b1cdbd2cSJim Jagielski
930*b1cdbd2cSJim Jagielski
UpdatePara()931*b1cdbd2cSJim Jagielski void SvxRuler::UpdatePara()
932*b1cdbd2cSJim Jagielski
933*b1cdbd2cSJim Jagielski /*
934*b1cdbd2cSJim Jagielski [Beschreibung]
935*b1cdbd2cSJim Jagielski
936*b1cdbd2cSJim Jagielski Anzeige der Absatzeinzuege aktualisieren:
937*b1cdbd2cSJim Jagielski Linken Rand, Erstzeileneinzug, rechten Rand Absatz aktualisieren
938*b1cdbd2cSJim Jagielski pIndents[0] = Buffer fuer alten Einzug
939*b1cdbd2cSJim Jagielski pIndents[1] = Buffer fuer alten Einzug
940*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE] = Erstzeileneinzug
941*b1cdbd2cSJim Jagielski pIndents[3] = linker Rand
942*b1cdbd2cSJim Jagielski pIndents[4] = rechter Rand
943*b1cdbd2cSJim Jagielski pIndents[5] = left border distance
944*b1cdbd2cSJim Jagielski pIndents[6] = right border distance
945*b1cdbd2cSJim Jagielski
946*b1cdbd2cSJim Jagielski */
947*b1cdbd2cSJim Jagielski
948*b1cdbd2cSJim Jagielski {
949*b1cdbd2cSJim Jagielski // Abhaengigkeit zu PagePosItem
950*b1cdbd2cSJim Jagielski if(pParaItem && pPagePosItem && !pObjectItem)
951*b1cdbd2cSJim Jagielski {
952*b1cdbd2cSJim Jagielski sal_Bool bRTLText = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
953*b1cdbd2cSJim Jagielski // Erstzeileneinzug, ist negativ zum linken Absatzrand
954*b1cdbd2cSJim Jagielski long nLeftFrameMargin = GetLeftFrameMargin();
955*b1cdbd2cSJim Jagielski long nRightFrameMargin = GetRightFrameMargin();
956*b1cdbd2cSJim Jagielski if(bRTLText)
957*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos =
958*b1cdbd2cSJim Jagielski ConvertHPosPixel(
959*b1cdbd2cSJim Jagielski nRightFrameMargin -
960*b1cdbd2cSJim Jagielski pParaItem->GetTxtLeft() -
961*b1cdbd2cSJim Jagielski pParaItem->GetTxtFirstLineOfst() + lAppNullOffset );
962*b1cdbd2cSJim Jagielski else
963*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos =
964*b1cdbd2cSJim Jagielski ConvertHPosPixel(
965*b1cdbd2cSJim Jagielski nLeftFrameMargin +
966*b1cdbd2cSJim Jagielski pParaItem->GetTxtLeft() +
967*b1cdbd2cSJim Jagielski pParaItem->GetTxtFirstLineOfst() +
968*b1cdbd2cSJim Jagielski lAppNullOffset);
969*b1cdbd2cSJim Jagielski if( pParaItem->IsAutoFirst() )
970*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nStyle |= RULER_STYLE_INVISIBLE;
971*b1cdbd2cSJim Jagielski else
972*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nStyle &= ~RULER_STYLE_INVISIBLE;
973*b1cdbd2cSJim Jagielski
974*b1cdbd2cSJim Jagielski if(bRTLText)
975*b1cdbd2cSJim Jagielski {
976*b1cdbd2cSJim Jagielski // left margin
977*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos =
978*b1cdbd2cSJim Jagielski ConvertHPosPixel(
979*b1cdbd2cSJim Jagielski nRightFrameMargin -
980*b1cdbd2cSJim Jagielski pParaItem->GetTxtLeft() + lAppNullOffset);
981*b1cdbd2cSJim Jagielski // right margin
982*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos =
983*b1cdbd2cSJim Jagielski ConvertHPosPixel(
984*b1cdbd2cSJim Jagielski nLeftFrameMargin +
985*b1cdbd2cSJim Jagielski pParaItem->GetRight() + lAppNullOffset);
986*b1cdbd2cSJim Jagielski }
987*b1cdbd2cSJim Jagielski else
988*b1cdbd2cSJim Jagielski {
989*b1cdbd2cSJim Jagielski // linker Rand
990*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos =
991*b1cdbd2cSJim Jagielski ConvertHPosPixel(
992*b1cdbd2cSJim Jagielski nLeftFrameMargin +
993*b1cdbd2cSJim Jagielski pParaItem->GetTxtLeft() + lAppNullOffset);
994*b1cdbd2cSJim Jagielski // rechter Rand, immer negativ zum rechten Rand des umgebenden Frames
995*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos =
996*b1cdbd2cSJim Jagielski ConvertHPosPixel(
997*b1cdbd2cSJim Jagielski nRightFrameMargin -
998*b1cdbd2cSJim Jagielski pParaItem->GetRight() + lAppNullOffset);
999*b1cdbd2cSJim Jagielski }
1000*b1cdbd2cSJim Jagielski if(pParaBorderItem)
1001*b1cdbd2cSJim Jagielski {
1002*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_BORDER].nPos =
1003*b1cdbd2cSJim Jagielski ConvertHPosPixel( nLeftFrameMargin + lAppNullOffset);
1004*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_BORDER].nPos =
1005*b1cdbd2cSJim Jagielski ConvertHPosPixel(nRightFrameMargin - lAppNullOffset);
1006*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_BORDER].nStyle = pIndents[INDENT_RIGHT_BORDER].nStyle &= ~RULER_STYLE_INVISIBLE;
1007*b1cdbd2cSJim Jagielski }
1008*b1cdbd2cSJim Jagielski else
1009*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_BORDER].nStyle = pIndents[INDENT_RIGHT_BORDER].nStyle |= RULER_STYLE_INVISIBLE;
1010*b1cdbd2cSJim Jagielski
1011*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1012*b1cdbd2cSJim Jagielski }
1013*b1cdbd2cSJim Jagielski else
1014*b1cdbd2cSJim Jagielski {
1015*b1cdbd2cSJim Jagielski if(pIndents)
1016*b1cdbd2cSJim Jagielski {
1017*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos =
1018*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos =
1019*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos = 0;
1020*b1cdbd2cSJim Jagielski }
1021*b1cdbd2cSJim Jagielski SetIndents(); // ausschalten
1022*b1cdbd2cSJim Jagielski }
1023*b1cdbd2cSJim Jagielski }
1024*b1cdbd2cSJim Jagielski
1025*b1cdbd2cSJim Jagielski
UpdatePara(const SvxLRSpaceItem * pItem)1026*b1cdbd2cSJim Jagielski void SvxRuler::UpdatePara
1027*b1cdbd2cSJim Jagielski (
1028*b1cdbd2cSJim Jagielski const SvxLRSpaceItem *pItem // neuer Wert Absatzeinzuege
1029*b1cdbd2cSJim Jagielski )
1030*b1cdbd2cSJim Jagielski
1031*b1cdbd2cSJim Jagielski /*
1032*b1cdbd2cSJim Jagielski [Beschreibung]
1033*b1cdbd2cSJim Jagielski
1034*b1cdbd2cSJim Jagielski Neuen Wert Absatzeinzuege merken
1035*b1cdbd2cSJim Jagielski */
1036*b1cdbd2cSJim Jagielski
1037*b1cdbd2cSJim Jagielski {
1038*b1cdbd2cSJim Jagielski if(bActive)
1039*b1cdbd2cSJim Jagielski {
1040*b1cdbd2cSJim Jagielski delete pParaItem; pParaItem = 0;
1041*b1cdbd2cSJim Jagielski if(pItem)
1042*b1cdbd2cSJim Jagielski pParaItem = new SvxLRSpaceItem(*pItem);
1043*b1cdbd2cSJim Jagielski StartListening_Impl();
1044*b1cdbd2cSJim Jagielski }
1045*b1cdbd2cSJim Jagielski }
UpdateParaBorder(const SvxLRSpaceItem * pItem)1046*b1cdbd2cSJim Jagielski void SvxRuler::UpdateParaBorder(const SvxLRSpaceItem * pItem )
1047*b1cdbd2cSJim Jagielski /*
1048*b1cdbd2cSJim Jagielski [Description]
1049*b1cdbd2cSJim Jagielski Border distance
1050*b1cdbd2cSJim Jagielski */
1051*b1cdbd2cSJim Jagielski
1052*b1cdbd2cSJim Jagielski {
1053*b1cdbd2cSJim Jagielski if(bActive)
1054*b1cdbd2cSJim Jagielski {
1055*b1cdbd2cSJim Jagielski delete pParaBorderItem; pParaBorderItem = 0;
1056*b1cdbd2cSJim Jagielski if(pItem)
1057*b1cdbd2cSJim Jagielski pParaBorderItem = new SvxLRSpaceItem(*pItem);
1058*b1cdbd2cSJim Jagielski StartListening_Impl();
1059*b1cdbd2cSJim Jagielski }
1060*b1cdbd2cSJim Jagielski }
1061*b1cdbd2cSJim Jagielski
1062*b1cdbd2cSJim Jagielski
UpdatePage()1063*b1cdbd2cSJim Jagielski void SvxRuler::UpdatePage()
1064*b1cdbd2cSJim Jagielski
1065*b1cdbd2cSJim Jagielski /*
1066*b1cdbd2cSJim Jagielski [Beschreibung]
1067*b1cdbd2cSJim Jagielski
1068*b1cdbd2cSJim Jagielski Anzeige von Postion und Breite der Seite aktualisieren
1069*b1cdbd2cSJim Jagielski
1070*b1cdbd2cSJim Jagielski */
1071*b1cdbd2cSJim Jagielski
1072*b1cdbd2cSJim Jagielski {
1073*b1cdbd2cSJim Jagielski if(pPagePosItem)
1074*b1cdbd2cSJim Jagielski {
1075*b1cdbd2cSJim Jagielski // alle Objekte werden automatisch angepasst
1076*b1cdbd2cSJim Jagielski if(bHorz)
1077*b1cdbd2cSJim Jagielski SetPagePos(
1078*b1cdbd2cSJim Jagielski pEditWin->LogicToPixel(pPagePosItem->GetPos()).X(),
1079*b1cdbd2cSJim Jagielski pEditWin->LogicToPixel(Size(pPagePosItem->GetWidth(),0)).
1080*b1cdbd2cSJim Jagielski Width());
1081*b1cdbd2cSJim Jagielski else
1082*b1cdbd2cSJim Jagielski SetPagePos(
1083*b1cdbd2cSJim Jagielski pEditWin->LogicToPixel(pPagePosItem->GetPos()).Y(),
1084*b1cdbd2cSJim Jagielski pEditWin->LogicToPixel(Size(0, pPagePosItem->GetHeight())).
1085*b1cdbd2cSJim Jagielski Height());
1086*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
1087*b1cdbd2cSJim Jagielski SetNullOffset(ConvertSizePixel(-lAppNullOffset + lLogicNullOffset));
1088*b1cdbd2cSJim Jagielski }
1089*b1cdbd2cSJim Jagielski else
1090*b1cdbd2cSJim Jagielski SetPagePos();
1091*b1cdbd2cSJim Jagielski
1092*b1cdbd2cSJim Jagielski long lPos = 0;
1093*b1cdbd2cSJim Jagielski Point aOwnPos = GetPosPixel();
1094*b1cdbd2cSJim Jagielski Point aEdtWinPos = pEditWin->GetPosPixel();
1095*b1cdbd2cSJim Jagielski if( Application::GetSettings().GetLayoutRTL() && bHorz )
1096*b1cdbd2cSJim Jagielski {
1097*b1cdbd2cSJim Jagielski //#i73321# in RTL the window and the ruler is not mirrored but the
1098*b1cdbd2cSJim Jagielski // influence of the vertical ruler is inverted
1099*b1cdbd2cSJim Jagielski Size aOwnSize = GetSizePixel();
1100*b1cdbd2cSJim Jagielski Size aEdtWinSize = pEditWin->GetSizePixel();
1101*b1cdbd2cSJim Jagielski lPos = aOwnSize.Width() - aEdtWinSize.Width();
1102*b1cdbd2cSJim Jagielski lPos -= (aEdtWinPos - aOwnPos).X();
1103*b1cdbd2cSJim Jagielski }
1104*b1cdbd2cSJim Jagielski else
1105*b1cdbd2cSJim Jagielski {
1106*b1cdbd2cSJim Jagielski Point aPos(aEdtWinPos - aOwnPos);
1107*b1cdbd2cSJim Jagielski lPos= bHorz ? aPos.X() : aPos.Y();
1108*b1cdbd2cSJim Jagielski }
1109*b1cdbd2cSJim Jagielski
1110*b1cdbd2cSJim Jagielski // Leider bekommen wir den Offset des Editfensters zum Lineal nie
1111*b1cdbd2cSJim Jagielski // per Statusmeldung. Also setzen wir ihn selbst, wenn noetig.
1112*b1cdbd2cSJim Jagielski
1113*b1cdbd2cSJim Jagielski if(lPos!=pRuler_Imp->lOldWinPos)
1114*b1cdbd2cSJim Jagielski {
1115*b1cdbd2cSJim Jagielski pRuler_Imp->lOldWinPos=lPos;
1116*b1cdbd2cSJim Jagielski SetWinPos(lPos);
1117*b1cdbd2cSJim Jagielski }
1118*b1cdbd2cSJim Jagielski }
1119*b1cdbd2cSJim Jagielski
1120*b1cdbd2cSJim Jagielski
Update(const SvxPagePosSizeItem * pItem)1121*b1cdbd2cSJim Jagielski void SvxRuler::Update
1122*b1cdbd2cSJim Jagielski (
1123*b1cdbd2cSJim Jagielski const SvxPagePosSizeItem *pItem // neuer Wert Seitenattribute
1124*b1cdbd2cSJim Jagielski )
1125*b1cdbd2cSJim Jagielski
1126*b1cdbd2cSJim Jagielski /*
1127*b1cdbd2cSJim Jagielski [Beschreibung]
1128*b1cdbd2cSJim Jagielski
1129*b1cdbd2cSJim Jagielski Neuen Wert Seitenattribute merken
1130*b1cdbd2cSJim Jagielski
1131*b1cdbd2cSJim Jagielski */
1132*b1cdbd2cSJim Jagielski
1133*b1cdbd2cSJim Jagielski {
1134*b1cdbd2cSJim Jagielski if(bActive)
1135*b1cdbd2cSJim Jagielski {
1136*b1cdbd2cSJim Jagielski delete pPagePosItem; pPagePosItem = 0;
1137*b1cdbd2cSJim Jagielski if(pItem)
1138*b1cdbd2cSJim Jagielski pPagePosItem = new SvxPagePosSizeItem(*pItem);
1139*b1cdbd2cSJim Jagielski StartListening_Impl();
1140*b1cdbd2cSJim Jagielski }
1141*b1cdbd2cSJim Jagielski }
1142*b1cdbd2cSJim Jagielski
1143*b1cdbd2cSJim Jagielski
1144*b1cdbd2cSJim Jagielski //
1145*b1cdbd2cSJim Jagielski
SetDefTabDist(long l)1146*b1cdbd2cSJim Jagielski void SvxRuler::SetDefTabDist
1147*b1cdbd2cSJim Jagielski (
1148*b1cdbd2cSJim Jagielski long l // Neuer Abstand fuer DefaultTabs in App-Metrik
1149*b1cdbd2cSJim Jagielski )
1150*b1cdbd2cSJim Jagielski
1151*b1cdbd2cSJim Jagielski /*
1152*b1cdbd2cSJim Jagielski [Beschreibung]
1153*b1cdbd2cSJim Jagielski
1154*b1cdbd2cSJim Jagielski Neuer Abstand fuer DefaultTabs wird gesetzt
1155*b1cdbd2cSJim Jagielski
1156*b1cdbd2cSJim Jagielski */
1157*b1cdbd2cSJim Jagielski
1158*b1cdbd2cSJim Jagielski {
1159*b1cdbd2cSJim Jagielski
1160*b1cdbd2cSJim Jagielski lDefTabDist = l;
1161*b1cdbd2cSJim Jagielski UpdateTabs();
1162*b1cdbd2cSJim Jagielski }
1163*b1cdbd2cSJim Jagielski
1164*b1cdbd2cSJim Jagielski
GetDefTabDist() const1165*b1cdbd2cSJim Jagielski long SvxRuler::GetDefTabDist() const
1166*b1cdbd2cSJim Jagielski
1167*b1cdbd2cSJim Jagielski /*
1168*b1cdbd2cSJim Jagielski [Beschreibung]
1169*b1cdbd2cSJim Jagielski
1170*b1cdbd2cSJim Jagielski Wert fuer DefaultTabs erfragen (wird in App.-Methik geliefert)
1171*b1cdbd2cSJim Jagielski
1172*b1cdbd2cSJim Jagielski */
1173*b1cdbd2cSJim Jagielski
1174*b1cdbd2cSJim Jagielski {
1175*b1cdbd2cSJim Jagielski return lDefTabDist;
1176*b1cdbd2cSJim Jagielski }
1177*b1cdbd2cSJim Jagielski
1178*b1cdbd2cSJim Jagielski
ToSvTab_Impl(SvxTabAdjust eAdj)1179*b1cdbd2cSJim Jagielski sal_uInt16 ToSvTab_Impl(SvxTabAdjust eAdj)
1180*b1cdbd2cSJim Jagielski
1181*b1cdbd2cSJim Jagielski /*
1182*b1cdbd2cSJim Jagielski [Beschreibung]
1183*b1cdbd2cSJim Jagielski
1184*b1cdbd2cSJim Jagielski Interne Konvertierungsroutinen zwischen SV-Tab.-Enum und Svx
1185*b1cdbd2cSJim Jagielski
1186*b1cdbd2cSJim Jagielski */
1187*b1cdbd2cSJim Jagielski
1188*b1cdbd2cSJim Jagielski {
1189*b1cdbd2cSJim Jagielski switch(eAdj) {
1190*b1cdbd2cSJim Jagielski case SVX_TAB_ADJUST_LEFT: return RULER_TAB_LEFT;
1191*b1cdbd2cSJim Jagielski case SVX_TAB_ADJUST_RIGHT: return RULER_TAB_RIGHT;
1192*b1cdbd2cSJim Jagielski case SVX_TAB_ADJUST_DECIMAL: return RULER_TAB_DECIMAL;
1193*b1cdbd2cSJim Jagielski case SVX_TAB_ADJUST_CENTER: return RULER_TAB_CENTER;
1194*b1cdbd2cSJim Jagielski case SVX_TAB_ADJUST_DEFAULT: return RULER_TAB_DEFAULT;
1195*b1cdbd2cSJim Jagielski default: ;//prevent warning
1196*b1cdbd2cSJim Jagielski }
1197*b1cdbd2cSJim Jagielski return 0;
1198*b1cdbd2cSJim Jagielski }
1199*b1cdbd2cSJim Jagielski
1200*b1cdbd2cSJim Jagielski
ToAttrTab_Impl(sal_uInt16 eAdj)1201*b1cdbd2cSJim Jagielski SvxTabAdjust ToAttrTab_Impl(sal_uInt16 eAdj)
1202*b1cdbd2cSJim Jagielski {
1203*b1cdbd2cSJim Jagielski switch(eAdj) {
1204*b1cdbd2cSJim Jagielski case RULER_TAB_LEFT: return SVX_TAB_ADJUST_LEFT ;
1205*b1cdbd2cSJim Jagielski case RULER_TAB_RIGHT: return SVX_TAB_ADJUST_RIGHT ;
1206*b1cdbd2cSJim Jagielski case RULER_TAB_DECIMAL: return SVX_TAB_ADJUST_DECIMAL ;
1207*b1cdbd2cSJim Jagielski case RULER_TAB_CENTER: return SVX_TAB_ADJUST_CENTER ;
1208*b1cdbd2cSJim Jagielski case RULER_TAB_DEFAULT: return SVX_TAB_ADJUST_DEFAULT ;
1209*b1cdbd2cSJim Jagielski }
1210*b1cdbd2cSJim Jagielski return SVX_TAB_ADJUST_LEFT;
1211*b1cdbd2cSJim Jagielski }
1212*b1cdbd2cSJim Jagielski
1213*b1cdbd2cSJim Jagielski
UpdateTabs()1214*b1cdbd2cSJim Jagielski void SvxRuler::UpdateTabs()
1215*b1cdbd2cSJim Jagielski
1216*b1cdbd2cSJim Jagielski /*
1217*b1cdbd2cSJim Jagielski [Beschreibung]
1218*b1cdbd2cSJim Jagielski
1219*b1cdbd2cSJim Jagielski Anzeige der Tabulatoren
1220*b1cdbd2cSJim Jagielski
1221*b1cdbd2cSJim Jagielski */
1222*b1cdbd2cSJim Jagielski
1223*b1cdbd2cSJim Jagielski {
1224*b1cdbd2cSJim Jagielski if(IsDrag())
1225*b1cdbd2cSJim Jagielski return;
1226*b1cdbd2cSJim Jagielski if(pPagePosItem && pParaItem && pTabStopItem && !pObjectItem)
1227*b1cdbd2cSJim Jagielski {
1228*b1cdbd2cSJim Jagielski // Puffer fuer DefaultTabStop
1229*b1cdbd2cSJim Jagielski // Abstand letzter Tab <-> Rechter Absatzrand / DefaultTabDist
1230*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
1231*b1cdbd2cSJim Jagielski long nLeftFrameMargin = GetLeftFrameMargin();
1232*b1cdbd2cSJim Jagielski long nRightFrameMargin = GetRightFrameMargin();
1233*b1cdbd2cSJim Jagielski
1234*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
1235*b1cdbd2cSJim Jagielski const long nParaItemTxtLeft = pParaItem->GetTxtLeft();
1236*b1cdbd2cSJim Jagielski
1237*b1cdbd2cSJim Jagielski const long lParaIndent = nLeftFrameMargin + nParaItemTxtLeft;
1238*b1cdbd2cSJim Jagielski
1239*b1cdbd2cSJim Jagielski const long lLastTab =
1240*b1cdbd2cSJim Jagielski pTabStopItem->Count()?
1241*b1cdbd2cSJim Jagielski ConvertHPosPixel((*pTabStopItem)[pTabStopItem->Count()-1].GetTabPos()): 0;
1242*b1cdbd2cSJim Jagielski const long lPosPixel =
1243*b1cdbd2cSJim Jagielski ConvertHPosPixel(lParaIndent) + lLastTab;
1244*b1cdbd2cSJim Jagielski const long lRightIndent =
1245*b1cdbd2cSJim Jagielski ConvertHPosPixel(nRightFrameMargin - pParaItem->GetRight());
1246*b1cdbd2cSJim Jagielski long nDefTabDist = ConvertHPosPixel(lDefTabDist);
1247*b1cdbd2cSJim Jagielski if( !nDefTabDist )
1248*b1cdbd2cSJim Jagielski nDefTabDist = 1;
1249*b1cdbd2cSJim Jagielski const sal_uInt16 nDefTabBuf = lPosPixel > lRightIndent ||
1250*b1cdbd2cSJim Jagielski lLastTab > lRightIndent
1251*b1cdbd2cSJim Jagielski ? 0
1252*b1cdbd2cSJim Jagielski : (sal_uInt16)( (lRightIndent - lPosPixel) / nDefTabDist );
1253*b1cdbd2cSJim Jagielski
1254*b1cdbd2cSJim Jagielski if(pTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize)
1255*b1cdbd2cSJim Jagielski {
1256*b1cdbd2cSJim Jagielski delete[] pTabs;
1257*b1cdbd2cSJim Jagielski // 10 (GAP) auf Vorrat
1258*b1cdbd2cSJim Jagielski nTabBufSize = pTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP;
1259*b1cdbd2cSJim Jagielski pTabs = new RulerTab[nTabBufSize];
1260*b1cdbd2cSJim Jagielski }
1261*b1cdbd2cSJim Jagielski
1262*b1cdbd2cSJim Jagielski nTabCount = 0;
1263*b1cdbd2cSJim Jagielski sal_uInt16 j;
1264*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
1265*b1cdbd2cSJim Jagielski const long lRightPixMargin = ConvertSizePixel(nRightFrameMargin - nParaItemTxtLeft );
1266*b1cdbd2cSJim Jagielski const long lParaIndentPix = ConvertSizePixel(lParaIndent);
1267*b1cdbd2cSJim Jagielski for(j = 0; j < pTabStopItem->Count(); ++j)
1268*b1cdbd2cSJim Jagielski {
1269*b1cdbd2cSJim Jagielski const SvxTabStop *pTab = &(*pTabStopItem)[j];
1270*b1cdbd2cSJim Jagielski pTabs[nTabCount+TAB_GAP].nPos =
1271*b1cdbd2cSJim Jagielski ConvertHPosPixel(
1272*b1cdbd2cSJim Jagielski (pRuler_Imp->bIsTabsRelativeToIndent ? lParaIndent : 0 ) + pTab->GetTabPos() + lAppNullOffset);
1273*b1cdbd2cSJim Jagielski if(bRTL)
1274*b1cdbd2cSJim Jagielski {
1275*b1cdbd2cSJim Jagielski pTabs[nTabCount+TAB_GAP].nPos = lParaIndentPix + lRightPixMargin - pTabs[nTabCount+TAB_GAP].nPos;
1276*b1cdbd2cSJim Jagielski }
1277*b1cdbd2cSJim Jagielski pTabs[nTabCount+TAB_GAP].nStyle = ToSvTab_Impl(pTab->GetAdjustment());
1278*b1cdbd2cSJim Jagielski ++nTabCount;
1279*b1cdbd2cSJim Jagielski }
1280*b1cdbd2cSJim Jagielski if(!pTabStopItem->Count())
1281*b1cdbd2cSJim Jagielski pTabs[0].nPos = bRTL ? lRightPixMargin : lParaIndentPix;
1282*b1cdbd2cSJim Jagielski
1283*b1cdbd2cSJim Jagielski // Rest mit Default-Tabs fuellen
1284*b1cdbd2cSJim Jagielski if(bRTL)
1285*b1cdbd2cSJim Jagielski {
1286*b1cdbd2cSJim Jagielski for(j = 0; j < nDefTabBuf; ++j)
1287*b1cdbd2cSJim Jagielski {
1288*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos =
1289*b1cdbd2cSJim Jagielski pTabs[nTabCount].nPos - nDefTabDist;
1290*b1cdbd2cSJim Jagielski
1291*b1cdbd2cSJim Jagielski if(j == 0 )
1292*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos -=
1293*b1cdbd2cSJim Jagielski ((pTabs[nTabCount + TAB_GAP].nPos - lRightPixMargin)
1294*b1cdbd2cSJim Jagielski % nDefTabDist );
1295*b1cdbd2cSJim Jagielski if(pTabs[nTabCount+TAB_GAP].nPos <= lParaIndentPix)
1296*b1cdbd2cSJim Jagielski break;
1297*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
1298*b1cdbd2cSJim Jagielski ++nTabCount;
1299*b1cdbd2cSJim Jagielski }
1300*b1cdbd2cSJim Jagielski }
1301*b1cdbd2cSJim Jagielski else
1302*b1cdbd2cSJim Jagielski {
1303*b1cdbd2cSJim Jagielski for(j = 0; j < nDefTabBuf; ++j)
1304*b1cdbd2cSJim Jagielski {
1305*b1cdbd2cSJim Jagielski if( j == 0 )
1306*b1cdbd2cSJim Jagielski {
1307*b1cdbd2cSJim Jagielski //set the first default tab stop
1308*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTabsRelativeToIndent)
1309*b1cdbd2cSJim Jagielski {
1310*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos =
1311*b1cdbd2cSJim Jagielski (pTabs[nTabCount].nPos + nDefTabDist);
1312*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos -=
1313*b1cdbd2cSJim Jagielski ((pTabs[nTabCount + TAB_GAP].nPos - lParaIndentPix)
1314*b1cdbd2cSJim Jagielski % nDefTabDist );
1315*b1cdbd2cSJim Jagielski }
1316*b1cdbd2cSJim Jagielski else
1317*b1cdbd2cSJim Jagielski {
1318*b1cdbd2cSJim Jagielski if( pTabs[nTabCount].nPos < 0 )
1319*b1cdbd2cSJim Jagielski {
1320*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos = ( pTabs[nTabCount].nPos / nDefTabDist ) * nDefTabDist;
1321*b1cdbd2cSJim Jagielski }
1322*b1cdbd2cSJim Jagielski else
1323*b1cdbd2cSJim Jagielski {
1324*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos = ( pTabs[nTabCount].nPos / nDefTabDist + 1 ) * nDefTabDist;
1325*b1cdbd2cSJim Jagielski }
1326*b1cdbd2cSJim Jagielski }
1327*b1cdbd2cSJim Jagielski
1328*b1cdbd2cSJim Jagielski }
1329*b1cdbd2cSJim Jagielski else
1330*b1cdbd2cSJim Jagielski {
1331*b1cdbd2cSJim Jagielski //simply add the default distance to the last position
1332*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nPos =
1333*b1cdbd2cSJim Jagielski pTabs[nTabCount].nPos + nDefTabDist;
1334*b1cdbd2cSJim Jagielski }
1335*b1cdbd2cSJim Jagielski
1336*b1cdbd2cSJim Jagielski if(pTabs[nTabCount+TAB_GAP].nPos >= lRightIndent)
1337*b1cdbd2cSJim Jagielski break;
1338*b1cdbd2cSJim Jagielski pTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
1339*b1cdbd2cSJim Jagielski ++nTabCount;
1340*b1cdbd2cSJim Jagielski }
1341*b1cdbd2cSJim Jagielski }
1342*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
1343*b1cdbd2cSJim Jagielski DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize zu klein");
1344*b1cdbd2cSJim Jagielski }
1345*b1cdbd2cSJim Jagielski else
1346*b1cdbd2cSJim Jagielski {
1347*b1cdbd2cSJim Jagielski SetTabs();
1348*b1cdbd2cSJim Jagielski }
1349*b1cdbd2cSJim Jagielski }
1350*b1cdbd2cSJim Jagielski
1351*b1cdbd2cSJim Jagielski
Update(const SvxTabStopItem * pItem)1352*b1cdbd2cSJim Jagielski void SvxRuler::Update
1353*b1cdbd2cSJim Jagielski (
1354*b1cdbd2cSJim Jagielski const SvxTabStopItem *pItem // Neuer Wert fuer Tabulatoren
1355*b1cdbd2cSJim Jagielski )
1356*b1cdbd2cSJim Jagielski
1357*b1cdbd2cSJim Jagielski /*
1358*b1cdbd2cSJim Jagielski [Beschreibung]
1359*b1cdbd2cSJim Jagielski
1360*b1cdbd2cSJim Jagielski Neuen Wert fuer Tabulatoren merken; alten gfs. loeschen
1361*b1cdbd2cSJim Jagielski
1362*b1cdbd2cSJim Jagielski */
1363*b1cdbd2cSJim Jagielski
1364*b1cdbd2cSJim Jagielski {
1365*b1cdbd2cSJim Jagielski if(bActive)
1366*b1cdbd2cSJim Jagielski {
1367*b1cdbd2cSJim Jagielski delete pTabStopItem; pTabStopItem = 0;
1368*b1cdbd2cSJim Jagielski if(pItem)
1369*b1cdbd2cSJim Jagielski {
1370*b1cdbd2cSJim Jagielski pTabStopItem = new SvxTabStopItem(*pItem);
1371*b1cdbd2cSJim Jagielski if(!bHorz)
1372*b1cdbd2cSJim Jagielski pTabStopItem->SetWhich(SID_ATTR_TABSTOP_VERTICAL);
1373*b1cdbd2cSJim Jagielski }
1374*b1cdbd2cSJim Jagielski StartListening_Impl();
1375*b1cdbd2cSJim Jagielski }
1376*b1cdbd2cSJim Jagielski }
1377*b1cdbd2cSJim Jagielski
1378*b1cdbd2cSJim Jagielski
Update(const SvxObjectItem * pItem)1379*b1cdbd2cSJim Jagielski void SvxRuler::Update
1380*b1cdbd2cSJim Jagielski (
1381*b1cdbd2cSJim Jagielski const SvxObjectItem *pItem // Neuer Wert fuer Objekte
1382*b1cdbd2cSJim Jagielski )
1383*b1cdbd2cSJim Jagielski
1384*b1cdbd2cSJim Jagielski /*
1385*b1cdbd2cSJim Jagielski [Beschreibung]
1386*b1cdbd2cSJim Jagielski
1387*b1cdbd2cSJim Jagielski Neuen Wert fuer Objekte merken
1388*b1cdbd2cSJim Jagielski
1389*b1cdbd2cSJim Jagielski */
1390*b1cdbd2cSJim Jagielski
1391*b1cdbd2cSJim Jagielski {
1392*b1cdbd2cSJim Jagielski if(bActive)
1393*b1cdbd2cSJim Jagielski {
1394*b1cdbd2cSJim Jagielski delete pObjectItem; pObjectItem = 0;
1395*b1cdbd2cSJim Jagielski if(pItem)
1396*b1cdbd2cSJim Jagielski pObjectItem = new SvxObjectItem(*pItem);
1397*b1cdbd2cSJim Jagielski StartListening_Impl();
1398*b1cdbd2cSJim Jagielski }
1399*b1cdbd2cSJim Jagielski }
1400*b1cdbd2cSJim Jagielski
1401*b1cdbd2cSJim Jagielski
SetNullOffsetLogic(long lVal)1402*b1cdbd2cSJim Jagielski void SvxRuler::SetNullOffsetLogic
1403*b1cdbd2cSJim Jagielski (
1404*b1cdbd2cSJim Jagielski long lVal // Setzen des logischen NullOffsets
1405*b1cdbd2cSJim Jagielski )
1406*b1cdbd2cSJim Jagielski {
1407*b1cdbd2cSJim Jagielski lAppNullOffset = lLogicNullOffset - lVal;
1408*b1cdbd2cSJim Jagielski bAppSetNullOffset = sal_True;
1409*b1cdbd2cSJim Jagielski Ruler::SetNullOffset(ConvertSizePixel(lVal));
1410*b1cdbd2cSJim Jagielski Update();
1411*b1cdbd2cSJim Jagielski }
1412*b1cdbd2cSJim Jagielski
1413*b1cdbd2cSJim Jagielski
Update()1414*b1cdbd2cSJim Jagielski void SvxRuler::Update()
1415*b1cdbd2cSJim Jagielski
1416*b1cdbd2cSJim Jagielski /*
1417*b1cdbd2cSJim Jagielski [Beschreibung]
1418*b1cdbd2cSJim Jagielski
1419*b1cdbd2cSJim Jagielski Aktualisierung der Anzeige anstossen
1420*b1cdbd2cSJim Jagielski
1421*b1cdbd2cSJim Jagielski */
1422*b1cdbd2cSJim Jagielski
1423*b1cdbd2cSJim Jagielski {
1424*b1cdbd2cSJim Jagielski if(IsDrag())
1425*b1cdbd2cSJim Jagielski return;
1426*b1cdbd2cSJim Jagielski UpdatePage();
1427*b1cdbd2cSJim Jagielski UpdateFrame();
1428*b1cdbd2cSJim Jagielski if((nFlags & SVXRULER_SUPPORT_OBJECT) == SVXRULER_SUPPORT_OBJECT)
1429*b1cdbd2cSJim Jagielski UpdateObject();
1430*b1cdbd2cSJim Jagielski else
1431*b1cdbd2cSJim Jagielski UpdateColumns();
1432*b1cdbd2cSJim Jagielski
1433*b1cdbd2cSJim Jagielski if(0 != (nFlags & (SVXRULER_SUPPORT_PARAGRAPH_MARGINS |SVXRULER_SUPPORT_PARAGRAPH_MARGINS_VERTICAL)))
1434*b1cdbd2cSJim Jagielski UpdatePara();
1435*b1cdbd2cSJim Jagielski if(0 != (nFlags & SVXRULER_SUPPORT_TABS))
1436*b1cdbd2cSJim Jagielski UpdateTabs();
1437*b1cdbd2cSJim Jagielski }
1438*b1cdbd2cSJim Jagielski
1439*b1cdbd2cSJim Jagielski
GetPageWidth() const1440*b1cdbd2cSJim Jagielski inline long SvxRuler::GetPageWidth() const
1441*b1cdbd2cSJim Jagielski {
1442*b1cdbd2cSJim Jagielski return bHorz ? pPagePosItem->GetWidth() : pPagePosItem->GetHeight();
1443*b1cdbd2cSJim Jagielski
1444*b1cdbd2cSJim Jagielski }
1445*b1cdbd2cSJim Jagielski
1446*b1cdbd2cSJim Jagielski
GetFrameLeft() const1447*b1cdbd2cSJim Jagielski inline long SvxRuler::GetFrameLeft() const
1448*b1cdbd2cSJim Jagielski
1449*b1cdbd2cSJim Jagielski /*
1450*b1cdbd2cSJim Jagielski [Beschreibung]
1451*b1cdbd2cSJim Jagielski
1452*b1cdbd2cSJim Jagielski Erfragen des linken Randes in Pixeln
1453*b1cdbd2cSJim Jagielski
1454*b1cdbd2cSJim Jagielski */
1455*b1cdbd2cSJim Jagielski
1456*b1cdbd2cSJim Jagielski
1457*b1cdbd2cSJim Jagielski {
1458*b1cdbd2cSJim Jagielski return bAppSetNullOffset?
1459*b1cdbd2cSJim Jagielski GetMargin1() + ConvertSizePixel(lLogicNullOffset):
1460*b1cdbd2cSJim Jagielski Ruler::GetNullOffset();
1461*b1cdbd2cSJim Jagielski }
1462*b1cdbd2cSJim Jagielski
SetFrameLeft(long l)1463*b1cdbd2cSJim Jagielski inline void SvxRuler::SetFrameLeft(long l)
1464*b1cdbd2cSJim Jagielski
1465*b1cdbd2cSJim Jagielski /*
1466*b1cdbd2cSJim Jagielski [Beschreibung]
1467*b1cdbd2cSJim Jagielski
1468*b1cdbd2cSJim Jagielski Setzen des linken Randes in Pixeln
1469*b1cdbd2cSJim Jagielski
1470*b1cdbd2cSJim Jagielski */
1471*b1cdbd2cSJim Jagielski
1472*b1cdbd2cSJim Jagielski {
1473*b1cdbd2cSJim Jagielski sal_Bool bProtectColumns =
1474*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsSizeProtected() ||
1475*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsPosProtected();
1476*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
1477*b1cdbd2cSJim Jagielski SetMargin1(l - ConvertSizePixel(lLogicNullOffset),
1478*b1cdbd2cSJim Jagielski bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE);
1479*b1cdbd2cSJim Jagielski else
1480*b1cdbd2cSJim Jagielski Ruler::SetNullOffset(l);
1481*b1cdbd2cSJim Jagielski }
1482*b1cdbd2cSJim Jagielski
1483*b1cdbd2cSJim Jagielski
GetFirstLineIndent() const1484*b1cdbd2cSJim Jagielski long SvxRuler::GetFirstLineIndent() const
1485*b1cdbd2cSJim Jagielski
1486*b1cdbd2cSJim Jagielski /*
1487*b1cdbd2cSJim Jagielski [Beschreibung]
1488*b1cdbd2cSJim Jagielski
1489*b1cdbd2cSJim Jagielski Erstzeileneinzug in Pixels erfragen
1490*b1cdbd2cSJim Jagielski */
1491*b1cdbd2cSJim Jagielski
1492*b1cdbd2cSJim Jagielski {
1493*b1cdbd2cSJim Jagielski return pParaItem? pIndents[INDENT_FIRST_LINE].nPos: GetMargin1();
1494*b1cdbd2cSJim Jagielski }
1495*b1cdbd2cSJim Jagielski
1496*b1cdbd2cSJim Jagielski
GetLeftIndent() const1497*b1cdbd2cSJim Jagielski long SvxRuler::GetLeftIndent() const
1498*b1cdbd2cSJim Jagielski
1499*b1cdbd2cSJim Jagielski /*
1500*b1cdbd2cSJim Jagielski [Beschreibung]
1501*b1cdbd2cSJim Jagielski
1502*b1cdbd2cSJim Jagielski Linken Absatzrand in Pixels erfragen
1503*b1cdbd2cSJim Jagielski */
1504*b1cdbd2cSJim Jagielski
1505*b1cdbd2cSJim Jagielski {
1506*b1cdbd2cSJim Jagielski return pParaItem? pIndents[INDENT_LEFT_MARGIN].nPos: GetMargin1();
1507*b1cdbd2cSJim Jagielski }
1508*b1cdbd2cSJim Jagielski
1509*b1cdbd2cSJim Jagielski
1510*b1cdbd2cSJim Jagielski
GetRightIndent() const1511*b1cdbd2cSJim Jagielski long SvxRuler::GetRightIndent() const
1512*b1cdbd2cSJim Jagielski
1513*b1cdbd2cSJim Jagielski /*
1514*b1cdbd2cSJim Jagielski [Beschreibung]
1515*b1cdbd2cSJim Jagielski
1516*b1cdbd2cSJim Jagielski Rechten Absatzrand in Pixels erfragen
1517*b1cdbd2cSJim Jagielski */
1518*b1cdbd2cSJim Jagielski
1519*b1cdbd2cSJim Jagielski {
1520*b1cdbd2cSJim Jagielski return pParaItem? pIndents[INDENT_RIGHT_MARGIN].nPos: GetMargin2();
1521*b1cdbd2cSJim Jagielski }
1522*b1cdbd2cSJim Jagielski
1523*b1cdbd2cSJim Jagielski
GetLogicRightIndent() const1524*b1cdbd2cSJim Jagielski long SvxRuler::GetLogicRightIndent() const
1525*b1cdbd2cSJim Jagielski
1526*b1cdbd2cSJim Jagielski /*
1527*b1cdbd2cSJim Jagielski [Beschreibung]
1528*b1cdbd2cSJim Jagielski
1529*b1cdbd2cSJim Jagielski Rechten Absatzrand in Logic erfragen
1530*b1cdbd2cSJim Jagielski */
1531*b1cdbd2cSJim Jagielski
1532*b1cdbd2cSJim Jagielski {
1533*b1cdbd2cSJim Jagielski return pParaItem ? GetRightFrameMargin()-pParaItem->GetRight() : GetRightFrameMargin();
1534*b1cdbd2cSJim Jagielski }
1535*b1cdbd2cSJim Jagielski
1536*b1cdbd2cSJim Jagielski // linker Rand in App-Werten; ist entweder der Seitenrand (=0)
1537*b1cdbd2cSJim Jagielski // oder der linke Rand der Spalte, die im Spaltenattribut als
1538*b1cdbd2cSJim Jagielski // altuelle Spalte eingestellt ist.
1539*b1cdbd2cSJim Jagielski
GetLeftFrameMargin() const1540*b1cdbd2cSJim Jagielski long SvxRuler::GetLeftFrameMargin() const
1541*b1cdbd2cSJim Jagielski {
1542*b1cdbd2cSJim Jagielski // #126721# for some unknown reason the current column is set to 0xffff
1543*b1cdbd2cSJim Jagielski DBG_ASSERT(!pColumnItem || pColumnItem->GetActColumn() < pColumnItem->Count(),
1544*b1cdbd2cSJim Jagielski "issue #126721# - invalid current column!");
1545*b1cdbd2cSJim Jagielski long nLeft =
1546*b1cdbd2cSJim Jagielski pColumnItem && pColumnItem->Count() && pColumnItem->GetActColumn() < pColumnItem->Count() ?
1547*b1cdbd2cSJim Jagielski (*pColumnItem)[pColumnItem->GetActColumn()].nStart : 0;
1548*b1cdbd2cSJim Jagielski if(pParaBorderItem && (!pColumnItem || pColumnItem->IsTable()))
1549*b1cdbd2cSJim Jagielski nLeft += pParaBorderItem->GetLeft();
1550*b1cdbd2cSJim Jagielski return nLeft;
1551*b1cdbd2cSJim Jagielski }
1552*b1cdbd2cSJim Jagielski
GetLeftMin() const1553*b1cdbd2cSJim Jagielski inline long SvxRuler::GetLeftMin() const
1554*b1cdbd2cSJim Jagielski {
1555*b1cdbd2cSJim Jagielski DBG_ASSERT(pMinMaxItem, "kein MinMax-Wert gesetzt");
1556*b1cdbd2cSJim Jagielski return pMinMaxItem?
1557*b1cdbd2cSJim Jagielski bHorz? pMinMaxItem->GetValue().Left(): pMinMaxItem->GetValue().Top()
1558*b1cdbd2cSJim Jagielski : 0;
1559*b1cdbd2cSJim Jagielski }
1560*b1cdbd2cSJim Jagielski
GetRightMax() const1561*b1cdbd2cSJim Jagielski inline long SvxRuler::GetRightMax() const
1562*b1cdbd2cSJim Jagielski {
1563*b1cdbd2cSJim Jagielski DBG_ASSERT(pMinMaxItem, "kein MinMax-Wert gesetzt");
1564*b1cdbd2cSJim Jagielski return pMinMaxItem?
1565*b1cdbd2cSJim Jagielski bHorz? pMinMaxItem->GetValue().Right(): pMinMaxItem->GetValue().Bottom()
1566*b1cdbd2cSJim Jagielski : 0;
1567*b1cdbd2cSJim Jagielski }
1568*b1cdbd2cSJim Jagielski
1569*b1cdbd2cSJim Jagielski
GetRightFrameMargin() const1570*b1cdbd2cSJim Jagielski long SvxRuler::GetRightFrameMargin() const
1571*b1cdbd2cSJim Jagielski
1572*b1cdbd2cSJim Jagielski /*
1573*b1cdbd2cSJim Jagielski [Beschreibung]
1574*b1cdbd2cSJim Jagielski
1575*b1cdbd2cSJim Jagielski Rechten umgebenden Rand erfragen (in logischen Einheiten)
1576*b1cdbd2cSJim Jagielski
1577*b1cdbd2cSJim Jagielski */
1578*b1cdbd2cSJim Jagielski
1579*b1cdbd2cSJim Jagielski {
1580*b1cdbd2cSJim Jagielski if(pColumnItem)
1581*b1cdbd2cSJim Jagielski {
1582*b1cdbd2cSJim Jagielski if(!IsActLastColumn( sal_True ))
1583*b1cdbd2cSJim Jagielski {
1584*b1cdbd2cSJim Jagielski long nRet = (*pColumnItem)[GetActRightColumn( sal_True )].nEnd;
1585*b1cdbd2cSJim Jagielski if(pColumnItem->IsTable() && pParaBorderItem)
1586*b1cdbd2cSJim Jagielski nRet -= pParaBorderItem->GetRight();
1587*b1cdbd2cSJim Jagielski return nRet;
1588*b1cdbd2cSJim Jagielski }
1589*b1cdbd2cSJim Jagielski }
1590*b1cdbd2cSJim Jagielski
1591*b1cdbd2cSJim Jagielski long l = lLogicNullOffset;
1592*b1cdbd2cSJim Jagielski
1593*b1cdbd2cSJim Jagielski // gfs. rechten Tabelleneinzug abziehen
1594*b1cdbd2cSJim Jagielski if(pColumnItem && pColumnItem->IsTable())
1595*b1cdbd2cSJim Jagielski l += pColumnItem->GetRight();
1596*b1cdbd2cSJim Jagielski else if(bHorz && pLRSpaceItem)
1597*b1cdbd2cSJim Jagielski l += pLRSpaceItem->GetRight();
1598*b1cdbd2cSJim Jagielski else if(!bHorz && pULSpaceItem)
1599*b1cdbd2cSJim Jagielski l += pULSpaceItem->GetLower();
1600*b1cdbd2cSJim Jagielski
1601*b1cdbd2cSJim Jagielski if(pParaBorderItem &&
1602*b1cdbd2cSJim Jagielski (!pColumnItem || pColumnItem->IsTable()||IsActLastColumn( sal_True )))
1603*b1cdbd2cSJim Jagielski l += pParaBorderItem->GetRight();
1604*b1cdbd2cSJim Jagielski
1605*b1cdbd2cSJim Jagielski if(bHorz)
1606*b1cdbd2cSJim Jagielski l = pPagePosItem->GetWidth() - l;
1607*b1cdbd2cSJim Jagielski else
1608*b1cdbd2cSJim Jagielski l = pPagePosItem->GetHeight() - l;
1609*b1cdbd2cSJim Jagielski return l;
1610*b1cdbd2cSJim Jagielski }
1611*b1cdbd2cSJim Jagielski
1612*b1cdbd2cSJim Jagielski #define NEG_FLAG ( (nFlags & SVXRULER_SUPPORT_NEGATIVE_MARGINS) == \
1613*b1cdbd2cSJim Jagielski SVXRULER_SUPPORT_NEGATIVE_MARGINS )
1614*b1cdbd2cSJim Jagielski #define TAB_FLAG ( pColumnItem && pColumnItem->IsTable() )
1615*b1cdbd2cSJim Jagielski
GetCorrectedDragPos(sal_Bool bLeft,sal_Bool bRight)1616*b1cdbd2cSJim Jagielski long SvxRuler::GetCorrectedDragPos( sal_Bool bLeft, sal_Bool bRight )
1617*b1cdbd2cSJim Jagielski
1618*b1cdbd2cSJim Jagielski /*
1619*b1cdbd2cSJim Jagielski [Beschreibung]
1620*b1cdbd2cSJim Jagielski
1621*b1cdbd2cSJim Jagielski Korrigiert die Position innerhalb der errechneten Grenzwerte.
1622*b1cdbd2cSJim Jagielski Die Grenzwerte sind in Pixel relativ zum Seitenrand.
1623*b1cdbd2cSJim Jagielski
1624*b1cdbd2cSJim Jagielski */
1625*b1cdbd2cSJim Jagielski
1626*b1cdbd2cSJim Jagielski {
1627*b1cdbd2cSJim Jagielski const long lNullPix = Ruler::GetNullOffset();
1628*b1cdbd2cSJim Jagielski long lDragPos = GetDragPos() + lNullPix;
1629*b1cdbd2cSJim Jagielski ADD_DEBUG_TEXT("lDragPos: ", String::CreateFromInt32(lDragPos))
1630*b1cdbd2cSJim Jagielski sal_Bool bHoriRows = bHorz && pRuler_Imp->bIsTableRows;
1631*b1cdbd2cSJim Jagielski if((bLeft || (bHoriRows)) && lDragPos < nMaxLeft)
1632*b1cdbd2cSJim Jagielski lDragPos = nMaxLeft;
1633*b1cdbd2cSJim Jagielski else if((bRight||bHoriRows) && lDragPos > nMaxRight)
1634*b1cdbd2cSJim Jagielski lDragPos = nMaxRight;
1635*b1cdbd2cSJim Jagielski return lDragPos - lNullPix;
1636*b1cdbd2cSJim Jagielski }
1637*b1cdbd2cSJim Jagielski
1638*b1cdbd2cSJim Jagielski
1639*b1cdbd2cSJim Jagielski
ModifyTabs_Impl(sal_uInt16 nCount,RulerTab * pTabs,long lDiff)1640*b1cdbd2cSJim Jagielski void ModifyTabs_Impl
1641*b1cdbd2cSJim Jagielski (
1642*b1cdbd2cSJim Jagielski sal_uInt16 nCount, // Anzahl Tabs
1643*b1cdbd2cSJim Jagielski RulerTab *pTabs, // Tab-Puffer
1644*b1cdbd2cSJim Jagielski long lDiff // zu addierende Differenz
1645*b1cdbd2cSJim Jagielski )
1646*b1cdbd2cSJim Jagielski
1647*b1cdbd2cSJim Jagielski /*
1648*b1cdbd2cSJim Jagielski [Beschreibung]
1649*b1cdbd2cSJim Jagielski
1650*b1cdbd2cSJim Jagielski Hilfsroutine; alle Tabs um einen festen Wert verschieben
1651*b1cdbd2cSJim Jagielski
1652*b1cdbd2cSJim Jagielski */
1653*b1cdbd2cSJim Jagielski {
1654*b1cdbd2cSJim Jagielski if( pTabs )
1655*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < nCount; ++i) pTabs[i].nPos += lDiff;
1656*b1cdbd2cSJim Jagielski }
1657*b1cdbd2cSJim Jagielski
1658*b1cdbd2cSJim Jagielski
1659*b1cdbd2cSJim Jagielski
DragMargin1()1660*b1cdbd2cSJim Jagielski void SvxRuler::DragMargin1()
1661*b1cdbd2cSJim Jagielski
1662*b1cdbd2cSJim Jagielski /*
1663*b1cdbd2cSJim Jagielski [Beschreibung]
1664*b1cdbd2cSJim Jagielski
1665*b1cdbd2cSJim Jagielski Draggen des linken Frame-Randes
1666*b1cdbd2cSJim Jagielski
1667*b1cdbd2cSJim Jagielski */
1668*b1cdbd2cSJim Jagielski {
1669*b1cdbd2cSJim Jagielski const long lDragPos = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG, sal_True );
1670*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz);
1671*b1cdbd2cSJim Jagielski if(pColumnItem&&
1672*b1cdbd2cSJim Jagielski (//nDragType & DRAG_OBJECT_SIZE_LINEAR ||
1673*b1cdbd2cSJim Jagielski nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
1674*b1cdbd2cSJim Jagielski DragBorders();
1675*b1cdbd2cSJim Jagielski AdjustMargin1(lDragPos);
1676*b1cdbd2cSJim Jagielski }
AdjustMargin1(long lDiff)1677*b1cdbd2cSJim Jagielski void SvxRuler::AdjustMargin1(long lDiff)
1678*b1cdbd2cSJim Jagielski {
1679*b1cdbd2cSJim Jagielski const long nOld = bAppSetNullOffset? GetMargin1(): GetNullOffset();
1680*b1cdbd2cSJim Jagielski const long lDragPos = lDiff;
1681*b1cdbd2cSJim Jagielski sal_Bool bProtectColumns =
1682*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsSizeProtected() ||
1683*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsPosProtected();
1684*b1cdbd2cSJim Jagielski
1685*b1cdbd2cSJim Jagielski const sal_uInt16 nMarginStyle =
1686*b1cdbd2cSJim Jagielski bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
1687*b1cdbd2cSJim Jagielski
1688*b1cdbd2cSJim Jagielski if(!bAppSetNullOffset)
1689*b1cdbd2cSJim Jagielski {
1690*b1cdbd2cSJim Jagielski long _lDiff = lDragPos;
1691*b1cdbd2cSJim Jagielski SetNullOffset(nOld + _lDiff);
1692*b1cdbd2cSJim Jagielski if(!pColumnItem||!(nDragType & DRAG_OBJECT_SIZE_LINEAR))
1693*b1cdbd2cSJim Jagielski {
1694*b1cdbd2cSJim Jagielski SetMargin2( GetMargin2() - _lDiff, nMarginStyle );
1695*b1cdbd2cSJim Jagielski
1696*b1cdbd2cSJim Jagielski if(!pColumnItem && !pObjectItem && pParaItem)
1697*b1cdbd2cSJim Jagielski {
1698*b1cdbd2cSJim Jagielski // Rechten Einzug an alter Position
1699*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1700*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1701*b1cdbd2cSJim Jagielski }
1702*b1cdbd2cSJim Jagielski if(pObjectItem)
1703*b1cdbd2cSJim Jagielski {
1704*b1cdbd2cSJim Jagielski pObjectBorders[GetObjectBordersOff(0)].nPos -= _lDiff;
1705*b1cdbd2cSJim Jagielski pObjectBorders[GetObjectBordersOff(1)].nPos -= _lDiff;
1706*b1cdbd2cSJim Jagielski SetBorders(2, pObjectBorders + GetObjectBordersOff(0));
1707*b1cdbd2cSJim Jagielski }
1708*b1cdbd2cSJim Jagielski if(pColumnItem)
1709*b1cdbd2cSJim Jagielski {
1710*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
1711*b1cdbd2cSJim Jagielski pBorders[i].nPos -= _lDiff;
1712*b1cdbd2cSJim Jagielski SetBorders(pColumnItem->Count()-1, pBorders);
1713*b1cdbd2cSJim Jagielski if(pColumnItem->IsFirstAct())
1714*b1cdbd2cSJim Jagielski {
1715*b1cdbd2cSJim Jagielski // Rechten Einzug an alter Position
1716*b1cdbd2cSJim Jagielski if(pParaItem)
1717*b1cdbd2cSJim Jagielski {
1718*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1719*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1720*b1cdbd2cSJim Jagielski }
1721*b1cdbd2cSJim Jagielski }
1722*b1cdbd2cSJim Jagielski else
1723*b1cdbd2cSJim Jagielski {
1724*b1cdbd2cSJim Jagielski if(pParaItem)
1725*b1cdbd2cSJim Jagielski {
1726*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos -= _lDiff;
1727*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos -= _lDiff;
1728*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1729*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1730*b1cdbd2cSJim Jagielski }
1731*b1cdbd2cSJim Jagielski }
1732*b1cdbd2cSJim Jagielski if(pTabStopItem&& (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
1733*b1cdbd2cSJim Jagielski &&!IsActFirstColumn())
1734*b1cdbd2cSJim Jagielski {
1735*b1cdbd2cSJim Jagielski ModifyTabs_Impl(nTabCount+TAB_GAP, pTabs, -_lDiff);
1736*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
1737*b1cdbd2cSJim Jagielski }
1738*b1cdbd2cSJim Jagielski }
1739*b1cdbd2cSJim Jagielski }
1740*b1cdbd2cSJim Jagielski }
1741*b1cdbd2cSJim Jagielski else
1742*b1cdbd2cSJim Jagielski {
1743*b1cdbd2cSJim Jagielski long _lDiff = lDragPos - nOld;
1744*b1cdbd2cSJim Jagielski SetMargin1(nOld + _lDiff, nMarginStyle );
1745*b1cdbd2cSJim Jagielski
1746*b1cdbd2cSJim Jagielski if(!pColumnItem||!(nDragType & (DRAG_OBJECT_SIZE_LINEAR |
1747*b1cdbd2cSJim Jagielski DRAG_OBJECT_SIZE_PROPORTIONAL)))
1748*b1cdbd2cSJim Jagielski {
1749*b1cdbd2cSJim Jagielski if(!pColumnItem && !pObjectItem && pParaItem)
1750*b1cdbd2cSJim Jagielski {
1751*b1cdbd2cSJim Jagielski // Linke Einzuege an alter Position
1752*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1753*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1754*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1755*b1cdbd2cSJim Jagielski }
1756*b1cdbd2cSJim Jagielski
1757*b1cdbd2cSJim Jagielski if(pColumnItem)
1758*b1cdbd2cSJim Jagielski {
1759*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
1760*b1cdbd2cSJim Jagielski pBorders[i].nPos += _lDiff;
1761*b1cdbd2cSJim Jagielski SetBorders(pColumnItem->Count()-1, pBorders);
1762*b1cdbd2cSJim Jagielski if(pColumnItem->IsFirstAct())
1763*b1cdbd2cSJim Jagielski {
1764*b1cdbd2cSJim Jagielski // Linke Einzuege an alter Position
1765*b1cdbd2cSJim Jagielski if(pParaItem)
1766*b1cdbd2cSJim Jagielski {
1767*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1768*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1769*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1770*b1cdbd2cSJim Jagielski }
1771*b1cdbd2cSJim Jagielski }
1772*b1cdbd2cSJim Jagielski else
1773*b1cdbd2cSJim Jagielski {
1774*b1cdbd2cSJim Jagielski if(pParaItem)
1775*b1cdbd2cSJim Jagielski {
1776*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1777*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1778*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos += _lDiff;
1779*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1780*b1cdbd2cSJim Jagielski }
1781*b1cdbd2cSJim Jagielski }
1782*b1cdbd2cSJim Jagielski }
1783*b1cdbd2cSJim Jagielski if(pTabStopItem)
1784*b1cdbd2cSJim Jagielski {
1785*b1cdbd2cSJim Jagielski ModifyTabs_Impl(nTabCount+TAB_GAP, pTabs, _lDiff);
1786*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
1787*b1cdbd2cSJim Jagielski }
1788*b1cdbd2cSJim Jagielski }
1789*b1cdbd2cSJim Jagielski }
1790*b1cdbd2cSJim Jagielski }
1791*b1cdbd2cSJim Jagielski
1792*b1cdbd2cSJim Jagielski
DragMargin2()1793*b1cdbd2cSJim Jagielski void SvxRuler::DragMargin2()
1794*b1cdbd2cSJim Jagielski /*
1795*b1cdbd2cSJim Jagielski [Beschreibung]
1796*b1cdbd2cSJim Jagielski
1797*b1cdbd2cSJim Jagielski Draggen des rechten Frame-Randes
1798*b1cdbd2cSJim Jagielski
1799*b1cdbd2cSJim Jagielski */
1800*b1cdbd2cSJim Jagielski {
1801*b1cdbd2cSJim Jagielski const long lDragPos = GetCorrectedDragPos( sal_True, !TAB_FLAG || !NEG_FLAG);
1802*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 5 : 7, bHorz);
1803*b1cdbd2cSJim Jagielski long lDiff = lDragPos - GetMargin2();
1804*b1cdbd2cSJim Jagielski
1805*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows && !bHorz && pColumnItem&&
1806*b1cdbd2cSJim Jagielski (//nDragType & DRAG_OBJECT_SIZE_LINEAR ||
1807*b1cdbd2cSJim Jagielski nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
1808*b1cdbd2cSJim Jagielski DragBorders();
1809*b1cdbd2cSJim Jagielski
1810*b1cdbd2cSJim Jagielski sal_Bool bProtectColumns =
1811*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsSizeProtected() ||
1812*b1cdbd2cSJim Jagielski pRuler_Imp->aProtectItem.IsPosProtected();
1813*b1cdbd2cSJim Jagielski const sal_uInt16 nMarginStyle =
1814*b1cdbd2cSJim Jagielski bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
1815*b1cdbd2cSJim Jagielski SetMargin2( lDragPos, nMarginStyle );
1816*b1cdbd2cSJim Jagielski
1817*b1cdbd2cSJim Jagielski // Rechten Einzug an alter Position
1818*b1cdbd2cSJim Jagielski if((!pColumnItem || IsActLastColumn()) && pParaItem)
1819*b1cdbd2cSJim Jagielski {
1820*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos += lDiff;
1821*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1822*b1cdbd2cSJim Jagielski }
1823*b1cdbd2cSJim Jagielski }
1824*b1cdbd2cSJim Jagielski
1825*b1cdbd2cSJim Jagielski
DragIndents()1826*b1cdbd2cSJim Jagielski void SvxRuler::DragIndents()
1827*b1cdbd2cSJim Jagielski /*
1828*b1cdbd2cSJim Jagielski [Beschreibung]
1829*b1cdbd2cSJim Jagielski
1830*b1cdbd2cSJim Jagielski Draggen der Absatzeinzuege
1831*b1cdbd2cSJim Jagielski
1832*b1cdbd2cSJim Jagielski */
1833*b1cdbd2cSJim Jagielski {
1834*b1cdbd2cSJim Jagielski const long lDragPos = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos();
1835*b1cdbd2cSJim Jagielski const sal_uInt16 nIdx = GetDragAryPos()+INDENT_GAP;
1836*b1cdbd2cSJim Jagielski const long lDiff = pIndents[nIdx].nPos - lDragPos;
1837*b1cdbd2cSJim Jagielski
1838*b1cdbd2cSJim Jagielski if((nIdx == INDENT_FIRST_LINE ||
1839*b1cdbd2cSJim Jagielski nIdx == INDENT_LEFT_MARGIN ) &&
1840*b1cdbd2cSJim Jagielski (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
1841*b1cdbd2cSJim Jagielski DRAG_OBJECT_LEFT_INDENT_ONLY)
1842*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos -= lDiff;
1843*b1cdbd2cSJim Jagielski
1844*b1cdbd2cSJim Jagielski pIndents[nIdx].nPos = lDragPos;
1845*b1cdbd2cSJim Jagielski
1846*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents + INDENT_GAP);
1847*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, 1, bHorz);
1848*b1cdbd2cSJim Jagielski }
1849*b1cdbd2cSJim Jagielski
1850*b1cdbd2cSJim Jagielski
DrawLine_Impl(long & _lTabPos,int nNew,sal_Bool Hori)1851*b1cdbd2cSJim Jagielski void SvxRuler::DrawLine_Impl(long &_lTabPos, int nNew, sal_Bool Hori)
1852*b1cdbd2cSJim Jagielski /*
1853*b1cdbd2cSJim Jagielski [Beschreibung]
1854*b1cdbd2cSJim Jagielski
1855*b1cdbd2cSJim Jagielski Ausgaberoutine fuer Hilfslinie beim Vereschieben von Tabs, Tabellen-
1856*b1cdbd2cSJim Jagielski und anderen Spalten
1857*b1cdbd2cSJim Jagielski
1858*b1cdbd2cSJim Jagielski */
1859*b1cdbd2cSJim Jagielski {
1860*b1cdbd2cSJim Jagielski if(Hori)
1861*b1cdbd2cSJim Jagielski {
1862*b1cdbd2cSJim Jagielski const long nHeight = pEditWin->GetOutputSize().Height();
1863*b1cdbd2cSJim Jagielski Point aZero=pEditWin->GetMapMode().GetOrigin();
1864*b1cdbd2cSJim Jagielski if(_lTabPos!=-1)
1865*b1cdbd2cSJim Jagielski pEditWin->InvertTracking(
1866*b1cdbd2cSJim Jagielski Rectangle( Point(_lTabPos, -aZero.Y()),
1867*b1cdbd2cSJim Jagielski Point(_lTabPos, -aZero.Y()+nHeight)),
1868*b1cdbd2cSJim Jagielski SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
1869*b1cdbd2cSJim Jagielski if( nNew & 1 )
1870*b1cdbd2cSJim Jagielski {
1871*b1cdbd2cSJim Jagielski
1872*b1cdbd2cSJim Jagielski _lTabPos = ConvertHSizeLogic(
1873*b1cdbd2cSJim Jagielski GetCorrectedDragPos( ( nNew&4 ) != 0, ( nNew&2 ) != 0 ) +
1874*b1cdbd2cSJim Jagielski GetNullOffset() );
1875*b1cdbd2cSJim Jagielski if(pPagePosItem)
1876*b1cdbd2cSJim Jagielski _lTabPos += pPagePosItem->GetPos().X();
1877*b1cdbd2cSJim Jagielski pEditWin->InvertTracking(
1878*b1cdbd2cSJim Jagielski Rectangle(Point(_lTabPos, -aZero.Y()),
1879*b1cdbd2cSJim Jagielski Point(_lTabPos, -aZero.Y()+nHeight)),
1880*b1cdbd2cSJim Jagielski SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
1881*b1cdbd2cSJim Jagielski }
1882*b1cdbd2cSJim Jagielski }
1883*b1cdbd2cSJim Jagielski else
1884*b1cdbd2cSJim Jagielski {
1885*b1cdbd2cSJim Jagielski const long nWidth = pEditWin->GetOutputSize().Width();
1886*b1cdbd2cSJim Jagielski Point aZero=pEditWin->GetMapMode().GetOrigin();
1887*b1cdbd2cSJim Jagielski if(_lTabPos != -1)
1888*b1cdbd2cSJim Jagielski {
1889*b1cdbd2cSJim Jagielski pEditWin->InvertTracking(
1890*b1cdbd2cSJim Jagielski Rectangle( Point(-aZero.X(), _lTabPos),
1891*b1cdbd2cSJim Jagielski Point(-aZero.X()+nWidth, _lTabPos)),
1892*b1cdbd2cSJim Jagielski SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
1893*b1cdbd2cSJim Jagielski }
1894*b1cdbd2cSJim Jagielski
1895*b1cdbd2cSJim Jagielski if(nNew & 1)
1896*b1cdbd2cSJim Jagielski {
1897*b1cdbd2cSJim Jagielski _lTabPos = ConvertVSizeLogic(GetCorrectedDragPos()+GetNullOffset());
1898*b1cdbd2cSJim Jagielski if(pPagePosItem)
1899*b1cdbd2cSJim Jagielski _lTabPos += pPagePosItem->GetPos().Y();
1900*b1cdbd2cSJim Jagielski pEditWin->InvertTracking(
1901*b1cdbd2cSJim Jagielski Rectangle( Point(-aZero.X(), _lTabPos),
1902*b1cdbd2cSJim Jagielski Point(-aZero.X()+nWidth, _lTabPos)),
1903*b1cdbd2cSJim Jagielski SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
1904*b1cdbd2cSJim Jagielski }
1905*b1cdbd2cSJim Jagielski }
1906*b1cdbd2cSJim Jagielski }
1907*b1cdbd2cSJim Jagielski
1908*b1cdbd2cSJim Jagielski
1909*b1cdbd2cSJim Jagielski
1910*b1cdbd2cSJim Jagielski
DragTabs()1911*b1cdbd2cSJim Jagielski void SvxRuler::DragTabs()
1912*b1cdbd2cSJim Jagielski
1913*b1cdbd2cSJim Jagielski /*
1914*b1cdbd2cSJim Jagielski [Beschreibung]
1915*b1cdbd2cSJim Jagielski
1916*b1cdbd2cSJim Jagielski Draggen von Tabs
1917*b1cdbd2cSJim Jagielski
1918*b1cdbd2cSJim Jagielski */
1919*b1cdbd2cSJim Jagielski {
1920*b1cdbd2cSJim Jagielski
1921*b1cdbd2cSJim Jagielski long lDragPos = GetCorrectedDragPos(sal_True, sal_False);
1922*b1cdbd2cSJim Jagielski
1923*b1cdbd2cSJim Jagielski sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
1924*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, 7, bHorz);
1925*b1cdbd2cSJim Jagielski
1926*b1cdbd2cSJim Jagielski long nDiff = lDragPos - pTabs[nIdx].nPos;
1927*b1cdbd2cSJim Jagielski
1928*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
1929*b1cdbd2cSJim Jagielski {
1930*b1cdbd2cSJim Jagielski
1931*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nIdx; i < nTabCount; ++i)
1932*b1cdbd2cSJim Jagielski {
1933*b1cdbd2cSJim Jagielski pTabs[i].nPos += nDiff;
1934*b1cdbd2cSJim Jagielski // auf Maximum begrenzen
1935*b1cdbd2cSJim Jagielski if(pTabs[i].nPos > GetMargin2())
1936*b1cdbd2cSJim Jagielski pTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
1937*b1cdbd2cSJim Jagielski else
1938*b1cdbd2cSJim Jagielski pTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
1939*b1cdbd2cSJim Jagielski }
1940*b1cdbd2cSJim Jagielski }
1941*b1cdbd2cSJim Jagielski else if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
1942*b1cdbd2cSJim Jagielski {
1943*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist -= nDiff;
1944*b1cdbd2cSJim Jagielski pTabs[nIdx].nPos = lDragPos;
1945*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
1946*b1cdbd2cSJim Jagielski {
1947*b1cdbd2cSJim Jagielski if(pTabs[i].nStyle & RULER_TAB_DEFAULT)
1948*b1cdbd2cSJim Jagielski // bei den DefaultTabs kann abgebrochen werden
1949*b1cdbd2cSJim Jagielski break;
1950*b1cdbd2cSJim Jagielski long nDelta = pRuler_Imp->nTotalDist * pRuler_Imp->pPercBuf[i];
1951*b1cdbd2cSJim Jagielski nDelta /= 1000;
1952*b1cdbd2cSJim Jagielski pTabs[i].nPos = pTabs[nIdx].nPos + nDelta;
1953*b1cdbd2cSJim Jagielski if(pTabs[i].nPos+GetNullOffset() > nMaxRight)
1954*b1cdbd2cSJim Jagielski pTabs[i].nStyle |= RULER_STYLE_INVISIBLE;
1955*b1cdbd2cSJim Jagielski else
1956*b1cdbd2cSJim Jagielski pTabs[i].nStyle &= ~RULER_STYLE_INVISIBLE;
1957*b1cdbd2cSJim Jagielski }
1958*b1cdbd2cSJim Jagielski }
1959*b1cdbd2cSJim Jagielski else
1960*b1cdbd2cSJim Jagielski pTabs[nIdx].nPos = lDragPos;
1961*b1cdbd2cSJim Jagielski
1962*b1cdbd2cSJim Jagielski if(IsDragDelete())
1963*b1cdbd2cSJim Jagielski pTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
1964*b1cdbd2cSJim Jagielski else
1965*b1cdbd2cSJim Jagielski pTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
1966*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
1967*b1cdbd2cSJim Jagielski }
1968*b1cdbd2cSJim Jagielski
1969*b1cdbd2cSJim Jagielski
1970*b1cdbd2cSJim Jagielski
SetActive(sal_Bool bOn)1971*b1cdbd2cSJim Jagielski void SvxRuler::SetActive(sal_Bool bOn)
1972*b1cdbd2cSJim Jagielski {
1973*b1cdbd2cSJim Jagielski if(bOn)
1974*b1cdbd2cSJim Jagielski {
1975*b1cdbd2cSJim Jagielski Activate();
1976*b1cdbd2cSJim Jagielski /* pBindings->Invalidate( SID_RULER_LR_MIN_MAX, sal_True, sal_True );
1977*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_LR_MIN_MAX );
1978*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_ATTR_LONG_ULSPACE, sal_True, sal_True );
1979*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_ULSPACE );
1980*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_ATTR_LONG_LRSPACE, sal_True, sal_True );
1981*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_LRSPACE );
1982*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_RULER_PAGE_POS, sal_True, sal_True );
1983*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PAGE_POS );
1984*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_ATTR_TABSTOP, sal_True, sal_True );
1985*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_TABSTOP );
1986*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_ATTR_PARA_LRSPACE, sal_True, sal_True );
1987*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_PARA_LRSPACE );
1988*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_RULER_BORDERS, sal_True, sal_True );
1989*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_BORDERS );
1990*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_RULER_OBJECT, sal_True, sal_True );
1991*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_OBJECT );
1992*b1cdbd2cSJim Jagielski pBindings->Invalidate( SID_RULER_PROTECT, sal_True, sal_True );
1993*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PROTECT );*/
1994*b1cdbd2cSJim Jagielski }
1995*b1cdbd2cSJim Jagielski else
1996*b1cdbd2cSJim Jagielski Deactivate();
1997*b1cdbd2cSJim Jagielski if(bActive!=bOn)
1998*b1cdbd2cSJim Jagielski {
1999*b1cdbd2cSJim Jagielski pBindings->EnterRegistrations();
2000*b1cdbd2cSJim Jagielski if(bOn)
2001*b1cdbd2cSJim Jagielski for(sal_uInt16 i=0;i<pRuler_Imp->nControlerItems;i++)
2002*b1cdbd2cSJim Jagielski pCtrlItem[i]->ReBind();
2003*b1cdbd2cSJim Jagielski else
2004*b1cdbd2cSJim Jagielski for(sal_uInt16 j=0;j<pRuler_Imp->nControlerItems;j++)
2005*b1cdbd2cSJim Jagielski pCtrlItem[j]->UnBind();
2006*b1cdbd2cSJim Jagielski pBindings->LeaveRegistrations();
2007*b1cdbd2cSJim Jagielski }
2008*b1cdbd2cSJim Jagielski bActive = bOn;
2009*b1cdbd2cSJim Jagielski }
2010*b1cdbd2cSJim Jagielski
2011*b1cdbd2cSJim Jagielski
2012*b1cdbd2cSJim Jagielski
2013*b1cdbd2cSJim Jagielski
UpdateParaContents_Impl(long l,UpdateType eType)2014*b1cdbd2cSJim Jagielski void SvxRuler::UpdateParaContents_Impl
2015*b1cdbd2cSJim Jagielski (
2016*b1cdbd2cSJim Jagielski long l, // Differenz
2017*b1cdbd2cSJim Jagielski UpdateType eType // Art (alle, links oder rechts)
2018*b1cdbd2cSJim Jagielski )
2019*b1cdbd2cSJim Jagielski
2020*b1cdbd2cSJim Jagielski /*
2021*b1cdbd2cSJim Jagielski [Beschreibung]
2022*b1cdbd2cSJim Jagielski
2023*b1cdbd2cSJim Jagielski Hilfsroutine; Mitfuehren von Tabulatoren und Absatzraendern
2024*b1cdbd2cSJim Jagielski
2025*b1cdbd2cSJim Jagielski */
2026*b1cdbd2cSJim Jagielski {
2027*b1cdbd2cSJim Jagielski switch(eType) {
2028*b1cdbd2cSJim Jagielski case MOVE_RIGHT:
2029*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos += l;
2030*b1cdbd2cSJim Jagielski break;
2031*b1cdbd2cSJim Jagielski case MOVE_ALL:
2032*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos += l;
2033*b1cdbd2cSJim Jagielski // no break
2034*b1cdbd2cSJim Jagielski case MOVE_LEFT:
2035*b1cdbd2cSJim Jagielski {
2036*b1cdbd2cSJim Jagielski pIndents[INDENT_FIRST_LINE].nPos += l;
2037*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos += l;
2038*b1cdbd2cSJim Jagielski if ( pTabs )
2039*b1cdbd2cSJim Jagielski {
2040*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < nTabCount+TAB_GAP;++i)
2041*b1cdbd2cSJim Jagielski pTabs[i].nPos += l;
2042*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
2043*b1cdbd2cSJim Jagielski }
2044*b1cdbd2cSJim Jagielski break;
2045*b1cdbd2cSJim Jagielski }
2046*b1cdbd2cSJim Jagielski }
2047*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
2048*b1cdbd2cSJim Jagielski }
2049*b1cdbd2cSJim Jagielski
2050*b1cdbd2cSJim Jagielski
2051*b1cdbd2cSJim Jagielski
DragBorders()2052*b1cdbd2cSJim Jagielski void SvxRuler::DragBorders()
2053*b1cdbd2cSJim Jagielski
2054*b1cdbd2cSJim Jagielski /*
2055*b1cdbd2cSJim Jagielski [Beschreibung]
2056*b1cdbd2cSJim Jagielski
2057*b1cdbd2cSJim Jagielski Draggen von Borders (Tabellen- und anderen Spalten)
2058*b1cdbd2cSJim Jagielski
2059*b1cdbd2cSJim Jagielski */
2060*b1cdbd2cSJim Jagielski {
2061*b1cdbd2cSJim Jagielski sal_Bool bLeftIndentsCorrected = sal_False, bRightIndentsCorrected = sal_False;
2062*b1cdbd2cSJim Jagielski int nIdx;
2063*b1cdbd2cSJim Jagielski
2064*b1cdbd2cSJim Jagielski if(GetDragType()==RULER_TYPE_BORDER)
2065*b1cdbd2cSJim Jagielski {
2066*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, 7, bHorz);
2067*b1cdbd2cSJim Jagielski nIdx = GetDragAryPos();
2068*b1cdbd2cSJim Jagielski }
2069*b1cdbd2cSJim Jagielski else
2070*b1cdbd2cSJim Jagielski nIdx=0;
2071*b1cdbd2cSJim Jagielski
2072*b1cdbd2cSJim Jagielski sal_uInt16 nDragSize = GetDragSize();
2073*b1cdbd2cSJim Jagielski long lDiff = 0;
2074*b1cdbd2cSJim Jagielski
2075*b1cdbd2cSJim Jagielski // the drag position has to be corrected to be able to prevent borders from passing each other
2076*b1cdbd2cSJim Jagielski long lPos = GetCorrectedDragPos();
2077*b1cdbd2cSJim Jagielski
2078*b1cdbd2cSJim Jagielski
2079*b1cdbd2cSJim Jagielski switch(nDragSize)
2080*b1cdbd2cSJim Jagielski {
2081*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_MOVE:
2082*b1cdbd2cSJim Jagielski {
2083*b1cdbd2cSJim Jagielski ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargin))
2084*b1cdbd2cSJim Jagielski lDiff = GetDragType()==RULER_TYPE_BORDER ?
2085*b1cdbd2cSJim Jagielski lPos-nDragOffset - pBorders[nIdx].nPos
2086*b1cdbd2cSJim Jagielski : GetDragType() == RULER_TYPE_MARGIN1 ? lPos - pRuler_Imp->lLastLMargin : lPos - pRuler_Imp->lLastRMargin;
2087*b1cdbd2cSJim Jagielski
2088*b1cdbd2cSJim Jagielski // pBorders[nIdx].nPos += lDiff;
2089*b1cdbd2cSJim Jagielski // lDiff = pBorders[nIdx].nPos - nOld;
2090*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
2091*b1cdbd2cSJim Jagielski {
2092*b1cdbd2cSJim Jagielski long nRight = GetMargin2()-lMinFrame; // rechter Begrenzer
2093*b1cdbd2cSJim Jagielski for(int i = nBorderCount-2; i >= nIdx; --i)
2094*b1cdbd2cSJim Jagielski {
2095*b1cdbd2cSJim Jagielski long l = pBorders[i].nPos;
2096*b1cdbd2cSJim Jagielski pBorders[i].nPos += lDiff;
2097*b1cdbd2cSJim Jagielski pBorders[i].nPos = Min(pBorders[i].nPos, nRight - pBorders[i].nWidth);
2098*b1cdbd2cSJim Jagielski nRight = pBorders[i].nPos - lMinFrame;
2099*b1cdbd2cSJim Jagielski // RR der Spalte aktualisieren
2100*b1cdbd2cSJim Jagielski if(i == GetActRightColumn())
2101*b1cdbd2cSJim Jagielski {
2102*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
2103*b1cdbd2cSJim Jagielski bRightIndentsCorrected = sal_True;
2104*b1cdbd2cSJim Jagielski }
2105*b1cdbd2cSJim Jagielski // LAR, EZE der Spalte aktualisieren
2106*b1cdbd2cSJim Jagielski else if(i == GetActLeftColumn())
2107*b1cdbd2cSJim Jagielski {
2108*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
2109*b1cdbd2cSJim Jagielski bLeftIndentsCorrected = sal_True;
2110*b1cdbd2cSJim Jagielski }
2111*b1cdbd2cSJim Jagielski }
2112*b1cdbd2cSJim Jagielski }
2113*b1cdbd2cSJim Jagielski else if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2114*b1cdbd2cSJim Jagielski {
2115*b1cdbd2cSJim Jagielski int nLimit;
2116*b1cdbd2cSJim Jagielski long lLeft;
2117*b1cdbd2cSJim Jagielski int nStartLimit = nBorderCount-2;
2118*b1cdbd2cSJim Jagielski switch(GetDragType())
2119*b1cdbd2cSJim Jagielski {
2120*b1cdbd2cSJim Jagielski default: ;//prevent warning
2121*b1cdbd2cSJim Jagielski DBG_ERROR("svx::SvxRuler::DragBorders(), unknown drag type!" );
2122*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER:
2123*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows)
2124*b1cdbd2cSJim Jagielski {
2125*b1cdbd2cSJim Jagielski pBorders[nIdx].nPos += lDiff;
2126*b1cdbd2cSJim Jagielski if(bHorz)
2127*b1cdbd2cSJim Jagielski {
2128*b1cdbd2cSJim Jagielski lLeft = pBorders[nIdx].nPos;
2129*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist -= lDiff;
2130*b1cdbd2cSJim Jagielski nLimit=nIdx+1;
2131*b1cdbd2cSJim Jagielski }
2132*b1cdbd2cSJim Jagielski else
2133*b1cdbd2cSJim Jagielski {
2134*b1cdbd2cSJim Jagielski lLeft = 0;
2135*b1cdbd2cSJim Jagielski nStartLimit = nIdx - 1;
2136*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist += lDiff;
2137*b1cdbd2cSJim Jagielski nLimit = 0;
2138*b1cdbd2cSJim Jagielski }
2139*b1cdbd2cSJim Jagielski }
2140*b1cdbd2cSJim Jagielski else
2141*b1cdbd2cSJim Jagielski {
2142*b1cdbd2cSJim Jagielski nLimit=nIdx+1;
2143*b1cdbd2cSJim Jagielski pBorders[nIdx].nPos += lDiff;
2144*b1cdbd2cSJim Jagielski lLeft = pBorders[nIdx].nPos;
2145*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist-=lDiff;
2146*b1cdbd2cSJim Jagielski }
2147*b1cdbd2cSJim Jagielski break;
2148*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1:
2149*b1cdbd2cSJim Jagielski nLimit=0;
2150*b1cdbd2cSJim Jagielski lLeft=pRuler_Imp->lLastLMargin+lDiff;
2151*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist-=lDiff;
2152*b1cdbd2cSJim Jagielski break;
2153*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2:
2154*b1cdbd2cSJim Jagielski nLimit = 0;
2155*b1cdbd2cSJim Jagielski lLeft= 0;//pRuler_Imp->lLastRMargin + lDiff;
2156*b1cdbd2cSJim Jagielski nStartLimit = nBorderCount - 2;
2157*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist += lDiff;
2158*b1cdbd2cSJim Jagielski break;
2159*b1cdbd2cSJim Jagielski }
2160*b1cdbd2cSJim Jagielski
2161*b1cdbd2cSJim Jagielski for(int i = nStartLimit; i >= nLimit; --i)
2162*b1cdbd2cSJim Jagielski {
2163*b1cdbd2cSJim Jagielski
2164*b1cdbd2cSJim Jagielski long l = pBorders[i].nPos;
2165*b1cdbd2cSJim Jagielski pBorders[i].nPos=lLeft+
2166*b1cdbd2cSJim Jagielski (pRuler_Imp->nTotalDist*pRuler_Imp->pPercBuf[i])/1000+
2167*b1cdbd2cSJim Jagielski pRuler_Imp->pBlockBuf[i];
2168*b1cdbd2cSJim Jagielski
2169*b1cdbd2cSJim Jagielski // RR der Spalte aktualisieren
2170*b1cdbd2cSJim Jagielski if(!pRuler_Imp->bIsTableRows)
2171*b1cdbd2cSJim Jagielski {
2172*b1cdbd2cSJim Jagielski if(i == GetActRightColumn())
2173*b1cdbd2cSJim Jagielski {
2174*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
2175*b1cdbd2cSJim Jagielski bRightIndentsCorrected = sal_True;
2176*b1cdbd2cSJim Jagielski }
2177*b1cdbd2cSJim Jagielski // LAR, EZE der Spalte aktualisieren
2178*b1cdbd2cSJim Jagielski else if(i == GetActLeftColumn())
2179*b1cdbd2cSJim Jagielski {
2180*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
2181*b1cdbd2cSJim Jagielski bLeftIndentsCorrected = sal_True;
2182*b1cdbd2cSJim Jagielski }
2183*b1cdbd2cSJim Jagielski }
2184*b1cdbd2cSJim Jagielski }
2185*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows)
2186*b1cdbd2cSJim Jagielski {
2187*b1cdbd2cSJim Jagielski //in vertical tables the left borders have to be moved
2188*b1cdbd2cSJim Jagielski if(bHorz)
2189*b1cdbd2cSJim Jagielski {
2190*b1cdbd2cSJim Jagielski for(int i = 0; i < nIdx; ++i)
2191*b1cdbd2cSJim Jagielski pBorders[i].nPos += lDiff;
2192*b1cdbd2cSJim Jagielski AdjustMargin1(lDiff);
2193*b1cdbd2cSJim Jagielski }
2194*b1cdbd2cSJim Jagielski else
2195*b1cdbd2cSJim Jagielski {
2196*b1cdbd2cSJim Jagielski //otherwise the right borders are moved
2197*b1cdbd2cSJim Jagielski for(int i = pColumnItem->Count() - 1; i > nIdx; --i)
2198*b1cdbd2cSJim Jagielski pBorders[i].nPos += lDiff;
2199*b1cdbd2cSJim Jagielski SetMargin2( GetMargin2() + lDiff, 0 );
2200*b1cdbd2cSJim Jagielski }
2201*b1cdbd2cSJim Jagielski }
2202*b1cdbd2cSJim Jagielski }
2203*b1cdbd2cSJim Jagielski else if(pRuler_Imp->bIsTableRows)
2204*b1cdbd2cSJim Jagielski {
2205*b1cdbd2cSJim Jagielski //moving rows: if a row is resized all following rows
2206*b1cdbd2cSJim Jagielski //have to be moved by the same amount.
2207*b1cdbd2cSJim Jagielski //This includes the left border when the table is not limited
2208*b1cdbd2cSJim Jagielski //to a lower frame border.
2209*b1cdbd2cSJim Jagielski int nLimit;
2210*b1cdbd2cSJim Jagielski long lLeft;
2211*b1cdbd2cSJim Jagielski if(GetDragType()==RULER_TYPE_BORDER)
2212*b1cdbd2cSJim Jagielski {
2213*b1cdbd2cSJim Jagielski nLimit=nIdx+1;
2214*b1cdbd2cSJim Jagielski lLeft=(pBorders[nIdx].nPos+=lDiff);
2215*b1cdbd2cSJim Jagielski }
2216*b1cdbd2cSJim Jagielski else
2217*b1cdbd2cSJim Jagielski {
2218*b1cdbd2cSJim Jagielski nLimit=0;
2219*b1cdbd2cSJim Jagielski lLeft=pRuler_Imp->lLastLMargin+lDiff;
2220*b1cdbd2cSJim Jagielski }
2221*b1cdbd2cSJim Jagielski //in vertical tables the left borders have to be moved
2222*b1cdbd2cSJim Jagielski if(bHorz)
2223*b1cdbd2cSJim Jagielski {
2224*b1cdbd2cSJim Jagielski for(int i = 0; i < nIdx; ++i)
2225*b1cdbd2cSJim Jagielski {
2226*b1cdbd2cSJim Jagielski pBorders[i].nPos += lDiff;
2227*b1cdbd2cSJim Jagielski }
2228*b1cdbd2cSJim Jagielski AdjustMargin1(lDiff);
2229*b1cdbd2cSJim Jagielski }
2230*b1cdbd2cSJim Jagielski else
2231*b1cdbd2cSJim Jagielski {
2232*b1cdbd2cSJim Jagielski //otherwise the right borders are moved
2233*b1cdbd2cSJim Jagielski for(int i = nBorderCount-2; i >= nLimit; --i)
2234*b1cdbd2cSJim Jagielski {
2235*b1cdbd2cSJim Jagielski pBorders[i].nPos += lDiff;
2236*b1cdbd2cSJim Jagielski }
2237*b1cdbd2cSJim Jagielski SetMargin2( GetMargin2() + lDiff, 0 );
2238*b1cdbd2cSJim Jagielski }
2239*b1cdbd2cSJim Jagielski }
2240*b1cdbd2cSJim Jagielski else
2241*b1cdbd2cSJim Jagielski pBorders[nIdx].nPos+=lDiff;
2242*b1cdbd2cSJim Jagielski break;
2243*b1cdbd2cSJim Jagielski }
2244*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_1:
2245*b1cdbd2cSJim Jagielski {
2246*b1cdbd2cSJim Jagielski lDiff = lPos - pBorders[nIdx].nPos;
2247*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth += pBorders[nIdx].nPos - lPos;
2248*b1cdbd2cSJim Jagielski pBorders[nIdx].nPos = lPos;
2249*b1cdbd2cSJim Jagielski break;
2250*b1cdbd2cSJim Jagielski }
2251*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_2:
2252*b1cdbd2cSJim Jagielski {
2253*b1cdbd2cSJim Jagielski const long nOld = pBorders[nIdx].nWidth;
2254*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth = lPos - pBorders[nIdx].nPos;
2255*b1cdbd2cSJim Jagielski lDiff = pBorders[nIdx].nWidth - nOld;
2256*b1cdbd2cSJim Jagielski break;
2257*b1cdbd2cSJim Jagielski }
2258*b1cdbd2cSJim Jagielski }
2259*b1cdbd2cSJim Jagielski if(!bRightIndentsCorrected &&
2260*b1cdbd2cSJim Jagielski GetActRightColumn() == nIdx &&
2261*b1cdbd2cSJim Jagielski nDragSize != RULER_DRAGSIZE_2 && pIndents &&
2262*b1cdbd2cSJim Jagielski !pRuler_Imp->bIsTableRows)
2263*b1cdbd2cSJim Jagielski {
2264*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(lDiff, MOVE_RIGHT);
2265*b1cdbd2cSJim Jagielski }
2266*b1cdbd2cSJim Jagielski else if(!bLeftIndentsCorrected &&
2267*b1cdbd2cSJim Jagielski GetActLeftColumn()==nIdx &&
2268*b1cdbd2cSJim Jagielski nDragSize != RULER_DRAGSIZE_1 && pIndents)
2269*b1cdbd2cSJim Jagielski {
2270*b1cdbd2cSJim Jagielski UpdateParaContents_Impl(lDiff, MOVE_LEFT);
2271*b1cdbd2cSJim Jagielski }
2272*b1cdbd2cSJim Jagielski SetBorders(pColumnItem->Count()-1, pBorders);
2273*b1cdbd2cSJim Jagielski }
2274*b1cdbd2cSJim Jagielski
2275*b1cdbd2cSJim Jagielski
DragObjectBorder()2276*b1cdbd2cSJim Jagielski void SvxRuler::DragObjectBorder()
2277*b1cdbd2cSJim Jagielski
2278*b1cdbd2cSJim Jagielski /*
2279*b1cdbd2cSJim Jagielski [Beschreibung]
2280*b1cdbd2cSJim Jagielski
2281*b1cdbd2cSJim Jagielski Draggen von Objektraendern
2282*b1cdbd2cSJim Jagielski
2283*b1cdbd2cSJim Jagielski */
2284*b1cdbd2cSJim Jagielski {
2285*b1cdbd2cSJim Jagielski if(RULER_DRAGSIZE_MOVE == GetDragSize())
2286*b1cdbd2cSJim Jagielski {
2287*b1cdbd2cSJim Jagielski const long lPos = GetCorrectedDragPos();
2288*b1cdbd2cSJim Jagielski const sal_uInt16 nIdx = GetDragAryPos();
2289*b1cdbd2cSJim Jagielski pObjectBorders[GetObjectBordersOff(nIdx)].nPos = lPos;
2290*b1cdbd2cSJim Jagielski SetBorders(2, pObjectBorders + GetObjectBordersOff(0));
2291*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, 7, bHorz);
2292*b1cdbd2cSJim Jagielski
2293*b1cdbd2cSJim Jagielski }
2294*b1cdbd2cSJim Jagielski }
2295*b1cdbd2cSJim Jagielski
2296*b1cdbd2cSJim Jagielski
ApplyMargins()2297*b1cdbd2cSJim Jagielski void SvxRuler::ApplyMargins()
2298*b1cdbd2cSJim Jagielski /*
2299*b1cdbd2cSJim Jagielski [Beschreibung]
2300*b1cdbd2cSJim Jagielski
2301*b1cdbd2cSJim Jagielski Anwenden von Randeinstellungen; durch Draggen veraendert.
2302*b1cdbd2cSJim Jagielski
2303*b1cdbd2cSJim Jagielski */
2304*b1cdbd2cSJim Jagielski {
2305*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = 0;
2306*b1cdbd2cSJim Jagielski sal_uInt16 nId = SID_ATTR_LONG_LRSPACE;
2307*b1cdbd2cSJim Jagielski if(bHorz)
2308*b1cdbd2cSJim Jagielski {
2309*b1cdbd2cSJim Jagielski const long lOldNull = lLogicNullOffset;
2310*b1cdbd2cSJim Jagielski if(pRuler_Imp->lMaxLeftLogic!=-1&&nMaxLeft==GetMargin1()+Ruler::GetNullOffset())
2311*b1cdbd2cSJim Jagielski pLRSpaceItem->SetLeft(lLogicNullOffset=pRuler_Imp->lMaxLeftLogic);
2312*b1cdbd2cSJim Jagielski else
2313*b1cdbd2cSJim Jagielski pLRSpaceItem->SetLeft(PixelHAdjust(
2314*b1cdbd2cSJim Jagielski lLogicNullOffset = ConvertHPosLogic(GetFrameLeft()) -
2315*b1cdbd2cSJim Jagielski lAppNullOffset, pLRSpaceItem->GetLeft()));
2316*b1cdbd2cSJim Jagielski
2317*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
2318*b1cdbd2cSJim Jagielski lAppNullOffset += lLogicNullOffset - lOldNull;
2319*b1cdbd2cSJim Jagielski
2320*b1cdbd2cSJim Jagielski if(pRuler_Imp->lMaxRightLogic!=-1
2321*b1cdbd2cSJim Jagielski &&nMaxRight==GetMargin2()+Ruler::GetNullOffset())
2322*b1cdbd2cSJim Jagielski pLRSpaceItem->SetRight(GetPageWidth()-pRuler_Imp->lMaxRightLogic);
2323*b1cdbd2cSJim Jagielski else
2324*b1cdbd2cSJim Jagielski pLRSpaceItem->SetRight(
2325*b1cdbd2cSJim Jagielski PixelHAdjust(
2326*b1cdbd2cSJim Jagielski Max((long)0,pPagePosItem->GetWidth() -
2327*b1cdbd2cSJim Jagielski pLRSpaceItem->GetLeft() -
2328*b1cdbd2cSJim Jagielski (ConvertHPosLogic(GetMargin2()) -
2329*b1cdbd2cSJim Jagielski lAppNullOffset)),pLRSpaceItem->GetRight()));
2330*b1cdbd2cSJim Jagielski pItem = pLRSpaceItem;
2331*b1cdbd2cSJim Jagielski #ifdef DEBUGLIN
2332*b1cdbd2cSJim Jagielski Debug_Impl(pEditWin,*pLRSpaceItem);
2333*b1cdbd2cSJim Jagielski #endif // DEBUGLIN
2334*b1cdbd2cSJim Jagielski }
2335*b1cdbd2cSJim Jagielski else {
2336*b1cdbd2cSJim Jagielski const long lOldNull = lLogicNullOffset;
2337*b1cdbd2cSJim Jagielski pULSpaceItem->SetUpper(
2338*b1cdbd2cSJim Jagielski PixelVAdjust(
2339*b1cdbd2cSJim Jagielski lLogicNullOffset =
2340*b1cdbd2cSJim Jagielski ConvertVPosLogic(GetFrameLeft()) -
2341*b1cdbd2cSJim Jagielski lAppNullOffset,pULSpaceItem->GetUpper()));
2342*b1cdbd2cSJim Jagielski if(bAppSetNullOffset)
2343*b1cdbd2cSJim Jagielski lAppNullOffset += lLogicNullOffset - lOldNull;
2344*b1cdbd2cSJim Jagielski pULSpaceItem->SetLower(
2345*b1cdbd2cSJim Jagielski PixelVAdjust(
2346*b1cdbd2cSJim Jagielski Max((long)0, pPagePosItem->GetHeight() -
2347*b1cdbd2cSJim Jagielski pULSpaceItem->GetUpper() -
2348*b1cdbd2cSJim Jagielski (ConvertVPosLogic(GetMargin2()) -
2349*b1cdbd2cSJim Jagielski lAppNullOffset)),pULSpaceItem->GetLower()));
2350*b1cdbd2cSJim Jagielski pItem = pULSpaceItem;
2351*b1cdbd2cSJim Jagielski nId = SID_ATTR_LONG_ULSPACE;
2352*b1cdbd2cSJim Jagielski #ifdef DEBUGLIN
2353*b1cdbd2cSJim Jagielski Debug_Impl(pEditWin,*pULSpaceItem);
2354*b1cdbd2cSJim Jagielski #endif // DEBUGLIN
2355*b1cdbd2cSJim Jagielski }
2356*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( nId, SFX_CALLMODE_RECORD, pItem, 0L );
2357*b1cdbd2cSJim Jagielski if(pTabStopItem)
2358*b1cdbd2cSJim Jagielski UpdateTabs();
2359*b1cdbd2cSJim Jagielski }
2360*b1cdbd2cSJim Jagielski
2361*b1cdbd2cSJim Jagielski
ApplyIndents()2362*b1cdbd2cSJim Jagielski void SvxRuler::ApplyIndents()
2363*b1cdbd2cSJim Jagielski /*
2364*b1cdbd2cSJim Jagielski [Beschreibung]
2365*b1cdbd2cSJim Jagielski
2366*b1cdbd2cSJim Jagielski Anwenden von Absatzeinstellungen; durch Draggen veraendert.
2367*b1cdbd2cSJim Jagielski
2368*b1cdbd2cSJim Jagielski */
2369*b1cdbd2cSJim Jagielski {
2370*b1cdbd2cSJim Jagielski long nNewTxtLeft;
2371*b1cdbd2cSJim Jagielski if(pColumnItem&&!IsActFirstColumn( sal_True ))
2372*b1cdbd2cSJim Jagielski {
2373*b1cdbd2cSJim Jagielski long nLeftCol=GetActLeftColumn( sal_True );
2374*b1cdbd2cSJim Jagielski nNewTxtLeft =
2375*b1cdbd2cSJim Jagielski PixelHAdjust(
2376*b1cdbd2cSJim Jagielski ConvertHPosLogic(
2377*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos-
2378*b1cdbd2cSJim Jagielski (pBorders[nLeftCol].nPos +
2379*b1cdbd2cSJim Jagielski pBorders[nLeftCol].nWidth))-
2380*b1cdbd2cSJim Jagielski lAppNullOffset,pParaItem->GetTxtLeft());
2381*b1cdbd2cSJim Jagielski }
2382*b1cdbd2cSJim Jagielski else
2383*b1cdbd2cSJim Jagielski nNewTxtLeft =
2384*b1cdbd2cSJim Jagielski PixelHAdjust(
2385*b1cdbd2cSJim Jagielski ConvertHPosLogic(pIndents[INDENT_LEFT_MARGIN].nPos),
2386*b1cdbd2cSJim Jagielski pParaItem->GetTxtLeft());
2387*b1cdbd2cSJim Jagielski
2388*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2389*b1cdbd2cSJim Jagielski
2390*b1cdbd2cSJim Jagielski long nNewFirstLineOffset;
2391*b1cdbd2cSJim Jagielski if(bRTL)
2392*b1cdbd2cSJim Jagielski {
2393*b1cdbd2cSJim Jagielski long nRightFrameMargin = GetRightFrameMargin();
2394*b1cdbd2cSJim Jagielski nNewFirstLineOffset = PixelHAdjust(nRightFrameMargin -
2395*b1cdbd2cSJim Jagielski ConvertHPosLogic(pIndents[INDENT_FIRST_LINE].nPos ) -
2396*b1cdbd2cSJim Jagielski lAppNullOffset,
2397*b1cdbd2cSJim Jagielski pParaItem->GetTxtFirstLineOfst());
2398*b1cdbd2cSJim Jagielski }
2399*b1cdbd2cSJim Jagielski else
2400*b1cdbd2cSJim Jagielski nNewFirstLineOffset=
2401*b1cdbd2cSJim Jagielski PixelHAdjust(
2402*b1cdbd2cSJim Jagielski ConvertHPosLogic(pIndents[INDENT_FIRST_LINE].nPos -
2403*b1cdbd2cSJim Jagielski pIndents[INDENT_LEFT_MARGIN].nPos) -
2404*b1cdbd2cSJim Jagielski lAppNullOffset,
2405*b1cdbd2cSJim Jagielski pParaItem->GetTxtFirstLineOfst());
2406*b1cdbd2cSJim Jagielski
2407*b1cdbd2cSJim Jagielski // #62986# : Ist der neue TxtLeft kleiner als der alte FirstLineIndent,
2408*b1cdbd2cSJim Jagielski // dann geht die Differenz verloren und der Absatz wird insgesamt
2409*b1cdbd2cSJim Jagielski // zu weit eingerueckt, deswegen erst den FirstLineOffset setzen, dann den TxtLeft
2410*b1cdbd2cSJim Jagielski if(bRTL)
2411*b1cdbd2cSJim Jagielski {
2412*b1cdbd2cSJim Jagielski long nLeftFrameMargin = GetLeftFrameMargin();
2413*b1cdbd2cSJim Jagielski long nRightFrameMargin = GetRightFrameMargin();
2414*b1cdbd2cSJim Jagielski nNewTxtLeft = nRightFrameMargin - nNewTxtLeft - nLeftFrameMargin;
2415*b1cdbd2cSJim Jagielski nNewFirstLineOffset -= nNewTxtLeft;
2416*b1cdbd2cSJim Jagielski if(pParaBorderItem)
2417*b1cdbd2cSJim Jagielski {
2418*b1cdbd2cSJim Jagielski nNewTxtLeft += pParaBorderItem->GetLeft() + pParaBorderItem->GetRight();
2419*b1cdbd2cSJim Jagielski nNewFirstLineOffset -= pParaBorderItem->GetRight();
2420*b1cdbd2cSJim Jagielski }
2421*b1cdbd2cSJim Jagielski }
2422*b1cdbd2cSJim Jagielski pParaItem->SetTxtFirstLineOfst(
2423*b1cdbd2cSJim Jagielski sal::static_int_cast< short >(nNewFirstLineOffset));
2424*b1cdbd2cSJim Jagielski pParaItem->SetTxtLeft(nNewTxtLeft);
2425*b1cdbd2cSJim Jagielski
2426*b1cdbd2cSJim Jagielski if(pColumnItem && ((!bRTL && !IsActLastColumn( sal_True ))|| (bRTL && !IsActFirstColumn())))
2427*b1cdbd2cSJim Jagielski {
2428*b1cdbd2cSJim Jagielski if(bRTL)
2429*b1cdbd2cSJim Jagielski {
2430*b1cdbd2cSJim Jagielski long nActBorder = pBorders[GetActLeftColumn( sal_True )].nPos;
2431*b1cdbd2cSJim Jagielski long nRightMargin = pIndents[INDENT_RIGHT_MARGIN].nPos;
2432*b1cdbd2cSJim Jagielski long nConvert = ConvertHPosLogic( nRightMargin - nActBorder );
2433*b1cdbd2cSJim Jagielski pParaItem->SetRight( PixelHAdjust( nConvert - lAppNullOffset, pParaItem->GetRight() ) );
2434*b1cdbd2cSJim Jagielski }
2435*b1cdbd2cSJim Jagielski else
2436*b1cdbd2cSJim Jagielski {
2437*b1cdbd2cSJim Jagielski pParaItem->SetRight(
2438*b1cdbd2cSJim Jagielski PixelHAdjust(
2439*b1cdbd2cSJim Jagielski ConvertHPosLogic(
2440*b1cdbd2cSJim Jagielski pBorders[GetActRightColumn( sal_True )].nPos -
2441*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos) -
2442*b1cdbd2cSJim Jagielski lAppNullOffset,
2443*b1cdbd2cSJim Jagielski pParaItem->GetRight()));
2444*b1cdbd2cSJim Jagielski }
2445*b1cdbd2cSJim Jagielski
2446*b1cdbd2cSJim Jagielski }
2447*b1cdbd2cSJim Jagielski else
2448*b1cdbd2cSJim Jagielski {
2449*b1cdbd2cSJim Jagielski if(bRTL)
2450*b1cdbd2cSJim Jagielski {
2451*b1cdbd2cSJim Jagielski pParaItem->SetRight( PixelHAdjust(
2452*b1cdbd2cSJim Jagielski ConvertHPosLogic(GetMargin1() +
2453*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos) - GetLeftFrameMargin() +
2454*b1cdbd2cSJim Jagielski (pParaBorderItem ? pParaBorderItem->GetLeft() : 0) -
2455*b1cdbd2cSJim Jagielski lAppNullOffset, pParaItem->GetRight()));
2456*b1cdbd2cSJim Jagielski }
2457*b1cdbd2cSJim Jagielski else
2458*b1cdbd2cSJim Jagielski {
2459*b1cdbd2cSJim Jagielski pParaItem->SetRight( PixelHAdjust(
2460*b1cdbd2cSJim Jagielski ConvertHPosLogic(GetMargin2() -
2461*b1cdbd2cSJim Jagielski pIndents[INDENT_RIGHT_MARGIN].nPos) -
2462*b1cdbd2cSJim Jagielski lAppNullOffset, pParaItem->GetRight()));
2463*b1cdbd2cSJim Jagielski }
2464*b1cdbd2cSJim Jagielski }
2465*b1cdbd2cSJim Jagielski sal_uInt16 nParaId = bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL;
2466*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( nParaId, SFX_CALLMODE_RECORD, pParaItem, 0L );
2467*b1cdbd2cSJim Jagielski UpdateTabs();
2468*b1cdbd2cSJim Jagielski }
2469*b1cdbd2cSJim Jagielski
2470*b1cdbd2cSJim Jagielski
ApplyTabs()2471*b1cdbd2cSJim Jagielski void SvxRuler::ApplyTabs()
2472*b1cdbd2cSJim Jagielski /*
2473*b1cdbd2cSJim Jagielski [Beschreibung]
2474*b1cdbd2cSJim Jagielski
2475*b1cdbd2cSJim Jagielski Anwenden von Tabulatoreinstellungen; durch Draggen veraendert.
2476*b1cdbd2cSJim Jagielski
2477*b1cdbd2cSJim Jagielski */
2478*b1cdbd2cSJim Jagielski {
2479*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2480*b1cdbd2cSJim Jagielski const sal_uInt16 nCoreIdx = GetDragAryPos();
2481*b1cdbd2cSJim Jagielski if(IsDragDelete())
2482*b1cdbd2cSJim Jagielski {
2483*b1cdbd2cSJim Jagielski pTabStopItem->Remove(nCoreIdx);
2484*b1cdbd2cSJim Jagielski }
2485*b1cdbd2cSJim Jagielski else if(DRAG_OBJECT_SIZE_LINEAR & nDragType ||
2486*b1cdbd2cSJim Jagielski DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType)
2487*b1cdbd2cSJim Jagielski {
2488*b1cdbd2cSJim Jagielski SvxTabStopItem *pItem = new SvxTabStopItem(pTabStopItem->Which());
2489*b1cdbd2cSJim Jagielski //remove default tab stops
2490*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < pItem->Count(); )
2491*b1cdbd2cSJim Jagielski {
2492*b1cdbd2cSJim Jagielski if ( SVX_TAB_ADJUST_DEFAULT == (*pItem)[i].GetAdjustment() )
2493*b1cdbd2cSJim Jagielski {
2494*b1cdbd2cSJim Jagielski pItem->Remove(i);
2495*b1cdbd2cSJim Jagielski continue;
2496*b1cdbd2cSJim Jagielski }
2497*b1cdbd2cSJim Jagielski ++i;
2498*b1cdbd2cSJim Jagielski }
2499*b1cdbd2cSJim Jagielski
2500*b1cdbd2cSJim Jagielski sal_uInt16 j;
2501*b1cdbd2cSJim Jagielski for(j = 0; j < nCoreIdx; ++j)
2502*b1cdbd2cSJim Jagielski {
2503*b1cdbd2cSJim Jagielski pItem->Insert((*pTabStopItem)[j]);
2504*b1cdbd2cSJim Jagielski }
2505*b1cdbd2cSJim Jagielski for(; j < pTabStopItem->Count(); ++j)
2506*b1cdbd2cSJim Jagielski {
2507*b1cdbd2cSJim Jagielski SvxTabStop aTabStop = (*pTabStopItem)[j];
2508*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() = PixelHAdjust(
2509*b1cdbd2cSJim Jagielski ConvertHPosLogic(pTabs[j+TAB_GAP].nPos -
2510*b1cdbd2cSJim Jagielski GetLeftIndent()) -
2511*b1cdbd2cSJim Jagielski lAppNullOffset,
2512*b1cdbd2cSJim Jagielski aTabStop.GetTabPos());
2513*b1cdbd2cSJim Jagielski pItem->Insert(aTabStop);
2514*b1cdbd2cSJim Jagielski }
2515*b1cdbd2cSJim Jagielski delete pTabStopItem;
2516*b1cdbd2cSJim Jagielski pTabStopItem = pItem;
2517*b1cdbd2cSJim Jagielski }
2518*b1cdbd2cSJim Jagielski else if( pTabStopItem->Count() == 0 )
2519*b1cdbd2cSJim Jagielski return;
2520*b1cdbd2cSJim Jagielski else
2521*b1cdbd2cSJim Jagielski {
2522*b1cdbd2cSJim Jagielski SvxTabStop aTabStop = (*pTabStopItem)[nCoreIdx];
2523*b1cdbd2cSJim Jagielski if(pRuler_Imp->lMaxRightLogic!=-1&&
2524*b1cdbd2cSJim Jagielski pTabs[nCoreIdx+TAB_GAP].nPos+Ruler::GetNullOffset()==nMaxRight)
2525*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() = pRuler_Imp->lMaxRightLogic-lLogicNullOffset;
2526*b1cdbd2cSJim Jagielski else
2527*b1cdbd2cSJim Jagielski {
2528*b1cdbd2cSJim Jagielski if(bRTL)
2529*b1cdbd2cSJim Jagielski {
2530*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
2531*b1cdbd2cSJim Jagielski const long nTmpLeftIndent = pRuler_Imp->bIsTabsRelativeToIndent ?
2532*b1cdbd2cSJim Jagielski GetLeftIndent() :
2533*b1cdbd2cSJim Jagielski ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset );
2534*b1cdbd2cSJim Jagielski
2535*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() = PixelHAdjust(
2536*b1cdbd2cSJim Jagielski ConvertHPosLogic( nTmpLeftIndent - pTabs[nCoreIdx+TAB_GAP].nPos) - lAppNullOffset,
2537*b1cdbd2cSJim Jagielski aTabStop.GetTabPos());
2538*b1cdbd2cSJim Jagielski }
2539*b1cdbd2cSJim Jagielski else
2540*b1cdbd2cSJim Jagielski {
2541*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
2542*b1cdbd2cSJim Jagielski const long nTmpLeftIndent = pRuler_Imp->bIsTabsRelativeToIndent ?
2543*b1cdbd2cSJim Jagielski GetLeftIndent() :
2544*b1cdbd2cSJim Jagielski 0;
2545*b1cdbd2cSJim Jagielski
2546*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() = PixelHAdjust(
2547*b1cdbd2cSJim Jagielski ConvertHPosLogic( pTabs[nCoreIdx+TAB_GAP].nPos - nTmpLeftIndent ) - lAppNullOffset,
2548*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() );
2549*b1cdbd2cSJim Jagielski }
2550*b1cdbd2cSJim Jagielski }
2551*b1cdbd2cSJim Jagielski pTabStopItem->Remove(nCoreIdx);
2552*b1cdbd2cSJim Jagielski pTabStopItem->Insert(aTabStop);
2553*b1cdbd2cSJim Jagielski }
2554*b1cdbd2cSJim Jagielski sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
2555*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( nTabStopId, SFX_CALLMODE_RECORD, pTabStopItem, 0L );
2556*b1cdbd2cSJim Jagielski UpdateTabs();
2557*b1cdbd2cSJim Jagielski }
2558*b1cdbd2cSJim Jagielski
2559*b1cdbd2cSJim Jagielski
ApplyBorders()2560*b1cdbd2cSJim Jagielski void SvxRuler::ApplyBorders()
2561*b1cdbd2cSJim Jagielski /*
2562*b1cdbd2cSJim Jagielski [Beschreibung]
2563*b1cdbd2cSJim Jagielski
2564*b1cdbd2cSJim Jagielski Anwenden von (Tabellen-)Spalteneinstellungen; durch Draggen veraendert.
2565*b1cdbd2cSJim Jagielski
2566*b1cdbd2cSJim Jagielski */
2567*b1cdbd2cSJim Jagielski {
2568*b1cdbd2cSJim Jagielski if(pColumnItem->IsTable())
2569*b1cdbd2cSJim Jagielski {
2570*b1cdbd2cSJim Jagielski long l = GetFrameLeft();
2571*b1cdbd2cSJim Jagielski if(l != pRuler_Imp->nColLeftPix)
2572*b1cdbd2cSJim Jagielski pColumnItem->SetLeft( PixelHAdjust(
2573*b1cdbd2cSJim Jagielski ConvertHPosLogic(l) - lAppNullOffset, pColumnItem->GetLeft()));
2574*b1cdbd2cSJim Jagielski l = GetMargin2();
2575*b1cdbd2cSJim Jagielski if(l != pRuler_Imp->nColRightPix)
2576*b1cdbd2cSJim Jagielski {
2577*b1cdbd2cSJim Jagielski long nWidthOrHeight = bHorz ? pPagePosItem->GetWidth() : pPagePosItem->GetHeight();
2578*b1cdbd2cSJim Jagielski pColumnItem->SetRight( PixelHAdjust( nWidthOrHeight -
2579*b1cdbd2cSJim Jagielski pColumnItem->GetLeft() - ConvertHPosLogic(l) -
2580*b1cdbd2cSJim Jagielski lAppNullOffset, pColumnItem->GetRight() ) );
2581*b1cdbd2cSJim Jagielski }
2582*b1cdbd2cSJim Jagielski }
2583*b1cdbd2cSJim Jagielski for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
2584*b1cdbd2cSJim Jagielski {
2585*b1cdbd2cSJim Jagielski long& nEnd = (*pColumnItem)[i].nEnd;
2586*b1cdbd2cSJim Jagielski nEnd = PIXEL_H_ADJUST(
2587*b1cdbd2cSJim Jagielski ConvertPosLogic(pBorders[i].nPos),
2588*b1cdbd2cSJim Jagielski (*pColumnItem)[i].nEnd);
2589*b1cdbd2cSJim Jagielski long& nStart = (*pColumnItem)[i+1].nStart;
2590*b1cdbd2cSJim Jagielski nStart = PIXEL_H_ADJUST(
2591*b1cdbd2cSJim Jagielski ConvertSizeLogic(pBorders[i].nPos +
2592*b1cdbd2cSJim Jagielski pBorders[i].nWidth) -
2593*b1cdbd2cSJim Jagielski lAppNullOffset,
2594*b1cdbd2cSJim Jagielski (*pColumnItem)[i+1].nStart);
2595*b1cdbd2cSJim Jagielski // Es kann sein, dass aufgrund der PIXEL_H_ADJUST rejustierung auf
2596*b1cdbd2cSJim Jagielski // alte Werte die Breite < 0 wird. Das rerejustieren wir.
2597*b1cdbd2cSJim Jagielski if( nEnd > nStart )
2598*b1cdbd2cSJim Jagielski nStart = nEnd;
2599*b1cdbd2cSJim Jagielski }
2600*b1cdbd2cSJim Jagielski #ifdef DEBUGLIN
2601*b1cdbd2cSJim Jagielski Debug_Impl(pEditWin,*pColumnItem);
2602*b1cdbd2cSJim Jagielski #endif // DEBUGLIN
2603*b1cdbd2cSJim Jagielski SfxBoolItem aFlag(SID_RULER_ACT_LINE_ONLY,
2604*b1cdbd2cSJim Jagielski nDragType & DRAG_OBJECT_ACTLINE_ONLY? sal_True : sal_False);
2605*b1cdbd2cSJim Jagielski sal_uInt16 nColId = pRuler_Imp->bIsTableRows ? (bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL) :
2606*b1cdbd2cSJim Jagielski (bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
2607*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( nColId, SFX_CALLMODE_RECORD, pColumnItem, &aFlag, 0L );
2608*b1cdbd2cSJim Jagielski }
2609*b1cdbd2cSJim Jagielski
ApplyObject()2610*b1cdbd2cSJim Jagielski void SvxRuler::ApplyObject()
2611*b1cdbd2cSJim Jagielski /*
2612*b1cdbd2cSJim Jagielski [Beschreibung]
2613*b1cdbd2cSJim Jagielski
2614*b1cdbd2cSJim Jagielski Anwenden von Objekteinstellungen; durch Draggen veraendert.
2615*b1cdbd2cSJim Jagielski
2616*b1cdbd2cSJim Jagielski */
2617*b1cdbd2cSJim Jagielski {
2618*b1cdbd2cSJim Jagielski // zum Seitenrand
2619*b1cdbd2cSJim Jagielski long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
2620*b1cdbd2cSJim Jagielski pObjectItem->SetStartX(
2621*b1cdbd2cSJim Jagielski PixelAdjust(
2622*b1cdbd2cSJim Jagielski ConvertPosLogic(pObjectBorders[0].nPos)
2623*b1cdbd2cSJim Jagielski + nMargin - lAppNullOffset,pObjectItem->GetStartX()));
2624*b1cdbd2cSJim Jagielski pObjectItem->SetEndX(
2625*b1cdbd2cSJim Jagielski PixelAdjust(
2626*b1cdbd2cSJim Jagielski ConvertPosLogic(pObjectBorders[1].nPos)
2627*b1cdbd2cSJim Jagielski + nMargin - lAppNullOffset,pObjectItem->GetEndX()));
2628*b1cdbd2cSJim Jagielski nMargin = pULSpaceItem? pULSpaceItem->GetUpper(): 0;
2629*b1cdbd2cSJim Jagielski pObjectItem->SetStartY(
2630*b1cdbd2cSJim Jagielski PixelAdjust(
2631*b1cdbd2cSJim Jagielski ConvertPosLogic(pObjectBorders[2].nPos)
2632*b1cdbd2cSJim Jagielski + nMargin - lAppNullOffset,pObjectItem->GetStartY()));
2633*b1cdbd2cSJim Jagielski pObjectItem->SetEndY(
2634*b1cdbd2cSJim Jagielski PixelAdjust(
2635*b1cdbd2cSJim Jagielski ConvertPosLogic(pObjectBorders[3].nPos)
2636*b1cdbd2cSJim Jagielski + nMargin - lAppNullOffset,pObjectItem->GetEndY()));
2637*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( SID_RULER_OBJECT, SFX_CALLMODE_RECORD, pObjectItem, 0L );
2638*b1cdbd2cSJim Jagielski }
2639*b1cdbd2cSJim Jagielski
PrepareProportional_Impl(RulerType eType)2640*b1cdbd2cSJim Jagielski void SvxRuler::PrepareProportional_Impl(RulerType eType)
2641*b1cdbd2cSJim Jagielski /*
2642*b1cdbd2cSJim Jagielski [Beschreibung]
2643*b1cdbd2cSJim Jagielski
2644*b1cdbd2cSJim Jagielski Vorbereitung proportionales Draggen; es wird der proportionale
2645*b1cdbd2cSJim Jagielski Anteil bezogen auf die Gesamtbreite in Promille berechnet.
2646*b1cdbd2cSJim Jagielski
2647*b1cdbd2cSJim Jagielski */
2648*b1cdbd2cSJim Jagielski {
2649*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist = GetMargin2();
2650*b1cdbd2cSJim Jagielski switch((int)eType)
2651*b1cdbd2cSJim Jagielski {
2652*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2:
2653*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1:
2654*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER:
2655*b1cdbd2cSJim Jagielski {
2656*b1cdbd2cSJim Jagielski DBG_ASSERT(pColumnItem, "kein ColumnItem");
2657*b1cdbd2cSJim Jagielski
2658*b1cdbd2cSJim Jagielski pRuler_Imp->SetPercSize(pColumnItem->Count());
2659*b1cdbd2cSJim Jagielski
2660*b1cdbd2cSJim Jagielski long lPos;
2661*b1cdbd2cSJim Jagielski long lWidth=0;
2662*b1cdbd2cSJim Jagielski sal_uInt16 nStart;
2663*b1cdbd2cSJim Jagielski sal_uInt16 nIdx=GetDragAryPos();
2664*b1cdbd2cSJim Jagielski lWidth=0;
2665*b1cdbd2cSJim Jagielski long lActWidth=0;
2666*b1cdbd2cSJim Jagielski long lActBorderSum;
2667*b1cdbd2cSJim Jagielski long lOrigLPos;
2668*b1cdbd2cSJim Jagielski
2669*b1cdbd2cSJim Jagielski if(eType != RULER_TYPE_BORDER)
2670*b1cdbd2cSJim Jagielski {
2671*b1cdbd2cSJim Jagielski lOrigLPos = GetMargin1();
2672*b1cdbd2cSJim Jagielski nStart = 0;
2673*b1cdbd2cSJim Jagielski lActBorderSum = 0;
2674*b1cdbd2cSJim Jagielski }
2675*b1cdbd2cSJim Jagielski else
2676*b1cdbd2cSJim Jagielski {
2677*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows &&!bHorz)
2678*b1cdbd2cSJim Jagielski {
2679*b1cdbd2cSJim Jagielski lOrigLPos = GetMargin1();
2680*b1cdbd2cSJim Jagielski nStart = 0;
2681*b1cdbd2cSJim Jagielski }
2682*b1cdbd2cSJim Jagielski else
2683*b1cdbd2cSJim Jagielski {
2684*b1cdbd2cSJim Jagielski lOrigLPos = pBorders[nIdx].nPos + pBorders[nIdx].nWidth;
2685*b1cdbd2cSJim Jagielski nStart = 1;
2686*b1cdbd2cSJim Jagielski }
2687*b1cdbd2cSJim Jagielski lActBorderSum = pBorders[nIdx].nWidth;
2688*b1cdbd2cSJim Jagielski }
2689*b1cdbd2cSJim Jagielski
2690*b1cdbd2cSJim Jagielski //in horizontal mode the percentage value has to be
2691*b1cdbd2cSJim Jagielski //calculated on a "current change" position base
2692*b1cdbd2cSJim Jagielski //because the height of the table changes while dragging
2693*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows && RULER_TYPE_BORDER == eType)
2694*b1cdbd2cSJim Jagielski {
2695*b1cdbd2cSJim Jagielski sal_uInt16 nStartBorder;
2696*b1cdbd2cSJim Jagielski sal_uInt16 nEndBorder;
2697*b1cdbd2cSJim Jagielski if(bHorz)
2698*b1cdbd2cSJim Jagielski {
2699*b1cdbd2cSJim Jagielski nStartBorder = nIdx + 1;
2700*b1cdbd2cSJim Jagielski nEndBorder = pColumnItem->Count() - 1;
2701*b1cdbd2cSJim Jagielski }
2702*b1cdbd2cSJim Jagielski else
2703*b1cdbd2cSJim Jagielski {
2704*b1cdbd2cSJim Jagielski nStartBorder = 0;
2705*b1cdbd2cSJim Jagielski nEndBorder = nIdx;
2706*b1cdbd2cSJim Jagielski }
2707*b1cdbd2cSJim Jagielski
2708*b1cdbd2cSJim Jagielski lWidth = pBorders[nIdx].nPos;
2709*b1cdbd2cSJim Jagielski if(bHorz)
2710*b1cdbd2cSJim Jagielski lWidth = GetMargin2() - lWidth;
2711*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist = lWidth;
2712*b1cdbd2cSJim Jagielski lPos = lOrigLPos = pBorders[nIdx].nPos;
2713*b1cdbd2cSJim Jagielski
2714*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nStartBorder; i < nEndBorder; ++i)
2715*b1cdbd2cSJim Jagielski {
2716*b1cdbd2cSJim Jagielski if(bHorz)
2717*b1cdbd2cSJim Jagielski {
2718*b1cdbd2cSJim Jagielski lActWidth += pBorders[i].nPos - lPos;
2719*b1cdbd2cSJim Jagielski lPos = pBorders[i].nPos + pBorders[i].nWidth;
2720*b1cdbd2cSJim Jagielski }
2721*b1cdbd2cSJim Jagielski else
2722*b1cdbd2cSJim Jagielski lActWidth = pBorders[i].nPos;
2723*b1cdbd2cSJim Jagielski pRuler_Imp->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
2724*b1cdbd2cSJim Jagielski / pRuler_Imp->nTotalDist);
2725*b1cdbd2cSJim Jagielski pRuler_Imp->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
2726*b1cdbd2cSJim Jagielski lActBorderSum += pBorders[i].nWidth;
2727*b1cdbd2cSJim Jagielski }
2728*b1cdbd2cSJim Jagielski }
2729*b1cdbd2cSJim Jagielski else
2730*b1cdbd2cSJim Jagielski {
2731*b1cdbd2cSJim Jagielski lPos = lOrigLPos;
2732*b1cdbd2cSJim Jagielski for(sal_uInt16 ii = nStart; ii < pColumnItem->Count() - 1; ++ii)
2733*b1cdbd2cSJim Jagielski {
2734*b1cdbd2cSJim Jagielski lWidth += pBorders[ii].nPos - lPos;
2735*b1cdbd2cSJim Jagielski lPos = pBorders[ii].nPos + pBorders[ii].nWidth;
2736*b1cdbd2cSJim Jagielski }
2737*b1cdbd2cSJim Jagielski
2738*b1cdbd2cSJim Jagielski lWidth += GetMargin2() - lPos;
2739*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist = lWidth;
2740*b1cdbd2cSJim Jagielski lPos = lOrigLPos;
2741*b1cdbd2cSJim Jagielski
2742*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nStart; i < pColumnItem->Count() - 1; ++i)
2743*b1cdbd2cSJim Jagielski {
2744*b1cdbd2cSJim Jagielski lActWidth += pBorders[i].nPos - lPos;
2745*b1cdbd2cSJim Jagielski lPos = pBorders[i].nPos + pBorders[i].nWidth;
2746*b1cdbd2cSJim Jagielski pRuler_Imp->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
2747*b1cdbd2cSJim Jagielski / pRuler_Imp->nTotalDist);
2748*b1cdbd2cSJim Jagielski pRuler_Imp->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
2749*b1cdbd2cSJim Jagielski lActBorderSum += pBorders[i].nWidth;
2750*b1cdbd2cSJim Jagielski }
2751*b1cdbd2cSJim Jagielski }
2752*b1cdbd2cSJim Jagielski }
2753*b1cdbd2cSJim Jagielski break;
2754*b1cdbd2cSJim Jagielski case RULER_TYPE_TAB:
2755*b1cdbd2cSJim Jagielski {
2756*b1cdbd2cSJim Jagielski const sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
2757*b1cdbd2cSJim Jagielski pRuler_Imp->nTotalDist -= pTabs[nIdx].nPos;
2758*b1cdbd2cSJim Jagielski pRuler_Imp->SetPercSize(nTabCount);
2759*b1cdbd2cSJim Jagielski for(sal_uInt16 n=0;n<=nIdx;pRuler_Imp->pPercBuf[n++]=0) ;
2760*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
2761*b1cdbd2cSJim Jagielski {
2762*b1cdbd2cSJim Jagielski const long nDelta = pTabs[i].nPos - pTabs[nIdx].nPos;
2763*b1cdbd2cSJim Jagielski pRuler_Imp->pPercBuf[i] = (sal_uInt16)((nDelta * 1000) / pRuler_Imp->nTotalDist);
2764*b1cdbd2cSJim Jagielski }
2765*b1cdbd2cSJim Jagielski break;
2766*b1cdbd2cSJim Jagielski }
2767*b1cdbd2cSJim Jagielski }
2768*b1cdbd2cSJim Jagielski }
2769*b1cdbd2cSJim Jagielski
2770*b1cdbd2cSJim Jagielski
EvalModifier()2771*b1cdbd2cSJim Jagielski void SvxRuler::EvalModifier()
2772*b1cdbd2cSJim Jagielski
2773*b1cdbd2cSJim Jagielski /*
2774*b1cdbd2cSJim Jagielski [Beschreibung]
2775*b1cdbd2cSJim Jagielski
2776*b1cdbd2cSJim Jagielski Modifier Draggen auswerten
2777*b1cdbd2cSJim Jagielski
2778*b1cdbd2cSJim Jagielski Shift: Linear verschieben
2779*b1cdbd2cSJim Jagielski Control: Proportional verschieben
2780*b1cdbd2cSJim Jagielski Shift+Control: Tabelle: nur aktuelle Zeile
2781*b1cdbd2cSJim Jagielski alt: Bemassungspfeile (n.i.) //!!
2782*b1cdbd2cSJim Jagielski
2783*b1cdbd2cSJim Jagielski */
2784*b1cdbd2cSJim Jagielski
2785*b1cdbd2cSJim Jagielski {
2786*b1cdbd2cSJim Jagielski sal_uInt16 nModifier = GetDragModifier();
2787*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows)
2788*b1cdbd2cSJim Jagielski {
2789*b1cdbd2cSJim Jagielski //rows can only be moved in one way, additionally current column is possible
2790*b1cdbd2cSJim Jagielski if(nModifier == KEY_SHIFT)
2791*b1cdbd2cSJim Jagielski nModifier = 0;
2792*b1cdbd2cSJim Jagielski }
2793*b1cdbd2cSJim Jagielski switch(nModifier)
2794*b1cdbd2cSJim Jagielski {
2795*b1cdbd2cSJim Jagielski case KEY_SHIFT:
2796*b1cdbd2cSJim Jagielski nDragType = DRAG_OBJECT_SIZE_LINEAR;
2797*b1cdbd2cSJim Jagielski break;
2798*b1cdbd2cSJim Jagielski case KEY_MOD1: {
2799*b1cdbd2cSJim Jagielski const RulerType eType = GetDragType();
2800*b1cdbd2cSJim Jagielski nDragType = DRAG_OBJECT_SIZE_PROPORTIONAL;
2801*b1cdbd2cSJim Jagielski if( RULER_TYPE_TAB == eType ||
2802*b1cdbd2cSJim Jagielski ( ( RULER_TYPE_BORDER == eType || RULER_TYPE_MARGIN1 == eType || RULER_TYPE_MARGIN2 == eType) &&
2803*b1cdbd2cSJim Jagielski pColumnItem ) )
2804*b1cdbd2cSJim Jagielski PrepareProportional_Impl(eType);
2805*b1cdbd2cSJim Jagielski break;
2806*b1cdbd2cSJim Jagielski }
2807*b1cdbd2cSJim Jagielski case KEY_MOD1 | KEY_SHIFT:
2808*b1cdbd2cSJim Jagielski if(GetDragType()!=RULER_TYPE_MARGIN1&&
2809*b1cdbd2cSJim Jagielski GetDragType()!=RULER_TYPE_MARGIN2)
2810*b1cdbd2cSJim Jagielski nDragType = DRAG_OBJECT_ACTLINE_ONLY;
2811*b1cdbd2cSJim Jagielski break;
2812*b1cdbd2cSJim Jagielski // alt: Bemassungspfeile
2813*b1cdbd2cSJim Jagielski }
2814*b1cdbd2cSJim Jagielski }
2815*b1cdbd2cSJim Jagielski
2816*b1cdbd2cSJim Jagielski
Click()2817*b1cdbd2cSJim Jagielski void __EXPORT SvxRuler::Click()
2818*b1cdbd2cSJim Jagielski
2819*b1cdbd2cSJim Jagielski /*
2820*b1cdbd2cSJim Jagielski [Beschreibung]
2821*b1cdbd2cSJim Jagielski
2822*b1cdbd2cSJim Jagielski Ueberladener Handler SV; setzt Tab per Dispatcheraufruf
2823*b1cdbd2cSJim Jagielski
2824*b1cdbd2cSJim Jagielski */
2825*b1cdbd2cSJim Jagielski
2826*b1cdbd2cSJim Jagielski {
2827*b1cdbd2cSJim Jagielski lcl_logRulerUse(::rtl::OUString::createFromAscii(".special://SfxRuler/Click"));
2828*b1cdbd2cSJim Jagielski Ruler::Click();
2829*b1cdbd2cSJim Jagielski if( bActive )
2830*b1cdbd2cSJim Jagielski {
2831*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_LR_MIN_MAX );
2832*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_ULSPACE );
2833*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_LONG_LRSPACE );
2834*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PAGE_POS );
2835*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
2836*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
2837*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
2838*b1cdbd2cSJim Jagielski pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
2839*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_OBJECT );
2840*b1cdbd2cSJim Jagielski pBindings->Update( SID_RULER_PROTECT );
2841*b1cdbd2cSJim Jagielski pBindings->Update( SID_ATTR_PARA_LRSPACE_VERTICAL );
2842*b1cdbd2cSJim Jagielski }
2843*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2844*b1cdbd2cSJim Jagielski if(pTabStopItem &&
2845*b1cdbd2cSJim Jagielski (nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS)
2846*b1cdbd2cSJim Jagielski {
2847*b1cdbd2cSJim Jagielski sal_Bool bContentProtected = pRuler_Imp->aProtectItem.IsCntntProtected();
2848*b1cdbd2cSJim Jagielski if( bContentProtected ) return;
2849*b1cdbd2cSJim Jagielski const long lPos = GetClickPos();
2850*b1cdbd2cSJim Jagielski if((bRTL && lPos < Min(GetFirstLineIndent(), GetLeftIndent()) && lPos > GetRightIndent()) ||
2851*b1cdbd2cSJim Jagielski (!bRTL && lPos > Min(GetFirstLineIndent(), GetLeftIndent()) && lPos < GetRightIndent()))
2852*b1cdbd2cSJim Jagielski {
2853*b1cdbd2cSJim Jagielski //convert position in left-to-right text
2854*b1cdbd2cSJim Jagielski long nTabPos;
2855*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
2856*b1cdbd2cSJim Jagielski if(bRTL)
2857*b1cdbd2cSJim Jagielski nTabPos = ( pRuler_Imp->bIsTabsRelativeToIndent ?
2858*b1cdbd2cSJim Jagielski GetLeftIndent() :
2859*b1cdbd2cSJim Jagielski ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ) ) -
2860*b1cdbd2cSJim Jagielski lPos;
2861*b1cdbd2cSJim Jagielski else
2862*b1cdbd2cSJim Jagielski nTabPos = lPos -
2863*b1cdbd2cSJim Jagielski ( pRuler_Imp->bIsTabsRelativeToIndent ?
2864*b1cdbd2cSJim Jagielski GetLeftIndent() :
2865*b1cdbd2cSJim Jagielski 0 );
2866*b1cdbd2cSJim Jagielski
2867*b1cdbd2cSJim Jagielski SvxTabStop aTabStop(ConvertHPosLogic(nTabPos),
2868*b1cdbd2cSJim Jagielski ToAttrTab_Impl(nDefTabType));
2869*b1cdbd2cSJim Jagielski pTabStopItem->Insert(aTabStop);
2870*b1cdbd2cSJim Jagielski UpdateTabs();
2871*b1cdbd2cSJim Jagielski }
2872*b1cdbd2cSJim Jagielski }
2873*b1cdbd2cSJim Jagielski }
2874*b1cdbd2cSJim Jagielski
2875*b1cdbd2cSJim Jagielski
CalcLimits(long & nMax1,long & nMax2,sal_Bool) const2876*b1cdbd2cSJim Jagielski sal_Bool SvxRuler::CalcLimits
2877*b1cdbd2cSJim Jagielski (
2878*b1cdbd2cSJim Jagielski long &nMax1, // zu setzenden Minimalwert
2879*b1cdbd2cSJim Jagielski long &nMax2, // zu setzenden Maximalwert
2880*b1cdbd2cSJim Jagielski sal_Bool
2881*b1cdbd2cSJim Jagielski ) const
2882*b1cdbd2cSJim Jagielski /*
2883*b1cdbd2cSJim Jagielski [Beschreibung]
2884*b1cdbd2cSJim Jagielski
2885*b1cdbd2cSJim Jagielski Defaultimplementierung der virtuellen Funktion; kann die Applikation
2886*b1cdbd2cSJim Jagielski ueberladen, um eine eigene Grenzwertbehandlung zu implementieren.
2887*b1cdbd2cSJim Jagielski Die Werte sind auf die Seite bezogen.
2888*b1cdbd2cSJim Jagielski */
2889*b1cdbd2cSJim Jagielski {
2890*b1cdbd2cSJim Jagielski nMax1 = LONG_MIN;
2891*b1cdbd2cSJim Jagielski nMax2 = LONG_MAX;
2892*b1cdbd2cSJim Jagielski return sal_False;
2893*b1cdbd2cSJim Jagielski }
2894*b1cdbd2cSJim Jagielski
2895*b1cdbd2cSJim Jagielski
CalcMinMax()2896*b1cdbd2cSJim Jagielski void SvxRuler::CalcMinMax()
2897*b1cdbd2cSJim Jagielski
2898*b1cdbd2cSJim Jagielski /*
2899*b1cdbd2cSJim Jagielski [Beschreibung]
2900*b1cdbd2cSJim Jagielski
2901*b1cdbd2cSJim Jagielski Berechnet die Grenzwerte fuers Draggen; diese sind in Pixeln
2902*b1cdbd2cSJim Jagielski relativ zum Seitenrand
2903*b1cdbd2cSJim Jagielski
2904*b1cdbd2cSJim Jagielski */
2905*b1cdbd2cSJim Jagielski
2906*b1cdbd2cSJim Jagielski {
2907*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2908*b1cdbd2cSJim Jagielski const long lNullPix = ConvertPosPixel(lLogicNullOffset);
2909*b1cdbd2cSJim Jagielski pRuler_Imp->lMaxLeftLogic=pRuler_Imp->lMaxRightLogic=-1;
2910*b1cdbd2cSJim Jagielski switch(GetDragType())
2911*b1cdbd2cSJim Jagielski {
2912*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1:
2913*b1cdbd2cSJim Jagielski { // linker Rand umgebender Frame
2914*b1cdbd2cSJim Jagielski // DragPos - NOf zwischen links - rechts
2915*b1cdbd2cSJim Jagielski pRuler_Imp->lMaxLeftLogic = GetLeftMin();
2916*b1cdbd2cSJim Jagielski nMaxLeft=ConvertSizePixel(pRuler_Imp->lMaxLeftLogic);
2917*b1cdbd2cSJim Jagielski
2918*b1cdbd2cSJim Jagielski if(!pColumnItem || pColumnItem->Count() == 1 )
2919*b1cdbd2cSJim Jagielski {
2920*b1cdbd2cSJim Jagielski if(bRTL)
2921*b1cdbd2cSJim Jagielski {
2922*b1cdbd2cSJim Jagielski nMaxRight = lNullPix - GetRightIndent() +
2923*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent()) -
2924*b1cdbd2cSJim Jagielski lMinFrame;
2925*b1cdbd2cSJim Jagielski }
2926*b1cdbd2cSJim Jagielski else
2927*b1cdbd2cSJim Jagielski {
2928*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + GetRightIndent() -
2929*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent()) -
2930*b1cdbd2cSJim Jagielski lMinFrame;
2931*b1cdbd2cSJim Jagielski }
2932*b1cdbd2cSJim Jagielski }
2933*b1cdbd2cSJim Jagielski else if(pRuler_Imp->bIsTableRows)
2934*b1cdbd2cSJim Jagielski {
2935*b1cdbd2cSJim Jagielski //top border is not moveable when table rows are displayed
2936*b1cdbd2cSJim Jagielski // protection of content means the margin is not moveable - it's just a page break inside of a cell
2937*b1cdbd2cSJim Jagielski if(bHorz && !pRuler_Imp->aProtectItem.IsCntntProtected())
2938*b1cdbd2cSJim Jagielski {
2939*b1cdbd2cSJim Jagielski nMaxLeft = pBorders[0].nMinPos + lNullPix;
2940*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2941*b1cdbd2cSJim Jagielski nMaxRight = GetRightIndent() + lNullPix -
2942*b1cdbd2cSJim Jagielski (pColumnItem->Count() - 1 ) * lMinFrame;
2943*b1cdbd2cSJim Jagielski else
2944*b1cdbd2cSJim Jagielski nMaxRight = pBorders[0].nPos - lMinFrame + lNullPix;
2945*b1cdbd2cSJim Jagielski }
2946*b1cdbd2cSJim Jagielski else
2947*b1cdbd2cSJim Jagielski nMaxLeft = nMaxRight = lNullPix;
2948*b1cdbd2cSJim Jagielski }
2949*b1cdbd2cSJim Jagielski else
2950*b1cdbd2cSJim Jagielski {
2951*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2952*b1cdbd2cSJim Jagielski //nDragType & DRAG_OBJECT_SIZE_LINEAR)
2953*b1cdbd2cSJim Jagielski {
2954*b1cdbd2cSJim Jagielski nMaxRight=lNullPix+CalcPropMaxRight();
2955*b1cdbd2cSJim Jagielski }
2956*b1cdbd2cSJim Jagielski else if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
2957*b1cdbd2cSJim Jagielski {
2958*b1cdbd2cSJim Jagielski nMaxRight = ConvertPosPixel(
2959*b1cdbd2cSJim Jagielski GetPageWidth() - (
2960*b1cdbd2cSJim Jagielski (pColumnItem->IsTable() && pLRSpaceItem)
2961*b1cdbd2cSJim Jagielski ? pLRSpaceItem->GetRight() : 0))
2962*b1cdbd2cSJim Jagielski - GetMargin2() + GetMargin1();
2963*b1cdbd2cSJim Jagielski }
2964*b1cdbd2cSJim Jagielski else
2965*b1cdbd2cSJim Jagielski {
2966*b1cdbd2cSJim Jagielski nMaxRight = lNullPix - lMinFrame;
2967*b1cdbd2cSJim Jagielski if(pColumnItem->IsFirstAct())
2968*b1cdbd2cSJim Jagielski {
2969*b1cdbd2cSJim Jagielski if(bRTL)
2970*b1cdbd2cSJim Jagielski {
2971*b1cdbd2cSJim Jagielski nMaxRight += Min(
2972*b1cdbd2cSJim Jagielski pBorders[0].nPos,
2973*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent()) - GetRightIndent());
2974*b1cdbd2cSJim Jagielski }
2975*b1cdbd2cSJim Jagielski else
2976*b1cdbd2cSJim Jagielski {
2977*b1cdbd2cSJim Jagielski nMaxRight += Min(
2978*b1cdbd2cSJim Jagielski pBorders[0].nPos, GetRightIndent() -
2979*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent()));
2980*b1cdbd2cSJim Jagielski }
2981*b1cdbd2cSJim Jagielski }
2982*b1cdbd2cSJim Jagielski else if( pColumnItem->Count() > 1 )
2983*b1cdbd2cSJim Jagielski nMaxRight += pBorders[0].nPos;
2984*b1cdbd2cSJim Jagielski else
2985*b1cdbd2cSJim Jagielski nMaxRight +=GetRightIndent() -
2986*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent());
2987*b1cdbd2cSJim Jagielski // den linken Tabellen-Rand nicht ueber den Seitenrand ziehen
2988*b1cdbd2cSJim Jagielski if(pLRSpaceItem&&pColumnItem->IsTable())
2989*b1cdbd2cSJim Jagielski {
2990*b1cdbd2cSJim Jagielski long nTmp=ConvertSizePixel(pLRSpaceItem->GetLeft());
2991*b1cdbd2cSJim Jagielski if(nTmp>nMaxLeft)
2992*b1cdbd2cSJim Jagielski nMaxLeft=nTmp;
2993*b1cdbd2cSJim Jagielski }
2994*b1cdbd2cSJim Jagielski }
2995*b1cdbd2cSJim Jagielski }
2996*b1cdbd2cSJim Jagielski break;
2997*b1cdbd2cSJim Jagielski }
2998*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2:
2999*b1cdbd2cSJim Jagielski { // rechter Rand umgebender Frame
3000*b1cdbd2cSJim Jagielski pRuler_Imp->lMaxRightLogic =
3001*b1cdbd2cSJim Jagielski pMinMaxItem ?
3002*b1cdbd2cSJim Jagielski GetPageWidth() - GetRightMax() : GetPageWidth();
3003*b1cdbd2cSJim Jagielski nMaxRight = ConvertSizePixel(pRuler_Imp->lMaxRightLogic);
3004*b1cdbd2cSJim Jagielski
3005*b1cdbd2cSJim Jagielski
3006*b1cdbd2cSJim Jagielski if(!pColumnItem)
3007*b1cdbd2cSJim Jagielski {
3008*b1cdbd2cSJim Jagielski if(bRTL)
3009*b1cdbd2cSJim Jagielski {
3010*b1cdbd2cSJim Jagielski nMaxLeft = GetMargin2() + GetRightIndent() -
3011*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+
3012*b1cdbd2cSJim Jagielski lMinFrame + lNullPix;
3013*b1cdbd2cSJim Jagielski }
3014*b1cdbd2cSJim Jagielski else
3015*b1cdbd2cSJim Jagielski {
3016*b1cdbd2cSJim Jagielski nMaxLeft = GetMargin2() - GetRightIndent() +
3017*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+
3018*b1cdbd2cSJim Jagielski lMinFrame + lNullPix;
3019*b1cdbd2cSJim Jagielski }
3020*b1cdbd2cSJim Jagielski }
3021*b1cdbd2cSJim Jagielski else if(pRuler_Imp->bIsTableRows)
3022*b1cdbd2cSJim Jagielski {
3023*b1cdbd2cSJim Jagielski // get the bottom move range from the last border position - only available for rows!
3024*b1cdbd2cSJim Jagielski // protection of content means the margin is not moveable - it's just a page break inside of a cell
3025*b1cdbd2cSJim Jagielski if(bHorz || pRuler_Imp->aProtectItem.IsCntntProtected())
3026*b1cdbd2cSJim Jagielski {
3027*b1cdbd2cSJim Jagielski nMaxLeft = nMaxRight = pBorders[pColumnItem->Count() - 1].nMaxPos + lNullPix;
3028*b1cdbd2cSJim Jagielski }
3029*b1cdbd2cSJim Jagielski else
3030*b1cdbd2cSJim Jagielski {
3031*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
3032*b1cdbd2cSJim Jagielski {
3033*b1cdbd2cSJim Jagielski nMaxLeft = (pColumnItem->Count()) * lMinFrame + lNullPix;
3034*b1cdbd2cSJim Jagielski }
3035*b1cdbd2cSJim Jagielski else
3036*b1cdbd2cSJim Jagielski {
3037*b1cdbd2cSJim Jagielski if(pColumnItem->Count() > 1)
3038*b1cdbd2cSJim Jagielski nMaxLeft = pBorders[pColumnItem->Count() - 2].nPos + lMinFrame + lNullPix;
3039*b1cdbd2cSJim Jagielski else
3040*b1cdbd2cSJim Jagielski nMaxLeft = lMinFrame + lNullPix;
3041*b1cdbd2cSJim Jagielski }
3042*b1cdbd2cSJim Jagielski if(pColumnItem->Count() > 1)
3043*b1cdbd2cSJim Jagielski nMaxRight = pBorders[pColumnItem->Count() - 2].nMaxPos + lNullPix;
3044*b1cdbd2cSJim Jagielski else
3045*b1cdbd2cSJim Jagielski nMaxRight -= GetRightIndent() - lNullPix;
3046*b1cdbd2cSJim Jagielski }
3047*b1cdbd2cSJim Jagielski }
3048*b1cdbd2cSJim Jagielski else
3049*b1cdbd2cSJim Jagielski {
3050*b1cdbd2cSJim Jagielski nMaxLeft = lMinFrame + lNullPix;
3051*b1cdbd2cSJim Jagielski if(IsActLastColumn() || pColumnItem->Count() < 2 ) //Falls letzte Spalte aktiv
3052*b1cdbd2cSJim Jagielski {
3053*b1cdbd2cSJim Jagielski if(bRTL)
3054*b1cdbd2cSJim Jagielski {
3055*b1cdbd2cSJim Jagielski nMaxLeft = lMinFrame + lNullPix + GetMargin2() +
3056*b1cdbd2cSJim Jagielski GetRightIndent() - Max(GetFirstLineIndent(),
3057*b1cdbd2cSJim Jagielski GetLeftIndent());
3058*b1cdbd2cSJim Jagielski }
3059*b1cdbd2cSJim Jagielski else
3060*b1cdbd2cSJim Jagielski {
3061*b1cdbd2cSJim Jagielski nMaxLeft = lMinFrame + lNullPix + GetMargin2() -
3062*b1cdbd2cSJim Jagielski GetRightIndent() + Max(GetFirstLineIndent(),
3063*b1cdbd2cSJim Jagielski GetLeftIndent());
3064*b1cdbd2cSJim Jagielski }
3065*b1cdbd2cSJim Jagielski }
3066*b1cdbd2cSJim Jagielski if( pColumnItem->Count() >= 2 )
3067*b1cdbd2cSJim Jagielski {
3068*b1cdbd2cSJim Jagielski long nNewMaxLeft =
3069*b1cdbd2cSJim Jagielski lMinFrame + lNullPix +
3070*b1cdbd2cSJim Jagielski pBorders[pColumnItem->Count()-2].nPos +
3071*b1cdbd2cSJim Jagielski pBorders[pColumnItem->Count()-2].nWidth;
3072*b1cdbd2cSJim Jagielski nMaxLeft=Max(nMaxLeft,nNewMaxLeft);
3073*b1cdbd2cSJim Jagielski }
3074*b1cdbd2cSJim Jagielski
3075*b1cdbd2cSJim Jagielski }
3076*b1cdbd2cSJim Jagielski break;
3077*b1cdbd2cSJim Jagielski }
3078*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER:
3079*b1cdbd2cSJim Jagielski { // Tabelle, Spalten (Modifier)
3080*b1cdbd2cSJim Jagielski const sal_uInt16 nIdx = GetDragAryPos();
3081*b1cdbd2cSJim Jagielski switch(GetDragSize())
3082*b1cdbd2cSJim Jagielski {
3083*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_1 :
3084*b1cdbd2cSJim Jagielski {
3085*b1cdbd2cSJim Jagielski nMaxRight = pBorders[nIdx].nPos +
3086*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth + lNullPix;
3087*b1cdbd2cSJim Jagielski
3088*b1cdbd2cSJim Jagielski if(0 == nIdx)
3089*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix;
3090*b1cdbd2cSJim Jagielski else
3091*b1cdbd2cSJim Jagielski nMaxLeft = pBorders[nIdx-1].nPos +
3092*b1cdbd2cSJim Jagielski pBorders[nIdx-1].nWidth + lNullPix;
3093*b1cdbd2cSJim Jagielski if(nIdx == pColumnItem->GetActColumn())
3094*b1cdbd2cSJim Jagielski {
3095*b1cdbd2cSJim Jagielski if(bRTL)
3096*b1cdbd2cSJim Jagielski {
3097*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[nIdx].nPos +
3098*b1cdbd2cSJim Jagielski GetRightIndent() - Max(GetFirstLineIndent(),
3099*b1cdbd2cSJim Jagielski GetLeftIndent());
3100*b1cdbd2cSJim Jagielski }
3101*b1cdbd2cSJim Jagielski else
3102*b1cdbd2cSJim Jagielski {
3103*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[nIdx].nPos -
3104*b1cdbd2cSJim Jagielski GetRightIndent() + Max(GetFirstLineIndent(),
3105*b1cdbd2cSJim Jagielski GetLeftIndent());
3106*b1cdbd2cSJim Jagielski }
3107*b1cdbd2cSJim Jagielski if(0 != nIdx)
3108*b1cdbd2cSJim Jagielski nMaxLeft -= pBorders[nIdx-1].nPos +
3109*b1cdbd2cSJim Jagielski pBorders[nIdx-1].nWidth;
3110*b1cdbd2cSJim Jagielski }
3111*b1cdbd2cSJim Jagielski nMaxLeft += lMinFrame;
3112*b1cdbd2cSJim Jagielski nMaxLeft += nDragOffset;
3113*b1cdbd2cSJim Jagielski break;
3114*b1cdbd2cSJim Jagielski }
3115*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_MOVE:
3116*b1cdbd2cSJim Jagielski {
3117*b1cdbd2cSJim Jagielski if(pColumnItem)
3118*b1cdbd2cSJim Jagielski {
3119*b1cdbd2cSJim Jagielski //nIdx contains the position of the currently moved item
3120*b1cdbd2cSJim Jagielski //next visible separator on the left
3121*b1cdbd2cSJim Jagielski sal_uInt16 nLeftCol=GetActLeftColumn(sal_False, nIdx);
3122*b1cdbd2cSJim Jagielski //next visible separator on the right
3123*b1cdbd2cSJim Jagielski sal_uInt16 nRightCol=GetActRightColumn(sal_False, nIdx);
3124*b1cdbd2cSJim Jagielski //next separator on the left - regardless if visible or not
3125*b1cdbd2cSJim Jagielski sal_uInt16 nActLeftCol=GetActLeftColumn();
3126*b1cdbd2cSJim Jagielski //next separator on the right - regardless if visible or not
3127*b1cdbd2cSJim Jagielski sal_uInt16 nActRightCol=GetActRightColumn();
3128*b1cdbd2cSJim Jagielski if(pColumnItem->IsTable())
3129*b1cdbd2cSJim Jagielski {
3130*b1cdbd2cSJim Jagielski if(nDragType & DRAG_OBJECT_ACTLINE_ONLY)
3131*b1cdbd2cSJim Jagielski {
3132*b1cdbd2cSJim Jagielski //the current row/column should be modified only
3133*b1cdbd2cSJim Jagielski //then the next/previous visible border position
3134*b1cdbd2cSJim Jagielski //marks the min/max positions
3135*b1cdbd2cSJim Jagielski nMaxLeft = nLeftCol == USHRT_MAX ?
3136*b1cdbd2cSJim Jagielski 0 :
3137*b1cdbd2cSJim Jagielski pBorders[nLeftCol].nPos;
3138*b1cdbd2cSJim Jagielski //rows can always be increased without a limit
3139*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows)
3140*b1cdbd2cSJim Jagielski nMaxRight = pBorders[nIdx].nMaxPos;
3141*b1cdbd2cSJim Jagielski else
3142*b1cdbd2cSJim Jagielski nMaxRight = nRightCol == USHRT_MAX ?
3143*b1cdbd2cSJim Jagielski GetMargin2():
3144*b1cdbd2cSJim Jagielski pBorders[nRightCol].nPos;
3145*b1cdbd2cSJim Jagielski nMaxLeft += lNullPix;
3146*b1cdbd2cSJim Jagielski nMaxRight += lNullPix;
3147*b1cdbd2cSJim Jagielski }
3148*b1cdbd2cSJim Jagielski else
3149*b1cdbd2cSJim Jagielski {
3150*b1cdbd2cSJim Jagielski if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType && !bHorz && pRuler_Imp->bIsTableRows)
3151*b1cdbd2cSJim Jagielski nMaxLeft = (nIdx + 1) * lMinFrame + lNullPix;
3152*b1cdbd2cSJim Jagielski else
3153*b1cdbd2cSJim Jagielski nMaxLeft = pBorders[nIdx].nMinPos + lNullPix;
3154*b1cdbd2cSJim Jagielski if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType||
3155*b1cdbd2cSJim Jagielski (DRAG_OBJECT_SIZE_LINEAR & nDragType) )
3156*b1cdbd2cSJim Jagielski {
3157*b1cdbd2cSJim Jagielski if(pRuler_Imp->bIsTableRows)
3158*b1cdbd2cSJim Jagielski {
3159*b1cdbd2cSJim Jagielski if(bHorz)
3160*b1cdbd2cSJim Jagielski nMaxRight = GetRightIndent() + lNullPix -
3161*b1cdbd2cSJim Jagielski (pColumnItem->Count() - nIdx - 1) * lMinFrame;
3162*b1cdbd2cSJim Jagielski else
3163*b1cdbd2cSJim Jagielski nMaxRight = pBorders[nIdx].nMaxPos + lNullPix;
3164*b1cdbd2cSJim Jagielski }
3165*b1cdbd2cSJim Jagielski else
3166*b1cdbd2cSJim Jagielski nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
3167*b1cdbd2cSJim Jagielski }
3168*b1cdbd2cSJim Jagielski else
3169*b1cdbd2cSJim Jagielski nMaxRight = pBorders[nIdx].nMaxPos + lNullPix;
3170*b1cdbd2cSJim Jagielski }
3171*b1cdbd2cSJim Jagielski nMaxLeft += lMinFrame;
3172*b1cdbd2cSJim Jagielski nMaxRight -= lMinFrame;
3173*b1cdbd2cSJim Jagielski
3174*b1cdbd2cSJim Jagielski }
3175*b1cdbd2cSJim Jagielski else
3176*b1cdbd2cSJim Jagielski {
3177*b1cdbd2cSJim Jagielski if(nLeftCol==USHRT_MAX)
3178*b1cdbd2cSJim Jagielski nMaxLeft=lNullPix;
3179*b1cdbd2cSJim Jagielski else
3180*b1cdbd2cSJim Jagielski nMaxLeft = pBorders[nLeftCol].nPos +
3181*b1cdbd2cSJim Jagielski pBorders[nLeftCol].nWidth + lNullPix;
3182*b1cdbd2cSJim Jagielski
3183*b1cdbd2cSJim Jagielski if(nActRightCol == nIdx)
3184*b1cdbd2cSJim Jagielski {
3185*b1cdbd2cSJim Jagielski if(bRTL)
3186*b1cdbd2cSJim Jagielski {
3187*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[nIdx].nPos +
3188*b1cdbd2cSJim Jagielski GetRightIndent() - Max(GetFirstLineIndent(),
3189*b1cdbd2cSJim Jagielski GetLeftIndent());
3190*b1cdbd2cSJim Jagielski if(nActLeftCol!=USHRT_MAX)
3191*b1cdbd2cSJim Jagielski nMaxLeft -= pBorders[nActLeftCol].nPos +
3192*b1cdbd2cSJim Jagielski pBorders[nActLeftCol].nWidth;
3193*b1cdbd2cSJim Jagielski }
3194*b1cdbd2cSJim Jagielski else
3195*b1cdbd2cSJim Jagielski {
3196*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[nIdx].nPos -
3197*b1cdbd2cSJim Jagielski GetRightIndent() + Max(GetFirstLineIndent(),
3198*b1cdbd2cSJim Jagielski GetLeftIndent());
3199*b1cdbd2cSJim Jagielski if(nActLeftCol!=USHRT_MAX)
3200*b1cdbd2cSJim Jagielski nMaxLeft -= pBorders[nActLeftCol].nPos +
3201*b1cdbd2cSJim Jagielski pBorders[nActLeftCol].nWidth;
3202*b1cdbd2cSJim Jagielski }
3203*b1cdbd2cSJim Jagielski }
3204*b1cdbd2cSJim Jagielski nMaxLeft += lMinFrame;
3205*b1cdbd2cSJim Jagielski nMaxLeft += nDragOffset;
3206*b1cdbd2cSJim Jagielski
3207*b1cdbd2cSJim Jagielski // nMaxRight
3208*b1cdbd2cSJim Jagielski // linear / proprotional verschieben
3209*b1cdbd2cSJim Jagielski if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType||
3210*b1cdbd2cSJim Jagielski (DRAG_OBJECT_SIZE_LINEAR & nDragType) )
3211*b1cdbd2cSJim Jagielski {
3212*b1cdbd2cSJim Jagielski nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
3213*b1cdbd2cSJim Jagielski }
3214*b1cdbd2cSJim Jagielski else if(DRAG_OBJECT_SIZE_LINEAR & nDragType)
3215*b1cdbd2cSJim Jagielski {
3216*b1cdbd2cSJim Jagielski nMaxRight=lNullPix+GetMargin2()-GetMargin1()+
3217*b1cdbd2cSJim Jagielski (nBorderCount-nIdx-1)*lMinFrame;
3218*b1cdbd2cSJim Jagielski }
3219*b1cdbd2cSJim Jagielski else
3220*b1cdbd2cSJim Jagielski {
3221*b1cdbd2cSJim Jagielski if(nRightCol==USHRT_MAX)
3222*b1cdbd2cSJim Jagielski { // letzte Spalte
3223*b1cdbd2cSJim Jagielski nMaxRight = GetMargin2() + lNullPix;
3224*b1cdbd2cSJim Jagielski if(IsActLastColumn())
3225*b1cdbd2cSJim Jagielski {
3226*b1cdbd2cSJim Jagielski if(bRTL)
3227*b1cdbd2cSJim Jagielski {
3228*b1cdbd2cSJim Jagielski nMaxRight -=
3229*b1cdbd2cSJim Jagielski GetMargin2() + GetRightIndent() -
3230*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3231*b1cdbd2cSJim Jagielski GetLeftIndent());
3232*b1cdbd2cSJim Jagielski }
3233*b1cdbd2cSJim Jagielski else
3234*b1cdbd2cSJim Jagielski {
3235*b1cdbd2cSJim Jagielski nMaxRight -=
3236*b1cdbd2cSJim Jagielski GetMargin2() - GetRightIndent() +
3237*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3238*b1cdbd2cSJim Jagielski GetLeftIndent());
3239*b1cdbd2cSJim Jagielski }
3240*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nIdx].nPos +
3241*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth;
3242*b1cdbd2cSJim Jagielski }
3243*b1cdbd2cSJim Jagielski }
3244*b1cdbd2cSJim Jagielski else
3245*b1cdbd2cSJim Jagielski {
3246*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + pBorders[nRightCol].nPos;
3247*b1cdbd2cSJim Jagielski sal_uInt16 nNotHiddenRightCol =
3248*b1cdbd2cSJim Jagielski GetActRightColumn(sal_True, nIdx);
3249*b1cdbd2cSJim Jagielski
3250*b1cdbd2cSJim Jagielski if( nActLeftCol == nIdx )
3251*b1cdbd2cSJim Jagielski {
3252*b1cdbd2cSJim Jagielski long nBorder = nNotHiddenRightCol ==
3253*b1cdbd2cSJim Jagielski USHRT_MAX ?
3254*b1cdbd2cSJim Jagielski GetMargin2() :
3255*b1cdbd2cSJim Jagielski pBorders[nNotHiddenRightCol].nPos;
3256*b1cdbd2cSJim Jagielski if(bRTL)
3257*b1cdbd2cSJim Jagielski {
3258*b1cdbd2cSJim Jagielski nMaxRight -= nBorder + GetRightIndent() -
3259*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3260*b1cdbd2cSJim Jagielski GetLeftIndent());
3261*b1cdbd2cSJim Jagielski }
3262*b1cdbd2cSJim Jagielski else
3263*b1cdbd2cSJim Jagielski {
3264*b1cdbd2cSJim Jagielski nMaxRight -= nBorder - GetRightIndent() +
3265*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3266*b1cdbd2cSJim Jagielski GetLeftIndent());
3267*b1cdbd2cSJim Jagielski }
3268*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nIdx].nPos +
3269*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth;
3270*b1cdbd2cSJim Jagielski }
3271*b1cdbd2cSJim Jagielski }
3272*b1cdbd2cSJim Jagielski nMaxRight -= lMinFrame;
3273*b1cdbd2cSJim Jagielski nMaxRight -= pBorders[nIdx].nWidth;
3274*b1cdbd2cSJim Jagielski }
3275*b1cdbd2cSJim Jagielski }
3276*b1cdbd2cSJim Jagielski }
3277*b1cdbd2cSJim Jagielski // ObjectItem
3278*b1cdbd2cSJim Jagielski else
3279*b1cdbd2cSJim Jagielski {
3280*b1cdbd2cSJim Jagielski if(pObjectItem->HasLimits())
3281*b1cdbd2cSJim Jagielski {
3282*b1cdbd2cSJim Jagielski if(CalcLimits(nMaxLeft, nMaxRight, nIdx & 1? sal_False : sal_True))
3283*b1cdbd2cSJim Jagielski {
3284*b1cdbd2cSJim Jagielski nMaxLeft = ConvertPosPixel(nMaxLeft);
3285*b1cdbd2cSJim Jagielski nMaxRight = ConvertPosPixel(nMaxRight);
3286*b1cdbd2cSJim Jagielski }
3287*b1cdbd2cSJim Jagielski }
3288*b1cdbd2cSJim Jagielski else
3289*b1cdbd2cSJim Jagielski {
3290*b1cdbd2cSJim Jagielski nMaxLeft = LONG_MIN;
3291*b1cdbd2cSJim Jagielski nMaxRight = LONG_MAX;
3292*b1cdbd2cSJim Jagielski }
3293*b1cdbd2cSJim Jagielski }
3294*b1cdbd2cSJim Jagielski break;
3295*b1cdbd2cSJim Jagielski }
3296*b1cdbd2cSJim Jagielski case RULER_DRAGSIZE_2:
3297*b1cdbd2cSJim Jagielski {
3298*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix + pBorders[nIdx].nPos;
3299*b1cdbd2cSJim Jagielski if(nIdx == pColumnItem->Count()-2) { // letzte Spalte
3300*b1cdbd2cSJim Jagielski nMaxRight = GetMargin2() + lNullPix;
3301*b1cdbd2cSJim Jagielski if(pColumnItem->IsLastAct()) {
3302*b1cdbd2cSJim Jagielski nMaxRight -=
3303*b1cdbd2cSJim Jagielski GetMargin2() - GetRightIndent() +
3304*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3305*b1cdbd2cSJim Jagielski GetLeftIndent());
3306*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nIdx].nPos +
3307*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth;
3308*b1cdbd2cSJim Jagielski }
3309*b1cdbd2cSJim Jagielski }
3310*b1cdbd2cSJim Jagielski else {
3311*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + pBorders[nIdx+1].nPos;
3312*b1cdbd2cSJim Jagielski if(pColumnItem->GetActColumn()-1 == nIdx) {
3313*b1cdbd2cSJim Jagielski nMaxRight -= pBorders[nIdx+1].nPos - GetRightIndent() +
3314*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(),
3315*b1cdbd2cSJim Jagielski GetLeftIndent());
3316*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nIdx].nPos +
3317*b1cdbd2cSJim Jagielski pBorders[nIdx].nWidth;
3318*b1cdbd2cSJim Jagielski }
3319*b1cdbd2cSJim Jagielski }
3320*b1cdbd2cSJim Jagielski nMaxRight -= lMinFrame;
3321*b1cdbd2cSJim Jagielski nMaxRight -= pBorders[nIdx].nWidth;
3322*b1cdbd2cSJim Jagielski break;
3323*b1cdbd2cSJim Jagielski }
3324*b1cdbd2cSJim Jagielski }
3325*b1cdbd2cSJim Jagielski nMaxRight += nDragOffset;
3326*b1cdbd2cSJim Jagielski break;
3327*b1cdbd2cSJim Jagielski }
3328*b1cdbd2cSJim Jagielski case RULER_TYPE_INDENT:
3329*b1cdbd2cSJim Jagielski {
3330*b1cdbd2cSJim Jagielski const sal_uInt16 nIdx = GetDragAryPos();
3331*b1cdbd2cSJim Jagielski switch(nIdx) {
3332*b1cdbd2cSJim Jagielski case INDENT_FIRST_LINE - INDENT_GAP:
3333*b1cdbd2cSJim Jagielski case INDENT_LEFT_MARGIN - INDENT_GAP:
3334*b1cdbd2cSJim Jagielski {
3335*b1cdbd2cSJim Jagielski if(bRTL)
3336*b1cdbd2cSJim Jagielski {
3337*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix + GetRightIndent();
3338*b1cdbd2cSJim Jagielski
3339*b1cdbd2cSJim Jagielski if(pColumnItem && !pColumnItem->IsFirstAct())
3340*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[pColumnItem->GetActColumn()-1].nPos +
3341*b1cdbd2cSJim Jagielski pBorders[pColumnItem->GetActColumn()-1].nWidth;
3342*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + GetMargin2();
3343*b1cdbd2cSJim Jagielski
3344*b1cdbd2cSJim Jagielski // zusammem draggen
3345*b1cdbd2cSJim Jagielski if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
3346*b1cdbd2cSJim Jagielski (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
3347*b1cdbd2cSJim Jagielski DRAG_OBJECT_LEFT_INDENT_ONLY)
3348*b1cdbd2cSJim Jagielski {
3349*b1cdbd2cSJim Jagielski if(GetLeftIndent() > GetFirstLineIndent())
3350*b1cdbd2cSJim Jagielski nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
3351*b1cdbd2cSJim Jagielski else
3352*b1cdbd2cSJim Jagielski nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
3353*b1cdbd2cSJim Jagielski }
3354*b1cdbd2cSJim Jagielski }
3355*b1cdbd2cSJim Jagielski else
3356*b1cdbd2cSJim Jagielski {
3357*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix;
3358*b1cdbd2cSJim Jagielski
3359*b1cdbd2cSJim Jagielski if(pColumnItem && !pColumnItem->IsFirstAct())
3360*b1cdbd2cSJim Jagielski nMaxLeft += pBorders[pColumnItem->GetActColumn()-1].nPos +
3361*b1cdbd2cSJim Jagielski pBorders[pColumnItem->GetActColumn()-1].nWidth;
3362*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + GetRightIndent() - lMinFrame;
3363*b1cdbd2cSJim Jagielski
3364*b1cdbd2cSJim Jagielski // zusammem draggen
3365*b1cdbd2cSJim Jagielski if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
3366*b1cdbd2cSJim Jagielski (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
3367*b1cdbd2cSJim Jagielski DRAG_OBJECT_LEFT_INDENT_ONLY)
3368*b1cdbd2cSJim Jagielski {
3369*b1cdbd2cSJim Jagielski if(GetLeftIndent() > GetFirstLineIndent())
3370*b1cdbd2cSJim Jagielski nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
3371*b1cdbd2cSJim Jagielski else
3372*b1cdbd2cSJim Jagielski nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
3373*b1cdbd2cSJim Jagielski }
3374*b1cdbd2cSJim Jagielski }
3375*b1cdbd2cSJim Jagielski }
3376*b1cdbd2cSJim Jagielski break;
3377*b1cdbd2cSJim Jagielski case INDENT_RIGHT_MARGIN - INDENT_GAP:
3378*b1cdbd2cSJim Jagielski {
3379*b1cdbd2cSJim Jagielski if(bRTL)
3380*b1cdbd2cSJim Jagielski {
3381*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix;
3382*b1cdbd2cSJim Jagielski nMaxRight = lNullPix + Min(GetFirstLineIndent(), GetLeftIndent()) - lMinFrame;
3383*b1cdbd2cSJim Jagielski if(pColumnItem)
3384*b1cdbd2cSJim Jagielski {
3385*b1cdbd2cSJim Jagielski sal_uInt16 nRightCol=GetActRightColumn( sal_True );
3386*b1cdbd2cSJim Jagielski if(!IsActLastColumn( sal_True ))
3387*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nRightCol].nPos;
3388*b1cdbd2cSJim Jagielski else
3389*b1cdbd2cSJim Jagielski nMaxRight += GetMargin2();
3390*b1cdbd2cSJim Jagielski }
3391*b1cdbd2cSJim Jagielski else
3392*b1cdbd2cSJim Jagielski nMaxLeft += GetMargin1();
3393*b1cdbd2cSJim Jagielski nMaxLeft += lMinFrame;
3394*b1cdbd2cSJim Jagielski }
3395*b1cdbd2cSJim Jagielski else
3396*b1cdbd2cSJim Jagielski {
3397*b1cdbd2cSJim Jagielski nMaxLeft = lNullPix +
3398*b1cdbd2cSJim Jagielski Max(GetFirstLineIndent(), GetLeftIndent());
3399*b1cdbd2cSJim Jagielski nMaxRight = lNullPix;
3400*b1cdbd2cSJim Jagielski if(pColumnItem)
3401*b1cdbd2cSJim Jagielski {
3402*b1cdbd2cSJim Jagielski sal_uInt16 nRightCol=GetActRightColumn( sal_True );
3403*b1cdbd2cSJim Jagielski if(!IsActLastColumn( sal_True ))
3404*b1cdbd2cSJim Jagielski nMaxRight += pBorders[nRightCol].nPos;
3405*b1cdbd2cSJim Jagielski else
3406*b1cdbd2cSJim Jagielski nMaxRight += GetMargin2();
3407*b1cdbd2cSJim Jagielski }
3408*b1cdbd2cSJim Jagielski else
3409*b1cdbd2cSJim Jagielski nMaxRight += GetMargin2();
3410*b1cdbd2cSJim Jagielski nMaxLeft += lMinFrame;
3411*b1cdbd2cSJim Jagielski }
3412*b1cdbd2cSJim Jagielski }
3413*b1cdbd2cSJim Jagielski break;
3414*b1cdbd2cSJim Jagielski }
3415*b1cdbd2cSJim Jagielski break;
3416*b1cdbd2cSJim Jagielski }
3417*b1cdbd2cSJim Jagielski case RULER_TYPE_TAB: // Tabs (Modifier)
3418*b1cdbd2cSJim Jagielski /*
3419*b1cdbd2cSJim Jagielski links = NOf + Max(LAR, EZ)
3420*b1cdbd2cSJim Jagielski rechts = NOf + RAR
3421*b1cdbd2cSJim Jagielski */
3422*b1cdbd2cSJim Jagielski nMaxLeft = bRTL ? lNullPix + GetRightIndent()
3423*b1cdbd2cSJim Jagielski : lNullPix + Min(GetFirstLineIndent(), GetLeftIndent());
3424*b1cdbd2cSJim Jagielski pRuler_Imp->lMaxRightLogic=GetLogicRightIndent()+lLogicNullOffset;
3425*b1cdbd2cSJim Jagielski nMaxRight = ConvertSizePixel(pRuler_Imp->lMaxRightLogic);
3426*b1cdbd2cSJim Jagielski break;
3427*b1cdbd2cSJim Jagielski default: ; //prevent warning
3428*b1cdbd2cSJim Jagielski }
3429*b1cdbd2cSJim Jagielski #ifdef DEBUGLIN
3430*b1cdbd2cSJim Jagielski {
3431*b1cdbd2cSJim Jagielski String aStr("MinLeft: ");
3432*b1cdbd2cSJim Jagielski Size aSize(nMaxLeft + lNullPix, 0);
3433*b1cdbd2cSJim Jagielski Size aSize2(nMaxRight + lNullPix, 0);
3434*b1cdbd2cSJim Jagielski aSize = pEditWin->PixelToLogic(aSize, MapMode(MAP_MM));
3435*b1cdbd2cSJim Jagielski aSize2 = pEditWin->PixelToLogic(aSize2, MapMode(MAP_MM));
3436*b1cdbd2cSJim Jagielski aStr += String(aSize.Width());
3437*b1cdbd2cSJim Jagielski aStr += " MaxRight: ";
3438*b1cdbd2cSJim Jagielski aStr += String(aSize2.Width());
3439*b1cdbd2cSJim Jagielski InfoBox(0, aStr).Execute();
3440*b1cdbd2cSJim Jagielski }
3441*b1cdbd2cSJim Jagielski #endif
3442*b1cdbd2cSJim Jagielski }
3443*b1cdbd2cSJim Jagielski
3444*b1cdbd2cSJim Jagielski
StartDrag()3445*b1cdbd2cSJim Jagielski long __EXPORT SvxRuler::StartDrag()
3446*b1cdbd2cSJim Jagielski
3447*b1cdbd2cSJim Jagielski /*
3448*b1cdbd2cSJim Jagielski [Beschreibung]
3449*b1cdbd2cSJim Jagielski
3450*b1cdbd2cSJim Jagielski Beginn eines Drag-Vorgangs (SV-Handler); wertet Modifier aus
3451*b1cdbd2cSJim Jagielski und berechnet Grenzwerte
3452*b1cdbd2cSJim Jagielski
3453*b1cdbd2cSJim Jagielski [Querverweise]
3454*b1cdbd2cSJim Jagielski
3455*b1cdbd2cSJim Jagielski <SvxRuler::EvalModifier()>
3456*b1cdbd2cSJim Jagielski <SvxRuler::CalcMinMax()>
3457*b1cdbd2cSJim Jagielski <SvxRuler::EndDrag()>
3458*b1cdbd2cSJim Jagielski
3459*b1cdbd2cSJim Jagielski */
3460*b1cdbd2cSJim Jagielski
3461*b1cdbd2cSJim Jagielski {
3462*b1cdbd2cSJim Jagielski lcl_logRulerUse(::rtl::OUString::createFromAscii(".special://SfxRuler/StartDrag"));
3463*b1cdbd2cSJim Jagielski sal_Bool bContentProtected = pRuler_Imp->aProtectItem.IsCntntProtected();
3464*b1cdbd2cSJim Jagielski if(!bValid)
3465*b1cdbd2cSJim Jagielski return sal_False;
3466*b1cdbd2cSJim Jagielski
3467*b1cdbd2cSJim Jagielski pRuler_Imp->lLastLMargin=GetMargin1();
3468*b1cdbd2cSJim Jagielski pRuler_Imp->lLastRMargin=GetMargin2();
3469*b1cdbd2cSJim Jagielski long bOk = 1;
3470*b1cdbd2cSJim Jagielski if(GetStartDragHdl().IsSet())
3471*b1cdbd2cSJim Jagielski bOk = Ruler::StartDrag();
3472*b1cdbd2cSJim Jagielski if(bOk) {
3473*b1cdbd2cSJim Jagielski lInitialDragPos = GetDragPos();
3474*b1cdbd2cSJim Jagielski switch(GetDragType()) {
3475*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1: // linker Rand umgebender Frame
3476*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2: // rechter Rand umgebender Frame
3477*b1cdbd2cSJim Jagielski if((bHorz && pLRSpaceItem) || (!bHorz && pULSpaceItem))
3478*b1cdbd2cSJim Jagielski {
3479*b1cdbd2cSJim Jagielski if(pColumnItem)
3480*b1cdbd2cSJim Jagielski EvalModifier();
3481*b1cdbd2cSJim Jagielski else
3482*b1cdbd2cSJim Jagielski nDragType = DRAG_OBJECT;
3483*b1cdbd2cSJim Jagielski }
3484*b1cdbd2cSJim Jagielski else
3485*b1cdbd2cSJim Jagielski bOk = sal_False;
3486*b1cdbd2cSJim Jagielski break;
3487*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER: // Tabelle, Spalten (Modifier)
3488*b1cdbd2cSJim Jagielski if(pColumnItem)
3489*b1cdbd2cSJim Jagielski {
3490*b1cdbd2cSJim Jagielski nDragOffset = pColumnItem->IsTable()? 0 :
3491*b1cdbd2cSJim Jagielski GetDragPos() - pBorders[GetDragAryPos()].nPos;
3492*b1cdbd2cSJim Jagielski EvalModifier();
3493*b1cdbd2cSJim Jagielski
3494*b1cdbd2cSJim Jagielski }
3495*b1cdbd2cSJim Jagielski else
3496*b1cdbd2cSJim Jagielski nDragOffset = 0;
3497*b1cdbd2cSJim Jagielski break;
3498*b1cdbd2cSJim Jagielski case RULER_TYPE_INDENT: { // Absatzeinzuege (Modifier)
3499*b1cdbd2cSJim Jagielski if( bContentProtected )
3500*b1cdbd2cSJim Jagielski return sal_False;
3501*b1cdbd2cSJim Jagielski sal_uInt16 nIndent = INDENT_LEFT_MARGIN;
3502*b1cdbd2cSJim Jagielski if((nIndent) == GetDragAryPos() + INDENT_GAP) { // Linker Absatzeinzug
3503*b1cdbd2cSJim Jagielski pIndents[0] = pIndents[INDENT_FIRST_LINE];
3504*b1cdbd2cSJim Jagielski pIndents[0].nStyle |= RULER_STYLE_DONTKNOW;
3505*b1cdbd2cSJim Jagielski EvalModifier();
3506*b1cdbd2cSJim Jagielski }
3507*b1cdbd2cSJim Jagielski else
3508*b1cdbd2cSJim Jagielski nDragType = DRAG_OBJECT;
3509*b1cdbd2cSJim Jagielski pIndents[1] = pIndents[GetDragAryPos()+INDENT_GAP];
3510*b1cdbd2cSJim Jagielski pIndents[1].nStyle |= RULER_STYLE_DONTKNOW;
3511*b1cdbd2cSJim Jagielski break;
3512*b1cdbd2cSJim Jagielski }
3513*b1cdbd2cSJim Jagielski case RULER_TYPE_TAB: // Tabs (Modifier)
3514*b1cdbd2cSJim Jagielski if( bContentProtected ) return sal_False;
3515*b1cdbd2cSJim Jagielski EvalModifier();
3516*b1cdbd2cSJim Jagielski pTabs[0] = pTabs[GetDragAryPos()+1];
3517*b1cdbd2cSJim Jagielski pTabs[0].nStyle |= RULER_STYLE_DONTKNOW;
3518*b1cdbd2cSJim Jagielski break;
3519*b1cdbd2cSJim Jagielski default:
3520*b1cdbd2cSJim Jagielski nDragType = NONE;
3521*b1cdbd2cSJim Jagielski }
3522*b1cdbd2cSJim Jagielski }
3523*b1cdbd2cSJim Jagielski else
3524*b1cdbd2cSJim Jagielski nDragType = NONE;
3525*b1cdbd2cSJim Jagielski if(bOk)
3526*b1cdbd2cSJim Jagielski CalcMinMax();
3527*b1cdbd2cSJim Jagielski return bOk;
3528*b1cdbd2cSJim Jagielski }
3529*b1cdbd2cSJim Jagielski
3530*b1cdbd2cSJim Jagielski
Drag()3531*b1cdbd2cSJim Jagielski void __EXPORT SvxRuler::Drag()
3532*b1cdbd2cSJim Jagielski /*
3533*b1cdbd2cSJim Jagielski [Beschreibung]
3534*b1cdbd2cSJim Jagielski
3535*b1cdbd2cSJim Jagielski SV-Draghandler
3536*b1cdbd2cSJim Jagielski
3537*b1cdbd2cSJim Jagielski */
3538*b1cdbd2cSJim Jagielski {
3539*b1cdbd2cSJim Jagielski if(IsDragCanceled())
3540*b1cdbd2cSJim Jagielski {
3541*b1cdbd2cSJim Jagielski Ruler::Drag();
3542*b1cdbd2cSJim Jagielski return;
3543*b1cdbd2cSJim Jagielski }
3544*b1cdbd2cSJim Jagielski switch(GetDragType()) {
3545*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1: // linker Rand umgebender Frame
3546*b1cdbd2cSJim Jagielski DragMargin1();
3547*b1cdbd2cSJim Jagielski pRuler_Imp->lLastLMargin=GetMargin1();
3548*b1cdbd2cSJim Jagielski break;
3549*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2: // rechter Rand umgebender Frame
3550*b1cdbd2cSJim Jagielski DragMargin2();
3551*b1cdbd2cSJim Jagielski pRuler_Imp->lLastRMargin = GetMargin2();
3552*b1cdbd2cSJim Jagielski break;
3553*b1cdbd2cSJim Jagielski case RULER_TYPE_INDENT: // Absatzeinzuege
3554*b1cdbd2cSJim Jagielski DragIndents();
3555*b1cdbd2cSJim Jagielski break;
3556*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER: // Tabelle, Spalten
3557*b1cdbd2cSJim Jagielski if(pColumnItem)
3558*b1cdbd2cSJim Jagielski DragBorders();
3559*b1cdbd2cSJim Jagielski else if(pObjectItem)
3560*b1cdbd2cSJim Jagielski DragObjectBorder();
3561*b1cdbd2cSJim Jagielski break;
3562*b1cdbd2cSJim Jagielski case RULER_TYPE_TAB: // Tabs
3563*b1cdbd2cSJim Jagielski DragTabs();
3564*b1cdbd2cSJim Jagielski break;
3565*b1cdbd2cSJim Jagielski default: ;//prevent warning
3566*b1cdbd2cSJim Jagielski }
3567*b1cdbd2cSJim Jagielski Ruler::Drag();
3568*b1cdbd2cSJim Jagielski }
3569*b1cdbd2cSJim Jagielski
3570*b1cdbd2cSJim Jagielski
EndDrag()3571*b1cdbd2cSJim Jagielski void __EXPORT SvxRuler::EndDrag()
3572*b1cdbd2cSJim Jagielski /*
3573*b1cdbd2cSJim Jagielski [Beschreibung]
3574*b1cdbd2cSJim Jagielski
3575*b1cdbd2cSJim Jagielski SV-Handler; wird beim Beenden des Draggens gerufen.
3576*b1cdbd2cSJim Jagielski Stoesst die Aktualisierung der Daten der Applikation an, indem
3577*b1cdbd2cSJim Jagielski durch Aufruf der jeweiligen Apply...()- Methoden die Daten an die
3578*b1cdbd2cSJim Jagielski Applikation geschickt werden.
3579*b1cdbd2cSJim Jagielski
3580*b1cdbd2cSJim Jagielski */
3581*b1cdbd2cSJim Jagielski {
3582*b1cdbd2cSJim Jagielski lcl_logRulerUse(::rtl::OUString::createFromAscii(".special://SfxRuler/EndDrag"));
3583*b1cdbd2cSJim Jagielski const sal_Bool bUndo = IsDragCanceled();
3584*b1cdbd2cSJim Jagielski const long lPos = GetDragPos();
3585*b1cdbd2cSJim Jagielski DrawLine_Impl(lTabPos, 6, bHorz);
3586*b1cdbd2cSJim Jagielski lTabPos=-1;
3587*b1cdbd2cSJim Jagielski if(!bUndo)
3588*b1cdbd2cSJim Jagielski switch(GetDragType())
3589*b1cdbd2cSJim Jagielski {
3590*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN1: // linker, oberer Rand umgebender Frame
3591*b1cdbd2cSJim Jagielski case RULER_TYPE_MARGIN2: // rechter, unterer Rand umgebender Frame
3592*b1cdbd2cSJim Jagielski {
3593*b1cdbd2cSJim Jagielski if(!pColumnItem || !pColumnItem->IsTable())
3594*b1cdbd2cSJim Jagielski ApplyMargins();
3595*b1cdbd2cSJim Jagielski
3596*b1cdbd2cSJim Jagielski if(pColumnItem &&
3597*b1cdbd2cSJim Jagielski (pColumnItem->IsTable() ||
3598*b1cdbd2cSJim Jagielski (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)))
3599*b1cdbd2cSJim Jagielski ApplyBorders();
3600*b1cdbd2cSJim Jagielski
3601*b1cdbd2cSJim Jagielski }
3602*b1cdbd2cSJim Jagielski break;
3603*b1cdbd2cSJim Jagielski case RULER_TYPE_BORDER: // Tabelle, Spalten
3604*b1cdbd2cSJim Jagielski if(lInitialDragPos != lPos ||
3605*b1cdbd2cSJim Jagielski (pRuler_Imp->bIsTableRows && bHorz)) //special case - the null offset is changed here
3606*b1cdbd2cSJim Jagielski {
3607*b1cdbd2cSJim Jagielski if(pColumnItem)
3608*b1cdbd2cSJim Jagielski {
3609*b1cdbd2cSJim Jagielski ApplyBorders();
3610*b1cdbd2cSJim Jagielski if(bHorz)
3611*b1cdbd2cSJim Jagielski UpdateTabs();
3612*b1cdbd2cSJim Jagielski }
3613*b1cdbd2cSJim Jagielski else if(pObjectItem)
3614*b1cdbd2cSJim Jagielski ApplyObject();
3615*b1cdbd2cSJim Jagielski }
3616*b1cdbd2cSJim Jagielski break;
3617*b1cdbd2cSJim Jagielski case RULER_TYPE_INDENT: // Absatzeinzuege
3618*b1cdbd2cSJim Jagielski if(lInitialDragPos != lPos)
3619*b1cdbd2cSJim Jagielski ApplyIndents();
3620*b1cdbd2cSJim Jagielski SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
3621*b1cdbd2cSJim Jagielski break;
3622*b1cdbd2cSJim Jagielski case RULER_TYPE_TAB: // Tabs
3623*b1cdbd2cSJim Jagielski {
3624*b1cdbd2cSJim Jagielski ApplyTabs();
3625*b1cdbd2cSJim Jagielski pTabs[GetDragAryPos()].nStyle &= ~RULER_STYLE_INVISIBLE;
3626*b1cdbd2cSJim Jagielski SetTabs(nTabCount, pTabs+TAB_GAP);
3627*b1cdbd2cSJim Jagielski }
3628*b1cdbd2cSJim Jagielski break;
3629*b1cdbd2cSJim Jagielski default: ; //prevent warning
3630*b1cdbd2cSJim Jagielski }
3631*b1cdbd2cSJim Jagielski nDragType = NONE;
3632*b1cdbd2cSJim Jagielski Ruler::EndDrag();
3633*b1cdbd2cSJim Jagielski if(bUndo)
3634*b1cdbd2cSJim Jagielski for(sal_uInt16 i=0;i<pRuler_Imp->nControlerItems;i++)
3635*b1cdbd2cSJim Jagielski {
3636*b1cdbd2cSJim Jagielski pCtrlItem[i]->ClearCache();
3637*b1cdbd2cSJim Jagielski pCtrlItem[i]->GetBindings().Invalidate(pCtrlItem[i]->GetId());
3638*b1cdbd2cSJim Jagielski // pCtrlItem[i]->UnBind();
3639*b1cdbd2cSJim Jagielski // pCtrlItem[i]->ReBind();
3640*b1cdbd2cSJim Jagielski }
3641*b1cdbd2cSJim Jagielski }
3642*b1cdbd2cSJim Jagielski
3643*b1cdbd2cSJim Jagielski
ExtraDown()3644*b1cdbd2cSJim Jagielski void __EXPORT SvxRuler::ExtraDown()
3645*b1cdbd2cSJim Jagielski
3646*b1cdbd2cSJim Jagielski /*
3647*b1cdbd2cSJim Jagielski [Beschreibung]
3648*b1cdbd2cSJim Jagielski
3649*b1cdbd2cSJim Jagielski Ueberladene SV-Methode; setzt den neuen Typ fuer den Defaulttabulator.
3650*b1cdbd2cSJim Jagielski */
3651*b1cdbd2cSJim Jagielski
3652*b1cdbd2cSJim Jagielski {
3653*b1cdbd2cSJim Jagielski // Tabulator Typ umschalten
3654*b1cdbd2cSJim Jagielski if(pTabStopItem &&
3655*b1cdbd2cSJim Jagielski (nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS) {
3656*b1cdbd2cSJim Jagielski ++nDefTabType;
3657*b1cdbd2cSJim Jagielski if(RULER_TAB_DEFAULT == nDefTabType)
3658*b1cdbd2cSJim Jagielski nDefTabType = RULER_TAB_LEFT;
3659*b1cdbd2cSJim Jagielski SetExtraType(RULER_EXTRA_TAB, nDefTabType);
3660*b1cdbd2cSJim Jagielski }
3661*b1cdbd2cSJim Jagielski Ruler::ExtraDown();
3662*b1cdbd2cSJim Jagielski }
3663*b1cdbd2cSJim Jagielski
3664*b1cdbd2cSJim Jagielski
Notify(SfxBroadcaster &,const SfxHint & rHint)3665*b1cdbd2cSJim Jagielski void __EXPORT SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
3666*b1cdbd2cSJim Jagielski /*
3667*b1cdbd2cSJim Jagielski
3668*b1cdbd2cSJim Jagielski [Beschreibung]
3669*b1cdbd2cSJim Jagielski
3670*b1cdbd2cSJim Jagielski Benachrichtigung durch die Bindings, dass die Statusaktualisierung
3671*b1cdbd2cSJim Jagielski beendet ist.
3672*b1cdbd2cSJim Jagielski Das Lineal aktualisiert seine Darstellung und meldet sich bei den
3673*b1cdbd2cSJim Jagielski Bindings wieder ab.
3674*b1cdbd2cSJim Jagielski
3675*b1cdbd2cSJim Jagielski */
3676*b1cdbd2cSJim Jagielski
3677*b1cdbd2cSJim Jagielski {
3678*b1cdbd2cSJim Jagielski // Aktualisierung anstossen
3679*b1cdbd2cSJim Jagielski if(bActive &&
3680*b1cdbd2cSJim Jagielski rHint.Type() == TYPE(SfxSimpleHint) &&
3681*b1cdbd2cSJim Jagielski ((SfxSimpleHint&) rHint ).GetId() == SFX_HINT_UPDATEDONE ) {
3682*b1cdbd2cSJim Jagielski Update();
3683*b1cdbd2cSJim Jagielski EndListening(*pBindings);
3684*b1cdbd2cSJim Jagielski bValid = sal_True;
3685*b1cdbd2cSJim Jagielski bListening = sal_False;
3686*b1cdbd2cSJim Jagielski }
3687*b1cdbd2cSJim Jagielski }
3688*b1cdbd2cSJim Jagielski
3689*b1cdbd2cSJim Jagielski
IMPL_LINK_INLINE_START(SvxRuler,MenuSelect,Menu *,pMenu)3690*b1cdbd2cSJim Jagielski IMPL_LINK_INLINE_START( SvxRuler, MenuSelect, Menu *, pMenu )
3691*b1cdbd2cSJim Jagielski
3692*b1cdbd2cSJim Jagielski /*
3693*b1cdbd2cSJim Jagielski [Beschreibung]
3694*b1cdbd2cSJim Jagielski
3695*b1cdbd2cSJim Jagielski Handler des Kontextmenues fuer das Umschalten der Masseinheit
3696*b1cdbd2cSJim Jagielski
3697*b1cdbd2cSJim Jagielski */
3698*b1cdbd2cSJim Jagielski
3699*b1cdbd2cSJim Jagielski {
3700*b1cdbd2cSJim Jagielski SetUnit(FieldUnit(pMenu->GetCurItemId()));
3701*b1cdbd2cSJim Jagielski return 0;
3702*b1cdbd2cSJim Jagielski }
IMPL_LINK_INLINE_END(SvxRuler,MenuSelect,Menu *,pMenu)3703*b1cdbd2cSJim Jagielski IMPL_LINK_INLINE_END( SvxRuler, MenuSelect, Menu *, pMenu )
3704*b1cdbd2cSJim Jagielski
3705*b1cdbd2cSJim Jagielski
3706*b1cdbd2cSJim Jagielski IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu )
3707*b1cdbd2cSJim Jagielski
3708*b1cdbd2cSJim Jagielski /*
3709*b1cdbd2cSJim Jagielski [Beschreibung]
3710*b1cdbd2cSJim Jagielski
3711*b1cdbd2cSJim Jagielski Handler des Tabulatormenues fuer das Setzen des Typs
3712*b1cdbd2cSJim Jagielski
3713*b1cdbd2cSJim Jagielski */
3714*b1cdbd2cSJim Jagielski
3715*b1cdbd2cSJim Jagielski {
3716*b1cdbd2cSJim Jagielski if(pTabStopItem && pTabStopItem->Count() > pRuler_Imp->nIdx)
3717*b1cdbd2cSJim Jagielski {
3718*b1cdbd2cSJim Jagielski SvxTabStop aTabStop = (*pTabStopItem)[pRuler_Imp->nIdx];
3719*b1cdbd2cSJim Jagielski aTabStop.GetAdjustment() = ToAttrTab_Impl(pMenu->GetCurItemId()-1);
3720*b1cdbd2cSJim Jagielski pTabStopItem->Remove(pRuler_Imp->nIdx);
3721*b1cdbd2cSJim Jagielski pTabStopItem->Insert(aTabStop);
3722*b1cdbd2cSJim Jagielski sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
3723*b1cdbd2cSJim Jagielski pBindings->GetDispatcher()->Execute( nTabStopId, SFX_CALLMODE_RECORD, pTabStopItem, 0L );
3724*b1cdbd2cSJim Jagielski UpdateTabs();
3725*b1cdbd2cSJim Jagielski pRuler_Imp->nIdx = 0;
3726*b1cdbd2cSJim Jagielski }
3727*b1cdbd2cSJim Jagielski return 0;
3728*b1cdbd2cSJim Jagielski }
3729*b1cdbd2cSJim Jagielski
3730*b1cdbd2cSJim Jagielski
Command(const CommandEvent & rCEvt)3731*b1cdbd2cSJim Jagielski void SvxRuler::Command( const CommandEvent& rCEvt )
3732*b1cdbd2cSJim Jagielski
3733*b1cdbd2cSJim Jagielski /*
3734*b1cdbd2cSJim Jagielski [Beschreibung]
3735*b1cdbd2cSJim Jagielski
3736*b1cdbd2cSJim Jagielski Mauskontextmenue fuer das Umschalten der Masseinheit
3737*b1cdbd2cSJim Jagielski
3738*b1cdbd2cSJim Jagielski */
3739*b1cdbd2cSJim Jagielski
3740*b1cdbd2cSJim Jagielski {
3741*b1cdbd2cSJim Jagielski if ( COMMAND_CONTEXTMENU == rCEvt.GetCommand() )
3742*b1cdbd2cSJim Jagielski {
3743*b1cdbd2cSJim Jagielski CancelDrag();
3744*b1cdbd2cSJim Jagielski sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
3745*b1cdbd2cSJim Jagielski if ( pTabs &&
3746*b1cdbd2cSJim Jagielski RULER_TYPE_TAB ==
3747*b1cdbd2cSJim Jagielski GetType( rCEvt.GetMousePosPixel(), &pRuler_Imp->nIdx ) &&
3748*b1cdbd2cSJim Jagielski pTabs[pRuler_Imp->nIdx+TAB_GAP].nStyle < RULER_TAB_DEFAULT )
3749*b1cdbd2cSJim Jagielski {
3750*b1cdbd2cSJim Jagielski PopupMenu aMenu;
3751*b1cdbd2cSJim Jagielski aMenu.SetSelectHdl(LINK(this, SvxRuler, TabMenuSelect));
3752*b1cdbd2cSJim Jagielski VirtualDevice aDev;
3753*b1cdbd2cSJim Jagielski const Size aSz(RULER_TAB_WIDTH+2, RULER_TAB_HEIGHT+2);
3754*b1cdbd2cSJim Jagielski aDev.SetOutputSize(aSz);
3755*b1cdbd2cSJim Jagielski aDev.SetBackground(Wallpaper(Color(COL_WHITE)));
3756*b1cdbd2cSJim Jagielski const Point aPt(aSz.Width() / 2, aSz.Height() / 2);
3757*b1cdbd2cSJim Jagielski
3758*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = RULER_TAB_LEFT; i < RULER_TAB_DEFAULT; ++i )
3759*b1cdbd2cSJim Jagielski {
3760*b1cdbd2cSJim Jagielski sal_uInt16 nStyle = bRTL ? i|RULER_TAB_RTL : i;
3761*b1cdbd2cSJim Jagielski nStyle |= (sal_uInt16)(bHorz ? WB_HORZ : WB_VERT);
3762*b1cdbd2cSJim Jagielski DrawTab(&aDev, aPt, nStyle);
3763*b1cdbd2cSJim Jagielski aMenu.InsertItem(i+1,
3764*b1cdbd2cSJim Jagielski String(ResId(RID_SVXSTR_RULER_START+i, DIALOG_MGR())),
3765*b1cdbd2cSJim Jagielski Image(aDev.GetBitmap(Point(), aSz), Color(COL_WHITE)));
3766*b1cdbd2cSJim Jagielski aMenu.CheckItem(i+1, i == pTabs[pRuler_Imp->nIdx+TAB_GAP].nStyle);
3767*b1cdbd2cSJim Jagielski aDev.SetOutputSize(aSz); // device loeschen
3768*b1cdbd2cSJim Jagielski }
3769*b1cdbd2cSJim Jagielski aMenu.Execute( this, rCEvt.GetMousePosPixel() );
3770*b1cdbd2cSJim Jagielski }
3771*b1cdbd2cSJim Jagielski else
3772*b1cdbd2cSJim Jagielski {
3773*b1cdbd2cSJim Jagielski PopupMenu aMenu(ResId(RID_SVXMN_RULER, DIALOG_MGR()));
3774*b1cdbd2cSJim Jagielski aMenu.SetSelectHdl(LINK(this, SvxRuler, MenuSelect));
3775*b1cdbd2cSJim Jagielski FieldUnit eUnit = GetUnit();
3776*b1cdbd2cSJim Jagielski const sal_uInt16 nCount = aMenu.GetItemCount();
3777*b1cdbd2cSJim Jagielski
3778*b1cdbd2cSJim Jagielski sal_Bool bReduceMetric = 0 != (nFlags &SVXRULER_SUPPORT_REDUCED_METRIC);
3779*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = nCount; i; --i )
3780*b1cdbd2cSJim Jagielski {
3781*b1cdbd2cSJim Jagielski const sal_uInt16 nId = aMenu.GetItemId(i - 1);
3782*b1cdbd2cSJim Jagielski aMenu.CheckItem(nId, nId == (sal_uInt16)eUnit);
3783*b1cdbd2cSJim Jagielski if(bReduceMetric &&
3784*b1cdbd2cSJim Jagielski (nId == FUNIT_M ||
3785*b1cdbd2cSJim Jagielski nId == FUNIT_KM ||
3786*b1cdbd2cSJim Jagielski nId == FUNIT_FOOT ||
3787*b1cdbd2cSJim Jagielski nId == FUNIT_MILE ))
3788*b1cdbd2cSJim Jagielski aMenu.RemoveItem(i - 1);
3789*b1cdbd2cSJim Jagielski }
3790*b1cdbd2cSJim Jagielski aMenu.Execute( this, rCEvt.GetMousePosPixel() );
3791*b1cdbd2cSJim Jagielski }
3792*b1cdbd2cSJim Jagielski }
3793*b1cdbd2cSJim Jagielski else
3794*b1cdbd2cSJim Jagielski Ruler::Command( rCEvt );
3795*b1cdbd2cSJim Jagielski }
3796*b1cdbd2cSJim Jagielski
3797*b1cdbd2cSJim Jagielski
GetActRightColumn(sal_Bool bForceDontConsiderHidden,sal_uInt16 nAct) const3798*b1cdbd2cSJim Jagielski sal_uInt16 SvxRuler::GetActRightColumn(
3799*b1cdbd2cSJim Jagielski sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct ) const
3800*b1cdbd2cSJim Jagielski {
3801*b1cdbd2cSJim Jagielski if( nAct == USHRT_MAX )
3802*b1cdbd2cSJim Jagielski nAct = pColumnItem->GetActColumn();
3803*b1cdbd2cSJim Jagielski else nAct++; //Damit man die ActDrag uebergeben kann
3804*b1cdbd2cSJim Jagielski
3805*b1cdbd2cSJim Jagielski sal_Bool bConsiderHidden = !bForceDontConsiderHidden &&
3806*b1cdbd2cSJim Jagielski !( nDragType & DRAG_OBJECT_ACTLINE_ONLY );
3807*b1cdbd2cSJim Jagielski
3808*b1cdbd2cSJim Jagielski while( nAct < pColumnItem->Count() - 1 )
3809*b1cdbd2cSJim Jagielski {
3810*b1cdbd2cSJim Jagielski if( (*pColumnItem)[nAct].bVisible || bConsiderHidden )
3811*b1cdbd2cSJim Jagielski return nAct;
3812*b1cdbd2cSJim Jagielski else
3813*b1cdbd2cSJim Jagielski nAct++;
3814*b1cdbd2cSJim Jagielski }
3815*b1cdbd2cSJim Jagielski return USHRT_MAX;
3816*b1cdbd2cSJim Jagielski }
3817*b1cdbd2cSJim Jagielski
3818*b1cdbd2cSJim Jagielski
3819*b1cdbd2cSJim Jagielski
GetActLeftColumn(sal_Bool bForceDontConsiderHidden,sal_uInt16 nAct) const3820*b1cdbd2cSJim Jagielski sal_uInt16 SvxRuler::GetActLeftColumn(
3821*b1cdbd2cSJim Jagielski sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct ) const
3822*b1cdbd2cSJim Jagielski {
3823*b1cdbd2cSJim Jagielski if(nAct==USHRT_MAX)
3824*b1cdbd2cSJim Jagielski nAct=pColumnItem->GetActColumn();
3825*b1cdbd2cSJim Jagielski
3826*b1cdbd2cSJim Jagielski sal_uInt16 nLOffs=1;
3827*b1cdbd2cSJim Jagielski
3828*b1cdbd2cSJim Jagielski sal_Bool bConsiderHidden = !bForceDontConsiderHidden &&
3829*b1cdbd2cSJim Jagielski !( nDragType & DRAG_OBJECT_ACTLINE_ONLY );
3830*b1cdbd2cSJim Jagielski
3831*b1cdbd2cSJim Jagielski while(nAct>=nLOffs)
3832*b1cdbd2cSJim Jagielski {
3833*b1cdbd2cSJim Jagielski if( (*pColumnItem)[ nAct - nLOffs ].bVisible || bConsiderHidden )
3834*b1cdbd2cSJim Jagielski return nAct-nLOffs;
3835*b1cdbd2cSJim Jagielski else
3836*b1cdbd2cSJim Jagielski nLOffs++;
3837*b1cdbd2cSJim Jagielski }
3838*b1cdbd2cSJim Jagielski return USHRT_MAX;
3839*b1cdbd2cSJim Jagielski }
3840*b1cdbd2cSJim Jagielski
3841*b1cdbd2cSJim Jagielski
IsActLastColumn(sal_Bool bForceDontConsiderHidden,sal_uInt16 nAct) const3842*b1cdbd2cSJim Jagielski sal_Bool SvxRuler::IsActLastColumn(
3843*b1cdbd2cSJim Jagielski sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct) const
3844*b1cdbd2cSJim Jagielski {
3845*b1cdbd2cSJim Jagielski return GetActRightColumn(bForceDontConsiderHidden, nAct)==USHRT_MAX;
3846*b1cdbd2cSJim Jagielski }
3847*b1cdbd2cSJim Jagielski
IsActFirstColumn(sal_Bool bForceDontConsiderHidden,sal_uInt16 nAct) const3848*b1cdbd2cSJim Jagielski sal_Bool SvxRuler::IsActFirstColumn(
3849*b1cdbd2cSJim Jagielski sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct) const
3850*b1cdbd2cSJim Jagielski {
3851*b1cdbd2cSJim Jagielski return GetActLeftColumn(bForceDontConsiderHidden, nAct)==USHRT_MAX;
3852*b1cdbd2cSJim Jagielski }
3853*b1cdbd2cSJim Jagielski
CalcPropMaxRight(sal_uInt16 nCol) const3854*b1cdbd2cSJim Jagielski long SvxRuler::CalcPropMaxRight(sal_uInt16 nCol) const
3855*b1cdbd2cSJim Jagielski {
3856*b1cdbd2cSJim Jagielski
3857*b1cdbd2cSJim Jagielski if(!(nDragType & DRAG_OBJECT_SIZE_LINEAR))
3858*b1cdbd2cSJim Jagielski {
3859*b1cdbd2cSJim Jagielski
3860*b1cdbd2cSJim Jagielski // ausgehend vom rechten Rand die Mindestbreiten
3861*b1cdbd2cSJim Jagielski // aller betroffenen Spalten abziehen
3862*b1cdbd2cSJim Jagielski long _nMaxRight = GetMargin2()-GetMargin1();
3863*b1cdbd2cSJim Jagielski
3864*b1cdbd2cSJim Jagielski long lFences=0;
3865*b1cdbd2cSJim Jagielski long lMinSpace=USHRT_MAX;
3866*b1cdbd2cSJim Jagielski long lOldPos;
3867*b1cdbd2cSJim Jagielski long lColumns=0;
3868*b1cdbd2cSJim Jagielski sal_uInt16 nStart;
3869*b1cdbd2cSJim Jagielski if(!pColumnItem->IsTable())
3870*b1cdbd2cSJim Jagielski {
3871*b1cdbd2cSJim Jagielski if(nCol==USHRT_MAX)
3872*b1cdbd2cSJim Jagielski {
3873*b1cdbd2cSJim Jagielski lOldPos=GetMargin1();
3874*b1cdbd2cSJim Jagielski nStart=0;
3875*b1cdbd2cSJim Jagielski }
3876*b1cdbd2cSJim Jagielski else
3877*b1cdbd2cSJim Jagielski {
3878*b1cdbd2cSJim Jagielski lOldPos=pBorders[nCol].nPos+pBorders[nCol].nWidth;
3879*b1cdbd2cSJim Jagielski nStart=nCol+1;
3880*b1cdbd2cSJim Jagielski lFences=pBorders[nCol].nWidth;
3881*b1cdbd2cSJim Jagielski }
3882*b1cdbd2cSJim Jagielski
3883*b1cdbd2cSJim Jagielski for(sal_uInt16 i = nStart; i < nBorderCount-1; ++i)
3884*b1cdbd2cSJim Jagielski {
3885*b1cdbd2cSJim Jagielski long lWidth=pBorders[i].nPos-lOldPos;
3886*b1cdbd2cSJim Jagielski lColumns+=lWidth;
3887*b1cdbd2cSJim Jagielski if(lWidth<lMinSpace)
3888*b1cdbd2cSJim Jagielski lMinSpace=lWidth;
3889*b1cdbd2cSJim Jagielski lOldPos=pBorders[i].nPos+pBorders[i].nWidth;
3890*b1cdbd2cSJim Jagielski lFences+=pBorders[i].nWidth;
3891*b1cdbd2cSJim Jagielski }
3892*b1cdbd2cSJim Jagielski long lWidth=GetMargin2()-lOldPos;
3893*b1cdbd2cSJim Jagielski lColumns+=lWidth;
3894*b1cdbd2cSJim Jagielski if(lWidth<lMinSpace)
3895*b1cdbd2cSJim Jagielski lMinSpace=lWidth;
3896*b1cdbd2cSJim Jagielski }
3897*b1cdbd2cSJim Jagielski else
3898*b1cdbd2cSJim Jagielski {
3899*b1cdbd2cSJim Jagielski sal_uInt16 nActCol;
3900*b1cdbd2cSJim Jagielski if(nCol==USHRT_MAX) //CalcMinMax fuer LeftMargin
3901*b1cdbd2cSJim Jagielski {
3902*b1cdbd2cSJim Jagielski lOldPos=GetMargin1();
3903*b1cdbd2cSJim Jagielski }
3904*b1cdbd2cSJim Jagielski else
3905*b1cdbd2cSJim Jagielski {
3906*b1cdbd2cSJim Jagielski lOldPos=pBorders[nCol].nPos;
3907*b1cdbd2cSJim Jagielski }
3908*b1cdbd2cSJim Jagielski lColumns=GetMargin2()-lOldPos;
3909*b1cdbd2cSJim Jagielski nActCol=nCol;
3910*b1cdbd2cSJim Jagielski lFences=0;
3911*b1cdbd2cSJim Jagielski while(nActCol<nBorderCount||nActCol==USHRT_MAX)
3912*b1cdbd2cSJim Jagielski {
3913*b1cdbd2cSJim Jagielski sal_uInt16 nRight;
3914*b1cdbd2cSJim Jagielski if(nActCol==USHRT_MAX)
3915*b1cdbd2cSJim Jagielski {
3916*b1cdbd2cSJim Jagielski nRight=0;
3917*b1cdbd2cSJim Jagielski while(!(*pColumnItem)[nRight].bVisible)
3918*b1cdbd2cSJim Jagielski nRight++;
3919*b1cdbd2cSJim Jagielski }
3920*b1cdbd2cSJim Jagielski else
3921*b1cdbd2cSJim Jagielski nRight=GetActRightColumn(sal_False, nActCol);
3922*b1cdbd2cSJim Jagielski long lWidth;
3923*b1cdbd2cSJim Jagielski if(nRight!=USHRT_MAX)
3924*b1cdbd2cSJim Jagielski {
3925*b1cdbd2cSJim Jagielski lWidth=pBorders[nRight].nPos-lOldPos;
3926*b1cdbd2cSJim Jagielski lOldPos=pBorders[nRight].nPos;
3927*b1cdbd2cSJim Jagielski }
3928*b1cdbd2cSJim Jagielski else
3929*b1cdbd2cSJim Jagielski lWidth=GetMargin2()-lOldPos;
3930*b1cdbd2cSJim Jagielski nActCol=nRight;
3931*b1cdbd2cSJim Jagielski if(lWidth<lMinSpace)
3932*b1cdbd2cSJim Jagielski lMinSpace=lWidth;
3933*b1cdbd2cSJim Jagielski if(nActCol==USHRT_MAX)
3934*b1cdbd2cSJim Jagielski break;
3935*b1cdbd2cSJim Jagielski }
3936*b1cdbd2cSJim Jagielski }
3937*b1cdbd2cSJim Jagielski
3938*b1cdbd2cSJim Jagielski _nMaxRight-=(long)(lFences+lMinFrame/(float)lMinSpace*lColumns);
3939*b1cdbd2cSJim Jagielski return _nMaxRight;
3940*b1cdbd2cSJim Jagielski }
3941*b1cdbd2cSJim Jagielski else
3942*b1cdbd2cSJim Jagielski {
3943*b1cdbd2cSJim Jagielski if(pColumnItem->IsTable())
3944*b1cdbd2cSJim Jagielski {
3945*b1cdbd2cSJim Jagielski sal_uInt16 nVisCols=0;
3946*b1cdbd2cSJim Jagielski for(sal_uInt16 i=GetActRightColumn(sal_False, nCol);i<nBorderCount;)
3947*b1cdbd2cSJim Jagielski {
3948*b1cdbd2cSJim Jagielski if((*pColumnItem)[i].bVisible)
3949*b1cdbd2cSJim Jagielski nVisCols++;
3950*b1cdbd2cSJim Jagielski i=GetActRightColumn(sal_False, i);
3951*b1cdbd2cSJim Jagielski }
3952*b1cdbd2cSJim Jagielski return GetMargin2()-GetMargin1()-(nVisCols+1)*lMinFrame;
3953*b1cdbd2cSJim Jagielski }
3954*b1cdbd2cSJim Jagielski else
3955*b1cdbd2cSJim Jagielski {
3956*b1cdbd2cSJim Jagielski long lWidth=0;
3957*b1cdbd2cSJim Jagielski for(sal_uInt16 i=nCol;i<nBorderCount-1;i++)
3958*b1cdbd2cSJim Jagielski {
3959*b1cdbd2cSJim Jagielski lWidth+=lMinFrame+pBorders[i].nWidth;
3960*b1cdbd2cSJim Jagielski }
3961*b1cdbd2cSJim Jagielski return GetMargin2()-GetMargin1()-lWidth;
3962*b1cdbd2cSJim Jagielski }
3963*b1cdbd2cSJim Jagielski }
3964*b1cdbd2cSJim Jagielski }
3965*b1cdbd2cSJim Jagielski /*-- 29.11.2007 08:24:23---------------------------------------------------
3966*b1cdbd2cSJim Jagielski //#i24363# tab stops relative to indent
3967*b1cdbd2cSJim Jagielski -----------------------------------------------------------------------*/
SetTabsRelativeToIndent(sal_Bool bRel)3968*b1cdbd2cSJim Jagielski void SvxRuler::SetTabsRelativeToIndent( sal_Bool bRel )
3969*b1cdbd2cSJim Jagielski {
3970*b1cdbd2cSJim Jagielski pRuler_Imp->bIsTabsRelativeToIndent = bRel;
3971*b1cdbd2cSJim Jagielski }
3972*b1cdbd2cSJim Jagielski
3973