?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sc / source / ui / dbgui / csvgrid.cxx
blobe1595b12c821c203ffae69f78e3fd79581323e61
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 "csvgrid.hxx"
21
22 #include <algorithm>
23 #include <memory>
24
25 #include <comphelper/string.hxx>
26 #include <svtools/colorcfg.hxx>
27 #include <svl/smplhint.hxx>
28 #include <sal/macros.h>
29 #include <tools/poly.hxx>
30 #include "scmod.hxx"
31 #include "asciiopt.hxx"
32 #include "impex.hxx"
33 #include "AccessibleCsvControl.hxx"
34
35 // *** edit engine ***
36 #include "scitems.hxx"
37 #include <editeng/eeitem.hxx>
38
39
40 #include <editeng/colritem.hxx>
41 #include <editeng/fhgtitem.hxx>
42 #include <editeng/fontitem.hxx>
43 #include <svl/itemset.hxx>
44 #include "editutil.hxx"
45 // *** edit engine ***
46
47
48 // ============================================================================
49
50 struct Func_SetType
51 {
52 sal_Int32 mnType;
53 inline Func_SetType( sal_Int32 nType ) : mnType( nType ) {}
54 inline void operator()( ScCsvColState& rState ) const
55 { rState.mnType = mnType; }
56 };
57
58 struct Func_Select
59 {
60 bool mbSelect;
61 inline Func_Select( bool bSelect ) : mbSelect( bSelect ) {}
62 inline void operator()( ScCsvColState& rState ) const
63 { rState.Select( mbSelect ); }
64 };
65
66
67 // ============================================================================
68
69 ScCsvGrid::ScCsvGrid( ScCsvControl& rParent ) :
70 ScCsvControl( rParent ),
71 mpColorConfig( 0 ),
72 mpEditEngine( new ScEditEngineDefaulter( EditEngine::CreatePool(), true ) ),
73 maHeaderFont( GetFont() ),
74 maColStates( 1 ),
75 maTypeNames( 1 ),
76 mnFirstImpLine( 0 ),
77 mnRecentSelCol( CSV_COLUMN_INVALID )
78 {
79 mpEditEngine->SetRefDevice( &maBackgrDev );
80 mpEditEngine->SetRefMapMode( MapMode( MAP_PIXEL ) );
81 maEdEngSize = mpEditEngine->GetPaperSize();
82
83 maPopup.SetMenuFlags( maPopup.GetMenuFlags() | MENU_FLAG_NOAUTOMNEMONICS );
84
85 EnableRTL( false ); // RTL
86 InitFonts();
87 ImplClearSplits();
88 }
89
90 ScCsvGrid::~ScCsvGrid()
91 {
92 OSL_ENSURE(mpColorConfig, "the object hasn't been initialized properly");
93 if (mpColorConfig)
94 mpColorConfig->RemoveListener(this);
95 }
96
97 void
98 ScCsvGrid::Init()
99 {
100 OSL_PRECOND(!mpColorConfig, "the object has already been initialized");
101 mpColorConfig = &SC_MOD()->GetColorConfig();
102 InitColors();
103 mpColorConfig->AddListener(this);
104 }
105
106 // common grid handling -------------------------------------------------------
107
108 void ScCsvGrid::UpdateLayoutData()
109 {
110 DisableRepaint();
111 SetFont( maMonoFont );
112 Execute( CSVCMD_SETCHARWIDTH, GetTextWidth( OUString( 'X' ) ) );
113 Execute( CSVCMD_SETLINEHEIGHT, GetTextHeight() + 1 );
114 SetFont( maHeaderFont );
115 Execute( CSVCMD_SETHDRHEIGHT, GetTextHeight() + 1 );
116 UpdateOffsetX();
117 EnableRepaint();
118 }
119
120 void ScCsvGrid::UpdateOffsetX()
121 {
122 sal_Int32 nLastLine = GetLastVisLine() + 1;
123 sal_Int32 nDigits = 2;
124 while( nLastLine /= 10 ) ++nDigits;
125 nDigits = std::max( nDigits, sal_Int32( 3 ) );
126 Execute( CSVCMD_SETHDRWIDTH, GetTextWidth( OUString( '0' ) ) * nDigits );
127 }
128
129 void ScCsvGrid::ApplyLayout( const ScCsvLayoutData& rOldData )
130 {
131 ScCsvDiff nDiff = GetLayoutData().GetDiff( rOldData );
132 if( nDiff == CSV_DIFF_EQUAL ) return;
133
134 DisableRepaint();
135
136 if( nDiff & CSV_DIFF_RULERCURSOR )
137 {
138 ImplInvertCursor( rOldData.mnPosCursor );
139 ImplInvertCursor( GetRulerCursorPos() );
140 }
141
142 if( nDiff & CSV_DIFF_POSCOUNT )
143 {
144 if( GetPosCount() < rOldData.mnPosCount )
145 {
146 SelectAll( false );
147 maSplits.RemoveRange( GetPosCount(), rOldData.mnPosCount );
148 }
149 else
150 maSplits.Remove( rOldData.mnPosCount );
151 maSplits.Insert( GetPosCount() );
152 maColStates.resize( maSplits.Count() - 1 );
153 }
154
155 if( nDiff & CSV_DIFF_LINEOFFSET )
156 {
157 Execute( CSVCMD_UPDATECELLTEXTS );
158 UpdateOffsetX();
159 }
160
161 ScCsvDiff nHVDiff = nDiff & (CSV_DIFF_HORIZONTAL | CSV_DIFF_VERTICAL);
162 if( nHVDiff == CSV_DIFF_POSOFFSET )
163 ImplDrawHorzScrolled( rOldData.mnPosOffset );
164 else if( nHVDiff != CSV_DIFF_EQUAL )
165 InvalidateGfx();
166
167 EnableRepaint();
168
169 if( nDiff & (CSV_DIFF_POSOFFSET | CSV_DIFF_LINEOFFSET) )
170 AccSendVisibleEvent();
171 }
172
173 void ScCsvGrid::SetFirstImportedLine( sal_Int32 nLine )
174 {
175 ImplDrawFirstLineSep( false );
176 mnFirstImpLine = nLine;
177 ImplDrawFirstLineSep( true );
178 ImplDrawGridDev();
179 Repaint();
180 }
181
182 sal_Int32 ScCsvGrid::GetNoScrollCol( sal_Int32 nPos ) const
183 {
184 sal_Int32 nNewPos = nPos;
185 if( nNewPos != CSV_POS_INVALID )
186 {
187 if( nNewPos < GetFirstVisPos() + CSV_SCROLL_DIST )
188 {
189 sal_Int32 nScroll = (GetFirstVisPos() > 0) ? CSV_SCROLL_DIST : 0;
190 nNewPos = GetFirstVisPos() + nScroll;
191 }
192 else if( nNewPos > GetLastVisPos() - CSV_SCROLL_DIST - 1L )
193 {
194 sal_Int32 nScroll = (GetFirstVisPos() < GetMaxPosOffset()) ? CSV_SCROLL_DIST : 0;
195 nNewPos = GetLastVisPos() - nScroll - 1;
196 }
197 }
198 return nNewPos;
199 }
200
201 void ScCsvGrid::InitColors()
202 {
203 OSL_PRECOND(mpColorConfig, "the object hasn't been initialized properly");
204 if ( !mpColorConfig )
205 return;
206 maBackColor.SetColor( static_cast< sal_uInt32 >( mpColorConfig->GetColorValue( ::svtools::DOCCOLOR ).nColor ) );
207 maGridColor.SetColor( static_cast< sal_uInt32 >( mpColorConfig->GetColorValue( ::svtools::CALCGRID ).nColor ) );
208 maGridPBColor.SetColor( static_cast< sal_uInt32 >( mpColorConfig->GetColorValue( ::svtools::CALCPAGEBREAK ).nColor ) );
209 maAppBackColor.SetColor( static_cast< sal_uInt32 >( mpColorConfig->GetColorValue( ::svtools::APPBACKGROUND ).nColor ) );
210 maTextColor.SetColor( static_cast< sal_uInt32 >( mpColorConfig->GetColorValue( ::svtools::FONTCOLOR ).nColor ) );
211
212 const StyleSettings& rSett = GetSettings().GetStyleSettings();
213 maHeaderBackColor = rSett.GetFaceColor();
214 maHeaderGridColor = rSett.GetDarkShadowColor();
215 maHeaderTextColor = rSett.GetButtonTextColor();
216 maSelectColor = rSett.GetActiveColor();
217
218 InvalidateGfx();
219 }
220
221 void ScCsvGrid::InitFonts()
222 {
223 maMonoFont = OutputDevice::GetDefaultFont( DEFAULTFONT_FIXED, LANGUAGE_ENGLISH_US, 0 );
224 maMonoFont.SetSize( Size( maMonoFont.GetSize().Width(), maHeaderFont.GetSize().Height() ) );
225
226 /* *** Set edit engine defaults ***
227 maMonoFont for Latin script, smaller default font for Asian and Complex script. */
228
229 // get default fonts
230 SvxFontItem aLatinItem( EE_CHAR_FONTINFO );
231 SvxFontItem aAsianItem( EE_CHAR_FONTINFO_CJK );
232 SvxFontItem aComplexItem( EE_CHAR_FONTINFO_CTL );
233 ::GetDefaultFonts( aLatinItem, aAsianItem, aComplexItem );
234
235 // create item set for defaults
236 SfxItemSet aDefSet( mpEditEngine->GetEmptyItemSet() );
237 EditEngine::SetFontInfoInItemSet( aDefSet, maMonoFont );
238 aDefSet.Put( aAsianItem );
239 aDefSet.Put( aComplexItem );
240
241 // set Asian/Complex font size to height of character in Latin font
242 sal_uLong nFontHt = static_cast< sal_uLong >( maMonoFont.GetSize().Height() );
243 aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CJK ) );
244 aDefSet.Put( SvxFontHeightItem( nFontHt, 100, EE_CHAR_FONTHEIGHT_CTL ) );
245
246 // copy other items from default font
247 const SfxPoolItem& rWeightItem = aDefSet.Get( EE_CHAR_WEIGHT );
248 aDefSet.Put( rWeightItem, EE_CHAR_WEIGHT_CJK );
249 aDefSet.Put( rWeightItem, EE_CHAR_WEIGHT_CTL );
250 const SfxPoolItem& rItalicItem = aDefSet.Get( EE_CHAR_ITALIC );
251 aDefSet.Put( rItalicItem, EE_CHAR_ITALIC_CJK );
252 aDefSet.Put( rItalicItem, EE_CHAR_ITALIC_CTL );
253 const SfxPoolItem& rLangItem = aDefSet.Get( EE_CHAR_LANGUAGE );
254 aDefSet.Put( rLangItem, EE_CHAR_LANGUAGE_CJK );
255 aDefSet.Put( rLangItem, EE_CHAR_LANGUAGE_CTL );
256
257 mpEditEngine->SetDefaults( aDefSet );
258 InvalidateGfx();
259 }
260
261 void ScCsvGrid::InitSizeData()
262 {
263 maWinSize = GetSizePixel();
264 maBackgrDev.SetOutputSizePixel( maWinSize );
265 maGridDev.SetOutputSizePixel( maWinSize );
266 InvalidateGfx();
267 }
268
269
270 // split handling -------------------------------------------------------------
271
272 void ScCsvGrid::InsertSplit( sal_Int32 nPos )
273 {
274 if( ImplInsertSplit( nPos ) )
275 {
276 DisableRepaint();
277 Execute( CSVCMD_EXPORTCOLUMNTYPE );
278 Execute( CSVCMD_UPDATECELLTEXTS );
279 sal_uInt32 nColIx = GetColumnFromPos( nPos );
280 ImplDrawColumn( nColIx - 1 );
281 ImplDrawColumn( nColIx );
282 ValidateGfx(); // performance: do not redraw all columns
283 EnableRepaint();
284 }
285 }
286
287 void ScCsvGrid::RemoveSplit( sal_Int32 nPos )
288 {
289 if( ImplRemoveSplit( nPos ) )
290 {
291 DisableRepaint();
292 Execute( CSVCMD_EXPORTCOLUMNTYPE );
293 Execute( CSVCMD_UPDATECELLTEXTS );
294 ImplDrawColumn( GetColumnFromPos( nPos ) );
295 ValidateGfx(); // performance: do not redraw all columns
296 EnableRepaint();
297 }
298 }
299
300 void ScCsvGrid::MoveSplit( sal_Int32 nPos, sal_Int32 nNewPos )
301 {
302 sal_uInt32 nColIx = GetColumnFromPos( nPos );
303 if( nColIx != CSV_COLUMN_INVALID )
304 {
305 DisableRepaint();
306 if( (GetColumnPos( nColIx - 1 ) < nNewPos) && (nNewPos < GetColumnPos( nColIx + 1 )) )
307 {
308 // move a split in the range between 2 others -> keep selection state of both columns
309 maSplits.Remove( nPos );
310 maSplits.Insert( nNewPos );
311 Execute( CSVCMD_UPDATECELLTEXTS );
312 ImplDrawColumn( nColIx - 1 );
313 ImplDrawColumn( nColIx );
314 ValidateGfx(); // performance: do not redraw all columns
315 AccSendTableUpdateEvent( nColIx - 1, nColIx );
316 }
317 else
318 {
319 ImplRemoveSplit( nPos );
320 ImplInsertSplit( nNewPos );
321 Execute( CSVCMD_EXPORTCOLUMNTYPE );
322 Execute( CSVCMD_UPDATECELLTEXTS );
323 }
324 EnableRepaint();
325 }
326 }
327
328 void ScCsvGrid::RemoveAllSplits()
329 {
330 DisableRepaint();
331 ImplClearSplits();
332 Execute( CSVCMD_EXPORTCOLUMNTYPE );
333 Execute( CSVCMD_UPDATECELLTEXTS );
334 EnableRepaint();
335 }
336
337 void ScCsvGrid::SetSplits( const ScCsvSplits& rSplits )
338 {
339 DisableRepaint();
340 ImplClearSplits();
341 sal_uInt32 nCount = rSplits.Count();
342 for( sal_uInt32 nIx = 0; nIx < nCount; ++nIx )
343 maSplits.Insert( rSplits[ nIx ] );
344 maColStates.clear();
345 maColStates.resize( maSplits.Count() - 1 );
346 Execute( CSVCMD_EXPORTCOLUMNTYPE );
347 Execute( CSVCMD_UPDATECELLTEXTS );
348 EnableRepaint();
349 }
350
351 bool ScCsvGrid::ImplInsertSplit( sal_Int32 nPos )
352 {
353 sal_uInt32 nColIx = GetColumnFromPos( nPos );
354 bool bRet = (nColIx < GetColumnCount()) && maSplits.Insert( nPos );
355 if( bRet )
356 {
357 ScCsvColState aState( GetColumnType( nColIx ) );
358 aState.Select( IsSelected( nColIx ) && IsSelected( nColIx + 1 ) );
359 maColStates.insert( maColStates.begin() + nColIx + 1, aState );
360 AccSendInsertColumnEvent( nColIx + 1, nColIx + 1 );
361 AccSendTableUpdateEvent( nColIx, nColIx );
362 }
363 return bRet;
364 }
365
366 bool ScCsvGrid::ImplRemoveSplit( sal_Int32 nPos )
367 {
368 bool bRet = maSplits.Remove( nPos );
369 if( bRet )
370 {
371 sal_uInt32 nColIx = GetColumnFromPos( nPos );
372 bool bSel = IsSelected( nColIx ) || IsSelected( nColIx + 1 );
373 maColStates.erase( maColStates.begin() + nColIx + 1 );
374 maColStates[ nColIx ].Select( bSel );
375 AccSendRemoveColumnEvent( nColIx + 1, nColIx + 1 );
376 AccSendTableUpdateEvent( nColIx, nColIx );
377 }
378 return bRet;
379 }
380
381 void ScCsvGrid::ImplClearSplits()
382 {
383 sal_uInt32 nColumns = GetColumnCount();
384 maSplits.Clear();
385 maSplits.Insert( 0 );
386 maSplits.Insert( GetPosCount() );
387 maColStates.resize( 1 );
388 InvalidateGfx();
389 AccSendRemoveColumnEvent( 1, nColumns - 1 );
390 }
391
392 // columns/column types -------------------------------------------------------
393
394 sal_uInt32 ScCsvGrid::GetFirstVisColumn() const
395 {
396 return GetColumnFromPos( GetFirstVisPos() );
397 }
398
399 sal_uInt32 ScCsvGrid::GetLastVisColumn() const
400 {
401 return GetColumnFromPos( std::min( GetLastVisPos(), GetPosCount() ) - 1 );
402 }
403
404 bool ScCsvGrid::IsValidColumn( sal_uInt32 nColIndex ) const
405 {
406 return nColIndex < GetColumnCount();
407 }
408
409 bool ScCsvGrid::IsVisibleColumn( sal_uInt32 nColIndex ) const
410 {
411 return IsValidColumn( nColIndex ) &&
412 (GetColumnPos( nColIndex ) < GetLastVisPos()) &&
413 (GetFirstVisPos() < GetColumnPos( nColIndex + 1 ));
414 }
415
416 sal_Int32 ScCsvGrid::GetColumnX( sal_uInt32 nColIndex ) const
417 {
418 return GetX( GetColumnPos( nColIndex ) );
419 }
420
421 sal_uInt32 ScCsvGrid::GetColumnFromX( sal_Int32 nX ) const
422 {
423 sal_Int32 nPos = (nX - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
424 return ((GetFirstVisPos() <= nPos) && (nPos <= GetLastVisPos())) ?
425 GetColumnFromPos( nPos ) : CSV_COLUMN_INVALID;
426 }
427
428 sal_uInt32 ScCsvGrid::GetColumnFromPos( sal_Int32 nPos ) const
429 {
430 return maSplits.UpperBound( nPos );
431 }
432
433 sal_Int32 ScCsvGrid::GetColumnWidth( sal_uInt32 nColIndex ) const
434 {
435 return IsValidColumn( nColIndex ) ? (GetColumnPos( nColIndex + 1 ) - GetColumnPos( nColIndex )) : 0;
436 }
437
438 void ScCsvGrid::SetColumnStates( const ScCsvColStateVec& rStates )
439 {
440 maColStates = rStates;
441 maColStates.resize( maSplits.Count() - 1 );
442 Execute( CSVCMD_EXPORTCOLUMNTYPE );
443 AccSendTableUpdateEvent( 0, GetColumnCount(), false );
444 AccSendSelectionEvent();
445 }
446
447 sal_Int32 ScCsvGrid::GetColumnType( sal_uInt32 nColIndex ) const
448 {
449 return IsValidColumn( nColIndex ) ? maColStates[ nColIndex ].mnType : CSV_TYPE_NOSELECTION;
450 }
451
452 void ScCsvGrid::SetColumnType( sal_uInt32 nColIndex, sal_Int32 nColType )
453 {
454 if( IsValidColumn( nColIndex ) )
455 {
456 maColStates[ nColIndex ].mnType = nColType;
457 AccSendTableUpdateEvent( nColIndex, nColIndex, false );
458 }
459 }
460
461 sal_Int32 ScCsvGrid::GetSelColumnType() const
462 {
463 sal_uInt32 nColIx = GetFirstSelected();
464 if( nColIx == CSV_COLUMN_INVALID )
465 return CSV_TYPE_NOSELECTION;
466
467 sal_Int32 nType = GetColumnType( nColIx );
468 while( (nColIx != CSV_COLUMN_INVALID) && (nType != CSV_TYPE_MULTI) )
469 {
470 if( nType != GetColumnType( nColIx ) )
471 nType = CSV_TYPE_MULTI;
472 nColIx = GetNextSelected( nColIx );
473 }
474 return nType;
475 }
476
477 void ScCsvGrid::SetSelColumnType( sal_Int32 nType )
478 {
479 if( (nType != CSV_TYPE_MULTI) && (nType != CSV_TYPE_NOSELECTION) )
480 {
481 for( sal_uInt32 nColIx = GetFirstSelected(); nColIx != CSV_COLUMN_INVALID; nColIx = GetNextSelected( nColIx ) )
482 SetColumnType( nColIx, nType );
483 Repaint( true );
484 Execute( CSVCMD_EXPORTCOLUMNTYPE );
485 }
486 }
487
488 void ScCsvGrid::SetTypeNames( const StringVec& rTypeNames )
489 {
490 OSL_ENSURE( !rTypeNames.empty(), "ScCsvGrid::SetTypeNames - vector is empty" );
491 maTypeNames = rTypeNames;
492 Repaint( true );
493
494 maPopup.Clear();
495 sal_uInt32 nCount = maTypeNames.size();
496 sal_uInt32 nIx;
497 sal_uInt16 nItemId;
498 for( nIx = 0, nItemId = 1; nIx < nCount; ++nIx, ++nItemId )
499 maPopup.InsertItem( nItemId, maTypeNames[ nIx ] );
500
501 ::std::for_each( maColStates.begin(), maColStates.end(), Func_SetType( CSV_TYPE_DEFAULT ) );
502 }
503
504 const String& ScCsvGrid::GetColumnTypeName( sal_uInt32 nColIndex ) const
505 {
506 sal_uInt32 nTypeIx = static_cast< sal_uInt32 >( GetColumnType( nColIndex ) );
507 return (nTypeIx < maTypeNames.size()) ? maTypeNames[ nTypeIx ] : EMPTY_STRING;
508 }
509
510 static sal_uInt8 lcl_GetExtColumnType( sal_Int32 nIntType )
511 {
512 static sal_uInt8 pExtTypes[] =
513 { SC_COL_STANDARD, SC_COL_TEXT, SC_COL_DMY, SC_COL_MDY, SC_COL_YMD, SC_COL_ENGLISH, SC_COL_SKIP };
514 static sal_Int32 nExtTypeCount = SAL_N_ELEMENTS(pExtTypes);
515 return pExtTypes[ ((0 <= nIntType) && (nIntType < nExtTypeCount)) ? nIntType : 0 ];
516 }
517
518 void ScCsvGrid::FillColumnDataSep( ScAsciiOptions& rOptions ) const
519 {
520 sal_uInt32 nCount = GetColumnCount();
521 ScCsvExpDataVec aDataVec;
522
523 for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
524 {
525 if( GetColumnType( nColIx ) != CSV_TYPE_DEFAULT )
526 // 1-based column index
527 aDataVec.push_back( ScCsvExpData(
528 static_cast< sal_Int32 >( nColIx + 1 ),
529 lcl_GetExtColumnType( GetColumnType( nColIx ) ) ) );
530 }
531 rOptions.SetColumnInfo( aDataVec );
532 }
533
534 void ScCsvGrid::FillColumnDataFix( ScAsciiOptions& rOptions ) const
535 {
536 sal_uInt32 nCount = std::min( GetColumnCount(), static_cast<sal_uInt32>(MAXCOLCOUNT) );
537 ScCsvExpDataVec aDataVec( nCount + 1 );
538
539 for( sal_uInt32 nColIx = 0; nColIx < nCount; ++nColIx )
540 {
541 ScCsvExpData& rData = aDataVec[ nColIx ];
542 rData.mnIndex = static_cast< sal_Int32 >( GetColumnPos( nColIx ) );
543 rData.mnType = lcl_GetExtColumnType( GetColumnType( nColIx ) );
544 }
545 aDataVec[ nCount ].mnIndex = SAL_MAX_INT32;
546 aDataVec[ nCount ].mnType = SC_COL_SKIP;
547 rOptions.SetColumnInfo( aDataVec );
548 }
549
550 void ScCsvGrid::ScrollVertRel( ScMoveMode eDir )
551 {
552 sal_Int32 nLine = GetFirstVisLine();
553 switch( eDir )
554 {
555 case MOVE_PREV: --nLine; break;
556 case MOVE_NEXT: ++nLine; break;
557 case MOVE_FIRST: nLine = 0; break;
558 case MOVE_LAST: nLine = GetMaxLineOffset(); break;
559 case MOVE_PREVPAGE: nLine -= GetVisLineCount() - 2; break;
560 case MOVE_NEXTPAGE: nLine += GetVisLineCount() - 2; break;
561 default:
562 {
563 // added to avoid warnings
564 }
565 }
566 Execute( CSVCMD_SETLINEOFFSET, nLine );
567 }
568
569 void ScCsvGrid::ExecutePopup( const Point& rPos )
570 {
571 sal_uInt16 nItemId = maPopup.Execute( this, rPos );
572 if( nItemId ) // 0 = cancelled
573 Execute( CSVCMD_SETCOLUMNTYPE, maPopup.GetItemPos( nItemId ) );
574 }
575
576
577 // selection handling ---------------------------------------------------------
578
579 bool ScCsvGrid::IsSelected( sal_uInt32 nColIndex ) const
580 {
581 return IsValidColumn( nColIndex ) && maColStates[ nColIndex ].IsSelected();
582 }
583
584 sal_uInt32 ScCsvGrid::GetFirstSelected() const
585 {
586 return IsSelected( 0 ) ? 0 : GetNextSelected( 0 );
587 }
588
589 sal_uInt32 ScCsvGrid::GetNextSelected( sal_uInt32 nFromIndex ) const
590 {
591 sal_uInt32 nColCount = GetColumnCount();
592 for( sal_uInt32 nColIx = nFromIndex + 1; nColIx < nColCount; ++nColIx )
593 if( IsSelected( nColIx ) )
594 return nColIx;
595 return CSV_COLUMN_INVALID;
596 }
597
598 void ScCsvGrid::Select( sal_uInt32 nColIndex, bool bSelect )
599 {
600 if( IsValidColumn( nColIndex ) )
601 {
602 maColStates[ nColIndex ].Select( bSelect );
603 ImplDrawColumnSelection( nColIndex );
604 Repaint();
605 Execute( CSVCMD_EXPORTCOLUMNTYPE );
606 if( bSelect )
607 mnRecentSelCol = nColIndex;
608 AccSendSelectionEvent();
609 }
610 }
611
612 void ScCsvGrid::ToggleSelect( sal_uInt32 nColIndex )
613 {
614 Select( nColIndex, !IsSelected( nColIndex ) );
615 }
616
617 void ScCsvGrid::SelectRange( sal_uInt32 nColIndex1, sal_uInt32 nColIndex2, bool bSelect )
618 {
619 if( nColIndex1 == CSV_COLUMN_INVALID )
620 Select( nColIndex2 );
621 else if( nColIndex2 == CSV_COLUMN_INVALID )
622 Select( nColIndex1 );
623 else if( nColIndex1 > nColIndex2 )
624 {
625 SelectRange( nColIndex2, nColIndex1, bSelect );
626 if( bSelect )
627 mnRecentSelCol = nColIndex1;
628 }
629 else if( IsValidColumn( nColIndex1 ) && IsValidColumn( nColIndex2 ) )
630 {
631 for( sal_uInt32 nColIx = nColIndex1; nColIx <= nColIndex2; ++nColIx )
632 {
633 maColStates[ nColIx ].Select( bSelect );
634 ImplDrawColumnSelection( nColIx );
635 }
636 Repaint();
637 Execute( CSVCMD_EXPORTCOLUMNTYPE );
638 if( bSelect )
639 mnRecentSelCol = nColIndex1;
640 AccSendSelectionEvent();
641 }
642 }
643
644 void ScCsvGrid::SelectAll( bool bSelect )
645 {
646 SelectRange( 0, GetColumnCount() - 1, bSelect );
647 }
648
649 void ScCsvGrid::MoveCursor( sal_uInt32 nColIndex )
650 {
651 DisableRepaint();
652 if( IsValidColumn( nColIndex ) )
653 {
654 sal_Int32 nPosBeg = GetColumnPos( nColIndex );
655 sal_Int32 nPosEnd = GetColumnPos( nColIndex + 1 );
656 sal_Int32 nMinPos = std::max( nPosBeg - CSV_SCROLL_DIST, sal_Int32( 0 ) );
657 sal_Int32 nMaxPos = std::min( nPosEnd - GetVisPosCount() + CSV_SCROLL_DIST + sal_Int32( 1 ), nMinPos );
658 if( nPosBeg - CSV_SCROLL_DIST + 1 <= GetFirstVisPos() )
659 Execute( CSVCMD_SETPOSOFFSET, nMinPos );
660 else if( nPosEnd + CSV_SCROLL_DIST >= GetLastVisPos() )
661 Execute( CSVCMD_SETPOSOFFSET, nMaxPos );
662 }
663 Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
664 EnableRepaint();
665 }
666
667 void ScCsvGrid::MoveCursorRel( ScMoveMode eDir )
668 {
669 if( GetFocusColumn() != CSV_COLUMN_INVALID )
670 {
671 switch( eDir )
672 {
673 case MOVE_FIRST:
674 MoveCursor( 0 );
675 break;
676 case MOVE_LAST:
677 MoveCursor( GetColumnCount() - 1 );
678 break;
679 case MOVE_PREV:
680 if( GetFocusColumn() > 0 )
681 MoveCursor( GetFocusColumn() - 1 );
682 break;
683 case MOVE_NEXT:
684 if( GetFocusColumn() < GetColumnCount() - 1 )
685 MoveCursor( GetFocusColumn() + 1 );
686 break;
687 default:
688 {
689 // added to avoid warnings
690 }
691 }
692 }
693 }
694
695 void ScCsvGrid::ImplClearSelection()
696 {
697 ::std::for_each( maColStates.begin(), maColStates.end(), Func_Select( false ) );
698 ImplDrawGridDev();
699 }
700
701 void ScCsvGrid::DoSelectAction( sal_uInt32 nColIndex, sal_uInt16 nModifier )
702 {
703 if( !(nModifier & KEY_MOD1) )
704 ImplClearSelection();
705 if( nModifier & KEY_SHIFT ) // SHIFT always expands
706 SelectRange( mnRecentSelCol, nColIndex );
707 else if( !(nModifier & KEY_MOD1) ) // no SHIFT/CTRL always selects 1 column
708 Select( nColIndex );
709 else if( IsTracking() ) // CTRL in tracking does not toggle
710 Select( nColIndex, mbMTSelecting );
711 else // CTRL only toggles
712 ToggleSelect( nColIndex );
713 Execute( CSVCMD_MOVEGRIDCURSOR, GetColumnPos( nColIndex ) );
714 }
715
716
717 // cell contents --------------------------------------------------------------
718
719 void ScCsvGrid::ImplSetTextLineSep(
720 sal_Int32 nLine, const OUString& rTextLine,
721 const String& rSepChars, sal_Unicode cTextSep, bool bMergeSep )
722 {
723 if( nLine < GetFirstVisLine() ) return;
724
725 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
726 while( maTexts.size() <= nLineIx )
727 maTexts.push_back( StringVec() );
728 StringVec& rStrVec = maTexts[ nLineIx ];
729 rStrVec.clear();
730
731 // scan for separators
732 String aCellText;
733 const sal_Unicode* pSepChars = rSepChars.GetBuffer();
734 const sal_Unicode* pChar = rTextLine.getStr();
735 sal_uInt32 nColIx = 0;
736
737 while( *pChar && (nColIx < sal::static_int_cast<sal_uInt32>(CSV_MAXCOLCOUNT)) )
738 {
739 // scan for next cell text
740 bool bIsQuoted = false;
741 bool bOverflowCell = false;
742 pChar = ScImportExport::ScanNextFieldFromString( pChar, aCellText,
743 cTextSep, pSepChars, bMergeSep, bIsQuoted, bOverflowCell );
744 /* TODO: signal overflow somewhere in UI */
745
746 // update column width
747 sal_Int32 nWidth = std::max( CSV_MINCOLWIDTH, aCellText.Len() + sal_Int32( 1 ) );
748 if( IsValidColumn( nColIx ) )
749 {
750 // expand existing column
751 sal_Int32 nDiff = nWidth - GetColumnWidth( nColIx );
752 if( nDiff > 0 )
753 {
754 Execute( CSVCMD_SETPOSCOUNT, GetPosCount() + nDiff );
755 for( sal_uInt32 nSplitIx = GetColumnCount() - 1; nSplitIx > nColIx; --nSplitIx )
756 {
757 sal_Int32 nPos = maSplits[ nSplitIx ];
758 maSplits.Remove( nPos );
759 maSplits.Insert( nPos + nDiff );
760 }
761 }
762 }
763 else
764 {
765 // append new column
766 sal_Int32 nLastPos = GetPosCount();
767 Execute( CSVCMD_SETPOSCOUNT, nLastPos + nWidth );
768 ImplInsertSplit( nLastPos );
769 }
770
771 if( aCellText.Len() <= CSV_MAXSTRLEN )
772 rStrVec.push_back( aCellText );
773 else
774 rStrVec.push_back( aCellText.Copy( 0, CSV_MAXSTRLEN ) );
775 ++nColIx;
776 }
777 InvalidateGfx();
778 }
779
780 void ScCsvGrid::ImplSetTextLineFix( sal_Int32 nLine, const OUString& rTextLine )
781 {
782 if( nLine < GetFirstVisLine() ) return;
783
784 sal_Int32 nChars = rTextLine.getLength();
785 if( nChars > GetPosCount() )
786 Execute( CSVCMD_SETPOSCOUNT, nChars );
787
788 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
789 while( maTexts.size() <= nLineIx )
790 maTexts.push_back( StringVec() );
791
792 StringVec& rStrVec = maTexts[ nLineIx ];
793 rStrVec.clear();
794 sal_uInt32 nColCount = GetColumnCount();
795 sal_Int32 nStrLen = rTextLine.getLength();
796 sal_Int32 nStrIx = 0;
797 for( sal_uInt32 nColIx = 0; (nColIx < nColCount) && (nStrIx < nStrLen); ++nColIx )
798 {
799 sal_Int32 nColWidth = GetColumnWidth( nColIx );
800 sal_Int32 nLen = std::min( std::min( nColWidth, static_cast<sal_Int32>(CSV_MAXSTRLEN) ), nStrLen - nStrIx);
801 rStrVec.push_back( rTextLine.copy( nStrIx, nLen ) );
802 nStrIx = nStrIx + nColWidth;
803 }
804 InvalidateGfx();
805 }
806
807 const String& ScCsvGrid::GetCellText( sal_uInt32 nColIndex, sal_Int32 nLine ) const
808 {
809 if( nLine < GetFirstVisLine() ) return EMPTY_STRING;
810
811 sal_uInt32 nLineIx = nLine - GetFirstVisLine();
812 if( nLineIx >= maTexts.size() ) return EMPTY_STRING;
813
814 const StringVec& rStrVec = maTexts[ nLineIx ];
815 if( nColIndex >= rStrVec.size() ) return EMPTY_STRING;
816
817 return rStrVec[ nColIndex ];
818 }
819
820
821 // event handling -------------------------------------------------------------
822
823 void ScCsvGrid::Resize()
824 {
825 ScCsvControl::Resize();
826 InitSizeData();
827 Execute( CSVCMD_UPDATECELLTEXTS );
828 }
829
830 void ScCsvGrid::GetFocus()
831 {
832 ScCsvControl::GetFocus();
833 Execute( CSVCMD_MOVEGRIDCURSOR, GetNoScrollCol( GetGridCursorPos() ) );
834 Repaint();
835 }
836
837 void ScCsvGrid::LoseFocus()
838 {
839 ScCsvControl::LoseFocus();
840 Repaint();
841 }
842
843 void ScCsvGrid::MouseButtonDown( const MouseEvent& rMEvt )
844 {
845 DisableRepaint();
846 if( !HasFocus() )
847 GrabFocus();
848
849 Point aPos( rMEvt.GetPosPixel() );
850 sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
851
852 if( rMEvt.IsLeft() )
853 {
854 if( (GetFirstX() > aPos.X()) || (aPos.X() > GetLastX()) ) // in header column
855 {
856 if( aPos.Y() <= GetHdrHeight() )
857 SelectAll();
858 }
859 else if( IsValidColumn( nColIx ) )
860 {
861 DoSelectAction( nColIx, rMEvt.GetModifier() );
862 mnMTCurrCol = nColIx;
863 mbMTSelecting = IsSelected( nColIx );
864 StartTracking( STARTTRACK_BUTTONREPEAT );
865 }
866 }
867 EnableRepaint();
868 }
869
870 void ScCsvGrid::Tracking( const TrackingEvent& rTEvt )
871 {
872 if( rTEvt.IsTrackingEnded() || rTEvt.IsTrackingRepeat() )
873 {
874 DisableRepaint();
875 const MouseEvent& rMEvt = rTEvt.GetMouseEvent();
876
877 sal_Int32 nPos = (rMEvt.GetPosPixel().X() - GetFirstX()) / GetCharWidth() + GetFirstVisPos();
878 // on mouse tracking: keep position valid
879 nPos = std::max( std::min( nPos, GetPosCount() - sal_Int32( 1 ) ), sal_Int32( 0 ) );
880 Execute( CSVCMD_MAKEPOSVISIBLE, nPos );
881
882 sal_uInt32 nColIx = GetColumnFromPos( nPos );
883 if( mnMTCurrCol != nColIx )
884 {
885 DoSelectAction( nColIx, rMEvt.GetModifier() );
886 mnMTCurrCol = nColIx;
887 }
888 EnableRepaint();
889 }
890 }
891
892 void ScCsvGrid::KeyInput( const KeyEvent& rKEvt )
893 {
894 const KeyCode& rKCode = rKEvt.GetKeyCode();
895 sal_uInt16 nCode = rKCode.GetCode();
896 bool bShift = rKCode.IsShift() == sal_True;
897 bool bMod1 = rKCode.IsMod1() == sal_True;
898
899 if( !rKCode.IsMod2() )
900 {
901 ScMoveMode eHDir = GetHorzDirection( nCode, !bMod1 );
902 ScMoveMode eVDir = GetVertDirection( nCode, bMod1 );
903
904 if( eHDir != MOVE_NONE )
905 {
906 DisableRepaint();
907 MoveCursorRel( eHDir );
908 if( !bMod1 )
909 ImplClearSelection();
910 if( bShift )
911 SelectRange( mnRecentSelCol, GetFocusColumn() );
912 else if( !bMod1 )
913 Select( GetFocusColumn() );
914 EnableRepaint();
915 }
916 else if( eVDir != MOVE_NONE )
917 ScrollVertRel( eVDir );
918 else if( nCode == KEY_SPACE )
919 {
920 if( !bMod1 )
921 ImplClearSelection();
922 if( bShift )
923 SelectRange( mnRecentSelCol, GetFocusColumn() );
924 else if( bMod1 )
925 ToggleSelect( GetFocusColumn() );
926 else
927 Select( GetFocusColumn() );
928 }
929 else if( !bShift && bMod1 )
930 {
931 if( nCode == KEY_A )
932 SelectAll();
933 else if( (KEY_1 <= nCode) && (nCode <= KEY_9) )
934 {
935 sal_uInt32 nType = nCode - KEY_1;
936 if( nType < maTypeNames.size() )
937 Execute( CSVCMD_SETCOLUMNTYPE, nType );
938 }
939 }
940 }
941
942 if( rKCode.GetGroup() != KEYGROUP_CURSOR )
943 ScCsvControl::KeyInput( rKEvt );
944 }
945
946 void ScCsvGrid::Command( const CommandEvent& rCEvt )
947 {
948 switch( rCEvt.GetCommand() )
949 {
950 case COMMAND_CONTEXTMENU:
951 {
952 if( rCEvt.IsMouseEvent() )
953 {
954 Point aPos( rCEvt.GetMousePosPixel() );
955 sal_uInt32 nColIx = GetColumnFromX( aPos.X() );
956 if( IsValidColumn( nColIx ) && (GetFirstX() <= aPos.X()) && (aPos.X() <= GetLastX()) )
957 {
958 if( !IsSelected( nColIx ) )
959 DoSelectAction( nColIx, 0 ); // focus & select
960 ExecutePopup( aPos );
961 }
962 }
963 else
964 {
965 sal_uInt32 nColIx = GetFocusColumn();
966 if( !IsSelected( nColIx ) )
967 Select( nColIx );
968 sal_Int32 nX1 = std::max( GetColumnX( nColIx ), GetFirstX() );
969 sal_Int32 nX2 = std::min( GetColumnX( nColIx + 1 ), GetWidth() );
970 ExecutePopup( Point( (nX1 + nX2) / 2, GetHeight() / 2 ) );
971 }
972 }
973 break;
974 case COMMAND_WHEEL:
975 {
976 Point aPoint;
977 Rectangle aRect( aPoint, maWinSize );
978 if( aRect.IsInside( rCEvt.GetMousePosPixel() ) )
979 {
980 const CommandWheelData* pData = rCEvt.GetWheelData();
981 if( pData && (pData->GetMode() == COMMAND_WHEEL_SCROLL) && !pData->IsHorz() )
982 Execute( CSVCMD_SETLINEOFFSET, GetFirstVisLine() - pData->GetNotchDelta() );
983 }
984 }
985 break;
986 default:
987 ScCsvControl::Command( rCEvt );
988 }
989 }
990
991 void ScCsvGrid::DataChanged( const DataChangedEvent& rDCEvt )
992 {
993 if( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
994 {
995 InitColors();
996 InitFonts();
997 UpdateLayoutData();
998 Execute( CSVCMD_UPDATECELLTEXTS );
999 }
1000 ScCsvControl::DataChanged( rDCEvt );
1001 }
1002
1003 void ScCsvGrid::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 )
1004 {
1005 InitColors();
1006 Repaint();
1007 }
1008
1009
1010 // painting -------------------------------------------------------------------
1011
1012 void ScCsvGrid::Paint( const Rectangle& )
1013 {
1014 Repaint();
1015 }
1016
1017 void ScCsvGrid::ImplRedraw()
1018 {
1019 if( IsVisible() )
1020 {
1021 if( !IsValidGfx() )
1022 {
1023 ValidateGfx();
1024 ImplDrawBackgrDev();
1025 ImplDrawGridDev();
1026 }
1027 DrawOutDev( Point(), maWinSize, Point(), maWinSize, maGridDev );
1028 ImplDrawTrackingRect( GetFocusColumn() );
1029 }
1030 }
1031
1032 EditEngine* ScCsvGrid::GetEditEngine()
1033 {
1034 return mpEditEngine.get();
1035 }
1036
1037 void ScCsvGrid::ImplSetColumnClipRegion( OutputDevice& rOutDev, sal_uInt32 nColIndex )
1038 {
1039 rOutDev.SetClipRegion( Region( Rectangle(
1040 std::max( GetColumnX( nColIndex ), GetFirstX() ) + 1, 0,
1041 std::min( GetColumnX( nColIndex + 1 ), GetLastX() ), GetHeight() - 1 ) ) );
1042 }
1043
1044 void ScCsvGrid::ImplDrawColumnHeader( OutputDevice& rOutDev, sal_uInt32 nColIndex, Color aFillColor )
1045 {
1046 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1047 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1048 sal_Int32 nHdrHt = GetHdrHeight();
1049
1050 rOutDev.SetLineColor();
1051 rOutDev.SetFillColor( aFillColor );
1052 rOutDev.DrawRect( Rectangle( nX1, 0, nX2, nHdrHt ) );
1053
1054 rOutDev.SetFont( maHeaderFont );
1055 rOutDev.SetTextColor( maHeaderTextColor );
1056 rOutDev.SetTextFillColor();
1057 rOutDev.DrawText( Point( nX1 + 1, 0 ), GetColumnTypeName( nColIndex ) );
1058
1059 rOutDev.SetLineColor( maHeaderGridColor );
1060 rOutDev.DrawLine( Point( nX1, nHdrHt ), Point( nX2, nHdrHt ) );
1061 rOutDev.DrawLine( Point( nX2, 0 ), Point( nX2, nHdrHt ) );
1062 }
1063
1064 void ScCsvGrid::ImplDrawCellText( const Point& rPos, const String& rText )
1065 {
1066 String aPlainText( rText );
1067 aPlainText.SearchAndReplaceAll( '\t', ' ' );
1068 aPlainText.SearchAndReplaceAll( '\n', ' ' );
1069 mpEditEngine->SetPaperSize( maEdEngSize );
1070
1071 /* #i60296# If string contains mixed script types, the space character
1072 U+0020 may be drawn with a wrong width (from non-fixed-width Asian or
1073 Complex font). Now we draw every non-space portion separately. */
1074 xub_StrLen nTokenCount = comphelper::string::getTokenCount(aPlainText, ' ');
1075 sal_Int32 nCharIxInt = 0;
1076 for( xub_StrLen nToken = 0; nToken < nTokenCount; ++nToken )
1077 {
1078 sal_Int32 nBeginIx = nCharIxInt;
1079 String aToken = aPlainText.GetToken( 0, ' ', nCharIxInt );
1080 if( aToken.Len() > 0 )
1081 {
1082 sal_Int32 nX = rPos.X() + GetCharWidth() * nBeginIx;
1083 mpEditEngine->SetText( aToken );
1084 mpEditEngine->Draw( &maBackgrDev, Point( nX, rPos.Y() ) );
1085 }
1086 }
1087
1088 xub_StrLen nCharIx = 0;
1089 while( (nCharIx = rText.Search( '\t', nCharIx )) != STRING_NOTFOUND )
1090 {
1091 sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
1092 sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
1093 sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
1094 Color aColor( maTextColor );
1095 maBackgrDev.SetLineColor( aColor );
1096 maBackgrDev.DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
1097 maBackgrDev.DrawLine( Point( nX2 - 2, nY - 2 ), Point( nX2, nY ) );
1098 maBackgrDev.DrawLine( Point( nX2 - 2, nY + 2 ), Point( nX2, nY ) );
1099 ++nCharIx;
1100 }
1101 nCharIx = 0;
1102 while( (nCharIx = rText.Search( '\n', nCharIx )) != STRING_NOTFOUND )
1103 {
1104 sal_Int32 nX1 = rPos.X() + GetCharWidth() * nCharIx;
1105 sal_Int32 nX2 = nX1 + GetCharWidth() - 2;
1106 sal_Int32 nY = rPos.Y() + GetLineHeight() / 2;
1107 Color aColor( maTextColor );
1108 maBackgrDev.SetLineColor( aColor );
1109 maBackgrDev.DrawLine( Point( nX1, nY ), Point( nX2, nY ) );
1110 maBackgrDev.DrawLine( Point( nX1 + 2, nY - 2 ), Point( nX1, nY ) );
1111 maBackgrDev.DrawLine( Point( nX1 + 2, nY + 2 ), Point( nX1, nY ) );
1112 maBackgrDev.DrawLine( Point( nX2, nY - 2 ), Point( nX2, nY ) );
1113 ++nCharIx;
1114 }
1115 }
1116
1117 void ScCsvGrid::ImplDrawFirstLineSep( bool bSet )
1118 {
1119 if( IsVisibleLine( mnFirstImpLine ) && (mnFirstImpLine != GetFirstVisLine() ) )
1120 {
1121 sal_Int32 nY = GetY( mnFirstImpLine );
1122 sal_Int32 nX = std::min( GetColumnX( GetLastVisColumn() + 1 ), GetLastX() );
1123 maBackgrDev.SetLineColor( bSet ? maGridPBColor : maGridColor );
1124 maBackgrDev.DrawLine( Point( GetFirstX() + 1, nY ), Point( nX, nY ) );
1125 }
1126 }
1127
1128 void ScCsvGrid::ImplDrawColumnBackgr( sal_uInt32 nColIndex )
1129 {
1130 if( !IsVisibleColumn( nColIndex ) )
1131 return;
1132
1133 ImplSetColumnClipRegion( maBackgrDev, nColIndex );
1134
1135 // grid
1136 maBackgrDev.SetLineColor();
1137 maBackgrDev.SetFillColor( maBackColor );
1138 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1139 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1140 sal_Int32 nY2 = GetY( GetLastVisLine() + 1 );
1141 sal_Int32 nHdrHt = GetHdrHeight();
1142 Rectangle aRect( nX1, nHdrHt, nX2, nY2 );
1143 maBackgrDev.DrawRect( aRect );
1144 maBackgrDev.SetLineColor( maGridColor );
1145 maBackgrDev.DrawGrid( aRect, Size( 1, GetLineHeight() ), GRID_HORZLINES );
1146 maBackgrDev.DrawLine( Point( nX2, nHdrHt ), Point( nX2, nY2 ) );
1147 ImplDrawFirstLineSep( true );
1148
1149 // cell texts
1150 mpEditEngine->SetDefaultItem( SvxColorItem( maTextColor, EE_CHAR_COLOR ) );
1151 size_t nLineCount = ::std::min( static_cast< size_t >( GetLastVisLine() - GetFirstVisLine() + 1 ), maTexts.size() );
1152 // #i67432# cut string to avoid edit engine performance problems with very large strings
1153 sal_Int32 nFirstVisPos = ::std::max( GetColumnPos( nColIndex ), GetFirstVisPos() );
1154 sal_Int32 nLastVisPos = ::std::min( GetColumnPos( nColIndex + 1 ), GetLastVisPos() );
1155 xub_StrLen nStrPos = static_cast< xub_StrLen >( nFirstVisPos - GetColumnPos( nColIndex ) );
1156 xub_StrLen nStrLen = static_cast< xub_StrLen >( nLastVisPos - nFirstVisPos + 1 );
1157 sal_Int32 nStrX = GetX( nFirstVisPos );
1158 for( size_t nLine = 0; nLine < nLineCount; ++nLine )
1159 {
1160 StringVec& rStrVec = maTexts[ nLine ];
1161 if( (nColIndex < rStrVec.size()) && (rStrVec[ nColIndex ].Len() > nStrPos) )
1162 {
1163 String aText( rStrVec[ nColIndex ], nStrPos, nStrLen );
1164 ImplDrawCellText( Point( nStrX, GetY( GetFirstVisLine() + nLine ) ), aText );
1165 }
1166 }
1167
1168 // header
1169 ImplDrawColumnHeader( maBackgrDev, nColIndex, maHeaderBackColor );
1170
1171 maBackgrDev.SetClipRegion();
1172 }
1173
1174 void ScCsvGrid::ImplDrawRowHeaders()
1175 {
1176 maBackgrDev.SetLineColor();
1177 maBackgrDev.SetFillColor( maAppBackColor );
1178 Point aPoint( GetHdrX(), 0 );
1179 Rectangle aRect( aPoint, Size( GetHdrWidth() + 1, GetHeight() ) );
1180 maBackgrDev.DrawRect( aRect );
1181
1182 maBackgrDev.SetFillColor( maHeaderBackColor );
1183 aRect.Bottom() = GetY( GetLastVisLine() + 1 );
1184 maBackgrDev.DrawRect( aRect );
1185
1186 // line numbers
1187 maBackgrDev.SetFont( maHeaderFont );
1188 maBackgrDev.SetTextColor( maHeaderTextColor );
1189 maBackgrDev.SetTextFillColor();
1190 sal_Int32 nLastLine = GetLastVisLine();
1191 for( sal_Int32 nLine = GetFirstVisLine(); nLine <= nLastLine; ++nLine )
1192 {
1193 String aText( OUString::number( nLine + 1 ) );
1194 sal_Int32 nX = GetHdrX() + (GetHdrWidth() - maBackgrDev.GetTextWidth( aText )) / 2;
1195 maBackgrDev.DrawText( Point( nX, GetY( nLine ) ), aText );
1196 }
1197
1198 // grid
1199 maBackgrDev.SetLineColor( maHeaderGridColor );
1200 if( IsRTL() )
1201 {
1202 maBackgrDev.DrawLine( Point( 0, 0 ), Point( 0, GetHeight() - 1 ) );
1203 maBackgrDev.DrawLine( aRect.TopLeft(), aRect.BottomLeft() );
1204 }
1205 else
1206 maBackgrDev.DrawLine( aRect.TopRight(), aRect.BottomRight() );
1207 aRect.Top() = GetHdrHeight();
1208 maBackgrDev.DrawGrid( aRect, Size( 1, GetLineHeight() ), GRID_HORZLINES );
1209 }
1210
1211 void ScCsvGrid::ImplDrawBackgrDev()
1212 {
1213 maBackgrDev.SetLineColor();
1214 maBackgrDev.SetFillColor( maAppBackColor );
1215 maBackgrDev.DrawRect( Rectangle(
1216 Point( GetFirstX() + 1, 0 ), Size( GetWidth() - GetHdrWidth(), GetHeight() ) ) );
1217
1218 sal_uInt32 nLastCol = GetLastVisColumn();
1219 if (nLastCol == CSV_COLUMN_INVALID)
1220 return;
1221 for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
1222 ImplDrawColumnBackgr( nColIx );
1223
1224 ImplDrawRowHeaders();
1225 }
1226
1227 void ScCsvGrid::ImplDrawColumnSelection( sal_uInt32 nColIndex )
1228 {
1229 ImplInvertCursor( GetRulerCursorPos() );
1230 ImplSetColumnClipRegion( maGridDev, nColIndex );
1231 maGridDev.DrawOutDev( Point(), maWinSize, Point(), maWinSize, maBackgrDev );
1232
1233 if( IsSelected( nColIndex ) )
1234 {
1235 sal_Int32 nX1 = GetColumnX( nColIndex ) + 1;
1236 sal_Int32 nX2 = GetColumnX( nColIndex + 1 );
1237
1238 // header
1239 Rectangle aRect( nX1, 0, nX2, GetHdrHeight() );
1240 maGridDev.SetLineColor();
1241 if( maHeaderBackColor.IsDark() )
1242 // redraw with light gray background in dark mode
1243 ImplDrawColumnHeader( maGridDev, nColIndex, COL_LIGHTGRAY );
1244 else
1245 {
1246 // use transparent active color
1247 maGridDev.SetFillColor( maSelectColor );
1248 maGridDev.DrawTransparent( PolyPolygon( Polygon( aRect ) ), CSV_HDR_TRANSPARENCY );
1249 }
1250
1251 // column selection
1252 aRect = Rectangle( nX1, GetHdrHeight() + 1, nX2, GetY( GetLastVisLine() + 1 ) - 1 );
1253 ImplInvertRect( maGridDev, aRect );
1254 }
1255
1256 maGridDev.SetClipRegion();
1257 ImplInvertCursor( GetRulerCursorPos() );
1258 }
1259
1260 void ScCsvGrid::ImplDrawGridDev()
1261 {
1262 maGridDev.DrawOutDev( Point(), maWinSize, Point(), maWinSize, maBackgrDev );
1263 sal_uInt32 nLastCol = GetLastVisColumn();
1264 if (nLastCol == CSV_COLUMN_INVALID)
1265 return;
1266 for( sal_uInt32 nColIx = GetFirstVisColumn(); nColIx <= nLastCol; ++nColIx )
1267 ImplDrawColumnSelection( nColIx );
1268 }
1269
1270 void ScCsvGrid::ImplDrawColumn( sal_uInt32 nColIndex )
1271 {
1272 ImplDrawColumnBackgr( nColIndex );
1273 ImplDrawColumnSelection( nColIndex );
1274 }
1275
1276 void ScCsvGrid::ImplDrawHorzScrolled( sal_Int32 nOldPos )
1277 {
1278 sal_Int32 nPos = GetFirstVisPos();
1279 if( !IsValidGfx() || (nPos == nOldPos) )
1280 return;
1281 if( std::abs( nPos - nOldPos ) > GetVisPosCount() / 2 )
1282 {
1283 ImplDrawBackgrDev();
1284 ImplDrawGridDev();
1285 return;
1286 }
1287
1288 Point aSrc, aDest;
1289 sal_uInt32 nFirstColIx, nLastColIx;
1290 if( nPos < nOldPos )
1291 {
1292 aSrc = Point( GetFirstX() + 1, 0 );
1293 aDest = Point( GetFirstX() + GetCharWidth() * (nOldPos - nPos) + 1, 0 );
1294 nFirstColIx = GetColumnFromPos( nPos );
1295 nLastColIx = GetColumnFromPos( nOldPos );
1296 }
1297 else
1298 {
1299 aSrc = Point( GetFirstX() + GetCharWidth() * (nPos - nOldPos) + 1, 0 );
1300 aDest = Point( GetFirstX() + 1, 0 );
1301 nFirstColIx = GetColumnFromPos( std::min( nOldPos + GetVisPosCount(), GetPosCount() ) - 1 );
1302 nLastColIx = GetColumnFromPos( std::min( nPos + GetVisPosCount(), GetPosCount() ) - 1 );
1303 }
1304
1305 ImplInvertCursor( GetRulerCursorPos() + (nPos - nOldPos) );
1306 Rectangle aRectangle( GetFirstX(), 0, GetLastX(), GetHeight() - 1 );
1307 Region aClipReg( aRectangle );
1308 maBackgrDev.SetClipRegion( aClipReg );
1309 maBackgrDev.CopyArea( aDest, aSrc, maWinSize );
1310 maBackgrDev.SetClipRegion();
1311 maGridDev.SetClipRegion( aClipReg );
1312 maGridDev.CopyArea( aDest, aSrc, maWinSize );
1313 maGridDev.SetClipRegion();
1314 ImplInvertCursor( GetRulerCursorPos() );
1315
1316 for( sal_uInt32 nColIx = nFirstColIx; nColIx <= nLastColIx; ++nColIx )
1317 ImplDrawColumn( nColIx );
1318
1319 sal_Int32 nLastX = GetX( GetPosCount() ) + 1;
1320 if( nLastX <= GetLastX() )
1321 {
1322 Rectangle aRect( nLastX, 0, GetLastX(), GetHeight() - 1 );
1323 maBackgrDev.SetLineColor();
1324 maBackgrDev.SetFillColor( maAppBackColor );
1325 maBackgrDev.DrawRect( aRect );
1326 maGridDev.SetLineColor();
1327 maGridDev.SetFillColor( maAppBackColor );
1328 maGridDev.DrawRect( aRect );
1329 }
1330 }
1331
1332 void ScCsvGrid::ImplInvertCursor( sal_Int32 nPos )
1333 {
1334 if( IsVisibleSplitPos( nPos ) )
1335 {
1336 sal_Int32 nX = GetX( nPos ) - 1;
1337 Rectangle aRect( Point( nX, 0 ), Size( 3, GetHdrHeight() ) );
1338 ImplInvertRect( maGridDev, aRect );
1339 aRect.Top() = GetHdrHeight() + 1;
1340 aRect.Bottom() = GetY( GetLastVisLine() + 1 );
1341 ImplInvertRect( maGridDev, aRect );
1342 }
1343 }
1344
1345 void ScCsvGrid::ImplDrawTrackingRect( sal_uInt32 nColIndex )
1346 {
1347 if( HasFocus() && IsVisibleColumn( nColIndex ) )
1348 {
1349 sal_Int32 nX1 = std::max( GetColumnX( nColIndex ), GetFirstX() ) + 1;
1350 sal_Int32 nX2 = std::min( GetColumnX( nColIndex + 1 ) - sal_Int32( 1 ), GetLastX() );
1351 sal_Int32 nY2 = std::min( GetY( GetLastVisLine() + 1 ), GetHeight() ) - 1;
1352 InvertTracking( Rectangle( nX1, 0, nX2, nY2 ), SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
1353 }
1354 }
1355
1356
1357 // accessibility ==============================================================
1358
1359 ScAccessibleCsvControl* ScCsvGrid::ImplCreateAccessible()
1360 {
1361 std::auto_ptr<ScAccessibleCsvControl> pControl(new ScAccessibleCsvGrid( *this ));
1362 pControl->Init();
1363 return pControl.release();
1364 }
1365
1366
1367 // ============================================================================
1368
1369 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE