Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "layout.hxx"
21 :
22 : #include "bastypes.hxx"
23 :
24 : #include <boost/make_shared.hpp>
25 :
26 : namespace basctl
27 : {
28 :
29 : namespace
30 : {
31 : // the thickness of the splitting lines
32 : static long const nSplitThickness = 3;
33 : } // namespace
34 :
35 : // ctor for derived classes
36 : // pParent: the parent window (Shell)
37 0 : Layout::Layout (Window* pParent) :
38 : Window(pParent, WB_CLIPCHILDREN),
39 : pChild(0),
40 : bFirstSize(true),
41 : aLeftSide(this, SplittedSide::Left),
42 0 : aBottomSide(this, SplittedSide::Bottom)
43 : {
44 0 : SetBackground(GetSettings().GetStyleSettings().GetWindowColor());
45 :
46 0 : Font aFont = GetFont();
47 0 : Size aSz = aFont.GetSize();
48 0 : aSz.Height() *= 1.5;
49 0 : aFont.SetSize(aSz);
50 0 : aFont.SetWeight(WEIGHT_BOLD);
51 0 : aFont.SetColor(GetSettings().GetStyleSettings().GetWindowTextColor());
52 0 : SetFont(aFont);
53 0 : }
54 :
55 : // virtual dtor
56 0 : Layout::~Layout()
57 0 : { }
58 :
59 : // removes a docking window
60 0 : void Layout::Remove (DockingWindow* pWin)
61 : {
62 0 : aLeftSide.Remove(pWin);
63 0 : aBottomSide.Remove(pWin);
64 0 : }
65 :
66 : // called by Window when resized
67 0 : void Layout::Resize()
68 : {
69 0 : if (IsVisible())
70 0 : ArrangeWindows();
71 0 : }
72 :
73 : // ArrangeWindows() -- arranges the child windows
74 0 : void Layout::ArrangeWindows ()
75 : {
76 : // prevent recursion via OnFirstSize() -> Add() -> ArrangeWindows()
77 : static bool bInArrangeWindows = false;
78 0 : if (bInArrangeWindows)
79 0 : return;
80 0 : bInArrangeWindows = true;
81 :
82 0 : Size const aSize = GetOutputSizePixel();
83 0 : long const nWidth = aSize.Width(), nHeight = aSize.Height();
84 0 : if (nWidth && nHeight) // non-empty size
85 : {
86 : // On first call the derived classes initializes the sizes of the
87 : // docking windows. This cannot be done at construction because
88 : // the Layout has empty size at that point.
89 0 : if (bFirstSize)
90 : {
91 0 : bFirstSize = false;
92 0 : this->OnFirstSize(nWidth, nHeight); // virtual
93 : }
94 :
95 : // sides
96 0 : aBottomSide.ArrangeIn(Rectangle(Point(0, 0), aSize));
97 0 : aLeftSide.ArrangeIn(Rectangle(Point(0, 0), Size(nWidth, nHeight - aBottomSide.GetSize())));
98 : // child in the middle
99 : pChild->SetPosSizePixel(
100 : Point(aLeftSide.GetSize(), 0),
101 0 : Size(nWidth - aLeftSide.GetSize(), nHeight - aBottomSide.GetSize())
102 0 : );
103 : }
104 :
105 0 : bInArrangeWindows = false;
106 : }
107 :
108 0 : void Layout::DockaWindow (DockingWindow*)
109 : {
110 0 : ArrangeWindows();
111 0 : }
112 :
113 0 : void Layout::Activating (BaseWindow& rWindow)
114 : {
115 : // first activation
116 0 : pChild = &rWindow;
117 0 : ArrangeWindows();
118 0 : Show();
119 0 : pChild->Activating();
120 0 : }
121 :
122 0 : void Layout::Deactivating ()
123 : {
124 0 : if (pChild)
125 0 : pChild->Deactivating();
126 0 : Hide();
127 0 : pChild = 0;
128 0 : }
129 :
130 : // virtual
131 0 : void Layout::DataChanged (DataChangedEvent const& rDCEvt)
132 : {
133 0 : Window::DataChanged(rDCEvt);
134 0 : if (rDCEvt.GetType() == DATACHANGED_SETTINGS && (rDCEvt.GetFlags() & SETTINGS_STYLE))
135 : {
136 0 : bool bInvalidate = false;
137 0 : Color aColor = GetSettings().GetStyleSettings().GetWindowColor();
138 0 : if (aColor != rDCEvt.GetOldSettings()->GetStyleSettings().GetWindowColor())
139 : {
140 0 : SetBackground(Wallpaper(aColor));
141 0 : bInvalidate = true;
142 : }
143 0 : aColor = GetSettings().GetStyleSettings().GetWindowTextColor();
144 0 : if (aColor != rDCEvt.GetOldSettings()->GetStyleSettings().GetWindowTextColor())
145 : {
146 0 : Font aFont(GetFont());
147 0 : aFont.SetColor(aColor);
148 0 : SetFont(aFont);
149 0 : bInvalidate = true;
150 : }
151 0 : if (bInvalidate)
152 0 : Invalidate();
153 : }
154 0 : }
155 :
156 : //
157 : // SplittedSide
158 : // ============
159 : //
160 :
161 : // ctor
162 0 : Layout::SplittedSide::SplittedSide (Layout* pParent, Side eSide) :
163 : rLayout(*pParent),
164 : bVertical(eSide == Left || eSide == Right),
165 : bLower(eSide == Left || eSide == Top),
166 : nSize(0),
167 0 : aSplitter(pParent, bVertical ? WB_HSCROLL : WB_VSCROLL)
168 : {
169 0 : InitSplitter(aSplitter);
170 0 : }
171 :
172 :
173 : // Add() -- adds a new window to the side (after construction)
174 0 : void Layout::SplittedSide::Add (DockingWindow* pWin, Size const& rSize)
175 : {
176 0 : long const nSize1 = (bVertical ? rSize.Width() : rSize.Height()) + nSplitThickness;
177 0 : long const nSize2 = bVertical ? rSize.Height() : rSize.Width();
178 : // nSize
179 0 : if (nSize1 > nSize)
180 0 : nSize = nSize1;
181 : // window
182 0 : Item aItem;
183 0 : aItem.pWin = pWin;
184 0 : aItem.nStartPos = vItems.empty() ? 0 : vItems.back().nEndPos + nSplitThickness;
185 0 : aItem.nEndPos = aItem.nStartPos + nSize2;
186 : // splitter
187 0 : if (!vItems.empty())
188 : {
189 0 : aItem.pSplit = boost::make_shared<Splitter>(&rLayout, bVertical ? WB_VSCROLL : WB_HSCROLL);
190 0 : aItem.pSplit->SetSplitPosPixel(aItem.nStartPos - nSplitThickness);
191 0 : InitSplitter(*aItem.pSplit);
192 : }
193 0 : vItems.push_back(aItem);
194 : // refresh
195 0 : rLayout.ArrangeWindows();
196 0 : }
197 :
198 : // Remove() -- removes a window from the side (if contains)
199 0 : void Layout::SplittedSide::Remove (DockingWindow* pWin)
200 : {
201 : // contains?
202 : unsigned iWin;
203 0 : for (iWin = 0; iWin != vItems.size(); ++iWin)
204 0 : if (vItems[iWin].pWin == pWin)
205 0 : break;
206 0 : if (iWin == vItems.size())
207 0 : return;
208 : // remove
209 0 : vItems.erase(vItems.begin() + iWin);
210 : // if that was the first one, remove the first splitter line
211 0 : if (iWin == 0 && !vItems.empty())
212 0 : vItems.front().pSplit.reset();
213 : }
214 :
215 : // creating a Point or a Size object
216 : // The coordinate order depends on bVertical (reversed if true).
217 0 : inline Size Layout::SplittedSide::MakeSize (long A, long B) const
218 : {
219 0 : return bVertical ? Size(B, A) : Size(A, B);
220 : }
221 0 : inline Point Layout::SplittedSide::MakePoint (long A, long B) const
222 : {
223 0 : return bVertical ? Point(B, A) : Point(A, B);
224 : }
225 :
226 : // IsDocking() -- is this window currently docking in the strip?
227 0 : bool Layout::SplittedSide::IsDocking (DockingWindow const& rWin)
228 : {
229 0 : return rWin.IsVisible() && !rWin.IsFloatingMode();
230 : }
231 :
232 : // IsEmpty() -- are there no windows docked in this strip?
233 0 : bool Layout::SplittedSide::IsEmpty () const
234 : {
235 0 : for (unsigned i = 0; i != vItems.size(); ++i)
236 0 : if (IsDocking(*vItems[i].pWin))
237 0 : return false;
238 0 : return true;
239 : }
240 :
241 : // GetSize() -- returns the width or height of the strip (depending on the direction)
242 0 : long Layout::SplittedSide::GetSize () const
243 : {
244 0 : return IsEmpty() ? 0 : nSize;
245 : }
246 :
247 : // Arrange() -- arranges the docking windows
248 : // rRect: the available space
249 0 : void Layout::SplittedSide::ArrangeIn (Rectangle const& rRect)
250 : {
251 : // saving the rectangle
252 0 : aRect = rRect;
253 :
254 : // the length of the side
255 0 : long const nLength = bVertical ? aRect.GetSize().Height() : aRect.GetSize().Width();
256 0 : long const nOtherSize = bVertical ? aRect.GetSize().Width() : aRect.GetSize().Height();
257 : // bVertical ? horizontal pozition : vertical pozition
258 0 : long const nPos1 = (bVertical ? aRect.Left() : aRect.Top()) +
259 0 : (bLower ? 0 : nOtherSize - (nSize - nSplitThickness));
260 : // bVertical ? vertical position : horizontal position
261 0 : long const nPos2 = bVertical ? aRect.Top() : aRect.Left();
262 :
263 : // main line
264 0 : bool const bEmpty = IsEmpty();
265 : // shown if any of the windows is docked
266 0 : if (!bEmpty)
267 : {
268 0 : aSplitter.Show();
269 : // split position
270 0 : aSplitter.SetSplitPosPixel((bLower ? nSize : nPos1) - nSplitThickness);
271 : // the actual position and size
272 : aSplitter.SetPosSizePixel(
273 0 : MakePoint(nPos2, aSplitter.GetSplitPosPixel()),
274 : MakeSize(nLength, nSplitThickness)
275 0 : );
276 : // dragging rectangle
277 0 : aSplitter.SetDragRectPixel(aRect);
278 : }
279 : else
280 0 : aSplitter.Hide();
281 :
282 : // positioning separator lines and windows
283 0 : bool bPrevDocking = false; // is the previous window docked?
284 0 : long nStartPos = 0; // window position in the strip
285 0 : unsigned iLastWin = vItems.size(); // index of last docking window in the strip
286 :
287 0 : for (unsigned i = 0; i != vItems.size(); ++i)
288 : {
289 : // window
290 0 : DockingWindow& rWin = *vItems[i].pWin;
291 0 : bool const bDocking = IsDocking(rWin);
292 0 : if (bDocking)
293 0 : iLastWin = i;
294 : // sizing window
295 : rWin.ResizeIfDocking(
296 0 : MakePoint(nPos2 + nStartPos, nPos1),
297 0 : MakeSize(vItems[i].nEndPos - nStartPos, nSize - nSplitThickness)
298 0 : );
299 : // splitting line before the window
300 0 : if (i > 0)
301 : {
302 0 : Splitter& rSplit = *vItems[i].pSplit;
303 : // If neither of two adjacent windows are docked,
304 : // the splitting line is hidden.
305 : // If this window is docking but the previous isn't,
306 : // then the splitting line is also hidden, because this window
307 : // will occupy the space of the previous.
308 0 : if (bPrevDocking)
309 : {
310 0 : rSplit.Show();
311 : // the actual position and size of the line
312 : rSplit.SetPosSizePixel(
313 0 : MakePoint(nPos2 + nStartPos - nSplitThickness, nPos1),
314 0 : MakeSize(nSplitThickness, nSize - nSplitThickness)
315 0 : );
316 : // the dragging rectangle
317 : rSplit.SetDragRectPixel(Rectangle(
318 : MakePoint(nPos2, nPos1),
319 0 : MakeSize(nLength, nSize - nSplitThickness)
320 0 : ));
321 : }
322 : else
323 0 : rSplit.Hide();
324 : }
325 : // next
326 0 : bPrevDocking = bDocking;
327 0 : if (bDocking)
328 0 : nStartPos = vItems[i].nEndPos + nSplitThickness;
329 : // We only set nStartPos if this window is docking, because otherwise
330 : // the next window will occupy also the space of this window.
331 : }
332 :
333 : // filling the remaining space with the last docking window
334 0 : if (!bEmpty && vItems[iLastWin].nEndPos != nLength)
335 : {
336 0 : Item& rItem = vItems[iLastWin];
337 0 : Size aSize = rItem.pWin->GetDockingSize();
338 0 : (bVertical ? aSize.Height() : aSize.Width()) += nLength - rItem.nEndPos;
339 0 : rItem.pWin->ResizeIfDocking(aSize);
340 : // and hiding the split line after the window
341 0 : if (iLastWin < vItems.size() - 1)
342 0 : vItems[iLastWin + 1].pSplit->Hide();
343 : }
344 0 : }
345 :
346 0 : IMPL_LINK(Layout::SplittedSide, SplitHdl, Splitter*, pSplitter)
347 : {
348 : // checking margins
349 0 : CheckMarginsFor(pSplitter);
350 : // changing stored sizes
351 0 : if (pSplitter == &aSplitter)
352 : {
353 : // nSize
354 0 : if (bLower)
355 0 : nSize = pSplitter->GetSplitPosPixel();
356 : else
357 0 : nSize = (bVertical ? aRect.Right() : aRect.Bottom()) + 1 - pSplitter->GetSplitPosPixel();
358 : }
359 : else
360 : {
361 : // Item::nStartPos, Item::nLength
362 0 : for (unsigned i = 1; i < vItems.size(); ++i)
363 : {
364 0 : if (vItems[i].pSplit.get() == pSplitter)
365 : {
366 : // before the line
367 0 : vItems[i - 1].nEndPos = pSplitter->GetSplitPosPixel();
368 : // after the line
369 0 : vItems[i].nStartPos = pSplitter->GetSplitPosPixel() + nSplitThickness;
370 : }
371 : }
372 : }
373 : // arranging windows
374 0 : rLayout.ArrangeWindows();
375 :
376 0 : return 0;
377 : }
378 :
379 0 : void Layout::SplittedSide::CheckMarginsFor (Splitter* pSplitter)
380 : {
381 : // The splitter line cannot be closer to the edges than nMargin pixels.
382 : static long const nMargin = 16;
383 : // Checking margins:
384 0 : if (long const nLength = pSplitter->IsHorizontal() ?
385 0 : aRect.GetWidth() : aRect.GetHeight()
386 : ) {
387 : // bounds
388 0 : long const nLower = (pSplitter->IsHorizontal() ? aRect.Left() : aRect.Top()) + nMargin;
389 0 : long const nUpper = nLower + nLength - 2*nMargin;
390 : // split position
391 0 : long const nPos = pSplitter->GetSplitPosPixel();
392 : // checking bounds
393 0 : if (nPos < nLower)
394 0 : pSplitter->SetSplitPosPixel(nLower);
395 0 : if (nPos > nUpper)
396 0 : pSplitter->SetSplitPosPixel(nUpper);
397 : }
398 0 : }
399 :
400 0 : void Layout::SplittedSide::InitSplitter (Splitter& rSplitter)
401 : {
402 : // link
403 0 : rSplitter.SetSplitHdl(LINK(this, SplittedSide, SplitHdl));
404 : // color
405 0 : Color aColor = rLayout.GetSettings().GetStyleSettings().GetShadowColor();
406 0 : rSplitter.SetLineColor(aColor);
407 0 : rSplitter.SetFillColor(aColor);
408 0 : }
409 :
410 :
411 : } // namespace basctl
412 :
413 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
