You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/kspread/selection.cc

1010 lines
25 KiB

/* This file is part of the KDE project
Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
Copyright (C) 2005-2006 Stefan Nikolaus <stefan.nikolaus@kdemail.net>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <tqregexp.h>
#include <kdebug.h>
#include "kspread_canvas.h"
#include "kspread_cell.h"
#include "kspread_doc.h"
#include "kspread_editors.h"
#include "kspread_sheet.h"
#include "kspread_view.h"
#include "kspread_util.h"
#include "selection.h"
// TODO Stefan: Substract points in selections
// TODO Stefan: KPart signal (kspread_events.h)
using namespace KSpread;
/***************************************************************************
class Selection::Private
****************************************************************************/
class Selection::Private
{
public:
Private(View *v)
{
view = v;
sheet = 0;
anchor = TQPoint(1,1);
cursor = TQPoint(1,1);
marker = TQPoint(1,1);
colors.push_back(TQt::red);
colors.push_back(TQt::blue);
colors.push_back(TQt::magenta);
colors.push_back(TQt::darkRed);
colors.push_back(TQt::darkGreen);
colors.push_back(TQt::darkMagenta);
colors.push_back(TQt::darkCyan);
colors.push_back(TQt::darkYellow);
multipleSelection = false;
activeElement = Iterator();
activeSubRegionStart = 0;
activeSubRegionLength = 0;
}
View* view;
Sheet* sheet;
TQPoint anchor;
TQPoint cursor;
TQPoint marker;
TQValueList<TQColor> colors;
bool multipleSelection : 1;
Selection::Iterator activeElement;
uint activeSubRegionStart;
uint activeSubRegionLength;
};
/***************************************************************************
class Selection
****************************************************************************/
namespace KSpread {
Selection::Selection(View *view)
: TQObject(view), Region(1,1)
{
d = new Private(view);
d->activeSubRegionStart = 0;
d->activeSubRegionLength = 1;
}
Selection::Selection(const Selection& selection)
: TQObject(selection.d->view), Region()
{
/* kdDebug() << k_funcinfo << endl;*/
d = new Private(selection.d->view);
d->sheet = selection.d->sheet;
d->activeSubRegionStart = 0;
d->activeSubRegionLength = cells().count();
}
Selection::~Selection()
{
delete d;
}
void Selection::initialize(const TQPoint& point, Sheet* sheet)
{
if (!util_isPointValid(point))
return;
if (!d->view->activeSheet())
return;
if (!sheet)
{
if (d->sheet)
{
sheet = d->sheet;
}
else
{
sheet = d->view->activeSheet();
}
}
Region changedRegion(*this);
changedRegion.add(extendToMergedAreas(TQRect(d->anchor,d->marker)));
TQPoint topLeft(point);
Cell* cell = d->view->activeSheet()->cellAt(point);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
d->anchor = topLeft;
d->cursor = point;
d->marker = topLeft;
fixSubRegionDimension(); // TODO remove this sanity check
Iterator it = cells().begin() += d->activeSubRegionStart + d->activeSubRegionLength;
if (it != insert(it, topLeft, sheet/*, true*/))
{
// if the point was inserted
clearSubRegion();
}
Element* element = *(cells().begin() += d->activeSubRegionStart);
// we end up with one element in the subregion
d->activeSubRegionLength = 1;
if (element && element->type() == Element::Point)
{
Point* point = static_cast<Point*>(element);
point->setColor(d->colors[cells().size() % d->colors.size()]);
}
else if (element && element->type() == Element::Range)
{
Range* range = static_cast<Range*>(element);
range->setColor(d->colors[cells().size() % d->colors.size()]);
}
d->activeElement = cells().begin();
if (changedRegion == *this)
{
emit changed(Region(topLeft, sheet));
return;
}
changedRegion.add(topLeft, sheet);
emit changed(changedRegion);
}
void Selection::initialize(const TQRect& range, Sheet* sheet)
{
if (!util_isRectValid(range) || ( range == TQRect(0,0,1,1) ))
return;
if (!sheet)
{
if (d->sheet)
{
sheet = d->sheet;
}
else
{
sheet = d->view->activeSheet();
}
}
Region changedRegion(*this);
changedRegion.add(extendToMergedAreas(TQRect(d->anchor,d->marker)));
TQPoint topLeft(range.topLeft());
Cell* cell = d->view->activeSheet()->cellAt(topLeft);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
TQPoint bottomRight(range.bottomRight());
cell = d->view->activeSheet()->cellAt(bottomRight);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
bottomRight = TQPoint(cell->column(), cell->row());
}
d->anchor = topLeft;
d->cursor = bottomRight;
d->marker = bottomRight;
fixSubRegionDimension(); // TODO remove this sanity check
Iterator it = cells().begin() += d->activeSubRegionStart + d->activeSubRegionLength;
if (it != insert(it, TQRect(topLeft, bottomRight), sheet/*, true*/))
{
// if the range was inserted
clearSubRegion();
}
Element* element = *(cells().begin() += d->activeSubRegionStart);
// we end up with one element in the subregion
d->activeSubRegionLength = 1;
if (element && element->type() == Element::Point)
{
Point* point = static_cast<Point*>(element);
point->setColor(d->colors[cells().size() % d->colors.size()]);
}
else if (element && element->type() == Element::Range)
{
Range* range = static_cast<Range*>(element);
range->setColor(d->colors[cells().size() % d->colors.size()]);
}
d->activeElement = cells().begin();
if (changedRegion == *this)
{
return;
}
changedRegion.add(TQRect(topLeft, bottomRight), sheet);
emit changed(changedRegion);
}
void Selection::initialize(const Region& region, Sheet* sheet)
{
if (!region.isValid())
return;
if (!sheet)
{
if (d->sheet)
{
sheet = d->sheet;
}
else
{
sheet = d->view->activeSheet();
}
}
Region changedRegion(*this);
changedRegion.add(extendToMergedAreas(TQRect(d->anchor,d->marker)));
// TODO Stefan: handle subregion insertion
// TODO Stefan: handle obscured cells correctly
clear();
Element* element = add(region);
if (element && element->type() == Element::Point)
{
Point* point = static_cast<Point*>(element);
point->setColor(d->colors[cells().size() % d->colors.size()]);
}
else if (element && element->type() == Element::Range)
{
Range* range = static_cast<Range*>(element);
range->setColor(d->colors[cells().size() % d->colors.size()]);
}
TQPoint topLeft(cells().last()->rect().normalize().topLeft());
Cell* cell = d->view->activeSheet()->cellAt(topLeft);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
TQPoint bottomRight(cells().last()->rect().normalize().bottomRight());
cell = d->view->activeSheet()->cellAt(bottomRight);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
bottomRight = TQPoint(cell->column(), cell->row());
}
d->anchor = topLeft;
d->cursor = topLeft;
d->marker = bottomRight;
d->activeElement = --cells().end();
d->activeSubRegionStart = 0;
d->activeSubRegionLength = cells().count();
if (changedRegion == *this)
{
return;
}
changedRegion.add( region );
emit changed(changedRegion);
}
void Selection::update()
{
emit changed(*this);
}
void Selection::update(const TQPoint& point)
{
uint count = cells().count();
if (cells().isEmpty())
{
add(point);
d->activeSubRegionLength += cells().count() - count;
return;
}
if (d->activeElement == cells().end())
{
// we're not empty, so this will not become again end()
d->activeElement--;
}
Sheet* sheet = (*d->activeElement)->sheet();
if (sheet != d->view->activeSheet())
{
extend(point);
d->activeSubRegionLength += cells().count() - count;
return;
}
TQPoint topLeft(point);
Cell* cell = d->view->activeSheet()->cellAt(point);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
if (topLeft == d->marker)
{
return;
}
TQRect area1 = (*d->activeElement)->rect().normalize();
TQRect newRange = extendToMergedAreas(TQRect(d->anchor, topLeft));
Element* oldElement = *d->activeElement;
// returns iterator to the next element or end
Iterator it = cells().remove(d->activeElement);
delete oldElement;
// returns iterator to the new element (before 'it') or 'it'
d->activeElement = insert(it, newRange, sheet, d->multipleSelection);
d->activeSubRegionLength += cells().count() - count;
// The call to insert() above can just return the iterator which has been
// passed in. This may be cells.end(), if the old active element was the
// iterator to the list's end (!= last element). So attempts to dereference
// it will fail.
if (d->activeElement == cells().end())
{
d->activeElement--;
}
TQRect area2 = (*d->activeElement)->rect().normalize();
Region changedRegion;
bool newLeft = area1.left() != area2.left();
bool newTop = area1.top() != area2.top();
bool newRight = area1.right() != area2.right();
bool newBottom = area1.bottom() != area2.bottom();
/* first, calculate some numbers that we'll use a few times */
int farLeft = TQMIN(area1.left(), area2.left());
int innerLeft = TQMAX(area1.left(), area2.left());
int farTop = TQMIN(area1.top(), area2.top());
int innerTop = TQMAX(area1.top(), area2.top());
int farRight = TQMAX(area1.right(), area2.right());
int innerRight = TQMIN(area1.right(), area2.right());
int farBottom = TQMAX(area1.bottom(), area2.bottom());
int innerBottom = TQMIN(area1.bottom(), area2.bottom());
if (newLeft)
{
changedRegion.add(TQRect(TQPoint(farLeft, innerTop),
TQPoint(innerLeft-1, innerBottom)));
if (newTop)
{
changedRegion.add(TQRect(TQPoint(farLeft, farTop),
TQPoint(innerLeft-1, innerTop-1)));
}
if (newBottom)
{
changedRegion.add(TQRect(TQPoint(farLeft, innerBottom+1),
TQPoint(innerLeft-1, farBottom)));
}
}
if (newTop)
{
changedRegion.add(TQRect(TQPoint(innerLeft, farTop),
TQPoint(innerRight, innerTop-1)));
}
if (newRight)
{
changedRegion.add(TQRect(TQPoint(innerRight+1, innerTop),
TQPoint(farRight, innerBottom)));
if (newTop)
{
changedRegion.add(TQRect(TQPoint(innerRight+1, farTop),
TQPoint(farRight, innerTop-1)));
}
if (newBottom)
{
changedRegion.add(TQRect(TQPoint(innerRight+1, innerBottom+1),
TQPoint(farRight, farBottom)));
}
}
if (newBottom)
{
changedRegion.add(TQRect(TQPoint(innerLeft, innerBottom+1),
TQPoint(innerRight, farBottom)));
}
d->marker = topLeft;
d->cursor = point;
emit changed(changedRegion);
}
void Selection::extend(const TQPoint& point, Sheet* sheet)
{
if (!util_isPointValid(point))
return;
if (isEmpty())
{
initialize(point, sheet);
return;
}
if (d->activeElement == cells().end())
{
// we're not empty, so this will not become again end()
d->activeElement--;
}
if (!sheet)
{
if (d->sheet)
{
sheet = d->sheet;
}
else
{
sheet = d->view->activeSheet();
}
}
Region changedRegion = Region(extendToMergedAreas(TQRect(d->marker,d->marker)));
TQPoint topLeft(point);
Cell* cell = d->view->activeSheet()->cellAt(point);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
uint count = cells().count();
if (d->multipleSelection)
{
d->activeElement = insert(++d->activeElement, point, sheet, false);
}
else
{
eor(topLeft, sheet);
d->activeElement = --cells().end();
}
d->anchor = (*d->activeElement)->rect().topLeft();
d->cursor = (*d->activeElement)->rect().bottomRight();
d->marker = d->cursor;
d->activeSubRegionLength += cells().count() - count;
changedRegion.add(topLeft, sheet);
changedRegion.add(*this);
emit changed(changedRegion);
}
void Selection::extend(const TQRect& range, Sheet* sheet)
{
//See comment in Selection::initialize(const TQRect& range, Sheet* sheet)
if (!util_isRectValid(range) || (range == TQRect(0,0,1,1)))
return;
if (isEmpty())
{
initialize(range, sheet);
return;
}
if (d->activeElement == cells().end())
{
// we're not empty, so this will not become again end()
d->activeElement--;
}
if (!sheet)
{
if (d->sheet)
{
sheet = d->sheet;
}
else
{
sheet = d->view->activeSheet();
}
}
TQPoint topLeft(range.topLeft());
Cell* cell = d->view->activeSheet()->cellAt(topLeft);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
topLeft = TQPoint(cell->column(), cell->row());
}
TQPoint bottomRight(range.bottomRight());
cell = d->view->activeSheet()->cellAt(bottomRight);
if (cell->isObscured() && cell->isPartOfMerged())
{
cell = cell->obscuringCells().first();
bottomRight = TQPoint(cell->column(), cell->row());
}
d->anchor = topLeft;
d->cursor = topLeft;
d->marker = bottomRight;
uint count = cells().count();
Element* element;
if (d->multipleSelection)
{
d->activeElement = insert(++d->activeElement, extendToMergedAreas(TQRect(topLeft, bottomRight)).normalize(), sheet, false);
element = (d->activeElement == cells().end()) ? 0 : *d->activeElement;
}
else
{
element = add(extendToMergedAreas(TQRect(topLeft, bottomRight)).normalize(), sheet);
d->activeElement = --cells().end();
}
if (element && element->type() == Element::Point)
{
Point* point = static_cast<Point*>(element);
point->setColor(d->colors[cells().size() % d->colors.size()]);
}
else if (element && element->type() == Element::Range)
{
Range* range = static_cast<Range*>(element);
range->setColor(d->colors[cells().size() % d->colors.size()]);
}
d->activeSubRegionLength += cells().count() - count;
emit changed(*this);
}
void Selection::extend(const Region& region)
{
if (!region.isValid())
return;
uint count = cells().count();
ConstIterator end(region.constEnd());
for (ConstIterator it = region.constBegin(); it != end; ++it)
{
Element *element = *it;
if (!element) continue;
if (element->type() == Element::Point)
{
Point* point = static_cast<Point*>(element);
extend(point->pos(), element->sheet());
}
else
{
extend(element->rect(), element->sheet());
}
}
d->activeSubRegionLength += cells().count() - count;
emit changed(*this);
}
Selection::Element* Selection::eor(const TQPoint& point, Sheet* sheet)
{
if (isSingular())
{
return Region::add(point, sheet);
}
return Region::eor(point, sheet);
}
const TQPoint& Selection::anchor() const
{
return d->anchor;
}
const TQPoint& Selection::cursor() const
{
return d->cursor;
}
const TQPoint& Selection::marker() const
{
return d->marker;
}
bool Selection::isSingular() const
{
return Region::isSingular();
}
TQRect Selection::selectionHandleArea() const
{
int column, row;
// complete rows/columns are selected, use the marker.
if (isColumnOrRowSelected())
{
column = d->marker.x();
row = d->marker.y();
}
else
{
column = lastRange().right();
row = lastRange().bottom();
}
const Cell* cell = d->view->activeSheet()->cellAt(column, row);
double xpos = d->view->activeSheet()->dblColumnPos( column );
double ypos = d->view->activeSheet()->dblRowPos( row );
double width = cell->dblWidth( column );
double height = cell->dblHeight( row );
TQPoint rightBottom( d->view->doc()->zoomItX( xpos + width ),
d->view->doc()->zoomItY( ypos + height ) );
TQRect handle( ( rightBottom.x() - 2 ),
( rightBottom.y() - 2 ),
( 5 ),
( 5 ) );
return handle;
}
TQString Selection::name(Sheet* sheet) const
{
return Region::name(sheet ? sheet : d->sheet);
}
void Selection::setSheet(Sheet* sheet)
{
d->sheet = sheet;
}
Sheet* Selection::sheet() const
{
return d->sheet;
}
void Selection::setActiveElement(const TQPoint& point)
{
uint counter = 0;
Iterator end = cells().end();
for (Iterator it = cells().begin(); it != end; ++it)
{
TQRect range = (*it)->rect();
if (range.topLeft() == point || range.bottomRight() == point)
{
d->anchor = range.topLeft();
d->cursor = range.bottomRight();
d->marker = range.bottomRight();
d->activeElement = it;
d->activeSubRegionStart = counter;
d->activeSubRegionLength = 1;
if (d->view->canvasWidget()->editor())
{
d->view->canvasWidget()->editor()->setCursorToRange(counter);
}
}
counter++;
}
}
void Selection::setActiveElement(uint pos)
{
if (pos >= cells().count())
{
kdDebug() << "Selection::setActiveElement: position exceeds list" << endl;
d->activeElement = cells().begin();
return;
}
Iterator it = cells().begin() += pos;
TQRect range = (*it)->rect();
d->anchor = range.topLeft();
d->cursor = range.bottomRight();
d->marker = range.bottomRight();
d->activeElement = it;
}
Region::Element* Selection::activeElement() const
{
return (d->activeElement == cells().end()) ? 0 : *d->activeElement;
}
void Selection::clear()
{
d->activeSubRegionStart = 0;
d->activeSubRegionLength = 0;
Region::clear();
d->activeElement = cells().begin();
}
void Selection::clearSubRegion()
{
if (isEmpty())
{
return;
}
// kdDebug() << *this << endl;
// kdDebug() << d->activeSubRegionStart << endl;
// kdDebug() << d->activeSubRegionLength << endl;
Iterator it = cells().begin();
Iterator end = it += d->activeSubRegionStart;
end += d->activeSubRegionLength;
while (it != end)
{
/* kdDebug() << (*it)->name() << endl;*/
delete *it;
it = cells().remove(it);
}
d->activeSubRegionLength = 0;
d->activeElement = it;
/* kdDebug() << "ENDE" << endl;*/
}
void Selection::fixSubRegionDimension()
{
if (d->activeSubRegionStart > cells().count())
{
kdDebug() << "Selection::fixSubRegionDimension: start position exceeds list" << endl;
d->activeSubRegionStart = 0;
d->activeSubRegionLength = cells().count();
return;
}
if (d->activeSubRegionStart + d->activeSubRegionLength > cells().count())
{
kdDebug() << "Selection::fixSubRegionDimension: length exceeds list" << endl;
d->activeSubRegionLength = cells().count() - d->activeSubRegionStart;
return;
}
}
void Selection::setActiveSubRegion(uint start, uint length)
{
// kdDebug() << k_funcinfo << endl;
d->activeSubRegionStart = start;
d->activeSubRegionLength = length;
fixSubRegionDimension();
d->activeElement = cells().begin() += d->activeSubRegionStart;
}
TQString Selection::activeSubRegionName() const
{
// kdDebug() << k_funcinfo << endl;
// kdDebug() << *this << endl;
// kdDebug() << "start = " << d->activeSubRegionStart << ", len = " << d->activeSubRegionLength << endl;
TQStringList names;
Iterator it = cells().begin();
it += d->activeSubRegionStart;
Iterator end = it;
end += d->activeSubRegionLength;
while (it != end)
{
names += (*it++)->name(d->sheet);
}
/* kdDebug() << "ENDE" << endl;*/
return names.isEmpty() ? "" : names.join(";");
}
void Selection::setMultipleSelection(bool state)
{
d->multipleSelection = state;
}
const TQValueList<TQColor>& Selection::colors() const
{
return d->colors;
}
TQRect Selection::lastRange(bool extend) const
{
TQRect selection = TQRect(d->anchor, d->marker).normalize();
return extend ? extendToMergedAreas(selection) : selection;
}
TQRect Selection::selection(bool extend) const
{
TQRect selection = TQRect(d->anchor, d->marker).normalize();
return extend ? extendToMergedAreas(selection) : selection;
}
TQRect Selection::extendToMergedAreas(TQRect area) const
{
if (!d->view->activeSheet())
return area;
area = area.normalize(); // TODO Stefan: avoid this
const Cell *cell = d->view->activeSheet()->cellAt(area.left(), area.top());
if( Region::Range(area).isColumn() || Region::Range(area).isRow() )
{
return area;
}
else if ( !(cell->isObscured() && cell->isPartOfMerged()) &&
(cell->mergedXCells() + 1) >= area.width() &&
(cell->mergedYCells() + 1) >= area.height())
{
/* if just a single cell is selected, we need to merge even when
the obscuring isn't forced. But only if this is the cell that
is doing the obscuring -- we still want to be able to click on a cell
that is being obscured.
*/
area.setWidth(cell->mergedXCells() + 1);
area.setHeight(cell->mergedYCells() + 1);
}
else
{
int top=area.top();
int left=area.left();
int bottom=area.bottom();
int right=area.right();
for ( int x = area.left(); x <= area.right(); x++ )
for ( int y = area.top(); y <= area.bottom(); y++ )
{
cell = d->view->activeSheet()->cellAt( x, y );
if( cell->doesMergeCells())
{
right=TQMAX(right,cell->mergedXCells()+x);
bottom=TQMAX(bottom,cell->mergedYCells()+y);
}
else if ( cell->isObscured() && cell->isPartOfMerged() )
{
cell = cell->obscuringCells().first();
left=TQMIN(left,cell->column());
top=TQMIN(top,cell->row());
bottom=TQMAX(bottom,cell->row() + cell->mergedYCells());
right=TQMAX(right,cell->column() + cell->mergedXCells());
}
}
area.setCoords(left,top,right,bottom);
}
return area;
}
Selection::Region::Point* Selection::createPoint(const TQPoint& point) const
{
return new Point(point);
}
Selection::Region::Point* Selection::createPoint(const TQString& string) const
{
return new Point(string);
}
Selection::Region::Point* Selection::createPoint(const Point& point) const
{
return new Point(point);
}
Selection::Region::Range* Selection::createRange(const TQRect& rect) const
{
return new Range(rect);
}
Selection::Region::Range* Selection::createRange(const TQString& string) const
{
return new Range(string);
}
Selection::Region::Range* Selection::createRange(const Range& range) const
{
return new Range(range);
}
/***************************************************************************
class Point
****************************************************************************/
Selection::Point::Point(const TQPoint& point)
: Region::Point(point),
m_color(TQt::black),
m_columnFixed(false),
m_rowFixed(false)
{
}
Selection::Point::Point(const TQString& string)
: Region::Point(string),
m_color(TQt::black),
m_columnFixed(false),
m_rowFixed(false)
{
if (!isValid())
{
return;
}
uint p = 0;
// Fixed?
if (string[p++] == '$')
{
m_columnFixed = true;
}
//search for the first character != text
int result = string.find( TQRegExp("[^A-Za-z]+"), p );
if (string[result] == '$')
{
m_rowFixed = true;
}
}
/***************************************************************************
class Range
****************************************************************************/
Selection::Range::Range(const TQRect& range)
: Region::Range(range),
m_color(TQt::black),
m_leftFixed(false),
m_rightFixed(false),
m_topFixed(false),
m_bottomFixed(false)
{
}
Selection::Range::Range(const TQString& string)
: Region::Range(string),
m_color(TQt::black),
m_leftFixed(false),
m_rightFixed(false),
m_topFixed(false),
m_bottomFixed(false)
{
if (!isValid())
{
return;
}
int delimiterPos = string.find(':');
if (delimiterPos == -1)
{
return;
}
Selection::Point ul(string.left(delimiterPos));
Selection::Point lr(string.mid(delimiterPos + 1));
if (!ul.isValid() || !lr.isValid())
{
return;
}
m_leftFixed = ul.columnFixed();
m_rightFixed = lr.columnFixed();
m_topFixed = ul.rowFixed();
m_bottomFixed = lr.rowFixed();
}
} // namespace KSpread
#include "selection.moc"