0432f847bb
Change-Id: Ia50265e397704131dc948bc2bcbf80a442054b71 Signed-off-by: Rodolfo Ribeiro Gomes <rodolforg@gmail.com> Reviewed-on: https://gerrit.libreoffice.org/6538 Reviewed-by: Markus Mohrhard <markus.mohrhard@googlemail.com> Tested-by: Markus Mohrhard <markus.mohrhard@googlemail.com>
984 lines
32 KiB
C++
984 lines
32 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <sfx2/dispatch.hxx>
|
|
#include <vcl/help.hxx>
|
|
#include <tools/poly.hxx>
|
|
#include <svtools/colorcfg.hxx>
|
|
|
|
#include "scresid.hxx"
|
|
#include "sc.hrc"
|
|
#include "tabvwsh.hxx"
|
|
#include "hdrcont.hxx"
|
|
#include "scmod.hxx"
|
|
#include "inputopt.hxx"
|
|
#include "gridmerg.hxx"
|
|
#include "document.hxx"
|
|
#include "markdata.hxx"
|
|
|
|
#define SC_DRAG_MIN 2
|
|
|
|
// passes in paint
|
|
// (selection left/right must be first because the continuous lines
|
|
// are partly overwritten later)
|
|
|
|
#define SC_HDRPAINT_SEL_BOTTOM 4
|
|
#define SC_HDRPAINT_BOTTOM 5
|
|
#define SC_HDRPAINT_TEXT 6
|
|
#define SC_HDRPAINT_COUNT 7
|
|
|
|
ScHeaderControl::ScHeaderControl( Window* pParent, SelectionEngine* pSelectionEngine,
|
|
SCCOLROW nNewSize, bool bNewVertical ) :
|
|
Window ( pParent ),
|
|
pSelEngine ( pSelectionEngine ),
|
|
bVertical ( bNewVertical ),
|
|
nSize ( nNewSize ),
|
|
nMarkStart ( 0 ),
|
|
nMarkEnd ( 0 ),
|
|
bMarkRange ( false ),
|
|
bDragging ( false ),
|
|
bIgnoreMove ( false )
|
|
{
|
|
// --- RTL --- no default mirroring for this window, the spreadsheet itself
|
|
// is also not mirrored
|
|
// mirror the vertical window for correct border drawing
|
|
// table layout depends on sheet format, not UI setting, so the
|
|
// borders of the vertical window have to be handled manually, too.
|
|
EnableRTL( false );
|
|
|
|
aNormFont = GetFont();
|
|
aNormFont.SetTransparent( sal_True ); //! WEIGHT_NORMAL hart setzen ???
|
|
aBoldFont = aNormFont;
|
|
aBoldFont.SetWeight( WEIGHT_BOLD );
|
|
|
|
SetFont(aBoldFont);
|
|
bBoldSet = true;
|
|
|
|
Size aSize = LogicToPixel( Size(
|
|
GetTextWidth(OUString("8888")),
|
|
GetTextHeight() ) );
|
|
aSize.Width() += 4; // place for highlight border
|
|
aSize.Height() += 3;
|
|
SetSizePixel( aSize );
|
|
|
|
nWidth = nSmallWidth = aSize.Width();
|
|
nBigWidth = LogicToPixel( Size( GetTextWidth(OUString("8888888")), 0 ) ).Width() + 5;
|
|
|
|
SetBackground(); // sonst Probleme auf OS/2 !?!?!
|
|
}
|
|
|
|
void ScHeaderControl::SetWidth( long nNew )
|
|
{
|
|
OSL_ENSURE( bVertical, "SetWidth works only on row headers" );
|
|
if ( nNew != nWidth )
|
|
{
|
|
Size aSize( nNew, GetSizePixel().Height() );
|
|
SetSizePixel( aSize );
|
|
|
|
nWidth = nNew;
|
|
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
ScHeaderControl::~ScHeaderControl()
|
|
{
|
|
}
|
|
|
|
void ScHeaderControl::DoPaint( SCCOLROW nStart, SCCOLROW nEnd )
|
|
{
|
|
bool bLayoutRTL = IsLayoutRTL();
|
|
long nLayoutSign = bLayoutRTL ? -1 : 1;
|
|
|
|
Rectangle aRect( Point(0,0), GetOutputSizePixel() );
|
|
if ( bVertical )
|
|
{
|
|
aRect.Top() = GetScrPos( nStart )-nLayoutSign; // extra pixel for line at top of selection
|
|
aRect.Bottom() = GetScrPos( nEnd+1 )-nLayoutSign;
|
|
}
|
|
else
|
|
{
|
|
aRect.Left() = GetScrPos( nStart )-nLayoutSign; // extra pixel for line left of selection
|
|
aRect.Right() = GetScrPos( nEnd+1 )-nLayoutSign;
|
|
}
|
|
Invalidate(aRect);
|
|
}
|
|
|
|
void ScHeaderControl::SetMark( bool bNewSet, SCCOLROW nNewStart, SCCOLROW nNewEnd )
|
|
{
|
|
bool bEnabled = SC_MOD()->GetInputOptions().GetMarkHeader(); //! cachen?
|
|
if (!bEnabled)
|
|
bNewSet = false;
|
|
|
|
bool bOldSet = bMarkRange;
|
|
SCCOLROW nOldStart = nMarkStart;
|
|
SCCOLROW nOldEnd = nMarkEnd;
|
|
PutInOrder( nNewStart, nNewEnd );
|
|
bMarkRange = bNewSet;
|
|
nMarkStart = nNewStart;
|
|
nMarkEnd = nNewEnd;
|
|
|
|
// Paint
|
|
|
|
if ( bNewSet )
|
|
{
|
|
if ( bOldSet )
|
|
{
|
|
if ( nNewStart == nOldStart )
|
|
{
|
|
if ( nNewEnd != nOldEnd )
|
|
DoPaint( std::min( nNewEnd, nOldEnd ) + 1, std::max( nNewEnd, nOldEnd ) );
|
|
}
|
|
else if ( nNewEnd == nOldEnd )
|
|
DoPaint( std::min( nNewStart, nOldStart ), std::max( nNewStart, nOldStart ) - 1 );
|
|
else if ( nNewStart > nOldEnd || nNewEnd < nOldStart )
|
|
{
|
|
// two areas
|
|
DoPaint( nOldStart, nOldEnd );
|
|
DoPaint( nNewStart, nNewEnd );
|
|
}
|
|
else // somehow overlapping... (it is not often)
|
|
DoPaint( std::min( nNewStart, nOldStart ), std::max( nNewEnd, nOldEnd ) );
|
|
}
|
|
else
|
|
DoPaint( nNewStart, nNewEnd ); // completely new selection
|
|
}
|
|
else if ( bOldSet )
|
|
DoPaint( nOldStart, nOldEnd ); // cancel selection
|
|
}
|
|
|
|
long ScHeaderControl::GetScrPos( SCCOLROW nEntryNo ) const
|
|
{
|
|
long nScrPos;
|
|
|
|
long nMax = ( bVertical ? GetOutputSizePixel().Height() : GetOutputSizePixel().Width() ) + 1;
|
|
if (nEntryNo >= nSize)
|
|
nScrPos = nMax;
|
|
else
|
|
{
|
|
nScrPos = 0;
|
|
for (SCCOLROW i=GetPos(); i<nEntryNo && nScrPos<nMax; i++)
|
|
{
|
|
sal_uInt16 nAdd = GetEntrySize(i);
|
|
if (nAdd)
|
|
nScrPos += nAdd;
|
|
else
|
|
{
|
|
SCCOLROW nHidden = GetHiddenCount(i);
|
|
if (nHidden > 0)
|
|
i += nHidden - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( IsLayoutRTL() )
|
|
nScrPos = nMax - nScrPos - 2;
|
|
|
|
return nScrPos;
|
|
}
|
|
|
|
// draw a rectangle across the window's width/height, with the outer part in a lighter color
|
|
|
|
void ScHeaderControl::DrawShadedRect( long nStart, long nEnd, const Color& rBaseColor )
|
|
{
|
|
Color aWhite( COL_WHITE );
|
|
|
|
Color aInner( rBaseColor ); // highlight color, unchanged
|
|
Color aCenter( rBaseColor );
|
|
aCenter.Merge( aWhite, 0xd0 ); // lighten up a bit
|
|
Color aOuter( rBaseColor );
|
|
aOuter.Merge( aWhite, 0xa0 ); // lighten up more
|
|
|
|
if ( IsMirrored() )
|
|
std::swap( aInner, aOuter ); // just swap colors instead of positions
|
|
|
|
Size aWinSize = GetSizePixel();
|
|
long nBarSize = bVertical ? aWinSize.Width() : aWinSize.Height();
|
|
long nCenterPos = (nBarSize / 2) - 1;
|
|
|
|
SetLineColor();
|
|
SetFillColor( aOuter );
|
|
if (bVertical)
|
|
DrawRect( Rectangle( 0, nStart, nCenterPos-1, nEnd ) );
|
|
else
|
|
DrawRect( Rectangle( nStart, 0, nEnd, nCenterPos-1 ) );
|
|
SetFillColor( aCenter );
|
|
if (bVertical)
|
|
DrawRect( Rectangle( nCenterPos, nStart, nCenterPos, nEnd ) );
|
|
else
|
|
DrawRect( Rectangle( nStart, nCenterPos, nEnd, nCenterPos ) );
|
|
SetFillColor( aInner );
|
|
if (bVertical)
|
|
DrawRect( Rectangle( nCenterPos+1, nStart, nBarSize-1, nEnd ) );
|
|
else
|
|
DrawRect( Rectangle( nStart, nCenterPos+1, nEnd, nBarSize-1 ) );
|
|
}
|
|
|
|
void ScHeaderControl::Paint( const Rectangle& rRect )
|
|
{
|
|
// fuer VCL ist es wichtig, wenig Aufrufe zu haben, darum werden die aeusseren
|
|
// Linien zusammengefasst
|
|
|
|
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
|
|
bool bHighContrast = rStyleSettings.GetHighContrastMode();
|
|
bool bDark = rStyleSettings.GetFaceColor().IsDark();
|
|
// Use the same distinction for bDark as in Window::DrawSelectionBackground
|
|
|
|
Color aTextColor = rStyleSettings.GetButtonTextColor();
|
|
Color aSelTextColor = rStyleSettings.GetHighlightTextColor();
|
|
aNormFont.SetColor( aTextColor );
|
|
if ( bHighContrast )
|
|
aBoldFont.SetColor( aTextColor );
|
|
else
|
|
aBoldFont.SetColor( aSelTextColor );
|
|
SetTextColor( ( bBoldSet && !bHighContrast ) ? aSelTextColor : aTextColor );
|
|
|
|
Color aBlack( COL_BLACK );
|
|
Color aSelLineColor = rStyleSettings.GetHighlightColor();
|
|
aSelLineColor.Merge( aBlack, 0xe0 ); // darken just a little bit
|
|
|
|
bool bLayoutRTL = IsLayoutRTL();
|
|
long nLayoutSign = bLayoutRTL ? -1 : 1;
|
|
bool bMirrored = IsMirrored();
|
|
|
|
OUString aString;
|
|
sal_uInt16 nBarSize;
|
|
Point aScrPos;
|
|
Size aTextSize;
|
|
|
|
if (bVertical)
|
|
nBarSize = (sal_uInt16) GetSizePixel().Width();
|
|
else
|
|
nBarSize = (sal_uInt16) GetSizePixel().Height();
|
|
|
|
SCCOLROW nPos = GetPos();
|
|
|
|
long nPStart = bVertical ? rRect.Top() : rRect.Left();
|
|
long nPEnd = bVertical ? rRect.Bottom() : rRect.Right();
|
|
|
|
long nTransStart = nPEnd + 1;
|
|
long nTransEnd = 0;
|
|
|
|
long nInitScrPos = 0;
|
|
if ( bLayoutRTL )
|
|
{
|
|
long nTemp = nPStart; // swap nPStart / nPEnd
|
|
nPStart = nPEnd;
|
|
nPEnd = nTemp;
|
|
nTemp = nTransStart; // swap nTransStart / nTransEnd
|
|
nTransStart = nTransEnd;
|
|
nTransEnd = nTemp;
|
|
if ( bVertical ) // start loops from the end
|
|
nInitScrPos = GetSizePixel().Height() - 1;
|
|
else
|
|
nInitScrPos = GetSizePixel().Width() - 1;
|
|
}
|
|
|
|
// aeussere Linien komplett durchzeichnen
|
|
// Zuerst Ende der letzten Zelle finden
|
|
|
|
long nLineEnd = nInitScrPos - nLayoutSign;
|
|
|
|
for (SCCOLROW i=nPos; i<nSize; i++)
|
|
{
|
|
sal_uInt16 nSizePix = GetEntrySize( i );
|
|
if (nSizePix)
|
|
{
|
|
nLineEnd += nSizePix * nLayoutSign;
|
|
|
|
if ( bMarkRange && i >= nMarkStart && i <= nMarkEnd )
|
|
{
|
|
long nLineStart = nLineEnd - ( nSizePix - 1 ) * nLayoutSign;
|
|
if ( nLineStart * nLayoutSign < nTransStart * nLayoutSign )
|
|
nTransStart = nLineStart;
|
|
if ( nLineEnd * nLayoutSign > nTransEnd * nLayoutSign )
|
|
nTransEnd = nLineEnd;
|
|
}
|
|
|
|
if ( nLineEnd * nLayoutSign > nPEnd * nLayoutSign )
|
|
{
|
|
nLineEnd = nPEnd;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SCCOLROW nHidden = GetHiddenCount(i);
|
|
if (nHidden > 0)
|
|
i += nHidden - 1;
|
|
}
|
|
}
|
|
|
|
// background is different for entry area and behind the entries
|
|
|
|
Rectangle aFillRect;
|
|
SetLineColor();
|
|
|
|
if ( nLineEnd * nLayoutSign >= nInitScrPos * nLayoutSign )
|
|
{
|
|
if ( bHighContrast )
|
|
{
|
|
// high contrast: single-color background
|
|
SetFillColor( rStyleSettings.GetFaceColor() );
|
|
if ( bVertical )
|
|
aFillRect = Rectangle( 0, nInitScrPos, nBarSize-1, nLineEnd );
|
|
else
|
|
aFillRect = Rectangle( nInitScrPos, 0, nLineEnd, nBarSize-1 );
|
|
DrawRect( aFillRect );
|
|
}
|
|
else
|
|
{
|
|
// normal: 3-part background
|
|
DrawShadedRect( nInitScrPos, nLineEnd, rStyleSettings.GetFaceColor() );
|
|
}
|
|
}
|
|
|
|
if ( nLineEnd * nLayoutSign < nPEnd * nLayoutSign )
|
|
{
|
|
SetFillColor( SC_MOD()->GetColorConfig().GetColorValue(svtools::APPBACKGROUND).nColor );
|
|
if ( bVertical )
|
|
aFillRect = Rectangle( 0, nLineEnd+nLayoutSign, nBarSize-1, nPEnd );
|
|
else
|
|
aFillRect = Rectangle( nLineEnd+nLayoutSign, 0, nPEnd, nBarSize-1 );
|
|
DrawRect( aFillRect );
|
|
}
|
|
|
|
if ( nLineEnd * nLayoutSign >= nPStart * nLayoutSign )
|
|
{
|
|
if ( nTransEnd * nLayoutSign >= nTransStart * nLayoutSign )
|
|
{
|
|
if ( bHighContrast )
|
|
{
|
|
if ( bDark )
|
|
{
|
|
// solid grey background for dark face color is drawn before lines
|
|
|
|
SetLineColor();
|
|
SetFillColor( COL_LIGHTGRAY );
|
|
if (bVertical)
|
|
DrawRect( Rectangle( 0, nTransStart, nBarSize-1, nTransEnd ) );
|
|
else
|
|
DrawRect( Rectangle( nTransStart, 0, nTransEnd, nBarSize-1 ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// background for selection
|
|
|
|
DrawShadedRect( nTransStart, nTransEnd, rStyleSettings.GetHighlightColor() );
|
|
}
|
|
}
|
|
|
|
SetLineColor( rStyleSettings.GetDarkShadowColor() );
|
|
if (bVertical)
|
|
{
|
|
long nDarkPos = bMirrored ? 0 : nBarSize-1;
|
|
DrawLine( Point( nDarkPos, nPStart ), Point( nDarkPos, nLineEnd ) );
|
|
}
|
|
else
|
|
DrawLine( Point( nPStart, nBarSize-1 ), Point( nLineEnd, nBarSize-1 ) );
|
|
|
|
// line in different color for selection
|
|
if ( nTransEnd * nLayoutSign >= nTransStart * nLayoutSign && !bHighContrast )
|
|
{
|
|
SetLineColor( aSelLineColor );
|
|
if (bVertical)
|
|
{
|
|
long nDarkPos = bMirrored ? 0 : nBarSize-1;
|
|
DrawLine( Point( nDarkPos, nTransStart ), Point( nDarkPos, nTransEnd ) );
|
|
}
|
|
else
|
|
DrawLine( Point( nTransStart, nBarSize-1 ), Point( nTransEnd, nBarSize-1 ) );
|
|
}
|
|
}
|
|
|
|
//
|
|
// loop through entries several times to avoid changing the line color too often
|
|
// and to allow merging of lines
|
|
//
|
|
|
|
ScGridMerger aGrid( this, 1, 1 );
|
|
|
|
// start at SC_HDRPAINT_BOTTOM instead of 0 - selection doesn't get different
|
|
// borders, light border at top isn't used anymore
|
|
// use SC_HDRPAINT_SEL_BOTTOM for different color
|
|
|
|
for (sal_uInt16 nPass = SC_HDRPAINT_SEL_BOTTOM; nPass < SC_HDRPAINT_COUNT; nPass++)
|
|
{
|
|
// set line color etc. before entry loop
|
|
switch ( nPass )
|
|
{
|
|
case SC_HDRPAINT_SEL_BOTTOM:
|
|
// same as non-selected for high contrast
|
|
SetLineColor( bHighContrast ? rStyleSettings.GetDarkShadowColor() : aSelLineColor );
|
|
break;
|
|
case SC_HDRPAINT_BOTTOM:
|
|
SetLineColor( rStyleSettings.GetDarkShadowColor() );
|
|
break;
|
|
case SC_HDRPAINT_TEXT:
|
|
// DrawSelectionBackground is used only for high contrast on light background
|
|
if ( nTransEnd * nLayoutSign >= nTransStart * nLayoutSign && bHighContrast && !bDark )
|
|
{
|
|
// Transparent selection background is drawn after lines, before text.
|
|
// Use DrawSelectionBackground to make sure there is a visible
|
|
// difference. The case of a dark face color, where DrawSelectionBackground
|
|
// would just paint over the lines, is handled separately (bDark).
|
|
// Otherwise, GetHighlightColor is used with 80% transparency.
|
|
// The window's background color (SetBackground) has to be the background
|
|
// of the cell area, for the contrast comparison in DrawSelectionBackground.
|
|
|
|
Rectangle aTransRect;
|
|
if (bVertical)
|
|
aTransRect = Rectangle( 0, nTransStart, nBarSize-1, nTransEnd );
|
|
else
|
|
aTransRect = Rectangle( nTransStart, 0, nTransEnd, nBarSize-1 );
|
|
SetBackground( Color( rStyleSettings.GetFaceColor() ) );
|
|
DrawSelectionBackground( aTransRect, 0, sal_True, false, false );
|
|
SetBackground();
|
|
}
|
|
break;
|
|
}
|
|
|
|
SCCOLROW nCount=0;
|
|
long nScrPos=nInitScrPos;
|
|
do
|
|
{
|
|
if (bVertical)
|
|
aScrPos = Point( 0, nScrPos );
|
|
else
|
|
aScrPos = Point( nScrPos, 0 );
|
|
|
|
SCCOLROW nEntryNo = nCount + nPos;
|
|
if ( nEntryNo >= nSize ) // MAXCOL/MAXROW
|
|
nScrPos = nPEnd + nLayoutSign; // beyond nPEnd -> stop
|
|
else
|
|
{
|
|
sal_uInt16 nSizePix = GetEntrySize( nEntryNo );
|
|
|
|
if (nSizePix == 0)
|
|
{
|
|
SCCOLROW nHidden = GetHiddenCount(nEntryNo);
|
|
if (nHidden > 0)
|
|
nCount += nHidden - 1;
|
|
}
|
|
else if ((nScrPos+nSizePix*nLayoutSign)*nLayoutSign >= nPStart*nLayoutSign)
|
|
{
|
|
Point aEndPos(aScrPos);
|
|
if (bVertical)
|
|
aEndPos = Point( aScrPos.X()+nBarSize-1, aScrPos.Y()+(nSizePix-1)*nLayoutSign );
|
|
else
|
|
aEndPos = Point( aScrPos.X()+(nSizePix-1)*nLayoutSign, aScrPos.Y()+nBarSize-1 );
|
|
|
|
bool bMark = bMarkRange && nEntryNo >= nMarkStart && nEntryNo <= nMarkEnd;
|
|
bool bNextToMark = bMarkRange && nEntryNo + 1 >= nMarkStart && nEntryNo <= nMarkEnd;
|
|
|
|
switch ( nPass )
|
|
{
|
|
case SC_HDRPAINT_SEL_BOTTOM:
|
|
case SC_HDRPAINT_BOTTOM:
|
|
if ( nPass == ( bNextToMark ? SC_HDRPAINT_SEL_BOTTOM : SC_HDRPAINT_BOTTOM ) )
|
|
{
|
|
if (bVertical)
|
|
aGrid.AddHorLine( aScrPos.X(), aEndPos.X(), aEndPos.Y() );
|
|
else
|
|
aGrid.AddVerLine( aEndPos.X(), aScrPos.Y(), aEndPos.Y() );
|
|
|
|
// thick bottom for hidden rows
|
|
// (drawn directly, without aGrid)
|
|
if ( nEntryNo+1 < nSize )
|
|
if ( GetEntrySize(nEntryNo+1)==0 )
|
|
{
|
|
if (bVertical)
|
|
DrawLine( Point(aScrPos.X(),aEndPos.Y()-nLayoutSign),
|
|
Point(aEndPos.X(),aEndPos.Y()-nLayoutSign) );
|
|
else
|
|
DrawLine( Point(aEndPos.X()-nLayoutSign,aScrPos.Y()),
|
|
Point(aEndPos.X()-nLayoutSign,aEndPos.Y()) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SC_HDRPAINT_TEXT:
|
|
if ( nSizePix > 1 ) // minimal check for small columns/rows
|
|
{
|
|
if ( bMark != bBoldSet )
|
|
{
|
|
if (bMark)
|
|
SetFont(aBoldFont);
|
|
else
|
|
SetFont(aNormFont);
|
|
bBoldSet = bMark;
|
|
}
|
|
aString = GetEntryText( nEntryNo );
|
|
aTextSize.Width() = GetTextWidth( aString );
|
|
aTextSize.Height() = GetTextHeight();
|
|
|
|
Point aTxtPos(aScrPos);
|
|
if (bVertical)
|
|
{
|
|
aTxtPos.X() += (nBarSize-aTextSize.Width())/2;
|
|
aTxtPos.Y() += (nSizePix*nLayoutSign-aTextSize.Height())/2;
|
|
if ( bMirrored )
|
|
aTxtPos.X() += 1; // dark border is left instead of right
|
|
}
|
|
else
|
|
{
|
|
aTxtPos.X() += (nSizePix*nLayoutSign-aTextSize.Width()+1)/2;
|
|
aTxtPos.Y() += (nBarSize-aTextSize.Height())/2;
|
|
}
|
|
DrawText( aTxtPos, aString );
|
|
}
|
|
break;
|
|
}
|
|
|
|
// bei Selektion der ganzen Zeile/Spalte:
|
|
// InvertRect( Rectangle( aScrPos, aEndPos ) );
|
|
}
|
|
nScrPos += nSizePix * nLayoutSign; // also if before the visible area
|
|
}
|
|
++nCount;
|
|
}
|
|
while ( nScrPos * nLayoutSign <= nPEnd * nLayoutSign );
|
|
|
|
aGrid.Flush();
|
|
}
|
|
}
|
|
|
|
SCCOLROW ScHeaderControl::GetMousePos( const MouseEvent& rMEvt, bool& rBorder ) const
|
|
{
|
|
bool bFound = false;
|
|
SCCOLROW nPos = GetPos();
|
|
SCCOLROW nHitNo = nPos;
|
|
SCCOLROW nEntryNo = 1 + nPos;
|
|
long nScrPos;
|
|
long nMousePos = bVertical ? rMEvt.GetPosPixel().Y() : rMEvt.GetPosPixel().X();
|
|
long nDif;
|
|
Size aSize = GetOutputSizePixel();
|
|
long nWinSize = bVertical ? aSize.Height() : aSize.Width();
|
|
|
|
bool bLayoutRTL = IsLayoutRTL();
|
|
long nLayoutSign = bLayoutRTL ? -1 : 1;
|
|
long nEndPos = bLayoutRTL ? -1 : nWinSize;
|
|
|
|
nScrPos = GetScrPos( nPos ) - nLayoutSign;
|
|
do
|
|
{
|
|
if (nEntryNo > nSize)
|
|
nScrPos = nEndPos + nLayoutSign;
|
|
else
|
|
nScrPos += GetEntrySize( nEntryNo - 1 ) * nLayoutSign; //! GetHiddenCount() ??
|
|
|
|
nDif = nMousePos - nScrPos;
|
|
if (nDif >= -2 && nDif <= 2)
|
|
{
|
|
bFound = true;
|
|
nHitNo=nEntryNo-1;
|
|
}
|
|
else if (nDif * nLayoutSign >= 0 && nEntryNo < nSize)
|
|
nHitNo = nEntryNo;
|
|
++nEntryNo;
|
|
}
|
|
while ( nScrPos * nLayoutSign < nEndPos * nLayoutSign && nDif * nLayoutSign > 0 );
|
|
|
|
rBorder = bFound;
|
|
return nHitNo;
|
|
}
|
|
|
|
bool ScHeaderControl::IsSelectionAllowed(SCCOLROW nPos) const
|
|
{
|
|
ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>(SfxViewShell::Current());
|
|
if (!pViewSh)
|
|
return false;
|
|
|
|
ScViewData* pViewData = pViewSh->GetViewData();
|
|
sal_uInt16 nTab = pViewData->GetTabNo();
|
|
ScDocument* pDoc = pViewData->GetDocument();
|
|
const ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
|
|
bool bSelectAllowed = true;
|
|
if ( pProtect && pProtect->isProtected() )
|
|
{
|
|
// This sheet is protected. Check if a context menu is allowed on this cell.
|
|
bool bCellsProtected = false;
|
|
if (bVertical)
|
|
{
|
|
// row header
|
|
SCROW nRPos = static_cast<SCROW>(nPos);
|
|
bCellsProtected = pDoc->HasAttrib(0, nRPos, nTab, MAXCOL, nRPos, nTab, HASATTR_PROTECTED);
|
|
}
|
|
else
|
|
{
|
|
// column header
|
|
SCCOL nCPos = static_cast<SCCOL>(nPos);
|
|
bCellsProtected = pDoc->HasAttrib(nCPos, 0, nTab, nCPos, MAXROW, nTab, HASATTR_PROTECTED);
|
|
}
|
|
|
|
bool bSelProtected = pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
|
|
bool bSelUnprotected = pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
|
|
|
|
if (bCellsProtected)
|
|
bSelectAllowed = bSelProtected;
|
|
else
|
|
bSelectAllowed = bSelUnprotected;
|
|
}
|
|
return bSelectAllowed;
|
|
}
|
|
|
|
void ScHeaderControl::MouseButtonDown( const MouseEvent& rMEvt )
|
|
{
|
|
if (IsDisabled())
|
|
return;
|
|
|
|
bIgnoreMove = false;
|
|
SelectWindow();
|
|
|
|
bool bIsBorder;
|
|
SCCOLROW nHitNo = GetMousePos( rMEvt, bIsBorder );
|
|
if (!IsSelectionAllowed(nHitNo))
|
|
return;
|
|
if ( ! rMEvt.IsLeft() )
|
|
return;
|
|
if ( bIsBorder && ResizeAllowed() )
|
|
{
|
|
nDragNo = nHitNo;
|
|
sal_uInt16 nClicks = rMEvt.GetClicks();
|
|
if ( nClicks && nClicks%2==0 )
|
|
{
|
|
SetEntrySize( nDragNo, HDR_SIZE_OPTIMUM );
|
|
SetPointer( Pointer( POINTER_ARROW ) );
|
|
}
|
|
else
|
|
{
|
|
if (bVertical)
|
|
nDragStart = rMEvt.GetPosPixel().Y();
|
|
else
|
|
nDragStart = rMEvt.GetPosPixel().X();
|
|
nDragPos = nDragStart;
|
|
ShowDragHelp();
|
|
DrawInvert( nDragPos );
|
|
|
|
StartTracking();
|
|
bDragging = true;
|
|
bDragMoved = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSelEngine->SetWindow( this );
|
|
Point aPoint;
|
|
Rectangle aVis( aPoint,GetOutputSizePixel() );
|
|
if (bVertical)
|
|
aVis.Left() = LONG_MIN, aVis.Right() = LONG_MAX;
|
|
else
|
|
aVis.Top() = LONG_MIN, aVis.Bottom() = LONG_MAX;
|
|
pSelEngine->SetVisibleArea( aVis );
|
|
|
|
SetMarking( true ); // must precede SelMouseButtonDown
|
|
pSelEngine->SelMouseButtonDown( rMEvt );
|
|
|
|
// In column/row headers a simple click already is a selection.
|
|
// -> Call SelMouseMove to ensure CreateAnchor is called (and DestroyAnchor
|
|
// if the next click is somewhere else with Control key).
|
|
pSelEngine->SelMouseMove( rMEvt );
|
|
|
|
if (IsMouseCaptured())
|
|
{
|
|
// Tracking statt CaptureMouse, damit sauber abgebrochen werden kann
|
|
//! Irgendwann sollte die SelectionEngine selber StartTracking rufen!?!
|
|
ReleaseMouse();
|
|
StartTracking();
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScHeaderControl::MouseButtonUp( const MouseEvent& rMEvt )
|
|
{
|
|
if ( IsDisabled() )
|
|
return;
|
|
|
|
SetMarking( false );
|
|
bIgnoreMove = false;
|
|
|
|
if ( bDragging )
|
|
{
|
|
DrawInvert( nDragPos );
|
|
ReleaseMouse();
|
|
bDragging = false;
|
|
|
|
long nScrPos = GetScrPos( nDragNo );
|
|
long nMousePos = bVertical ? rMEvt.GetPosPixel().Y() : rMEvt.GetPosPixel().X();
|
|
bool bLayoutRTL = IsLayoutRTL();
|
|
long nNewWidth = bLayoutRTL ? ( nScrPos - nMousePos + 1 )
|
|
: ( nMousePos + 2 - nScrPos );
|
|
|
|
if ( nNewWidth < 0 /* && !IsSelected(nDragNo) */ )
|
|
{
|
|
SCCOLROW nStart = 0;
|
|
SCCOLROW nEnd = nDragNo;
|
|
while (nNewWidth < 0)
|
|
{
|
|
nStart = nDragNo;
|
|
if (nDragNo>0)
|
|
{
|
|
--nDragNo;
|
|
nNewWidth += GetEntrySize( nDragNo ); //! GetHiddenCount() ???
|
|
}
|
|
else
|
|
nNewWidth = 0;
|
|
}
|
|
HideEntries( nStart, nEnd );
|
|
}
|
|
else
|
|
{
|
|
if (bDragMoved)
|
|
SetEntrySize( nDragNo, (sal_uInt16) nNewWidth );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pSelEngine->SelMouseButtonUp( rMEvt );
|
|
ReleaseMouse();
|
|
}
|
|
}
|
|
|
|
void ScHeaderControl::MouseMove( const MouseEvent& rMEvt )
|
|
{
|
|
if ( IsDisabled() )
|
|
{
|
|
SetPointer( Pointer( POINTER_ARROW ) );
|
|
return;
|
|
}
|
|
|
|
if ( bDragging )
|
|
{
|
|
long nNewPos = bVertical ? rMEvt.GetPosPixel().Y() : rMEvt.GetPosPixel().X();
|
|
if ( nNewPos != nDragPos )
|
|
{
|
|
DrawInvert( nDragPos );
|
|
nDragPos = nNewPos;
|
|
ShowDragHelp();
|
|
DrawInvert( nDragPos );
|
|
|
|
if (nDragPos <= nDragStart-SC_DRAG_MIN || nDragPos >= nDragStart+SC_DRAG_MIN)
|
|
bDragMoved = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool bIsBorder;
|
|
(void)GetMousePos( rMEvt, bIsBorder );
|
|
|
|
if ( bIsBorder && rMEvt.GetButtons()==0 && ResizeAllowed() )
|
|
SetPointer( Pointer( bVertical ? POINTER_VSIZEBAR : POINTER_HSIZEBAR ) );
|
|
else
|
|
SetPointer( Pointer( POINTER_ARROW ) );
|
|
|
|
if (!bIgnoreMove)
|
|
pSelEngine->SelMouseMove( rMEvt );
|
|
}
|
|
}
|
|
|
|
void ScHeaderControl::Tracking( const TrackingEvent& rTEvt )
|
|
{
|
|
// Distribute the tracking events to the various MouseEvents, because
|
|
// SelectionEngine does not know anything about Tracking
|
|
|
|
if ( rTEvt.IsTrackingCanceled() )
|
|
StopMarking();
|
|
else if ( rTEvt.IsTrackingEnded() )
|
|
MouseButtonUp( rTEvt.GetMouseEvent() );
|
|
else
|
|
MouseMove( rTEvt.GetMouseEvent() );
|
|
}
|
|
|
|
void ScHeaderControl::Command( const CommandEvent& rCEvt )
|
|
{
|
|
sal_uInt16 nCmd = rCEvt.GetCommand();
|
|
if ( nCmd == COMMAND_CONTEXTMENU )
|
|
{
|
|
StopMarking(); // finish selection / dragging
|
|
|
|
// execute popup menu
|
|
|
|
ScTabViewShell* pViewSh = PTR_CAST( ScTabViewShell,
|
|
SfxViewShell::Current() );
|
|
if ( pViewSh )
|
|
{
|
|
if ( rCEvt.IsMouseEvent() )
|
|
{
|
|
// #i18735# select the column/row under the mouse pointer
|
|
ScViewData* pViewData = pViewSh->GetViewData();
|
|
|
|
SelectWindow(); // also deselects drawing objects, stops draw text edit
|
|
if ( pViewData->HasEditView( pViewData->GetActivePart() ) )
|
|
SC_MOD()->InputEnterHandler(); // always end edit mode
|
|
|
|
MouseEvent aMEvt( rCEvt.GetMousePosPixel() );
|
|
bool bBorder;
|
|
SCCOLROW nPos = GetMousePos( aMEvt, bBorder );
|
|
if (!IsSelectionAllowed(nPos))
|
|
// Selecting this cell is not allowed, neither is context menu.
|
|
return;
|
|
|
|
SCTAB nTab = pViewData->GetTabNo();
|
|
ScRange aNewRange;
|
|
if ( bVertical )
|
|
aNewRange = ScRange( 0, sal::static_int_cast<SCROW>(nPos), nTab,
|
|
MAXCOL, sal::static_int_cast<SCROW>(nPos), nTab );
|
|
else
|
|
aNewRange = ScRange( sal::static_int_cast<SCCOL>(nPos), 0, nTab,
|
|
sal::static_int_cast<SCCOL>(nPos), MAXROW, nTab );
|
|
|
|
// see if any part of the range is already selected
|
|
ScRangeList aRanges;
|
|
pViewData->GetMarkData().FillRangeListWithMarks( &aRanges, false );
|
|
bool bSelected = aRanges.Intersects(aNewRange);
|
|
|
|
// select the range if no part of it was selected
|
|
if ( !bSelected )
|
|
pViewSh->MarkRange( aNewRange );
|
|
}
|
|
|
|
ScResId aResId( bVertical ? RID_POPUP_ROWHEADER : RID_POPUP_COLHEADER );
|
|
pViewSh->GetDispatcher()->ExecutePopup( aResId );
|
|
}
|
|
}
|
|
else if ( nCmd == COMMAND_STARTDRAG )
|
|
{
|
|
pSelEngine->Command( rCEvt );
|
|
}
|
|
}
|
|
|
|
void ScHeaderControl::StopMarking()
|
|
{
|
|
if ( bDragging )
|
|
{
|
|
DrawInvert( nDragPos );
|
|
bDragging = false;
|
|
}
|
|
|
|
SetMarking( false );
|
|
bIgnoreMove = true;
|
|
|
|
// don't call pSelEngine->Reset, so selection across the parts of
|
|
// a split/frozen view is possible
|
|
|
|
ReleaseMouse();
|
|
}
|
|
|
|
void ScHeaderControl::ShowDragHelp()
|
|
{
|
|
if (Help::IsQuickHelpEnabled())
|
|
{
|
|
long nScrPos = GetScrPos( nDragNo );
|
|
bool bLayoutRTL = IsLayoutRTL();
|
|
long nVal = bLayoutRTL ? ( nScrPos - nDragPos + 1 )
|
|
: ( nDragPos + 2 - nScrPos );
|
|
|
|
OUString aHelpStr = GetDragHelp( nVal );
|
|
Point aPos = OutputToScreenPixel( Point(0,0) );
|
|
Size aSize = GetSizePixel();
|
|
|
|
Point aMousePos = OutputToScreenPixel(GetPointerPosPixel());
|
|
|
|
Rectangle aRect;
|
|
sal_uInt16 nAlign;
|
|
if (!bVertical)
|
|
{
|
|
// above
|
|
aRect.Left() = aMousePos.X();
|
|
aRect.Top() = aPos.Y() - 4;
|
|
nAlign = QUICKHELP_BOTTOM|QUICKHELP_CENTER;
|
|
}
|
|
else
|
|
{
|
|
// top right
|
|
aRect.Left() = aPos.X() + aSize.Width() + 8;
|
|
aRect.Top() = aMousePos.Y() - 2;
|
|
nAlign = QUICKHELP_LEFT|QUICKHELP_BOTTOM;
|
|
}
|
|
|
|
aRect.Right() = aRect.Left();
|
|
aRect.Bottom() = aRect.Top();
|
|
|
|
Help::ShowQuickHelp(this, aRect, aHelpStr, nAlign);
|
|
}
|
|
}
|
|
|
|
void ScHeaderControl::RequestHelp( const HelpEvent& rHEvt )
|
|
{
|
|
// If the own QuickHelp is displayed, don't let RequestHelp remove it
|
|
|
|
bool bOwn = bDragging && Help::IsQuickHelpEnabled();
|
|
if (!bOwn)
|
|
Window::RequestHelp(rHEvt);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Dummys fuer virtuelle Methoden
|
|
// -----------------------------------------------------------------------
|
|
|
|
SCCOLROW ScHeaderControl::GetHiddenCount( SCCOLROW nEntryNo ) const
|
|
{
|
|
SCCOLROW nHidden = 0;
|
|
while ( nEntryNo < nSize && GetEntrySize( nEntryNo ) == 0 )
|
|
{
|
|
++nEntryNo;
|
|
++nHidden;
|
|
}
|
|
return nHidden;
|
|
}
|
|
|
|
bool ScHeaderControl::IsLayoutRTL() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ScHeaderControl::IsMirrored() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ScHeaderControl::IsDisabled() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ScHeaderControl::ResizeAllowed() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void ScHeaderControl::SelectWindow()
|
|
{
|
|
}
|
|
|
|
void ScHeaderControl::DrawInvert( long /* nDragPos */ )
|
|
{
|
|
}
|
|
|
|
OUString ScHeaderControl::GetDragHelp( long /* nVal */ )
|
|
{
|
|
return EMPTY_OUSTRING;
|
|
}
|
|
|
|
void ScHeaderControl::SetMarking( bool /* bSet */ )
|
|
{
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|