548 lines
15 KiB
C++
548 lines
15 KiB
C++
|
|
|
|
#include "tgrid.h"
|
|
#include "tw/colors.h"
|
|
#include "tw/event.h"
|
|
|
|
using namespace TwConsts;
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
class TGridColumn::Imp {
|
|
public:
|
|
vector<TGridCell> m_cells;
|
|
string m_name;
|
|
TGridColumn::Alignment m_alignment;
|
|
|
|
Imp(const string &name, Alignment alignment)
|
|
: m_name(name), m_alignment(alignment) {}
|
|
|
|
~Imp() {}
|
|
|
|
Imp &operator=(const Imp &src) {
|
|
m_cells = src.m_cells;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
// not implemented
|
|
Imp(const Imp &);
|
|
};
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TGridColumn::TGridColumn(const string &name, Alignment alignment)
|
|
: m_imp(new Imp(name, alignment)) {}
|
|
|
|
TGridColumn::~TGridColumn() { delete m_imp; }
|
|
|
|
TGridColumn *TGridColumn::createEmpty() { return new TGridColumn(); }
|
|
|
|
int TGridColumn::getRowCount() const { return m_imp->m_cells.size(); }
|
|
|
|
const TGridCell &TGridColumn::getCell(int row) const {
|
|
assert(row >= 0 && row < (int)m_imp->m_cells.size());
|
|
return m_imp->m_cells[row];
|
|
}
|
|
|
|
void TGridColumn::setCell(int row, const TGridCell &cell) {
|
|
assert(m_imp);
|
|
assert(row >= 0);
|
|
|
|
// checkColumn();
|
|
|
|
int firstRow = 0;
|
|
if (m_imp->m_cells.empty()) // se la colonna e' vuota
|
|
{
|
|
// if(!cell.isEmpty())
|
|
{
|
|
m_imp->m_cells.push_back(cell);
|
|
firstRow = row;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int oldCellCount = m_imp->m_cells.size();
|
|
assert(oldCellCount > 0);
|
|
int lastRow = firstRow + oldCellCount - 1;
|
|
|
|
if (row < firstRow) // prima
|
|
{
|
|
// if(cell.isEmpty()) return; //non faccio nulla
|
|
int delta = firstRow - row;
|
|
assert(delta > 0);
|
|
m_imp->m_cells.insert(m_imp->m_cells.begin(), delta - 1,
|
|
TGridCell()); // celle vuote
|
|
m_imp->m_cells.insert(m_imp->m_cells.begin(),
|
|
cell); // devo settare la prima comp. del vettore
|
|
firstRow = row; // row 'e la nuova firstrow
|
|
// updateIcon();
|
|
// checkColumn();
|
|
return;
|
|
} else if (row > lastRow) // dopo
|
|
{
|
|
// if(cell.isEmpty()) return; //non faccio nulla
|
|
int count = row - lastRow - 1;
|
|
// se necessario, inserisco celle vuote
|
|
for (int i = 0; i < count; ++i) m_imp->m_cells.push_back(TGridCell());
|
|
m_imp->m_cells.push_back(cell);
|
|
// checkColumn();
|
|
return;
|
|
}
|
|
//"[r0,r1]"
|
|
int index = row - firstRow;
|
|
assert(0 <= index && index < (int)m_imp->m_cells.size());
|
|
m_imp->m_cells[index] = cell;
|
|
// if(index == 0) updateIcon();
|
|
|
|
/*
|
|
if(cell.isEmpty())
|
|
{
|
|
if(row==lastRow)
|
|
{
|
|
// verifico la presenza di celle bianche alla fine
|
|
while(!m_imp->m_cells.empty() && m_imp->m_cells.back().isEmpty())
|
|
m_imp->m_cells.pop_back();
|
|
}
|
|
else
|
|
if(row==firstRow)
|
|
{
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while(!m_imp->m_cells.empty() && m_imp->m_cells.front().isEmpty())
|
|
{
|
|
m_imp->m_cells.erase(m_imp->m_cells.begin());
|
|
firstRow++;
|
|
}
|
|
}
|
|
|
|
if(m_imp->m_cells.empty())
|
|
firstRow = 0;
|
|
}
|
|
checkColumn();
|
|
*/
|
|
}
|
|
|
|
void TGridColumn::getCells(int row, int rowCount, TGridCell cells[]);
|
|
void TGridColumn::setCells(int row, int rowCount, const TGridCell cells[]);
|
|
|
|
void TGridColumn::insertEmptyCells(int row, int rowCount) {
|
|
assert(m_imp);
|
|
if (m_imp->m_cells.empty())
|
|
return; // se la colonna e' vuota non devo inserire celle
|
|
|
|
int firstRow = 0;
|
|
if (row >= firstRow + (int)m_imp->m_cells.size())
|
|
return; // dopo:non inserisco nulla
|
|
if (row <= firstRow) // prima
|
|
{
|
|
firstRow += rowCount;
|
|
} else // in mezzo
|
|
{
|
|
int delta = row - firstRow;
|
|
std::vector<TGridCell>::iterator it = m_imp->m_cells.begin();
|
|
std::advance(it, delta);
|
|
m_imp->m_cells.insert(it, rowCount, TGridCell());
|
|
}
|
|
}
|
|
|
|
void TGridColumn::removeCells(int row, int rowCount) {
|
|
if (rowCount <= 0) return;
|
|
if (m_imp->m_cells.empty()) return; // se la colonna e' vuota
|
|
assert(m_imp);
|
|
|
|
int firstRow = 0; // m_imp->m_first;
|
|
int cellCount = m_imp->m_cells.size();
|
|
|
|
if (row >= firstRow + cellCount) return; // sono "sotto" l'ultima cella
|
|
if (row < firstRow) {
|
|
if (row + rowCount <= firstRow) //"sono sopra la prima cella"
|
|
{ // aggiorno solo m_first
|
|
firstRow -= rowCount;
|
|
return;
|
|
}
|
|
rowCount += row - firstRow; // rowCount = row+rowCount-firstRow;
|
|
firstRow = row;
|
|
}
|
|
|
|
assert(row >= firstRow);
|
|
// le celle sotto firstRow+cellCount sono gia' vuote
|
|
if (rowCount > firstRow + cellCount - row)
|
|
rowCount = firstRow + cellCount - row;
|
|
if (rowCount <= 0) return;
|
|
|
|
if (row == firstRow) {
|
|
// cancello all'inizio
|
|
assert(rowCount <= cellCount);
|
|
std::vector<TGridCell>::iterator it = m_imp->m_cells.begin();
|
|
std::vector<TGridCell>::iterator it2 = m_imp->m_cells.begin();
|
|
std::advance(it2, rowCount);
|
|
// m_imp->m_cells.erase(&m_imp->m_cells[0],&m_imp->m_cells[rowCount]);
|
|
m_imp->m_cells.erase(it, it2);
|
|
// verifico la presenza di celle bianche all'inizio
|
|
while (!m_imp->m_cells.empty() /*&& m_imp->m_cells.front().isEmpty()*/) {
|
|
m_imp->m_cells.erase(m_imp->m_cells.begin());
|
|
firstRow++;
|
|
}
|
|
} else {
|
|
// cancello dopo l'inizio
|
|
int d = row - firstRow;
|
|
std::vector<TGridCell>::iterator it = m_imp->m_cells.begin();
|
|
std::vector<TGridCell>::iterator it2 = m_imp->m_cells.begin();
|
|
std::advance(it, d);
|
|
std::advance(it2, d + rowCount);
|
|
// m_imp->m_cells.erase(&m_imp->m_cells[d],&m_imp->m_cells[d+rowCount]);
|
|
m_imp->m_cells.erase(it, it2);
|
|
if (row + rowCount == firstRow + cellCount) {
|
|
// verifico la presenza di celle bianche alla fine
|
|
while (!m_imp->m_cells.empty() /*&& m_imp->m_cells.back().isEmpty()*/) {
|
|
m_imp->m_cells.pop_back();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_imp->m_cells.empty()) {
|
|
firstRow = 0;
|
|
}
|
|
// updateIcon();
|
|
}
|
|
|
|
void TGridColumn::clearCells(int row, int rowCount) {}
|
|
|
|
string TGridColumn::getName() const { return m_imp->m_name; }
|
|
|
|
TGridColumn::Alignment TGridColumn::getAlignment() const {
|
|
return m_imp->m_alignment;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
//-------------------------------------------------------------------
|
|
//-------------------------------------------------------------------
|
|
//-------------------------------------------------------------------
|
|
|
|
class TGrid::Data {
|
|
public:
|
|
Data(TWidget *w)
|
|
: m_w(w)
|
|
, m_selAction(0)
|
|
, m_dblClickAction(0)
|
|
, m_scrollbar(new TScrollbar(w))
|
|
, m_yoffset(0) {}
|
|
|
|
~Data() {
|
|
if (m_selAction) delete m_selAction;
|
|
|
|
if (m_dblClickAction) delete m_dblClickAction;
|
|
}
|
|
|
|
int posToRow(const TPoint &p);
|
|
|
|
void updateScrollBarStatus() {
|
|
if (!m_scrollbar) return;
|
|
int ly = m_w->getLy();
|
|
|
|
assert(m_columnSet.getColumnCount() > 0);
|
|
TGridColumnP col = m_columnSet.getColumn(0);
|
|
|
|
if ((col->getRowCount() * m_rowHeight) > ly)
|
|
m_scrollbar->show(); // m_scrollbar->setValue(m_yoffset,0, yrange-ly,
|
|
// ly);
|
|
else
|
|
m_scrollbar->hide(); // m_scrollbar->setValue(0,0, 0, 0);
|
|
m_scrollbar->invalidate();
|
|
}
|
|
|
|
TWidget *m_w;
|
|
|
|
TColumnSetT<TGridColumn> m_columnSet;
|
|
|
|
vector<int> m_selectedRows;
|
|
|
|
TGenericGridAction *m_selAction;
|
|
TGenericGridAction *m_dblClickAction;
|
|
TScrollbar *m_scrollbar;
|
|
int m_yoffset;
|
|
|
|
bool m_colSeparatorDragged;
|
|
int m_prevColSeparatorX;
|
|
int m_colSeparatorX;
|
|
int m_colIndex;
|
|
|
|
static int m_rowHeight;
|
|
};
|
|
|
|
int TGrid::Data::m_rowHeight = 20;
|
|
|
|
int TGrid::Data::posToRow(const TPoint &p) {
|
|
int y = m_w->getSize().ly - p.y + m_yoffset;
|
|
int item = y / m_rowHeight;
|
|
return item;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
//-------------------------------------------------------------------
|
|
|
|
TGrid::TGrid(TWidget *parent, string name) : TWidget(parent, name), m_data(0) {
|
|
m_data = new Data(this);
|
|
m_data->m_scrollbar->setAction(
|
|
new TScrollbarAction<TGrid>(this, &TGrid::scrollTo));
|
|
|
|
// setBackgroundColor(White);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TGrid::~TGrid() { delete m_data; }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::addColumn(const string &name, int width,
|
|
TGridColumn::Alignment align) {
|
|
TGridColumnP column = new TGridColumn(name, align);
|
|
column->setWidth(width);
|
|
m_data->m_columnSet.insertColumn(m_data->m_columnSet.getColumnCount(),
|
|
column);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::addRow() {
|
|
int colCount = m_data->m_columnSet.getColumnCount();
|
|
for (int i = 0; i < colCount; ++i) {
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(i);
|
|
col->setCell(col->getRowCount(), "");
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::removeRow(int row) {
|
|
int colCount = m_data->m_columnSet.getColumnCount();
|
|
for (int i = 0; i < colCount; ++i) {
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(i);
|
|
col->removeCells(row);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int TGrid::getColIndex(const string &colName) {
|
|
int colCount = m_data->m_columnSet.getColumnCount();
|
|
for (int i = 0; i < colCount; ++i) {
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(i);
|
|
if (colName == col->getName()) return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::setCell(int row, int col, const string &text) {
|
|
assert(row >= 0 && col >= 0);
|
|
TGridColumnP column = m_data->m_columnSet.touchColumn(col);
|
|
column->setCell(row, TGridCell(text));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int TGrid::getColCount() const { return m_data->m_columnSet.getColumnCount(); }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int TGrid::getRowCount() const {
|
|
assert(m_data->m_columnSet.getColumnCount() > 0);
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(0);
|
|
return col->getRowCount();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int TGrid::getSelectedRowCount() const { return m_data->m_selectedRows.size(); }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int TGrid::getSelectedRowIndex(int i) const {
|
|
assert(i >= 0 && i < (int)m_data->m_selectedRows.size());
|
|
return m_data->m_selectedRows[i];
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::select(int row, bool on) {
|
|
assert(row >= 0 && row < (int)getRowCount());
|
|
std::vector<int>::iterator it = std::find(m_data->m_selectedRows.begin(),
|
|
m_data->m_selectedRows.end(), row);
|
|
if (on) {
|
|
if (it == m_data->m_selectedRows.end())
|
|
m_data->m_selectedRows.push_back(row);
|
|
} else {
|
|
if (it != m_data->m_selectedRows.end()) m_data->m_selectedRows.erase(it);
|
|
}
|
|
if (m_data->m_selAction) m_data->m_selAction->sendCommand(row);
|
|
|
|
invalidate();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::unselectAll() {
|
|
m_data->m_selectedRows.clear();
|
|
invalidate();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
bool TGrid::isSelected(int row) const {
|
|
std::vector<int>::iterator it = std::find(m_data->m_selectedRows.begin(),
|
|
m_data->m_selectedRows.end(), row);
|
|
|
|
return it != m_data->m_selectedRows.end();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::scrollTo(int y) {
|
|
if (m_data->m_yoffset == y) return;
|
|
m_data->m_yoffset = y;
|
|
invalidate();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
void TGrid::draw() {
|
|
TDimension size = getSize();
|
|
|
|
// TRect gridHeaderPlacement(TPoint(0,size.ly-1), TDimension(size.lx-1,
|
|
// -m_data->m_rowHeight));
|
|
|
|
TRect gridHeaderPlacement(0, size.ly - 1 - m_data->m_rowHeight, size.lx - 1,
|
|
size.ly - 1);
|
|
|
|
setColor(Gray180 /*White*/);
|
|
fillRect(gridHeaderPlacement);
|
|
|
|
int gridHeaderY0 = gridHeaderPlacement.getP00().y;
|
|
|
|
for (int i = 0; i < m_data->m_columnSet.getColumnCount(); ++i) {
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(i);
|
|
int x0, x1;
|
|
col->getCoords(x0, x1);
|
|
|
|
// draw column header
|
|
setColor(Black);
|
|
drawText(
|
|
TRect(x0, gridHeaderY0, x1, gridHeaderY0 + m_data->m_rowHeight - 1),
|
|
col->getName());
|
|
|
|
int rowY = gridHeaderY0; // - m_data->m_rowHeight;
|
|
|
|
int y = size.ly - 1 - m_data->m_rowHeight;
|
|
for (int j = m_data->m_yoffset / m_data->m_rowHeight;
|
|
j < col->getRowCount() && y; ++j, y -= m_data->m_rowHeight) {
|
|
drawHLine(TPoint(0, rowY), size.lx);
|
|
|
|
TRect cellRect(x0, rowY - m_data->m_rowHeight - 1, x1, rowY);
|
|
|
|
if (isSelected(j)) {
|
|
setColor(Blue, 1);
|
|
fillRect(cellRect);
|
|
}
|
|
|
|
setColor(Black);
|
|
|
|
TWidget::Alignment align = TWidget::CENTER;
|
|
switch (col->getAlignment()) {
|
|
case TGridColumn::CenterAlignment:
|
|
align = TWidget::CENTER;
|
|
break;
|
|
case TGridColumn::RightAlignment:
|
|
align = TWidget::END;
|
|
break;
|
|
|
|
case TGridColumn::LeftAlignment:
|
|
align = TWidget::BEGIN;
|
|
break;
|
|
}
|
|
|
|
drawText(cellRect, col->getCell(j).m_text, align);
|
|
|
|
rowY -= m_data->m_rowHeight;
|
|
}
|
|
|
|
setColor(Gray210);
|
|
drawVLine(TPoint(x0, 0), size.ly);
|
|
drawVLine(TPoint(x1, 0), size.ly);
|
|
}
|
|
|
|
if (m_data->m_colSeparatorDragged) {
|
|
drawVLine(TPoint(m_data->m_colSeparatorX, 0), size.ly);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::configureNotify(const TDimension &d) {
|
|
m_data->m_scrollbar->setGeometry(d.lx - 20, 1, d.lx - 2, d.ly - 2);
|
|
m_data->updateScrollBarStatus();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::leftButtonDown(const TMouseEvent &e) {
|
|
m_data->m_colSeparatorDragged = false;
|
|
int rowCount = getRowCount();
|
|
|
|
int i = m_data->posToRow(e.m_pos);
|
|
if (i == 0) {
|
|
// la riga 0 e' l'header della tabella
|
|
|
|
for (int j = 0; j < m_data->m_columnSet.getColumnCount(); ++j) {
|
|
TGridColumnP col = m_data->m_columnSet.getColumn(j);
|
|
int x0, x1;
|
|
col->getCoords(x0, x1);
|
|
if (x0 - 3 < e.m_pos.x && e.m_pos.x < x0 + 3) {
|
|
m_data->m_colSeparatorDragged = true;
|
|
m_data->m_colSeparatorX = x0;
|
|
m_data->m_prevColSeparatorX = x0;
|
|
m_data->m_colIndex = j;
|
|
}
|
|
}
|
|
} else {
|
|
i--;
|
|
if (i >= 0 && i < (int)rowCount) {
|
|
if (!e.isShiftPressed()) unselectAll();
|
|
select(i, !isSelected(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::leftButtonDrag(const TMouseEvent &e) {
|
|
if (m_data->m_colSeparatorDragged) {
|
|
m_data->m_colSeparatorX += (e.m_pos.x - m_data->m_prevColSeparatorX);
|
|
m_data->m_prevColSeparatorX = e.m_pos.x;
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void TGrid::leftButtonUp(const TMouseEvent &e) {
|
|
if (m_data->m_colSeparatorDragged) {
|
|
TGridColumnP col0 = m_data->m_columnSet.getColumn(m_data->m_colIndex - 1);
|
|
TGridColumnP col1 = m_data->m_columnSet.getColumn(m_data->m_colIndex);
|
|
|
|
int col0X0, col0X1;
|
|
col0->getCoords(col0X0, col0X1);
|
|
|
|
int newWidth = m_data->m_colSeparatorX - col0X0;
|
|
int totWidth = col0->getWidth() + col1->getWidth();
|
|
|
|
col0->setWidth(newWidth);
|
|
col1->setWidth(totWidth - newWidth);
|
|
|
|
m_data->m_colSeparatorDragged = false;
|
|
invalidate();
|
|
}
|
|
}
|