603 lines
14 KiB
C++
603 lines
14 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();
|
||
|
}
|
||
|
}
|