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.
1010 lines
25 KiB
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"
|