?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / sc / source / ui / view / gridwin4.cxx
blob3da00b52b669756c4c08f6d7cb4584c8fcf7f9e5
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 "scitems.hxx"
21 #include <editeng/eeitem.hxx>
22
23 #include <svtools/colorcfg.hxx>
24 #include <editeng/colritem.hxx>
25 #include <editeng/editview.hxx>
26 #include <editeng/fhgtitem.hxx>
27 #include <editeng/scripttypeitem.hxx>
28 #include <sfx2/bindings.hxx>
29 #include <sfx2/printer.hxx>
30 #include <vcl/settings.hxx>
31
32 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
33 #include <comphelper/lok.hxx>
34
35 #include <svx/svdview.hxx>
36 #include "tabvwsh.hxx"
37
38 #include "gridwin.hxx"
39 #include "viewdata.hxx"
40 #include "output.hxx"
41 #include "document.hxx"
42 #include "attrib.hxx"
43 #include "patattr.hxx"
44 #include "dbdata.hxx"
45 #include "docoptio.hxx"
46 #include "notemark.hxx"
47 #include "dbfunc.hxx"
48 #include "scmod.hxx"
49 #include "inputhdl.hxx"
50 #include "rfindlst.hxx"
51 #include "hiranges.hxx"
52 #include "pagedata.hxx"
53 #include "docpool.hxx"
54 #include "globstr.hrc"
55 #include "docsh.hxx"
56 #include "cbutton.hxx"
57 #include "invmerge.hxx"
58 #include "editutil.hxx"
59 #include "inputopt.hxx"
60 #include "fillinfo.hxx"
61 #include "dpcontrol.hxx"
62 #include "queryparam.hxx"
63 #include "queryentry.hxx"
64 #include "markdata.hxx"
65 #include "sc.hrc"
66 #include <vcl/virdev.hxx>
67 #include <svx/sdrpaintwindow.hxx>
68
69 static void lcl_LimitRect( Rectangle& rRect, const Rectangle& rVisible )
70 {
71 if ( rRect.Top() < rVisible.Top()-1 ) rRect.Top() = rVisible.Top()-1;
72 if ( rRect.Bottom() > rVisible.Bottom()+1 ) rRect.Bottom() = rVisible.Bottom()+1;
73
74 // The header row must be drawn also when the inner rectangle is not visible,
75 // that is why there is no return value anymore.
76 // When it is far away, then lcl_DrawOneFrame is not even called.
77 }
78
79 static void lcl_DrawOneFrame( vcl::RenderContext* pDev, const Rectangle& rInnerPixel,
80 const OUString& rTitle, const Color& rColor, bool bTextBelow,
81 double nPPTX, double nPPTY, const Fraction& rZoomY,
82 ScDocument* pDoc, ScViewData* pButtonViewData, bool bLayoutRTL )
83 {
84 // pButtonViewData is only used to set the button size,
85 // can otherwise be NULL!
86
87 Rectangle aInner = rInnerPixel;
88 if ( bLayoutRTL )
89 {
90 aInner.Left() = rInnerPixel.Right();
91 aInner.Right() = rInnerPixel.Left();
92 }
93
94 Rectangle aVisible( Point(0,0), pDev->GetOutputSizePixel() );
95 lcl_LimitRect( aInner, aVisible );
96
97 Rectangle aOuter = aInner;
98 long nHor = (long) ( SC_SCENARIO_HSPACE * nPPTX );
99 long nVer = (long) ( SC_SCENARIO_VSPACE * nPPTY );
100 aOuter.Left() -= nHor;
101 aOuter.Right() += nHor;
102 aOuter.Top() -= nVer;
103 aOuter.Bottom() += nVer;
104
105 // use ScPatternAttr::GetFont only for font size
106 vcl::Font aAttrFont;
107 static_cast<const ScPatternAttr&>(pDoc->GetPool()->GetDefaultItem(ATTR_PATTERN)).
108 GetFont(aAttrFont,SC_AUTOCOL_BLACK,pDev,&rZoomY);
109
110 // everything else from application font
111 vcl::Font aAppFont = pDev->GetSettings().GetStyleSettings().GetAppFont();
112 aAppFont.SetFontSize( aAttrFont.GetFontSize() );
113
114 aAppFont.SetAlignment( ALIGN_TOP );
115 pDev->SetFont( aAppFont );
116
117 Size aTextSize( pDev->GetTextWidth( rTitle ), pDev->GetTextHeight() );
118
119 if ( bTextBelow )
120 aOuter.Bottom() += aTextSize.Height();
121 else
122 aOuter.Top() -= aTextSize.Height();
123
124 pDev->SetLineColor();
125 pDev->SetFillColor( rColor );
126 // left, top, right, bottom
127 pDev->DrawRect( Rectangle( aOuter.Left(), aOuter.Top(), aInner.Left(), aOuter.Bottom() ) );
128 pDev->DrawRect( Rectangle( aOuter.Left(), aOuter.Top(), aOuter.Right(), aInner.Top() ) );
129 pDev->DrawRect( Rectangle( aInner.Right(), aOuter.Top(), aOuter.Right(), aOuter.Bottom() ) );
130 pDev->DrawRect( Rectangle( aOuter.Left(), aInner.Bottom(), aOuter.Right(), aOuter.Bottom() ) );
131
132 long nButtonY = bTextBelow ? aInner.Bottom() : aOuter.Top();
133
134 ScDDComboBoxButton aComboButton(pDev);
135 aComboButton.SetOptSizePixel();
136 long nBWidth = ( aComboButton.GetSizePixel().Width() * rZoomY.GetNumerator() )
137 / rZoomY.GetDenominator();
138 long nBHeight = nVer + aTextSize.Height() + 1;
139 Size aButSize( nBWidth, nBHeight );
140 long nButtonPos = bLayoutRTL ? aOuter.Left() : aOuter.Right()-nBWidth+1;
141 aComboButton.Draw( Point(nButtonPos, nButtonY), aButSize );
142 if (pButtonViewData)
143 pButtonViewData->SetScenButSize( aButSize );
144
145 long nTextStart = bLayoutRTL ? aInner.Right() - aTextSize.Width() + 1 : aInner.Left();
146
147 bool bWasClip = false;
148 vcl::Region aOldClip;
149 bool bClip = ( aTextSize.Width() > aOuter.Right() - nBWidth - aInner.Left() );
150 if ( bClip )
151 {
152 if (pDev->IsClipRegion())
153 {
154 bWasClip = true;
155 aOldClip = pDev->GetActiveClipRegion();
156 }
157 long nClipStartX = bLayoutRTL ? aOuter.Left() + nBWidth : aInner.Left();
158 long nClipEndX = bLayoutRTL ? aInner.Right() : aOuter.Right() - nBWidth;
159 pDev->SetClipRegion( vcl::Region(Rectangle( nClipStartX, nButtonY + nVer/2,
160 nClipEndX, nButtonY + nVer/2 + aTextSize.Height())) );
161 }
162
163 pDev->DrawText( Point( nTextStart, nButtonY + nVer/2 ), rTitle );
164
165 if ( bClip )
166 {
167 if ( bWasClip )
168 pDev->SetClipRegion(aOldClip);
169 else
170 pDev->SetClipRegion();
171 }
172
173 pDev->SetFillColor();
174 pDev->SetLineColor( COL_BLACK );
175 pDev->DrawRect( aInner );
176 pDev->DrawRect( aOuter );
177 }
178
179 static void lcl_DrawScenarioFrames( OutputDevice* pDev, ScViewData* pViewData, ScSplitPos eWhich,
180 SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2 )
181 {
182 ScDocument* pDoc = pViewData->GetDocument();
183 SCTAB nTab = pViewData->GetTabNo();
184 SCTAB nTabCount = pDoc->GetTableCount();
185 if ( nTab+1<nTabCount && pDoc->IsScenario(nTab+1) && !pDoc->IsScenario(nTab) )
186 {
187 if ( nX1 > 0 ) --nX1;
188 if ( nY1>=2 ) nY1 -= 2; // Hack: Header row affects two cells
189 else if ( nY1 > 0 ) --nY1;
190 if ( nX2 < MAXCOL ) ++nX2;
191 if ( nY2 < MAXROW-1 ) nY2 += 2; // Hack: Header row affects two cells
192 else if ( nY2 < MAXROW ) ++nY2;
193 ScRange aViewRange( nX1,nY1,nTab, nX2,nY2,nTab );
194
195 //! cache the ranges in table!!!!
196
197 ScMarkData aMarks;
198 for (SCTAB i=nTab+1; i<nTabCount && pDoc->IsScenario(i); i++)
199 pDoc->MarkScenario( i, nTab, aMarks, false, SC_SCENARIO_SHOWFRAME );
200 ScRangeListRef xRanges = new ScRangeList;
201 aMarks.FillRangeListWithMarks( xRanges, false );
202
203 bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
204 long nLayoutSign = bLayoutRTL ? -1 : 1;
205
206 for (size_t j = 0, n = xRanges->size(); j < n; ++j)
207 {
208 ScRange aRange = *(*xRanges)[j];
209 // Always extend scenario frame to merged cells where no new non-covered cells
210 // are framed
211 pDoc->ExtendTotalMerge( aRange );
212
213 //! -> Extend repaint when merging !!!
214
215 if ( aRange.Intersects( aViewRange ) ) //! Space for Text/Button?
216 {
217 Point aStartPos = pViewData->GetScrPos(
218 aRange.aStart.Col(), aRange.aStart.Row(), eWhich, true );
219 Point aEndPos = pViewData->GetScrPos(
220 aRange.aEnd.Col()+1, aRange.aEnd.Row()+1, eWhich, true );
221 // on the grid:
222 aStartPos.X() -= nLayoutSign;
223 aStartPos.Y() -= 1;
224 aEndPos.X() -= nLayoutSign;
225 aEndPos.Y() -= 1;
226
227 bool bTextBelow = ( aRange.aStart.Row() == 0 );
228
229 OUString aCurrent;
230 Color aColor( COL_LIGHTGRAY );
231 for (SCTAB nAct=nTab+1; nAct<nTabCount && pDoc->IsScenario(nAct); nAct++)
232 if ( pDoc->IsActiveScenario(nAct) && pDoc->HasScenarioRange(nAct,aRange) )
233 {
234 OUString aDummyComment;
235 sal_uInt16 nDummyFlags;
236 pDoc->GetName( nAct, aCurrent );
237 pDoc->GetScenarioData( nAct, aDummyComment, aColor, nDummyFlags );
238 }
239
240 if (aCurrent.isEmpty())
241 aCurrent = ScGlobal::GetRscString( STR_EMPTYDATA );
242
243 //! Own text "(None)" instead of "(Empty)" ???
244
245 lcl_DrawOneFrame( pDev, Rectangle( aStartPos, aEndPos ),
246 aCurrent, aColor, bTextBelow,
247 pViewData->GetPPTX(), pViewData->GetPPTY(), pViewData->GetZoomY(),
248 pDoc, pViewData, bLayoutRTL );
249 }
250 }
251 }
252 }
253
254 static void lcl_DrawHighlight( ScOutputData& rOutputData, ScViewData* pViewData,
255 const std::vector<ScHighlightEntry>& rHighlightRanges )
256 {
257 SCTAB nTab = pViewData->GetTabNo();
258 std::vector<ScHighlightEntry>::const_iterator pIter;
259 for ( pIter = rHighlightRanges.begin(); pIter != rHighlightRanges.end(); ++pIter)
260 {
261 ScRange aRange = pIter->aRef;
262 if ( nTab >= aRange.aStart.Tab() && nTab <= aRange.aEnd.Tab() )
263 {
264 rOutputData.DrawRefMark(
265 aRange.aStart.Col(), aRange.aStart.Row(),
266 aRange.aEnd.Col(), aRange.aEnd.Row(),
267 pIter->aColor, false );
268 }
269 }
270 }
271
272 void ScGridWindow::DoInvertRect( const Rectangle& rPixel )
273 {
274 if ( rPixel == aInvertRect )
275 aInvertRect = Rectangle(); // Cancel
276 else
277 {
278 OSL_ENSURE( aInvertRect.IsEmpty(), "DoInvertRect no pairs" );
279
280 aInvertRect = rPixel; // Mark new rectangle
281 }
282
283 UpdateHeaderOverlay(); // uses aInvertRect
284 }
285
286 void ScGridWindow::PrePaint(vcl::RenderContext& /*rRenderContext*/)
287 {
288 // forward PrePaint to DrawingLayer
289 ScTabViewShell* pTabViewShell = pViewData->GetViewShell();
290
291 if(pTabViewShell)
292 {
293 SdrView* pDrawView = pTabViewShell->GetSdrView();
294
295 if (pDrawView)
296 {
297 pDrawView->PrePaint();
298 }
299 }
300 }
301
302 void ScGridWindow::Paint( vcl::RenderContext& /*rRenderContext*/, const Rectangle& rRect )
303 {
304 ScDocument* pDoc = pViewData->GetDocument();
305 if ( pDoc->IsInInterpreter() )
306 {
307 // Via Reschedule, interpretended cells do not trigger Invalidate again,
308 // otherwise for instance an error box would never appear (bug 36381).
309 // Later, through bNeedsRepaint everything is painted again.
310 if ( bNeedsRepaint )
311 {
312 //! Merge Rectangle?
313 aRepaintPixel = Rectangle(); // multiple -> paint all
314 }
315 else
316 {
317 bNeedsRepaint = true;
318 aRepaintPixel = LogicToPixel(rRect); // only affected ranges
319 }
320 return;
321 }
322
323 // #i117893# If GetSizePixel needs to call the resize handler, the resulting nested Paint call
324 // (possibly for a larger rectangle) has to be allowed. Call GetSizePixel before setting bIsInPaint.
325 GetSizePixel();
326
327 if (bIsInPaint)
328 return;
329
330 bIsInPaint = true;
331
332 Rectangle aPixRect = LogicToPixel( rRect );
333
334 SCCOL nX1 = pViewData->GetPosX(eHWhich);
335 SCROW nY1 = pViewData->GetPosY(eVWhich);
336
337 SCTAB nTab = pViewData->GetTabNo();
338
339 double nPPTX = pViewData->GetPPTX();
340 double nPPTY = pViewData->GetPPTY();
341
342 Rectangle aMirroredPixel = aPixRect;
343 if ( pDoc->IsLayoutRTL( nTab ) )
344 {
345 // mirror and swap
346 long nWidth = GetSizePixel().Width();
347 aMirroredPixel.Left() = nWidth - 1 - aPixRect.Right();
348 aMirroredPixel.Right() = nWidth - 1 - aPixRect.Left();
349 }
350
351 long nScrX = ScViewData::ToPixel( pDoc->GetColWidth( nX1, nTab ), nPPTX );
352 while ( nScrX <= aMirroredPixel.Left() && nX1 < MAXCOL )
353 {
354 ++nX1;
355 nScrX += ScViewData::ToPixel( pDoc->GetColWidth( nX1, nTab ), nPPTX );
356 }
357 SCCOL nX2 = nX1;
358 while ( nScrX <= aMirroredPixel.Right() && nX2 < MAXCOL )
359 {
360 ++nX2;
361 nScrX += ScViewData::ToPixel( pDoc->GetColWidth( nX2, nTab ), nPPTX );
362 }
363
364 long nScrY = 0;
365 ScViewData::AddPixelsWhile( nScrY, aPixRect.Top(), nY1, MAXROW, nPPTY, pDoc, nTab);
366 SCROW nY2 = nY1;
367 if (nScrY <= aPixRect.Bottom() && nY2 < MAXROW)
368 {
369 ++nY2;
370 ScViewData::AddPixelsWhile( nScrY, aPixRect.Bottom(), nY2, MAXROW, nPPTY, pDoc, nTab);
371 }
372
373 Draw( nX1,nY1,nX2,nY2, SC_UPDATE_MARKS ); // don't continue with painting
374
375 bIsInPaint = false;
376 }
377
378 void ScGridWindow::Draw( SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2, ScUpdateMode eMode )
379 {
380 ScDocShell* pDocSh = pViewData->GetDocShell();
381 ScDocument& rDoc = pDocSh->GetDocument();
382
383 // let's ignore the normal Draw() attempts when doing the tiled rendering,
384 // all the rendering should go through PaintTile() in that case.
385 // TODO revisit if we can actually turn this into an assert(), and clean
386 // up the callers
387 if (comphelper::LibreOfficeKit::isActive())
388 return;
389
390 ScModule* pScMod = SC_MOD();
391 bool bTextWysiwyg = pScMod->GetInputOptions().GetTextWysiwyg();
392
393 if (pViewData->IsMinimized())
394 return;
395
396 PutInOrder( nX1, nX2 );
397 PutInOrder( nY1, nY2 );
398
399 OSL_ENSURE( ValidCol(nX2) && ValidRow(nY2), "GridWin Draw area too big" );
400
401 UpdateVisibleRange();
402
403 if (nX2 < maVisibleRange.mnCol1 || nY2 < maVisibleRange.mnRow1)
404 return;
405 // invisible
406 if (nX1 < maVisibleRange.mnCol1)
407 nX1 = maVisibleRange.mnCol1;
408 if (nY1 < maVisibleRange.mnRow1)
409 nY1 = maVisibleRange.mnRow1;
410
411 if (nX1 > maVisibleRange.mnCol2 || nY1 > maVisibleRange.mnRow2)
412 return;
413
414 if (nX2 > maVisibleRange.mnCol2)
415 nX2 = maVisibleRange.mnCol2;
416 if (nY2 > maVisibleRange.mnRow2)
417 nY2 = maVisibleRange.mnRow2;
418
419 if ( eMode != SC_UPDATE_MARKS && nX2 < maVisibleRange.mnCol2)
420 nX2 = maVisibleRange.mnCol2; // to continue painting
421
422 // point of no return
423
424 ++nPaintCount; // mark that painting is in progress
425
426 SCTAB nTab = pViewData->GetTabNo();
427 rDoc.ExtendHidden( nX1, nY1, nX2, nY2, nTab );
428
429 Point aScrPos = pViewData->GetScrPos( nX1, nY1, eWhich );
430 long nMirrorWidth = GetSizePixel().Width();
431 bool bLayoutRTL = rDoc.IsLayoutRTL( nTab );
432 if ( bLayoutRTL )
433 {
434 long nEndPixel = pViewData->GetScrPos( nX2+1, maVisibleRange.mnRow1, eWhich ).X();
435 nMirrorWidth = aScrPos.X() - nEndPixel;
436 aScrPos.X() = nEndPixel + 1;
437 }
438
439 long nScrX = aScrPos.X();
440 long nScrY = aScrPos.Y();
441
442 SCCOL nCurX = pViewData->GetCurX();
443 SCROW nCurY = pViewData->GetCurY();
444 SCCOL nCurEndX = nCurX;
445 SCROW nCurEndY = nCurY;
446 rDoc.ExtendMerge( nCurX, nCurY, nCurEndX, nCurEndY, nTab );
447 bool bCurVis = nCursorHideCount==0 &&
448 ( nCurEndX+1 >= nX1 && nCurX <= nX2+1 && nCurEndY+1 >= nY1 && nCurY <= nY2+1 );
449
450 // AutoFill Handles
451 if ( !bCurVis && nCursorHideCount==0 && bAutoMarkVisible && aAutoMarkPos.Tab() == nTab &&
452 ( aAutoMarkPos.Col() != nCurX || aAutoMarkPos.Row() != nCurY ) )
453 {
454 SCCOL nHdlX = aAutoMarkPos.Col();
455 SCROW nHdlY = aAutoMarkPos.Row();
456 rDoc.ExtendMerge( nHdlX, nHdlY, nHdlX, nHdlY, nTab );
457 // left and top is unaffected
458
459 //! Paint AutoFill handles alone (without Cursor) ???
460 }
461
462 double nPPTX = pViewData->GetPPTX();
463 double nPPTY = pViewData->GetPPTY();
464
465 const ScViewOptions& rOpts = pViewData->GetOptions();
466
467 // data block
468
469 ScTableInfo aTabInfo;
470 rDoc.FillInfo( aTabInfo, nX1, nY1, nX2, nY2, nTab,
471 nPPTX, nPPTY, false, rOpts.GetOption(VOPT_FORMULAS),
472 &pViewData->GetMarkData() );
473
474 Fraction aZoomX = pViewData->GetZoomX();
475 Fraction aZoomY = pViewData->GetZoomY();
476 ScOutputData aOutputData( this, OUTTYPE_WINDOW, aTabInfo, &rDoc, nTab,
477 nScrX, nScrY, nX1, nY1, nX2, nY2, nPPTX, nPPTY,
478 &aZoomX, &aZoomY );
479
480 aOutputData.SetMirrorWidth( nMirrorWidth ); // needed for RTL
481 aOutputData.SetSpellCheckContext(mpSpellCheckCxt.get());
482
483 ScopedVclPtr< VirtualDevice > xFmtVirtDev;
484 bool bLogicText = bTextWysiwyg; // call DrawStrings in logic MapMode?
485
486 if ( bTextWysiwyg )
487 {
488 // use printer for text formatting
489
490 OutputDevice* pFmtDev = rDoc.GetPrinter();
491 pFmtDev->SetMapMode( pViewData->GetLogicMode(eWhich) );
492 aOutputData.SetFmtDevice( pFmtDev );
493 }
494 else if ( aZoomX != aZoomY && pViewData->IsOle() )
495 {
496 // #i45033# For OLE inplace editing with different zoom factors,
497 // use a virtual device with 1/100th mm as text formatting reference
498
499 xFmtVirtDev.disposeAndReset( VclPtr<VirtualDevice>::Create() );
500 xFmtVirtDev->SetMapMode( MAP_100TH_MM );
501 aOutputData.SetFmtDevice( xFmtVirtDev.get() );
502
503 bLogicText = true; // use logic MapMode
504 }
505
506 DrawContent(*this, aTabInfo, aOutputData, bLogicText, eMode);
507
508 // If something was inverted during the Paint (selection changed from Basic Macro)
509 // then this is now mixed up and has to be repainted
510 OSL_ENSURE(nPaintCount, "Wrong nPaintCount");
511 --nPaintCount;
512 if (!nPaintCount)
513 CheckNeedsRepaint();
514
515 // Flag drawn formula cells "unchanged".
516 rDoc.ResetChanged(ScRange(nX1, nY1, nTab, nX2, nY2, nTab));
517 rDoc.ClearFormulaContext();
518 }
519
520 void ScGridWindow::DrawContent(OutputDevice &rDevice, const ScTableInfo& rTableInfo, ScOutputData& aOutputData,
521 bool bLogicText, ScUpdateMode eMode)
522 {
523 ScModule* pScMod = SC_MOD();
524 ScDocShell* pDocSh = pViewData->GetDocShell();
525 ScDocument& rDoc = pDocSh->GetDocument();
526 const ScViewOptions& rOpts = pViewData->GetOptions();
527 bool bIsTiledRendering = comphelper::LibreOfficeKit::isActive();
528
529 SCTAB nTab = aOutputData.nTab;
530 SCCOL nX1 = aOutputData.nX1;
531 SCROW nY1 = aOutputData.nY1;
532 SCCOL nX2 = aOutputData.nX2;
533 SCROW nY2 = aOutputData.nY2;
534 long nScrX = aOutputData.nScrX;
535 long nScrY = aOutputData.nScrY;
536
537 const svtools::ColorConfig& rColorCfg = pScMod->GetColorConfig();
538 Color aGridColor( rColorCfg.GetColorValue( svtools::CALCGRID, false ).nColor );
539 if ( aGridColor.GetColor() == COL_TRANSPARENT )
540 {
541 // use view options' grid color only if color config has "automatic" color
542 aGridColor = rOpts.GetGridColor();
543 }
544
545 aOutputData.SetSyntaxMode ( pViewData->IsSyntaxMode() );
546 aOutputData.SetGridColor ( aGridColor );
547 aOutputData.SetShowNullValues ( rOpts.GetOption( VOPT_NULLVALS ) );
548 aOutputData.SetShowFormulas ( rOpts.GetOption( VOPT_FORMULAS ) );
549 aOutputData.SetShowSpellErrors ( rDoc.GetDocOptions().IsAutoSpell() );
550 aOutputData.SetMarkClipped ( rOpts.GetOption( VOPT_CLIPMARKS ) );
551
552 aOutputData.SetUseStyleColor( true ); // always set in table view
553
554 aOutputData.SetEditObject( GetEditObject() );
555 aOutputData.SetViewShell( pViewData->GetViewShell() );
556
557 bool bGrid = rOpts.GetOption( VOPT_GRID ) && pViewData->GetShowGrid();
558 bool bGridFirst = !rOpts.GetOption( VOPT_GRID_ONTOP );
559
560 bool bPage = rOpts.GetOption( VOPT_PAGEBREAKS );
561
562 if ( eMode == SC_UPDATE_CHANGED )
563 {
564 aOutputData.FindChanged();
565 aOutputData.SetSingleGrid(true);
566 }
567
568 bool bPageMode = pViewData->IsPagebreakMode();
569 if (bPageMode) // after FindChanged
570 {
571 // SetPagebreakMode initialisiert auch bPrinted Flags
572 aOutputData.SetPagebreakMode( pViewData->GetView()->GetPageBreakData() );
573 }
574
575 EditView* pEditView = nullptr;
576 bool bEditMode = pViewData->HasEditView(eWhich);
577 if ( bEditMode && pViewData->GetRefTabNo() == nTab )
578 {
579 SCCOL nEditCol;
580 SCROW nEditRow;
581 pViewData->GetEditView( eWhich, pEditView, nEditCol, nEditRow );
582 SCCOL nEditEndCol = pViewData->GetEditEndCol();
583 SCROW nEditEndRow = pViewData->GetEditEndRow();
584
585 if ( nEditEndCol >= nX1 && nEditCol <= nX2 && nEditEndRow >= nY1 && nEditRow <= nY2 )
586 aOutputData.SetEditCell( nEditCol, nEditRow );
587 else
588 bEditMode = false;
589 }
590
591 // define drawing layer map mode and paint rectangle
592 MapMode aDrawMode = GetDrawMapMode();
593 if (bIsTiledRendering)
594 {
595 // FIXME this shouldn't be necessary once we change the entire Calc to
596 // work in the logic coordinates (ideally 100ths of mm - so that it is
597 // the same as editeng and drawinglayer), and get rid of all the
598 // SetMapMode's and other unnecessary fun we have with pixels
599 // See also ScGridWindow::GetDrawMapMode() for the rest of this hack
600 aDrawMode.SetOrigin(PixelToLogic(Point(nScrX, nScrY), aDrawMode));
601 }
602 Rectangle aDrawingRectLogic;
603 bool bLayoutRTL = rDoc.IsLayoutRTL( nTab );
604
605 {
606 // get drawing pixel rect
607 Rectangle aDrawingRectPixel(Point(nScrX, nScrY), Size(aOutputData.GetScrW(), aOutputData.GetScrH()));
608
609 // correct for border (left/right)
610 if(MAXCOL == nX2)
611 {
612 if(bLayoutRTL)
613 {
614 aDrawingRectPixel.Left() = 0L;
615 }
616 else
617 {
618 aDrawingRectPixel.Right() = GetOutputSizePixel().getWidth();
619 }
620 }
621
622 // correct for border (bottom)
623 if(MAXROW == nY2)
624 {
625 aDrawingRectPixel.Bottom() = GetOutputSizePixel().getHeight();
626 }
627
628 // get logic positions
629 aDrawingRectLogic = PixelToLogic(aDrawingRectPixel, aDrawMode);
630 }
631
632 OutputDevice* pContentDev = &rDevice; // device for document content, used by overlay manager
633 SdrPaintWindow* pTargetPaintWindow = nullptr; // #i74769# work with SdrPaintWindow directly
634
635 {
636 // init redraw
637 ScTabViewShell* pTabViewShell = pViewData->GetViewShell();
638
639 if(pTabViewShell)
640 {
641 MapMode aCurrentMapMode(pContentDev->GetMapMode());
642 pContentDev->SetMapMode(aDrawMode);
643 SdrView* pDrawView = pTabViewShell->GetSdrView();
644
645 if(pDrawView)
646 {
647 // #i74769# Use new BeginDrawLayers() interface
648 vcl::Region aDrawingRegion(aDrawingRectLogic);
649 pTargetPaintWindow = pDrawView->BeginDrawLayers(pContentDev, aDrawingRegion);
650 OSL_ENSURE(pTargetPaintWindow, "BeginDrawLayers: Got no SdrPaintWindow (!)");
651
652 if (!bIsTiledRendering)
653 {
654 // #i74769# get target device from SdrPaintWindow, this may be the prerender
655 // device now, too.
656 pContentDev = &(pTargetPaintWindow->GetTargetOutputDevice());
657 aOutputData.SetContentDevice(pContentDev);
658 }
659 }
660
661 pContentDev->SetMapMode(aCurrentMapMode);
662 }
663 }
664
665 // edge (area) (Pixel)
666 if ( nX2==MAXCOL || nY2==MAXROW )
667 {
668 // save MapMode and set to pixel
669 MapMode aCurrentMapMode(pContentDev->GetMapMode());
670 pContentDev->SetMapMode(MAP_PIXEL);
671
672 Rectangle aPixRect = Rectangle( Point(), GetOutputSizePixel() );
673 pContentDev->SetFillColor( rColorCfg.GetColorValue(svtools::APPBACKGROUND).nColor );
674 pContentDev->SetLineColor();
675 if ( nX2==MAXCOL )
676 {
677 Rectangle aDrawRect( aPixRect );
678 if ( bLayoutRTL )
679 aDrawRect.Right() = nScrX - 1;
680 else
681 aDrawRect.Left() = nScrX + aOutputData.GetScrW();
682 if (aDrawRect.Right() >= aDrawRect.Left())
683 pContentDev->DrawRect( aDrawRect );
684 }
685 if ( nY2==MAXROW )
686 {
687 Rectangle aDrawRect( aPixRect );
688 aDrawRect.Top() = nScrY + aOutputData.GetScrH();
689 if ( nX2==MAXCOL )
690 {
691 // no double painting of the corner
692 if ( bLayoutRTL )
693 aDrawRect.Left() = nScrX;
694 else
695 aDrawRect.Right() = nScrX + aOutputData.GetScrW() - 1;
696 }
697 if (aDrawRect.Bottom() >= aDrawRect.Top())
698 pContentDev->DrawRect( aDrawRect );
699 }
700
701 // restore MapMode
702 pContentDev->SetMapMode(aCurrentMapMode);
703 }
704
705 if ( rDoc.HasBackgroundDraw( nTab, aDrawingRectLogic ) )
706 {
707 pContentDev->SetMapMode(MAP_PIXEL);
708 aOutputData.DrawClear();
709
710 // drawing background
711
712 pContentDev->SetMapMode(aDrawMode);
713 DrawRedraw( aOutputData, eMode, SC_LAYER_BACK );
714 }
715 else
716 aOutputData.SetSolidBackground(true);
717
718 aOutputData.DrawDocumentBackground();
719
720 if ( bGridFirst && ( bGrid || bPage ) )
721 aOutputData.DrawGrid(*pContentDev, bGrid, bPage);
722
723 aOutputData.DrawBackground(*pContentDev);
724
725 if ( !bGridFirst && ( bGrid || bPage ) )
726 aOutputData.DrawGrid(*pContentDev, bGrid, bPage);
727
728 pContentDev->SetMapMode(MAP_PIXEL);
729
730 if ( bPageMode )
731 {
732 // DrawPagePreview draws complete lines/page numbers, must always be clipped
733 if ( aOutputData.SetChangedClip() )
734 {
735 DrawPagePreview(nX1,nY1,nX2,nY2, *pContentDev);
736 pContentDev->SetClipRegion();
737 }
738 }
739
740 aOutputData.DrawShadow();
741 aOutputData.DrawFrame(*pContentDev);
742
743 // Show Note Mark
744 if ( rOpts.GetOption( VOPT_NOTES ) )
745 aOutputData.DrawNoteMarks(*pContentDev);
746
747 if ( !bLogicText )
748 aOutputData.DrawStrings(); // in pixel MapMode
749
750 // edit cells and printer-metrics text must be before the buttons
751 // (DataPilot buttons contain labels in UI font)
752
753 pContentDev->SetMapMode(pViewData->GetLogicMode(eWhich));
754 if ( bLogicText )
755 aOutputData.DrawStrings(true); // in logic MapMode if bLogicText is set
756 aOutputData.DrawEdit(true);
757
758 // the buttons are painted in absolute coordinates
759 if (bIsTiledRendering)
760 {
761 // Tiled offset nScrX, nScrY
762 MapMode aMap( MAP_PIXEL );
763 aMap.SetOrigin(Point(nScrX, nScrY));
764 pContentDev->SetMapMode(aMap);
765 }
766 else
767 pContentDev->SetMapMode(MAP_PIXEL);
768
769 // Autofilter- and Pivot-Buttons
770
771 DrawButtons(nX1, nX2, rTableInfo, pContentDev); // Pixel
772
773 pContentDev->SetMapMode(MAP_PIXEL);
774
775 aOutputData.DrawClipMarks();
776
777 // In any case, Szenario / ChangeTracking must happen after DrawGrid, also for !bGridFirst
778
779 //! Test, ob ChangeTrack-Anzeige aktiv ist
780 //! Szenario-Rahmen per View-Optionen abschaltbar?
781
782 SCTAB nTabCount = rDoc.GetTableCount();
783 const std::vector<ScHighlightEntry> &rHigh = pViewData->GetView()->GetHighlightRanges();
784 bool bHasScenario = ( nTab+1<nTabCount && rDoc.IsScenario(nTab+1) && !rDoc.IsScenario(nTab) );
785 bool bHasChange = ( rDoc.GetChangeTrack() != nullptr );
786
787 if ( bHasChange || bHasScenario || !rHigh.empty() )
788 {
789
790 //! Merge SetChangedClip() with DrawMarks() ?? (different MapMode!)
791
792 bool bAny = true;
793 if (eMode == SC_UPDATE_CHANGED)
794 bAny = aOutputData.SetChangedClip();
795 if (bAny)
796 {
797 if ( bHasChange )
798 aOutputData.DrawChangeTrack();
799
800 if ( bHasScenario )
801 lcl_DrawScenarioFrames( pContentDev, pViewData, eWhich, nX1,nY1,nX2,nY2 );
802
803 lcl_DrawHighlight( aOutputData, pViewData, rHigh );
804
805 if (eMode == SC_UPDATE_CHANGED)
806 pContentDev->SetClipRegion();
807 }
808 }
809
810 // Drawing foreground
811
812 pContentDev->SetMapMode(aDrawMode);
813
814 DrawRedraw( aOutputData, eMode, SC_LAYER_FRONT );
815 DrawRedraw( aOutputData, eMode, SC_LAYER_INTERN );
816 DrawSdrGrid( aDrawingRectLogic, pContentDev );
817
818 if (!bIsInScroll) // Drawing marks
819 {
820 if(eMode == SC_UPDATE_CHANGED && aOutputData.SetChangedClip())
821 {
822 pContentDev->SetClipRegion();
823 }
824 }
825
826 pContentDev->SetMapMode(MAP_PIXEL);
827
828 if ( pViewData->IsRefMode() && nTab >= pViewData->GetRefStartZ() && nTab <= pViewData->GetRefEndZ() )
829 {
830 Color aRefColor( rColorCfg.GetColorValue(svtools::CALCREFERENCE).nColor );
831 aOutputData.DrawRefMark( pViewData->GetRefStartX(), pViewData->GetRefStartY(),
832 pViewData->GetRefEndX(), pViewData->GetRefEndY(),
833 aRefColor, false );
834 }
835
836 // range finder
837
838 ScInputHandler* pHdl = pScMod->GetInputHdl( pViewData->GetViewShell() );
839 if (pHdl)
840 {
841 ScRangeFindList* pRangeFinder = pHdl->GetRangeFindList();
842 if ( pRangeFinder && !pRangeFinder->IsHidden() &&
843 pRangeFinder->GetDocName() == pDocSh->GetTitle() )
844 {
845 sal_uInt16 nCount = (sal_uInt16)pRangeFinder->Count();
846 for (sal_uInt16 i=0; i<nCount; i++)
847 {
848 ScRangeFindData& rData = pRangeFinder->GetObject(i);
849
850 ScRange aRef = rData.aRef;
851 aRef.PutInOrder();
852 if ( aRef.aStart.Tab() >= nTab && aRef.aEnd.Tab() <= nTab )
853 aOutputData.DrawRefMark( aRef.aStart.Col(), aRef.aStart.Row(),
854 aRef.aEnd.Col(), aRef.aEnd.Row(),
855 Color( rData.nColorData ),
856 true );
857 }
858 }
859 }
860
861 {
862 // end redraw
863 ScTabViewShell* pTabViewShell = pViewData->GetViewShell();
864
865 if(pTabViewShell)
866 {
867 MapMode aCurrentMapMode(pContentDev->GetMapMode());
868 pContentDev->SetMapMode(aDrawMode);
869 SdrView* pDrawView = pTabViewShell->GetSdrView();
870
871 if(pDrawView)
872 {
873 // #i74769# work with SdrPaintWindow directly
874 pDrawView->EndDrawLayers(*pTargetPaintWindow, true);
875 }
876
877 pContentDev->SetMapMode(aCurrentMapMode);
878 }
879 }
880
881 // In-place editing - when the user is typing, we need to paint the text
882 // using the editeng.
883 // It's being done after EndDrawLayers() to get it outside the overlay
884 // buffer and on top of everything.
885 if ( bEditMode && (pViewData->GetRefTabNo() == pViewData->GetTabNo()) )
886 {
887 // get the coordinates of the area we need to clear (overpaint by
888 // the background)
889 SCCOL nCol1 = pViewData->GetEditStartCol();
890 SCROW nRow1 = pViewData->GetEditStartRow();
891 SCCOL nCol2 = pViewData->GetEditEndCol();
892 SCROW nRow2 = pViewData->GetEditEndRow();
893 rDevice.SetLineColor();
894 rDevice.SetFillColor(pEditView->GetBackgroundColor());
895 Point aStart = pViewData->GetScrPos( nCol1, nRow1, eWhich );
896 Point aEnd = pViewData->GetScrPos( nCol2+1, nRow2+1, eWhich );
897
898 // don't overwrite grid
899 long nLayoutSign = bLayoutRTL ? -1 : 1;
900 aEnd.X() -= 2 * nLayoutSign;
901 aEnd.Y() -= 2;
902
903 // toggle the cursor off if its on to ensure the cursor invert
904 // background logic remains valid after the background is cleared on
905 // the next cursor flash
906 vcl::Cursor* pCrsr = pEditView->GetCursor();
907 const bool bVisCursor = pCrsr && pCrsr->IsVisible();
908 if (bVisCursor)
909 pCrsr->Hide();
910
911 // set the correct mapmode
912 Rectangle aBackground(aStart, aEnd);
913 if (bIsTiledRendering)
914 {
915 aBackground += Point(nScrX, nScrY);
916 rDevice.SetMapMode(aDrawMode);
917 }
918 else
919 rDevice.SetMapMode(pViewData->GetLogicMode());
920
921 // paint the background
922 rDevice.DrawRect(rDevice.PixelToLogic(aBackground));
923
924 // paint the editeng text
925 pEditView->Paint(rDevice.PixelToLogic(Rectangle(Point(nScrX, nScrY), Size(aOutputData.GetScrW(), aOutputData.GetScrH()))), &rDevice);
926 rDevice.SetMapMode(MAP_PIXEL);
927
928 // restore the cursor it was originally visible
929 if (bVisCursor)
930 pCrsr->Show();
931 }
932
933 if (pViewData->HasEditView(eWhich))
934 {
935 // flush OverlayManager before changing the MapMode
936 flushOverlayManager();
937
938 // set MapMode for text edit
939 rDevice.SetMapMode(pViewData->GetLogicMode());
940 }
941 else
942 rDevice.SetMapMode(aDrawMode);
943
944 if (mpNoteMarker)
945 mpNoteMarker->Draw(); // Above the cursor, in drawing map mode
946 }
947
948 void ScGridWindow::PaintTile( VirtualDevice& rDevice,
949 int nOutputWidth, int nOutputHeight,
950 int nTilePosX, int nTilePosY,
951 long nTileWidth, long nTileHeight )
952 {
953 // Output size is in pixels while tile position and size are in logical units (twips).
954
955 // Assumption: always paint the whole sheet i.e. "visible" range is always
956 // from (0,0) to last data position.
957
958 // Tile geometry is independent of the zoom level, but the output size is
959 // dependent of the zoom level. Determine the correct zoom level before
960 // we start.
961
962 // FIXME the painting works using a mixture of drawing with coordinates in
963 // pixels and in logic coordinates; it should be cleaned up to use logic
964 // coords only, and avoid all the SetMapMode()'s.
965 // Similarly to Writer, we should set the mapmode once on the rDevice, and
966 // not care about any zoom settings.
967
968 Fraction aFracX(long(nOutputWidth * TWIPS_PER_PIXEL), nTileWidth);
969 Fraction aFracY(long(nOutputHeight * TWIPS_PER_PIXEL), nTileHeight);
970
971 // page break zoom, and aLogicMode in ScViewData
972 pViewData->SetZoom(aFracX, aFracY, true);
973
974 double fTilePosXPixel = static_cast<double>(nTilePosX) * nOutputWidth / nTileWidth;
975 double fTilePosYPixel = static_cast<double>(nTilePosY) * nOutputHeight / nTileHeight;
976
977 SCTAB nTab = pViewData->GetTabNo();
978 ScDocument* pDoc = pViewData->GetDocument();
979
980 SCCOL nStartCol = 0, nEndCol = 0;
981 SCROW nStartRow = 0, nEndRow = 0;
982
983 // size of the document including drawings, charts, etc.
984 pDoc->GetTiledRenderingArea(nTab, nEndCol, nEndRow);
985
986 double fPPTX = pViewData->GetPPTX();
987 double fPPTY = pViewData->GetPPTY();
988
989 ScTableInfo aTabInfo;
990 pDoc->FillInfo(aTabInfo, nStartCol, nStartRow, nEndCol, nEndRow, nTab, fPPTX, fPPTY, false, false);
991
992 ScOutputData aOutputData(&rDevice, OUTTYPE_WINDOW, aTabInfo, pDoc, nTab,
993 -fTilePosXPixel, -fTilePosYPixel, nStartCol, nStartRow, nEndCol, nEndRow,
994 fPPTX, fPPTY);
995
996 // setup the SdrPage so that drawinglayer works correctly
997 ScDrawLayer* pModel = pDoc->GetDrawLayer();
998 std::unique_ptr<FmFormView> pDrawView;
999 if (pModel)
1000 {
1001 pDrawView.reset(new FmFormView(pModel, &rDevice));
1002 pDrawView->ShowSdrPage(pDrawView->GetModel()->GetPage(nTab));
1003 aOutputData.SetDrawView( pDrawView.get() );
1004 }
1005
1006 // draw the content
1007 DrawContent(rDevice, aTabInfo, aOutputData, true, SC_UPDATE_ALL);
1008 }
1009
1010 void ScGridWindow::LogicInvalidate(const Rectangle* pRectangle)
1011 {
1012 OString sRectangle;
1013 if (!pRectangle)
1014 sRectangle = "EMPTY";
1015 else
1016 {
1017 Rectangle aRectangle(*pRectangle);
1018 // When dragging shapes the map mode is disabled.
1019 if (IsMapModeEnabled())
1020 {
1021 if (GetMapMode().GetMapUnit() == MAP_100TH_MM)
1022 aRectangle = OutputDevice::LogicToLogic(aRectangle, MAP_100TH_MM, MAP_TWIP);
1023 }
1024 else
1025 aRectangle = PixelToLogic(aRectangle, MapMode(MAP_TWIP));
1026 sRectangle = aRectangle.toString();
1027 }
1028
1029 pViewData->GetDocument()->GetDrawLayer()->libreOfficeKitCallback(LOK_CALLBACK_INVALIDATE_TILES, sRectangle.getStr());
1030 }
1031
1032 void ScGridWindow::SetCellSelectionPixel(int nType, int nPixelX, int nPixelY)
1033 {
1034 ScTabView* pTabView = pViewData->GetView();
1035 ScTabViewShell* pViewShell = pViewData->GetViewShell();
1036 ScInputHandler* pInputHandler = SC_MOD()->GetInputHdl(pViewShell);
1037
1038 if (pInputHandler && pInputHandler->IsInputMode())
1039 {
1040 // we need to switch off the editeng
1041 ScTabView::UpdateInputLine();
1042 pViewShell->UpdateInputHandler();
1043 }
1044
1045 if (nType == LOK_SETTEXTSELECTION_RESET)
1046 {
1047 pTabView->DoneBlockMode();
1048 return;
1049 }
1050
1051 // obtain the current selection
1052 ScRangeList aRangeList = pViewData->GetMarkData().GetMarkedRanges();
1053
1054 SCCOL nCol1, nCol2;
1055 SCROW nRow1, nRow2;
1056 SCTAB nTab1, nTab2;
1057
1058 bool bWasEmpty = false;
1059 if (aRangeList.empty())
1060 {
1061 nCol1 = nCol2 = pViewData->GetCurX();
1062 nRow1 = nRow2 = pViewData->GetCurY();
1063 bWasEmpty = true;
1064 }
1065 else
1066 aRangeList.Combine().GetVars(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1067
1068 // convert the coordinates to column/row
1069 SCsCOL nNewPosX;
1070 SCsROW nNewPosY;
1071 SCTAB nTab = pViewData->GetTabNo();
1072 pViewData->GetPosFromPixel(nPixelX, nPixelY, eWhich, nNewPosX, nNewPosY);
1073
1074 // change the selection
1075 switch (nType)
1076 {
1077 case LOK_SETTEXTSELECTION_START:
1078 if (nNewPosX != nCol1 || nNewPosY != nRow1 || bWasEmpty)
1079 {
1080 pTabView->SetCursor(nNewPosX, nNewPosY);
1081 pTabView->DoneBlockMode();
1082 pTabView->InitBlockMode(nNewPosX, nNewPosY, nTab, true);
1083 pTabView->MarkCursor(nCol2, nRow2, nTab);
1084 }
1085 break;
1086 case LOK_SETTEXTSELECTION_END:
1087 if (nNewPosX != nCol2 || nNewPosY != nRow2 || bWasEmpty)
1088 {
1089 pTabView->SetCursor(nCol1, nRow1);
1090 pTabView->DoneBlockMode();
1091 pTabView->InitBlockMode(nCol1, nRow1, nTab, true);
1092 pTabView->MarkCursor(nNewPosX, nNewPosY, nTab);
1093 }
1094 break;
1095 default:
1096 assert(false);
1097 break;
1098 }
1099 }
1100
1101 void ScGridWindow::CheckNeedsRepaint()
1102 {
1103 // called at the end of painting, and from timer after background text width calculation
1104
1105 if (bNeedsRepaint)
1106 {
1107 bNeedsRepaint = false;
1108 if (aRepaintPixel.IsEmpty())
1109 Invalidate();
1110 else
1111 Invalidate(PixelToLogic(aRepaintPixel));
1112 aRepaintPixel = Rectangle();
1113
1114 // selection function in status bar might also be invalid
1115 SfxBindings& rBindings = pViewData->GetBindings();
1116 rBindings.Invalidate( SID_STATUS_SUM );
1117 rBindings.Invalidate( SID_ATTR_SIZE );
1118 rBindings.Invalidate( SID_TABLE_CELL );
1119 }
1120 }
1121
1122 void ScGridWindow::DrawPagePreview( SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2, vcl::RenderContext& rRenderContext)
1123 {
1124 ScPageBreakData* pPageData = pViewData->GetView()->GetPageBreakData();
1125 if (pPageData)
1126 {
1127 ScDocument* pDoc = pViewData->GetDocument();
1128 SCTAB nTab = pViewData->GetTabNo();
1129 Size aWinSize = GetOutputSizePixel();
1130 const svtools::ColorConfig& rColorCfg = SC_MOD()->GetColorConfig();
1131 Color aManual( rColorCfg.GetColorValue(svtools::CALCPAGEBREAKMANUAL).nColor );
1132 Color aAutomatic( rColorCfg.GetColorValue(svtools::CALCPAGEBREAK).nColor );
1133
1134 OUString aPageStr = ScGlobal::GetRscString( STR_PGNUM );
1135 if ( nPageScript == SvtScriptType::NONE )
1136 {
1137 // get script type of translated "Page" string only once
1138 nPageScript = pDoc->GetStringScriptType( aPageStr );
1139 if (nPageScript == SvtScriptType::NONE)
1140 nPageScript = ScGlobal::GetDefaultScriptType();
1141 }
1142
1143 vcl::Font aFont;
1144 std::unique_ptr<ScEditEngineDefaulter> pEditEng;
1145 const ScPatternAttr& rDefPattern = static_cast<const ScPatternAttr&>(pDoc->GetPool()->GetDefaultItem(ATTR_PATTERN));
1146 if ( nPageScript == SvtScriptType::LATIN )
1147 {
1148 // use single font and call DrawText directly
1149 rDefPattern.GetFont( aFont, SC_AUTOCOL_BLACK );
1150 aFont.SetColor( Color( COL_LIGHTGRAY ) );
1151 // font size is set as needed
1152 }
1153 else
1154 {
1155 // use EditEngine to draw mixed-script string
1156 pEditEng.reset(new ScEditEngineDefaulter( EditEngine::CreatePool(), true ));
1157 pEditEng->SetRefMapMode(rRenderContext.GetMapMode());
1158 SfxItemSet* pEditDefaults = new SfxItemSet( pEditEng->GetEmptyItemSet() );
1159 rDefPattern.FillEditItemSet( pEditDefaults );
1160 pEditDefaults->Put( SvxColorItem( Color( COL_LIGHTGRAY ), EE_CHAR_COLOR ) );
1161 pEditEng->SetDefaults( pEditDefaults );
1162 }
1163
1164 sal_uInt16 nCount = sal::static_int_cast<sal_uInt16>( pPageData->GetCount() );
1165 for (sal_uInt16 nPos=0; nPos<nCount; nPos++)
1166 {
1167 ScPrintRangeData& rData = pPageData->GetData(nPos);
1168 ScRange aRange = rData.GetPrintRange();
1169 if ( aRange.aStart.Col() <= nX2+1 && aRange.aEnd.Col()+1 >= nX1 &&
1170 aRange.aStart.Row() <= nY2+1 && aRange.aEnd.Row()+1 >= nY1 )
1171 {
1172 // 3 pixel frame around the print area
1173 // (middle pixel on the grid lines)
1174
1175 rRenderContext.SetLineColor();
1176 if (rData.IsAutomatic())
1177 rRenderContext.SetFillColor( aAutomatic );
1178 else
1179 rRenderContext.SetFillColor( aManual );
1180
1181 Point aStart = pViewData->GetScrPos(
1182 aRange.aStart.Col(), aRange.aStart.Row(), eWhich, true );
1183 Point aEnd = pViewData->GetScrPos(
1184 aRange.aEnd.Col() + 1, aRange.aEnd.Row() + 1, eWhich, true );
1185 aStart.X() -= 2;
1186 aStart.Y() -= 2;
1187
1188 // Prevent overflows:
1189 if ( aStart.X() < -10 ) aStart.X() = -10;
1190 if ( aStart.Y() < -10 ) aStart.Y() = -10;
1191 if ( aEnd.X() > aWinSize.Width() + 10 )
1192 aEnd.X() = aWinSize.Width() + 10;
1193 if ( aEnd.Y() > aWinSize.Height() + 10 )
1194 aEnd.Y() = aWinSize.Height() + 10;
1195
1196 rRenderContext.DrawRect( Rectangle( aStart, Point(aEnd.X(),aStart.Y()+2) ) );
1197 rRenderContext.DrawRect( Rectangle( aStart, Point(aStart.X()+2,aEnd.Y()) ) );
1198 rRenderContext.DrawRect( Rectangle( Point(aStart.X(),aEnd.Y()-2), aEnd ) );
1199 rRenderContext.DrawRect( Rectangle( Point(aEnd.X()-2,aStart.Y()), aEnd ) );
1200
1201 // Page breaks
1202 //! Display differently (dashed ????)
1203
1204 size_t nColBreaks = rData.GetPagesX();
1205 const SCCOL* pColEnd = rData.GetPageEndX();
1206 size_t nColPos;
1207 for (nColPos=0; nColPos+1<nColBreaks; nColPos++)
1208 {
1209 SCCOL nBreak = pColEnd[nColPos]+1;
1210 if ( nBreak >= nX1 && nBreak <= nX2+1 )
1211 {
1212 //! Search for hidden
1213 if (pDoc->HasColBreak(nBreak, nTab) & BREAK_MANUAL)
1214 rRenderContext.SetFillColor( aManual );
1215 else
1216 rRenderContext.SetFillColor( aAutomatic );
1217 Point aBreak = pViewData->GetScrPos(
1218 nBreak, aRange.aStart.Row(), eWhich, true );
1219 rRenderContext.DrawRect( Rectangle( aBreak.X()-1, aStart.Y(), aBreak.X(), aEnd.Y() ) );
1220 }
1221 }
1222
1223 size_t nRowBreaks = rData.GetPagesY();
1224 const SCROW* pRowEnd = rData.GetPageEndY();
1225 size_t nRowPos;
1226 for (nRowPos=0; nRowPos+1<nRowBreaks; nRowPos++)
1227 {
1228 SCROW nBreak = pRowEnd[nRowPos]+1;
1229 if ( nBreak >= nY1 && nBreak <= nY2+1 )
1230 {
1231 //! Search for hidden
1232 if (pDoc->HasRowBreak(nBreak, nTab) & BREAK_MANUAL)
1233 rRenderContext.SetFillColor( aManual );
1234 else
1235 rRenderContext.SetFillColor( aAutomatic );
1236 Point aBreak = pViewData->GetScrPos(
1237 aRange.aStart.Col(), nBreak, eWhich, true );
1238 rRenderContext.DrawRect( Rectangle( aStart.X(), aBreak.Y()-1, aEnd.X(), aBreak.Y() ) );
1239 }
1240 }
1241
1242 // Page numbers
1243
1244 SCROW nPrStartY = aRange.aStart.Row();
1245 for (nRowPos=0; nRowPos<nRowBreaks; nRowPos++)
1246 {
1247 SCROW nPrEndY = pRowEnd[nRowPos];
1248 if ( nPrEndY >= nY1 && nPrStartY <= nY2 )
1249 {
1250 SCCOL nPrStartX = aRange.aStart.Col();
1251 for (nColPos=0; nColPos<nColBreaks; nColPos++)
1252 {
1253 SCCOL nPrEndX = pColEnd[nColPos];
1254 if ( nPrEndX >= nX1 && nPrStartX <= nX2 )
1255 {
1256 Point aPageStart = pViewData->GetScrPos(
1257 nPrStartX, nPrStartY, eWhich, true );
1258 Point aPageEnd = pViewData->GetScrPos(
1259 nPrEndX+1,nPrEndY+1, eWhich, true );
1260
1261 long nPageNo = rData.GetFirstPage();
1262 if ( rData.IsTopDown() )
1263 nPageNo += ((long)nColPos)*nRowBreaks+nRowPos;
1264 else
1265 nPageNo += ((long)nRowPos)*nColBreaks+nColPos;
1266
1267 OUString aThisPageStr = aPageStr.replaceFirst("%1", OUString::number(nPageNo));
1268
1269 if ( pEditEng )
1270 {
1271 // find right font size with EditEngine
1272 long nHeight = 100;
1273 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
1274 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
1275 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
1276 pEditEng->SetText( aThisPageStr );
1277 Size aSize100( pEditEng->CalcTextWidth(), pEditEng->GetTextHeight() );
1278
1279 // 40% of width or 60% of height
1280 long nSizeX = 40 * ( aPageEnd.X() - aPageStart.X() ) / aSize100.Width();
1281 long nSizeY = 60 * ( aPageEnd.Y() - aPageStart.Y() ) / aSize100.Height();
1282 nHeight = std::min(nSizeX,nSizeY);
1283 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) );
1284 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) );
1285 pEditEng->SetDefaultItem( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) );
1286
1287 // centered output with EditEngine
1288 Size aTextSize( pEditEng->CalcTextWidth(), pEditEng->GetTextHeight() );
1289 Point aPos( (aPageStart.X()+aPageEnd.X()-aTextSize.Width())/2,
1290 (aPageStart.Y()+aPageEnd.Y()-aTextSize.Height())/2 );
1291 pEditEng->Draw( &rRenderContext, aPos );
1292 }
1293 else
1294 {
1295 // find right font size for DrawText
1296 aFont.SetFontSize( Size( 0,100 ) );
1297 rRenderContext.SetFont( aFont );
1298 Size aSize100(rRenderContext.GetTextWidth( aThisPageStr ), rRenderContext.GetTextHeight() );
1299
1300 // 40% of width or 60% of height
1301 long nSizeX = 40 * ( aPageEnd.X() - aPageStart.X() ) / aSize100.Width();
1302 long nSizeY = 60 * ( aPageEnd.Y() - aPageStart.Y() ) / aSize100.Height();
1303 aFont.SetFontSize( Size( 0,std::min(nSizeX,nSizeY) ) );
1304 rRenderContext.SetFont( aFont );
1305
1306 // centered output with DrawText
1307 Size aTextSize(rRenderContext.GetTextWidth( aThisPageStr ), rRenderContext.GetTextHeight() );
1308 Point aPos( (aPageStart.X()+aPageEnd.X()-aTextSize.Width())/2,
1309 (aPageStart.Y()+aPageEnd.Y()-aTextSize.Height())/2 );
1310 rRenderContext.DrawText( aPos, aThisPageStr );
1311 }
1312 }
1313 nPrStartX = nPrEndX + 1;
1314 }
1315 }
1316 nPrStartY = nPrEndY + 1;
1317 }
1318 }
1319 }
1320 }
1321 }
1322
1323 void ScGridWindow::DrawButtons(SCCOL nX1, SCCOL nX2, const ScTableInfo& rTabInfo, OutputDevice* pContentDev)
1324 {
1325 aComboButton.SetOutputDevice( pContentDev );
1326
1327 ScDocument* pDoc = pViewData->GetDocument();
1328 ScDPFieldButton aCellBtn(pContentDev, &GetSettings().GetStyleSettings(), &pViewData->GetZoomX(), &pViewData->GetZoomY(), pDoc);
1329
1330 SCCOL nCol;
1331 SCROW nRow;
1332 SCSIZE nArrY;
1333 SCSIZE nQuery;
1334 SCTAB nTab = pViewData->GetTabNo();
1335 ScDBData* pDBData = nullptr;
1336 std::unique_ptr<ScQueryParam> pQueryParam;
1337
1338 RowInfo* pRowInfo = rTabInfo.mpRowInfo;
1339 sal_uInt16 nArrCount = rTabInfo.mnArrCount;
1340
1341 bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1342
1343 Point aOldPos = aComboButton.GetPosPixel(); // store state for MouseDown/Up
1344 Size aOldSize = aComboButton.GetSizePixel();
1345
1346 for (nArrY=1; nArrY+1<nArrCount; nArrY++)
1347 {
1348 if ( pRowInfo[nArrY].bAutoFilter && pRowInfo[nArrY].bChanged )
1349 {
1350 RowInfo* pThisRowInfo = &pRowInfo[nArrY];
1351
1352 nRow = pThisRowInfo->nRowNo;
1353
1354 for (nCol=nX1; nCol<=nX2; nCol++)
1355 {
1356 CellInfo* pInfo = &pThisRowInfo->pCellInfo[nCol+1];
1357 //if several columns merged on a row, there should be only one auto button at the end of the columns.
1358 //if several rows merged on a column, the button may be in the middle, so "!pInfo->bVOverlapped" should not be used
1359 if ( pInfo->bAutoFilter && !pInfo->bHOverlapped )
1360 {
1361 if (!pQueryParam)
1362 pQueryParam.reset(new ScQueryParam);
1363
1364 bool bNewData = true;
1365 if (pDBData)
1366 {
1367 SCCOL nStartCol;
1368 SCROW nStartRow;
1369 SCCOL nEndCol;
1370 SCROW nEndRow;
1371 SCTAB nAreaTab;
1372 pDBData->GetArea( nAreaTab, nStartCol, nStartRow, nEndCol, nEndRow );
1373 if ( nCol >= nStartCol && nCol <= nEndCol &&
1374 nRow >= nStartRow && nRow <= nEndRow )
1375 bNewData = false;
1376 }
1377 if (bNewData)
1378 {
1379 pDBData = pDoc->GetDBAtCursor( nCol, nRow, nTab, ScDBDataPortion::AREA );
1380 if (pDBData)
1381 pDBData->GetQueryParam( *pQueryParam );
1382 else
1383 {
1384 // can also be part of DataPilot table
1385 }
1386 }
1387
1388 // pQueryParam can only include MAXQUERY entries
1389
1390 bool bSimpleQuery = true;
1391 bool bColumnFound = false;
1392 if (!pQueryParam->bInplace)
1393 bSimpleQuery = false;
1394 SCSIZE nCount = pQueryParam->GetEntryCount();
1395 for (nQuery = 0; nQuery < nCount && bSimpleQuery; ++nQuery)
1396 if (pQueryParam->GetEntry(nQuery).bDoQuery)
1397 {
1398 // Do no restrict to EQUAL here
1399 // (Column head should become blue also when ">1")
1400
1401 if (pQueryParam->GetEntry(nQuery).nField == nCol)
1402 bColumnFound = true;
1403 if (nQuery > 0)
1404 if (pQueryParam->GetEntry(nQuery).eConnect != SC_AND)
1405 bSimpleQuery = false;
1406 }
1407
1408 bool bArrowState = bSimpleQuery && bColumnFound;
1409 long nSizeX;
1410 long nSizeY;
1411 SCCOL nStartCol= nCol;
1412 SCROW nStartRow = nRow;
1413 //if address(nCol,nRow) is not the start pos of the merge area, the value of the nSizeX will be incorrect, it will be the length of the cell.
1414 //should first get the start pos of the merge area, then get the nSizeX through the start pos.
1415 pDoc->ExtendOverlapped(nStartCol, nStartRow,nCol, nRow, nTab);//get nStartCol,nStartRow
1416 pViewData->GetMergeSizePixel( nStartCol, nStartRow, nSizeX, nSizeY );//get nSizeX
1417 nSizeY = ScViewData::ToPixel(pDoc->GetRowHeight(nRow, nTab), pViewData->GetPPTY());
1418 Point aScrPos = pViewData->GetScrPos( nCol, nRow, eWhich );
1419
1420 aCellBtn.setBoundingBox(aScrPos, Size(nSizeX-1, nSizeY-1), bLayoutRTL);
1421 aCellBtn.setPopupLeft(bLayoutRTL); // #i114944# AutoFilter button is left-aligned in RTL
1422 aCellBtn.setDrawBaseButton(false);
1423 aCellBtn.setDrawPopupButton(true);
1424 aCellBtn.setHasHiddenMember(bArrowState);
1425 aCellBtn.draw();
1426 }
1427 }
1428 }
1429
1430 if ( pRowInfo[nArrY].bPivotButton && pRowInfo[nArrY].bChanged )
1431 {
1432 RowInfo* pThisRowInfo = &pRowInfo[nArrY];
1433 nRow = pThisRowInfo->nRowNo;
1434 for (nCol=nX1; nCol<=nX2; nCol++)
1435 {
1436 CellInfo* pInfo = &pThisRowInfo->pCellInfo[nCol+1];
1437 if (pInfo->bHOverlapped || pInfo->bVOverlapped)
1438 continue;
1439
1440 Point aScrPos = pViewData->GetScrPos( nCol, nRow, eWhich );
1441 long nSizeX;
1442 long nSizeY;
1443 pViewData->GetMergeSizePixel( nCol, nRow, nSizeX, nSizeY );
1444 long nPosX = aScrPos.X();
1445 long nPosY = aScrPos.Y();
1446 // bLayoutRTL is handled in setBoundingBox
1447
1448 OUString aStr = pDoc->GetString(nCol, nRow, nTab);
1449 aCellBtn.setText(aStr);
1450 aCellBtn.setBoundingBox(Point(nPosX, nPosY), Size(nSizeX-1, nSizeY-1), bLayoutRTL);
1451 aCellBtn.setPopupLeft(false); // DataPilot popup is always right-aligned for now
1452 aCellBtn.setDrawBaseButton(pInfo->bPivotButton);
1453 aCellBtn.setDrawPopupButton(pInfo->bPivotPopupButton);
1454 aCellBtn.setHasHiddenMember(pInfo->bFilterActive);
1455 aCellBtn.draw();
1456 }
1457 }
1458
1459 if ( bListValButton && pRowInfo[nArrY].nRowNo == aListValPos.Row() && pRowInfo[nArrY].bChanged )
1460 {
1461 Rectangle aRect = GetListValButtonRect( aListValPos );
1462 aComboButton.SetPosPixel( aRect.TopLeft() );
1463 aComboButton.SetSizePixel( aRect.GetSize() );
1464 pContentDev->SetClipRegion(vcl::Region(aRect));
1465 aComboButton.Draw();
1466 pContentDev->SetClipRegion(); // always called from Draw() without clip region
1467 aComboButton.SetPosPixel( aOldPos ); // restore old state
1468 aComboButton.SetSizePixel( aOldSize ); // for MouseUp/Down (AutoFilter)
1469 }
1470 }
1471
1472 pQueryParam.reset();
1473 aComboButton.SetOutputDevice( this );
1474 }
1475
1476 Rectangle ScGridWindow::GetListValButtonRect( const ScAddress& rButtonPos )
1477 {
1478 ScDocument* pDoc = pViewData->GetDocument();
1479 SCTAB nTab = pViewData->GetTabNo();
1480 bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1481 long nLayoutSign = bLayoutRTL ? -1 : 1;
1482
1483 ScDDComboBoxButton aButton( this ); // for optimal size
1484 Size aBtnSize = aButton.GetSizePixel();
1485
1486 SCCOL nCol = rButtonPos.Col();
1487 SCROW nRow = rButtonPos.Row();
1488
1489 long nCellSizeX; // width of this cell, including merged
1490 long nDummy;
1491 pViewData->GetMergeSizePixel( nCol, nRow, nCellSizeX, nDummy );
1492
1493 // for height, only the cell's row is used, excluding merged cells
1494 long nCellSizeY = ScViewData::ToPixel( pDoc->GetRowHeight( nRow, nTab ), pViewData->GetPPTY() );
1495 long nAvailable = nCellSizeX;
1496
1497 // left edge of next cell if there is a non-hidden next column
1498 SCCOL nNextCol = nCol + 1;
1499 const ScMergeAttr* pMerge = static_cast<const ScMergeAttr*>(pDoc->GetAttr( nCol,nRow,nTab, ATTR_MERGE ));
1500 if ( pMerge->GetColMerge() > 1 )
1501 nNextCol = nCol + pMerge->GetColMerge(); // next cell after the merged area
1502 while ( nNextCol <= MAXCOL && pDoc->ColHidden(nNextCol, nTab) )
1503 ++nNextCol;
1504 bool bNextCell = ( nNextCol <= MAXCOL );
1505 if ( bNextCell )
1506 nAvailable = ScViewData::ToPixel( pDoc->GetColWidth( nNextCol, nTab ), pViewData->GetPPTX() );
1507
1508 if ( nAvailable < aBtnSize.Width() )
1509 aBtnSize.Width() = nAvailable;
1510 if ( nCellSizeY < aBtnSize.Height() )
1511 aBtnSize.Height() = nCellSizeY;
1512
1513 Point aPos = pViewData->GetScrPos( nCol, nRow, eWhich, true );
1514 aPos.X() += nCellSizeX * nLayoutSign; // start of next cell
1515 if (!bNextCell)
1516 aPos.X() -= aBtnSize.Width() * nLayoutSign; // right edge of cell if next cell not available
1517 aPos.Y() += nCellSizeY - aBtnSize.Height();
1518 // X remains at the left edge
1519
1520 if ( bLayoutRTL )
1521 aPos.X() -= aBtnSize.Width()-1; // align right edge of button with cell border
1522
1523 return Rectangle( aPos, aBtnSize );
1524 }
1525
1526 bool ScGridWindow::IsAutoFilterActive( SCCOL nCol, SCROW nRow, SCTAB nTab )
1527 {
1528 ScDocument* pDoc = pViewData->GetDocument();
1529 ScDBData* pDBData = pDoc->GetDBAtCursor( nCol, nRow, nTab, ScDBDataPortion::AREA );
1530 ScQueryParam aQueryParam;
1531
1532 if ( pDBData )
1533 pDBData->GetQueryParam( aQueryParam );
1534 else
1535 {
1536 OSL_FAIL("Auto filter button without DBData");
1537 }
1538
1539 bool bSimpleQuery = true;
1540 bool bColumnFound = false;
1541 SCSIZE nQuery;
1542
1543 if ( !aQueryParam.bInplace )
1544 bSimpleQuery = false;
1545
1546 // aQueryParam can only include MAXQUERY entries
1547
1548 SCSIZE nCount = aQueryParam.GetEntryCount();
1549 for (nQuery = 0; nQuery < nCount && bSimpleQuery; ++nQuery)
1550 if ( aQueryParam.GetEntry(nQuery).bDoQuery )
1551 {
1552 if (aQueryParam.GetEntry(nQuery).nField == nCol)
1553 bColumnFound = true;
1554
1555 if (nQuery > 0)
1556 if (aQueryParam.GetEntry(nQuery).eConnect != SC_AND)
1557 bSimpleQuery = false;
1558 }
1559
1560 return ( bSimpleQuery && bColumnFound );
1561 }
1562
1563 void ScGridWindow::GetSelectionRects( ::std::vector< Rectangle >& rPixelRects )
1564 {
1565 ScMarkData aMultiMark( pViewData->GetMarkData() );
1566 aMultiMark.SetMarking( false );
1567 aMultiMark.MarkToMulti();
1568 ScDocument* pDoc = pViewData->GetDocument();
1569 SCTAB nTab = pViewData->GetTabNo();
1570
1571 bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1572 long nLayoutSign = bLayoutRTL ? -1 : 1;
1573 if ( !aMultiMark.IsMultiMarked() )
1574 return;
1575 ScRange aMultiRange;
1576 aMultiMark.GetMultiMarkArea( aMultiRange );
1577 SCCOL nX1 = aMultiRange.aStart.Col();
1578 SCROW nY1 = aMultiRange.aStart.Row();
1579 SCCOL nX2 = aMultiRange.aEnd.Col();
1580 SCROW nY2 = aMultiRange.aEnd.Row();
1581
1582 PutInOrder( nX1, nX2 );
1583 PutInOrder( nY1, nY2 );
1584
1585 bool bTestMerge = true;
1586 bool bRepeat = true;
1587
1588 SCCOL nTestX2 = nX2;
1589 SCROW nTestY2 = nY2;
1590 if (bTestMerge)
1591 pDoc->ExtendMerge( nX1,nY1, nTestX2,nTestY2, nTab );
1592
1593 SCCOL nPosX = pViewData->GetPosX( eHWhich );
1594 SCROW nPosY = pViewData->GetPosY( eVWhich );
1595 // is the selection visible at all?
1596 if (nTestX2 < nPosX || nTestY2 < nPosY)
1597 return;
1598 SCCOL nRealX1 = nX1;
1599 if (nX1 < nPosX)
1600 nX1 = nPosX;
1601 if (nY1 < nPosY)
1602 nY1 = nPosY;
1603
1604 if (!comphelper::LibreOfficeKit::isActive())
1605 {
1606 // limit the selection to only what is visible on the screen
1607 SCCOL nXRight = nPosX + pViewData->VisibleCellsX(eHWhich);
1608 if (nXRight > MAXCOL)
1609 nXRight = MAXCOL;
1610
1611 SCROW nYBottom = nPosY + pViewData->VisibleCellsY(eVWhich);
1612 if (nYBottom > MAXROW)
1613 nYBottom = MAXROW;
1614
1615 // is the selection visible at all?
1616 if (nX1 > nXRight || nY1 > nYBottom)
1617 return;
1618
1619 if (nX2 > nXRight)
1620 nX2 = nXRight;
1621 if (nY2 > nYBottom)
1622 nY2 = nYBottom;
1623 }
1624 else
1625 {
1626 SCCOL nMaxTiledCol;
1627 SCROW nMaxTiledRow;
1628 pDoc->GetTiledRenderingArea(nTab, nMaxTiledCol, nMaxTiledRow);
1629
1630 if (nX2 > nMaxTiledCol)
1631 nX2 = nMaxTiledCol;
1632 if (nY2 > nMaxTiledRow)
1633 nY2 = nMaxTiledRow;
1634 }
1635
1636 double nPPTX = pViewData->GetPPTX();
1637 double nPPTY = pViewData->GetPPTY();
1638
1639 ScInvertMerger aInvert( &rPixelRects );
1640
1641 Point aScrPos = pViewData->GetScrPos( nX1, nY1, eWhich );
1642 long nScrY = aScrPos.Y();
1643 bool bWasHidden = false;
1644 for (SCROW nY=nY1; nY<=nY2; nY++)
1645 {
1646 bool bFirstRow = ( nY == nPosY ); // first visible row?
1647 bool bDoHidden = false; // repeat hidden ?
1648 sal_uInt16 nHeightTwips = pDoc->GetRowHeight( nY,nTab );
1649 bool bDoRow = ( nHeightTwips != 0 );
1650 if (bDoRow)
1651 {
1652 if (bTestMerge)
1653 if (bWasHidden) // test hidden merge
1654 {
1655 bDoHidden = true;
1656 bDoRow = true;
1657 }
1658
1659 bWasHidden = false;
1660 }
1661 else
1662 {
1663 bWasHidden = true;
1664 if (bTestMerge)
1665 if (nY==nY2)
1666 bDoRow = true; // last cell of the block
1667 }
1668
1669 if ( bDoRow )
1670 {
1671 SCCOL nLoopEndX = nX2;
1672 if (nX2 < nX1) // the rest of the merge
1673 {
1674 SCCOL nStartX = nX1;
1675 while ( static_cast<const ScMergeFlagAttr*>(pDoc->
1676 GetAttr(nStartX,nY,nTab,ATTR_MERGE_FLAG))->IsHorOverlapped() )
1677 --nStartX;
1678 if (nStartX <= nX2)
1679 nLoopEndX = nX1;
1680 }
1681
1682 long nEndY = nScrY + ScViewData::ToPixel( nHeightTwips, nPPTY ) - 1;
1683 long nScrX = aScrPos.X();
1684 for (SCCOL nX=nX1; nX<=nLoopEndX; nX++)
1685 {
1686 long nWidth = ScViewData::ToPixel( pDoc->GetColWidth( nX,nTab ), nPPTX );
1687 if ( nWidth > 0 )
1688 {
1689 long nEndX = nScrX + ( nWidth - 1 ) * nLayoutSign;
1690 if (bTestMerge)
1691 {
1692 SCROW nThisY = nY;
1693 const ScPatternAttr* pPattern = pDoc->GetPattern( nX, nY, nTab );
1694 const ScMergeFlagAttr* pMergeFlag = static_cast<const ScMergeFlagAttr*>( &pPattern->
1695 GetItem(ATTR_MERGE_FLAG) );
1696 if ( pMergeFlag->IsVerOverlapped() && ( bDoHidden || bFirstRow ) )
1697 {
1698 while ( pMergeFlag->IsVerOverlapped() && nThisY > 0 &&
1699 (pDoc->RowHidden(nThisY-1, nTab) || bFirstRow) )
1700 {
1701 --nThisY;
1702 pPattern = pDoc->GetPattern( nX, nThisY, nTab );
1703 pMergeFlag = static_cast<const ScMergeFlagAttr*>( &pPattern->GetItem(ATTR_MERGE_FLAG) );
1704 }
1705 }
1706
1707 // only the rest of the merged is seen ?
1708 SCCOL nThisX = nX;
1709 if ( pMergeFlag->IsHorOverlapped() && nX == nPosX && nX > nRealX1 )
1710 {
1711 while ( pMergeFlag->IsHorOverlapped() )
1712 {
1713 --nThisX;
1714 pPattern = pDoc->GetPattern( nThisX, nThisY, nTab );
1715 pMergeFlag = static_cast<const ScMergeFlagAttr*>( &pPattern->GetItem(ATTR_MERGE_FLAG) );
1716 }
1717 }
1718
1719 if ( aMultiMark.IsCellMarked( nThisX, nThisY, true ) == bRepeat )
1720 {
1721 if ( !pMergeFlag->IsOverlapped() )
1722 {
1723 const ScMergeAttr* pMerge = static_cast<const ScMergeAttr*>(&pPattern->GetItem(ATTR_MERGE));
1724 if (pMerge->GetColMerge() > 0 || pMerge->GetRowMerge() > 0)
1725 {
1726 Point aEndPos = pViewData->GetScrPos(
1727 nThisX + pMerge->GetColMerge(),
1728 nThisY + pMerge->GetRowMerge(), eWhich );
1729 if ( aEndPos.X() * nLayoutSign > nScrX * nLayoutSign && aEndPos.Y() > nScrY )
1730 {
1731 aInvert.AddRect( Rectangle( nScrX,nScrY,
1732 aEndPos.X()-nLayoutSign,aEndPos.Y()-1 ) );
1733 }
1734 }
1735 else if ( nEndX * nLayoutSign >= nScrX * nLayoutSign && nEndY >= nScrY )
1736 {
1737 aInvert.AddRect( Rectangle( nScrX,nScrY,nEndX,nEndY ) );
1738 }
1739 }
1740 }
1741 }
1742 else // !bTestMerge
1743 {
1744 if ( aMultiMark.IsCellMarked( nX, nY, true ) == bRepeat &&
1745 nEndX * nLayoutSign >= nScrX * nLayoutSign && nEndY >= nScrY )
1746 {
1747 aInvert.AddRect( Rectangle( nScrX,nScrY,nEndX,nEndY ) );
1748 }
1749 }
1750
1751 nScrX = nEndX + nLayoutSign;
1752 }
1753 }
1754 nScrY = nEndY + 1;
1755 }
1756 }
1757 }
1758
1759 void ScGridWindow::DataChanged( const DataChangedEvent& rDCEvt )
1760 {
1761 Window::DataChanged(rDCEvt);
1762
1763 if ( (rDCEvt.GetType() == DataChangedEventType::PRINTER) ||
1764 (rDCEvt.GetType() == DataChangedEventType::DISPLAY) ||
1765 (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
1766 (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
1767 ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1768 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
1769 {
1770 if ( rDCEvt.GetType() == DataChangedEventType::FONTS && eWhich == pViewData->GetActivePart() )
1771 pViewData->GetDocShell()->UpdateFontList();
1772
1773 if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1774 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
1775 {
1776 if ( eWhich == pViewData->GetActivePart() ) // only once for the view
1777 {
1778 ScTabView* pView = pViewData->GetView();
1779
1780 // update scale in case the UI ScreenZoom has changed
1781 ScGlobal::UpdatePPT(this);
1782 pView->RecalcPPT();
1783
1784 // RepeatResize in case scroll bar sizes have changed
1785 pView->RepeatResize();
1786 pView->UpdateAllOverlays();
1787
1788 // invalidate cell attribs in input handler, in case the
1789 // EditEngine BackgroundColor has to be changed
1790 if ( pViewData->IsActive() )
1791 {
1792 ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
1793 if (pHdl)
1794 pHdl->ForgetLastPattern();
1795 }
1796 }
1797 }
1798
1799 Invalidate();
1800 }
1801 }
1802
1803 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE