void MyTableWidget::setText(int row, int column, const QString & text ) {
#if BE_VERBOSE
qDebug("MyTableWidget::setText: %d, %d", row, column);
#endif
bool existed;
QTableWidgetItem * i = getItem(row, column, &existed);
i->setText(text);
if (!existed) setItem(row, column, i);
}
/** Retranslate header columns. */
void Playlist::retranslateUi()
{
for (int i=0; i < columnCount(); i++) {
QTableWidgetItem *headerItem = horizontalHeaderItem(i);
const QString text = tr(headerItem->data(Qt::UserRole+1).toString().toStdString().data());
headerItem->setText(text);
columns->actions().at(i)->setText(text);
}
}
SaveOnExitDialogWidget::SaveOnExitDialogWidget(MainWindow *mainWindow, QList<RideItem *>dirtyList) :
QDialog(mainWindow, Qt::Dialog), mainWindow(mainWindow), dirtyList(dirtyList)
{
setWindowTitle("Save Changes");
QVBoxLayout *mainLayout = new QVBoxLayout(this);
// Warning text
warnText = new QLabel(tr("WARNING\n\nYou have made changes to some rides which\nhave not been saved. They are listed below."));
mainLayout->addWidget(warnText);
// File List
dirtyFiles = new QTableWidget(dirtyList.count(), 0, this);
dirtyFiles->setColumnCount(2);
dirtyFiles->horizontalHeader()->hide();
dirtyFiles->verticalHeader()->hide();
// Populate with dirty List
for (int i=0; i<dirtyList.count(); i++) {
// checkbox
QCheckBox *c = new QCheckBox;
c->setCheckState(Qt::Checked);
dirtyFiles->setCellWidget(i,0,c);
// filename
QTableWidgetItem *t = new QTableWidgetItem;
t->setText(dirtyList.at(i)->fileName);
t->setFlags(t->flags() & (~Qt::ItemIsEditable));
dirtyFiles->setItem(i,1,t);
}
// prettify the list
dirtyFiles->setShowGrid(false);
dirtyFiles->resizeColumnToContents(0);
dirtyFiles->resizeColumnToContents(1);
mainLayout->addWidget(dirtyFiles);
// Buttons
QHBoxLayout *buttonLayout = new QHBoxLayout;
saveButton = new QPushButton(tr("&Save and Exit"), this);
buttonLayout->addWidget(saveButton);
abandonButton = new QPushButton(tr("&Discard and Exit"), this);
buttonLayout->addWidget(abandonButton);
cancelButton = new QPushButton(tr("&Cancel Exit"), this);
buttonLayout->addWidget(cancelButton);
mainLayout->addLayout(buttonLayout);
// Don't warn me!
exitWarnCheckBox = new QCheckBox(tr("Always check for unsaved changes on exit"), this);
exitWarnCheckBox->setChecked(true);
mainLayout->addWidget(exitWarnCheckBox);
// connect up slots
connect(saveButton, SIGNAL(clicked()), this, SLOT(saveClicked()));
connect(abandonButton, SIGNAL(clicked()), this, SLOT(abandonClicked()));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelClicked()));
connect(exitWarnCheckBox, SIGNAL(clicked()), this, SLOT(warnSettingClicked()));
}
void model_import_dlg::on_dist_changed(QString dist)
{
QTableWidgetItem * item = ui.tableLod->item(ui.tableLod->currentRow(), 2);
if (item)
item->setText(dist);
model_import_dlg::validate_lods();
}
/** should be called in constructor for basic setup of
* table cells.
*/
void RatingsTable::setupCells()
{
PlayerList players = _group->const_players();
int plCnt = players.count();
setRowCount( plCnt + 1 );
setColumnCount( plCnt + 1 + 1 ); // 1 column for total rating results
for ( int i = 0; i < rowCount(); i ++ ) {
for ( int j = 0; j < plCnt + 1; j ++ ) {
QTableWidgetItem *item = new QTableWidgetItem( );
QString text;
if ( i == j ) {
item->setBackground( palette().brush( QPalette::Disabled,
QPalette::Background ) );
if ( i == 0 ) {
text = _group->name();
}
item->setFlags( Qt::NoItemFlags );
} else if ( i == 0 ) { // 0th row
text = players.at( j - 1 ).name();
item->setFlags( Qt::NoItemFlags );
} else if ( j == 0 ) { // 0th column
Player p = players.at( i - 1 );
text = p.name();
text += " (" + QString::number( p.rating(), 'f', 1 ) + ")";
item->setFlags( Qt::NoItemFlags );
} else {
item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
}
item->setText( text );
setItem( i, j, item );
}
QTableWidgetItem *item = new QTableWidgetItem( );
if ( i == 0 ) {
item->setText( tr( "New rating" ) );
}
item->setFlags( Qt::NoItemFlags );
setItem( i, plCnt + 1, item );
}
}
void TargetList::updateTargetTable(LandmarkList inputTargetList, QList<LandmarkList> inputScanLocations){
qDebug()<<"updating Table";
targetList = inputTargetList;
scanLocations = inputScanLocations;
if (inputTargetList.isEmpty()){
qDebug()<<"no targets";
return;
}
targetTable->clearContents();
for (int i=0; i<inputTargetList.length(); i++){
targetTable->insertRow(i);
QTableWidgetItem *cell = targetTable->item(i,0);
if (!cell){
cell = new QTableWidgetItem;
targetTable->setItem(i,0,cell);
}
cell->setText(QString::number(i));
cell = targetTable->item(i,1);
if (!cell){
cell = new QTableWidgetItem;
targetTable->setItem(i,1,cell);
}
cell->setText(QString::number(inputTargetList.value(i).x));
cell = targetTable->item(i,2);
if (!cell){
cell = new QTableWidgetItem;
targetTable->setItem(i,2,cell);
}
cell->setText(QString::number(inputTargetList.value(i).y));
}
targetTable->setCurrentCell(0,0);
targetTable->adjustSize();
}
void ZappyUI::pin(const std::string &args)
{
QString data;
data = args.c_str();
QStringList list = data.split(' ');
if (list.length() < 10)
return;
QString playerId = list.at(0);
QString strX = list.at(1);
QString strY = list.at(2);
QString strFeed = list.at(3);
QString strLinemate = list.at(4);
QString strDeraumere = list.at(5);
QString strSibur = list.at(6);
QString strMendiane = list.at(7);
QString strPhiras = list.at(8);
QString strThystame = list.at(9);
Player *zappie;
try
{
zappie = zappies.at(playerId.toStdString());
}
catch (std::out_of_range)
{
return;
}
if (zappie == nullptr)
return;
zappie->x = strX.toInt();
zappie->y = strY.toInt();
zappie->feed = strFeed.toInt();
zappie->linemate = strLinemate.toInt();
zappie->deraumere = strDeraumere.toInt();
zappie->sibur = strSibur.toInt();
zappie->mendiane = strMendiane.toInt();
zappie->phiras = strPhiras.toInt();
zappie->thystame = strThystame.toInt();
QTableWidgetItem *feed = new QTableWidgetItem();
QTableWidgetItem *linemate = new QTableWidgetItem();
QTableWidgetItem *deraumere = new QTableWidgetItem();
QTableWidgetItem *sibur = new QTableWidgetItem();
QTableWidgetItem *mendiane = new QTableWidgetItem();
QTableWidgetItem *phiras = new QTableWidgetItem();
QTableWidgetItem *thystame = new QTableWidgetItem();
feed->setText(strFeed);
linemate->setText(strLinemate);
deraumere->setText(strDeraumere);
sibur->setText(strSibur);
mendiane->setText(strMendiane);
phiras->setText(strPhiras);
thystame->setText(strThystame);
ui->tableau->setItem(zappie->rowIdx, 5, feed);
ui->tableau->setItem(zappie->rowIdx, 6, linemate);
ui->tableau->setItem(zappie->rowIdx, 7, deraumere);
ui->tableau->setItem(zappie->rowIdx, 8, sibur);
ui->tableau->setItem(zappie->rowIdx, 9, mendiane);
ui->tableau->setItem(zappie->rowIdx, 10, phiras);
ui->tableau->setItem(zappie->rowIdx, 11, thystame);
}
void ClientMain::UpdateStatsView()
{
ui.lblGameCyclesData->setText(tr("%1").arg(m_pIStrategizer->GameModel()->Clock().ElapsedGameCycles()));
map<ObjectStateType, set<TID>> workersState;
auto workerType = m_pIStrategizer->GameModel()->Self()->Race()->GetWorkerType();
int workerCount = 0;
for (auto& entityR : m_pIStrategizer->GameModel()->Self()->Entities())
{
if (entityR.second->TypeId() == workerType)
{
workersState[(ObjectStateType)entityR.second->P(OP_State)].insert(entityR.first);
++workerCount;
}
}
ui.lblWorkersCountData->setText(QString("%1").arg(workerCount));
QTableWidgetItem* cell = NULL;
for(int row = 0; row < ui.tblWorkerState->rowCount(); ++row)
{
cell = ui.tblWorkerState->item(row, 1);
ObjectStateType state = (ObjectStateType)cell->data(Qt::UserRole).toInt();
QString txt =QString("[%1]{").arg(workersState[state].size());
for (auto workerId : workersState[state])
{
auto pEntity = m_pIStrategizer->GameModel()->Self()->GetEntity(workerId);
if (pEntity != nullptr)
{
bool isLocked = pEntity->IsLocked();
txt += QString("%1").arg(workerId);
txt += QString("[%2],").arg(isLocked ? "L" : "F");
}
}
txt += "}";
cell->setText(txt);
}
ui.tblWorkerState->resizeColumnsToContents();
ui.lblFPSData->setText(tr("%1").arg("-"));
int currMemoryUsage = (int)GetProcessUsedMemoryKB();
ui.lblCurrUsedMemoryData->setText(QString("%1").arg(currMemoryUsage));
int deltaMemoryUsage = abs((int)currMemoryUsage - (int)m_startMemoryUsage);
ui.lblDeltaMemoryData->setText(QString("%1").arg(deltaMemoryUsage));
ui.lblObjectsMemoryData->setText(QString("%1").arg(EngineObject::AliveObjectsMemoryUsage() / 1024));
ui.lblObjectsCountData->setText(QString("%1").arg(EngineObject::AliveObjectsCount()));
}
void SpreadSheet::formulaEdited()
{
QTableWidgetItem *item = sheet1->item(sheet1->currentRow(),
sheet1->currentColumn());
if (item != 0)
item->setText(formulaEdit->text());
evaluate();
sheet1->setFocus();
}
void GeomServerUI::updateListGUI() {
objectTable->setColumnCount(2);
objectTable->setRowCount(m_numPlanes+m_numCath);
for (int ix1=0; ix1<m_numPlanes; ix1++) {
QString text;
text = QString("Plane ")+QString::number(ix1);
QTableWidgetItem *temp = new QTableWidgetItem();
temp->setText(text);
temp->setFlags(Qt::NoItemFlags);
objectTable->setItem(ix1, 0, temp);
QComboBox *tempCombo = new QComboBox();
objectTable->setCellWidget(ix1, 1, tempCombo);
tempCombo->addItem(QString("Ignore"));
tempCombo->addItem(QString("Read"));
tempCombo->addItem(QString("Write"));
tempCombo->addItem(QString("Error"));
tempCombo->setCurrentIndex(m_planeList.at(ix1).act);
connect(tempCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(itemStateChanged(int)));
}
for (int ix1=0; ix1<m_numCath; ix1++) {
QString text;
text += QString("Catheter ");
text += QString::number(ix1);
QTableWidgetItem *temp = new QTableWidgetItem();
temp->setText(text);
temp->setFlags(Qt::NoItemFlags);
objectTable->setItem(ix1+m_numPlanes, 0, temp);
QComboBox *tempCombo = new QComboBox();
objectTable->setCellWidget(ix1+m_numPlanes, 1, tempCombo);
tempCombo->addItem(QString("Ignore"));
tempCombo->addItem(QString("Read"));
tempCombo->addItem(QString("Write"));
tempCombo->addItem(QString("Error"));
tempCombo->setCurrentIndex(m_cathList.at(ix1).act);
connect(tempCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(itemStateChanged(int)));
}
}
void tablewidget::setText( QTableWidget * table,int row,int col,const QString& text )
{
QFont f = table->item( row,col )->font() ;
QTableWidgetItem * item = new QTableWidgetItem() ;
item->setText( text ) ;
item->setTextAlignment( Qt::AlignCenter ) ;
item->setFont( f ) ;
table->setItem( row,col,item ) ;
}
void Table::setItem(int row, int column, std::string text, bool suppressSignals)
{
QTableWidget *tablewidget = static_cast<QTableWidget*>(getQWidget());
bool oldSignalsState = tablewidget->blockSignals(suppressSignals);
QTableWidgetItem *item = tablewidget->item(row, column);
if(!item) item = new QTableWidgetItem;
item->setText(QString::fromStdString(text));
tablewidget->setItem(row, column, item);
tablewidget->blockSignals(oldSignalsState);
}
/****************************************************************************
**
** Copyright (C) 2016 - 2017
**
** This file is generated by the Magus toolkit
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
****************************************************************************/
// Include
#include <QApplication>
#include <QDesktopWidget>
#include <QRect>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QMessageBox>
#include <QHeaderView>
#include <QEvent>
#include <QPixmap>
#include <QImage>
#include <QMimeData>
#include <QTableWidgetItem>
#include <QTreeWidgetItem>
#include <QVector2D>
#include "constants.h"
#include "paintlayer_widget.h"
#include "paintlayer_dockwidget.h"
#include "paintlayer_dialog.h"
//****************************************************************************/
PaintLayerWidget::PaintLayerWidget(const QString& iconDir, PaintLayerDockWidget* paintLayerDockWidget, QWidget* parent) :
QWidget(parent),
mPaintLayerDockWidget(paintLayerDockWidget)
{
setWindowTitle(QString("Layers"));
QHBoxLayout* mainLayout = new QHBoxLayout;
QVBoxLayout* tableLayout = new QVBoxLayout;
mIconDir = iconDir;
mLayerIdCounter = 1;
mListenToSceneId = 0;
mListenToDeleteEvents = true;
helperIntVector.clear();
// Create table
mTable = new QTableWidget(0, 4, this);
mTable->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
mTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
mTable->setAcceptDrops(false);
mTable->setShowGrid(false);
mTable->viewport()->installEventFilter(this);
QRect rect = QApplication::desktop()->screenGeometry();
mTable->setColumnWidth(TOOL_LAYER_COLUMN_ICON, 2 * TOOL_LAYER_ICON_WIDTH);
mTable->setColumnWidth(TOOL_LAYER_COLUMN_NAME, TOOL_LAYER_NAME_WIDTH);
mTable->setColumnWidth(TOOL_LAYER_COLUMN_VISIBILITY, 2 * TOOL_LAYER_ICON_WIDTH);
mTable->setColumnWidth(TOOL_LAYER_COLUMN_FILLER, rect.width());
mTable->setSelectionBehavior(QAbstractItemView::SelectRows);
setStyleSheet("QLineEdit{padding: 0 0px; margin-left: 0px; margin-right: 0px; max-height: 28px; height: 28px;}");
connect(mTable, SIGNAL(clicked(QModelIndex)), this, SLOT(tableClicked(QModelIndex)));
connect(mTable, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(handleTableDoubleClicked(QModelIndex)));
// Set headers
QStringList headers;
headers << tr("Edit") << tr("Layer name") << tr("Visibility") << tr("");
mTable->setHorizontalHeaderLabels(headers);
QFont font;
font.setBold(true);
mTable->horizontalHeader()->setFont(font);
mTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
// Contextmenu
setContextMenuPolicy(Qt::CustomContextMenu);
mContextMenu = new QMenu(mTable);
mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_CREATE_LAYER, mTable));
mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_EDIT_LAYER, mTable));
mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_DELETE_LAYER, mTable));
mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_RENAME_LAYER, mTable));
mContextMenu->addAction(new QAction(TOOL_LAYER_ACTION_ALL_VISIBLE, mTable));
//mContextMenu->addAction(new QAction(QString("TEST"), mTable));
connect(mContextMenu, SIGNAL(triggered(QAction*)), this, SLOT(contextMenuItemSelected(QAction*)));
// Layout
tableLayout->addWidget(mTable);
mainLayout->addLayout(tableLayout);
setLayout(mainLayout);
}
//****************************************************************************/
PaintLayerWidget::~PaintLayerWidget(void)
{
QVector<QtLayer*>::iterator it;
for (it = mLayerVec.begin(); it != mLayerVec.end(); ++it)
delete *it;
mLayerVec.clear(); // The table is automatically deleted when this widget is deleted
}
//****************************************************************************/
bool PaintLayerWidget::eventFilter(QObject* object, QEvent* event)
{
QMouseEvent* mouseEvent = (QMouseEvent*) event;
switch ((int) event->type())
{
case QEvent::MouseButtonPress:
mouseClickHandler(mouseEvent);
break;
case QEvent::MouseButtonDblClick:
mouseDblClickHandler(mouseEvent);
break;
break;
}
return QObject::eventFilter(object, event);
}
//****************************************************************************/
void PaintLayerWidget::tableClicked(QModelIndex index)
{
// Toggle visibility
int row = index.row();
int col = index.column();
QtLayer* layer = mLayerVec.at(row);
if (col == TOOL_LAYER_COLUMN_VISIBILITY)
{
if (layer->visible)
updateVisibilityIcon(row, false);
else
updateVisibilityIcon(row, true);
}
// Signal that layer is selected
emit layerSelected(layer->layerId, layer->name);
}
//****************************************************************************/
QVector<int> PaintLayerWidget::getSelectedLayerIds(void)
{
helperIntVector.clear();
QList<QTableWidgetItem*> itemList = mTable->selectedItems();
foreach(QTableWidgetItem* item, itemList)
{
// Do not append all items, but only the rows; so only mark in case of a distinct column
if (item->column() == TOOL_LAYER_COLUMN_ICON)
helperIntVector.append(item->data(Qt::UserRole).toInt());
}
return helperIntVector;
}
//****************************************************************************/
void PaintLayerWidget::mouseClickHandler(QMouseEvent* event)
{
switch ((int) event->button())
{
case Qt::LeftButton:
{
// TODO
}
break;
case Qt::RightButton:
{
QPoint pos;
pos.setX(event->screenPos().x());
pos.setY(event->screenPos().y());
mContextMenu->popup(pos);
}
break;
}
}
//****************************************************************************/
void PaintLayerWidget::mouseDblClickHandler(QMouseEvent* event)
{
switch ((int) event->button())
{
case Qt::LeftButton:
{
if (mTable->currentColumn() == TOOL_LAYER_COLUMN_NAME)
{
QTableWidgetItem* item = mTable->currentItem();
if (item->column() == TOOL_LAYER_COLUMN_NAME)
{
// Its the name; edit it
mTable->editItem(item);
}
}
}
break;
}
}
//****************************************************************************/
void PaintLayerWidget::contextMenuItemSelected(QAction* action)
{
// ---------------- Create layer action ----------------
if (action->text() == TOOL_LAYER_ACTION_CREATE_LAYER)
{
createDefaultPaintLayer();
return;
}
else if (action->text() == TOOL_LAYER_ACTION_EDIT_LAYER)
{
editSelectedPaintLayer();
return;
}
else if (action->text() == TOOL_LAYER_ACTION_DELETE_LAYER)
{
deleteSelectedPaintLayer();
}
else if (action->text() == TOOL_LAYER_ACTION_RENAME_LAYER)
{
QTableWidgetItem* item = mTable->currentItem();
if (item && item->column() == TOOL_LAYER_COLUMN_NAME)
{
// Its the name; edit it
mTable->editItem(item);
}
}
else if (action->text() == TOOL_LAYER_ACTION_ALL_VISIBLE)
{
int rows = mTable->rowCount();
for(int row = 0; row < rows; ++row)
if (mLayerVec.at(row)->visible == false)
updateVisibilityIcon(row, true);
}
else if (action->text() == QString ("TEST"))
{
//setLayerName(3, QString("Test"));
//deleteLayer(QString("New layer 4"));
}
}
//****************************************************************************/
void PaintLayerWidget::updateVisibilityIcon(int row, bool visible, bool doEmit)
{
QTableWidgetItem* item = mTable->item(row, TOOL_LAYER_COLUMN_VISIBILITY);
if (!item)
return;
QtLayer* layer = mLayerVec.at(row);
updateVisibilityIconForLayerId(layer->layerId, visible, doEmit);
}
//****************************************************************************/
void PaintLayerWidget::updateVisibilityIconForLayerId(int layerId, bool visible, bool doEmit)
{
QtLayer* layer = getLayer(layerId);
if (!layer)
return;
QTableWidgetItem* item = getItem(layerId, TOOL_LAYER_COLUMN_VISIBILITY);
if (!item)
return;
QPixmap pixMap;
layer->visible = visible;
if (visible)
{
QImage image(mIconDir + TOOL_ICON_VIEW_VISIBLE);
pixMap = QPixmap::fromImage(image).scaled(TOOL_LAYER_ICON_WIDTH, TOOL_LAYER_ICON_WIDTH);
item->setData(Qt::DecorationRole, QVariant(pixMap));
}
else
{
QImage image(mIconDir + TOOL_ICON_VIEW_INVISIBLE);
pixMap = QPixmap::fromImage(image).scaled(TOOL_LAYER_ICON_WIDTH, TOOL_LAYER_ICON_WIDTH);
item->setData(Qt::DecorationRole, QVariant(pixMap));
}
if (doEmit)
emit layerVisibiltyChanged(layer->layerId, item->text(), layer->visible);
}
//****************************************************************************/
int PaintLayerWidget::newLayerId(void)
{
int maxId = 0;
QtLayer* layer;
QVector<QtLayer*>::iterator it;
for (it = mLayerVec.begin(); it != mLayerVec.end(); ++it)
{
layer = *it;
if (layer->layerId > maxId)
maxId = layer->layerId;
}
++maxId;
return maxId;
}
//****************************************************************************/
void PaintLayerWidget::addLayer(QtLayer* layer)
{
// Add the layer to the vector create a new row in the table
int row = mTable->rowCount();
mLayerVec.append(layer);
mTable->insertRow(row);
// Set the default brush icon
QTableWidgetItem* item = new QTableWidgetItem();
QImage image(DEFAULT_BRUSH_AND_PATH_QSTRING);
QPixmap pixMapLayer = QPixmap::fromImage(image).scaled(TOOL_LAYER_ICON_WIDTH, TOOL_LAYER_ICON_WIDTH);
item->setData(Qt::DecorationRole, QVariant(pixMapLayer));
item->setData(Qt::UserRole, QVariant(layer->layerId));
mTable->setItem(row, TOOL_LAYER_COLUMN_ICON, item);
// Set the name
item = new QTableWidgetItem();
QString newName = layer->name;
if (newName.size() == 0)
newName = QString("Paint layer ") + QVariant(layer->layerId).toString();
layer->name = newName;
item->setText(newName);
item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
item->setData(Qt::UserRole, QVariant(layer->layerId));
mTable->setItem(row, TOOL_LAYER_COLUMN_NAME, item);
// Set the visibility icon
item = new QTableWidgetItem();
QImage imageVis(mIconDir + TOOL_ICON_VIEW_VISIBLE);
QPixmap pixMapVis = QPixmap::fromImage(imageVis).scaled(TOOL_LAYER_ICON_WIDTH, TOOL_LAYER_ICON_WIDTH);
item->setData(Qt::DecorationRole, QVariant(pixMapVis));
item->setData(Qt::UserRole, QVariant(layer->layerId));
mTable->setItem(row, TOOL_LAYER_COLUMN_VISIBILITY, item);
// Set the layerId in the visibility icon
//item->setData(Qt::UserRole, QVariant(layer->layerId));
//mTable->resizeColumnToContents(0);
// Set the item to selected
mTable->resizeRowsToContents();
mTable->selectRow(row);
// Emit signal
emit layerCreatedOrAdded(layer->layerId, layer->name);
}
//****************************************************************************/
void PaintLayerWidget::createDefaultPaintLayer (void)
{
if (mPaintLayerDockWidget->currentDatablockExists())
{
if (mPaintLayerDockWidget->currentDatablockIsPbs())
{
createLayer(QString(""));
}
else
{
QMessageBox::information(0, QString("Warning"), QString("Painting on HLMS Unlit materials is not supported"));
}
}
else
{
QMessageBox::information(0, QString("Warning"), QString("Create / load a hlms material before creating a paint layer.\n"
"Did you forget to generate (cog icon) or edit the hlms material?"));
}
}
//****************************************************************************/
const QtLayer* PaintLayerWidget::createLayer(const QString& name)
{
// Fill the layer object
QtLayer* layer = new QtLayer();
layer->layerId = newLayerId();
layer->name = name;
layer->visible = true;
// Add the layer to the layer vector and the table
addLayer(layer);
return layer;
}
//****************************************************************************/
const QtLayer* PaintLayerWidget::createLayer(int layerId, const QString& name)
{
// Fill the layer object
QtLayer* layer = new QtLayer();
layer->layerId = layerId;
layer->name = name;
layer->visible = true;
// Add the layer to the layer vector and the table
addLayer(layer);
return layer;
}
//****************************************************************************/
int PaintLayerWidget::getRow(const QString& name)
{
int rows = mTable->rowCount();
QTableWidgetItem* item;
for (int row = 0; row < rows; ++row)
{
item = mTable->item(row, TOOL_LAYER_COLUMN_NAME);
if (item->text() == name)
return row;
}
return -1; // Not found
}
//****************************************************************************/
int PaintLayerWidget::getRow(int layerId)
{
int row = 0;
QtLayer* layer;
QVector<QtLayer*>::iterator it;
for (it = mLayerVec.begin(); it != mLayerVec.end(); ++it)
{
layer = *it;
if (layer->layerId == layerId)
return row;
++row;
}
return -1; // Not found
}
//****************************************************************************/
void PaintLayerWidget::deleteLayer (const QString& name)
{
int row = getRow(name);
if (row != -1)
{
// Delete the layer from the table and the vector
QString name = getName(row);
mTable->removeRow(row);
int layerId = removeFromLayerVec(row);
emit layerDeleted(layerId, name);
}
}
//****************************************************************************/
void PaintLayerWidget::deleteLayer (const QtLayer* layer)
{
// Delete the layer
int row = 0;
QVector<QtLayer*>::iterator it;
int layerId;
QString name;
for (it = mLayerVec.begin(); it != mLayerVec.end(); ++it)
{
if (layer == *it)
{
// Delete the layer from the table and the vector
layerId = layer->layerId;
mLayerVec.erase(it);
name = getName(row);
mTable->removeRow(row);
delete layer;
emit layerDeleted(layerId, name);
}
++row;
}
}
//****************************************************************************/
void PaintLayerWidget::deleteLayer (int layerId)
{
int row = getRow(layerId);
if (row != -1)
{
// Delete the layer from the table and the vector
QString name = getName(row);
mTable->removeRow(row);
int layerId = removeFromLayerVec(row);
emit layerDeleted(layerId, name);
}
}
//****************************************************************************/
void PaintLayerWidget::deleteAllLayers (void)
{
mTable->clearContents();
mTable->setRowCount(0);
mLayerVec.clear();
}
//****************************************************************************/
void PaintLayerWidget::deleteSelectedPaintLayer(void)
{
int layerId = getCurrentLayerId();
if (layerId < 0)
{
QMessageBox::information(0, QString("Warning"), QString("There is no layer to delete"));
return;
}
deleteLayer(getCurrentLayerId());
}
//****************************************************************************/
void PaintLayerWidget::editSelectedPaintLayer(void)
{
// First check whether there is a paint layer
int layerId = getCurrentLayerId();
if (layerId < 0)
{
QMessageBox::information(0, QString("Warning"), QString("There is no layer to edit"));
return;
}
// First set the correct column to current
int currentRow = mTable->currentRow();
mTable->setCurrentCell(currentRow, TOOL_LAYER_COLUMN_ICON); // Do this to set the correct column
// Get the current index
QModelIndex index = mTable->currentIndex();
handleTableDoubleClicked(index);
}
//****************************************************************************/
int PaintLayerWidget::removeFromLayerVec(int row)
{
int layerId;
QtLayer* layer = mLayerVec.at(row);
layerId = layer->layerId;
mLayerVec.removeAt(row);
delete layer;
return layerId;
}
//****************************************************************************/
void PaintLayerWidget::setLayerName(int layerId, const QString& newName)
{
int row = getRow(layerId);
if (row != -1)
{
QTableWidgetItem* item;
item = mTable->item(row, TOOL_LAYER_COLUMN_NAME);
item->setText(newName);
}
}
//-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-+#+-
void ovQAuthorSearchDialog::slotTermTableWidgetCellClicked( int row, int column )
{
if( this->getColumnIndex( ovQAuthorSearchDialog::TermColumn ) == column ) return;
QTableWidgetItem *item = this->ui->termTableWidget->item( row, column );
if( this->useStemColumn && this->getColumnIndex( ovQAuthorSearchDialog::StemColumn ) == column )
{
item->setText( "YES" == item->text() ? "NO" : "YES" );
}
else if( this->getColumnIndex( ovQAuthorSearchDialog::AndColumn ) == column && 0 != row )
{
item->setText( "AND" == item->text() ? "OR" : "AND" );
}
else if( this->getColumnIndex( ovQAuthorSearchDialog::NotColumn ) == column )
{
item->setText( "NOT" == item->text() ? "" : "NOT" );
}
}
void TargetList::addNewRow(QString fileName, QString name, QString coordinates, QString description)
{
// Creates image preview item
QTableWidgetItem *image = new QTableWidgetItem();
QBrush brush;
QImage brushImage;
if (fileName == "")
brushImage.load(defaultImagePath);
else
brushImage.load(fileName);
// Resize image -> Make this dependent on row/col size
int width = 150;
int height = 100;
QImage scaledBrushImage = brushImage.scaled(width, height, Qt::KeepAspectRatio);
image->setData(Qt::DecorationRole, QPixmap(fileName).scaled(150, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation));
image->setTextAlignment(Qt::AlignHCenter);
// Apply resized image
brush.setTextureImage(scaledBrushImage);
//image->setImage(brush);
// Creates name item
QFont font("Segoe UI", 11, QFont::Bold);
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setText(name);
nameItem->setFont(font);
// Creates coordinate item
QTableWidgetItem *coordItem = new QTableWidgetItem();
coordItem->setText(coordinates);
// Creates description item
QTableWidgetItem *descItem = new QTableWidgetItem();
descItem->setText(description);
// Places item in a TargetListItem and adds it to the target list
TargetListItem *newItem = new TargetListItem(image, nameItem, coordItem, descItem);
newItem->imageFilePath = fileName;
rows->prepend(newItem);
refreshTable();
}
void RedefineDlg::slotNewActionSelected(const int& index)
{
m_newType = m_typesList[index];
if (m_okTypeList.contains(m_newType)) {
QTableWidgetItem *item = new QTableWidgetItem;// add new type to UI
item->setText(m_newType);
m_widget->tableWidget->setItem(1, m_typeColumn, item);
this->enableButtonOk(true);
}
}
void WorkflowView::showItem(const QList<QString> & items)
{
// Setting row count to zero destroys all rows
setRowCount(0);
for(int i = 0; i < items.count(); i+=2) {
int newRow = rowCount();
insertRow(newRow);
QTableWidgetItem *variable = new QTableWidgetItem;
QTableWidgetItem *value = new QTableWidgetItem;
variable->setText(items[i]);
value->setText(items[i+1]);
setItem(newRow, 0, variable);
setItem(newRow, 1, value);
}
// Insert the last empty row for custom info
insertRow(rowCount());
}
void SkatLiveGameRoundTable::addRound(Database::Round *round){
Q_ASSERT(round != 0);
Database::Skat::SkatRound* skatround = static_cast<Database::Skat::SkatRound*>(round);
Q_ASSERT(skatround != 0);
this->insertRow(this->rowCount());
for(int i = 0; i<playerlist.size();i++){
QTableWidgetItem* item = new QTableWidgetItem("");
if (skatround->solist()->id() == playerlist.at(i)->id()){
item->setText(QString::number(skatround->points(playerlist.at(i))) + " (S)");
}
else{
item->setText(QString::number(skatround->points(playerlist.at(i))) + " (C)");
}
if (skatround->points(playerlist.at(i)) == 0){
item->setBackgroundColor(QColor("lightGray"));
}
if (skatround->points(playerlist.at(i)) > 0){
item->setBackgroundColor(QColor(148,0,0));
}
if (skatround->points(playerlist.at(i)) > 24){
item->setBackgroundColor(QColor(188,0,0));
}
if (skatround->points(playerlist.at(i)) > 36){
item->setBackgroundColor(QColor(220,0,0));
}
if (skatround->points(playerlist.at(i)) > 48){
item->setBackgroundColor(QColor(255,0,0));
}
item->setTextAlignment(Qt::AlignCenter);
this->setItem(this->rowCount()-1,i,item);
}
QTableWidgetItem* item = new QTableWidgetItem(QString::number(skatround->roundPoints()));
item->setTextAlignment(Qt::AlignCenter);
this->setItem(this->rowCount()-1,playerlist.size(),item);
QTableWidgetItem* item1 = new QTableWidgetItem("");
item1->setSizeHint(QSize(0,0));
this->setVerticalHeaderItem(this->rowCount()-1,item1);
}
void SongEditorPanelTagWidget::createTheTagTableWidget()
{
Hydrogen* engine = Hydrogen::get_instance();
Timeline* pTimeline = engine->getTimeline();
int patterngroupvectorsize;
patterngroupvectorsize = engine->getSong()->get_pattern_group_vector()->size();
for( int i = 0; i < patterngroupvectorsize; i++ )
{
tagTableWidget->insertRow( i );
}
std::vector<Timeline::HTimelineTagVector> timelineTagVector = pTimeline->m_timelinetagvector;
//read the tag vector and fill all tags into items
if( timelineTagVector.size() > 0 ){
for ( unsigned int t = 0; t < timelineTagVector.size(); t++ ){
QTableWidgetItem *newTagItem = new QTableWidgetItem();
newTagItem->setText( QString( "%1" ).arg( timelineTagVector[t].m_htimelinetag ) );
tagTableWidget->setItem( timelineTagVector[t].m_htimelinetagbeat, 0, newTagItem );
tagTableWidget->setCurrentItem( newTagItem );
tagTableWidget->openPersistentEditor( newTagItem );
}
}
//activate the clicked item and
//if you click on an existing tag
//fill in the old contend
if( timelineTagVector.size() > 0 ){
int vpos = -1;
QTableWidgetItem *newTagItem2 = new QTableWidgetItem();
newTagItem2->setText( QString( "" ) );
for ( unsigned int t = 0; t < timelineTagVector.size(); t++ ){
if( timelineTagVector[t].m_htimelinetagbeat == m_stimelineposition){
vpos = t;
}
}
if( vpos >-1 ){
newTagItem2->setText( QString( "%1" ).arg( timelineTagVector[vpos].m_htimelinetag ) );
}
tagTableWidget->setItem( m_stimelineposition , 0, newTagItem2 );
tagTableWidget->setCurrentItem( newTagItem2 );
tagTableWidget->openPersistentEditor( newTagItem2 );
}
//add first tag
if( timelineTagVector.size() == 0 ){
QTableWidgetItem *newTagItem3 = new QTableWidgetItem();
tagTableWidget->setItem( m_stimelineposition , 0, newTagItem3 );
tagTableWidget->setCurrentItem( newTagItem3 );
tagTableWidget->openPersistentEditor( newTagItem3 );
}
}
/**
* Fills error table.
*/
void LearningWidget::fillTable(){
if(model->selectedNetworkName().isEmpty() || model->selectedDatasetName().isEmpty()){
ui->errorTable->clear();
return;
}
DatasetTestModel mdl;
mdl.selectNetwork(model->selectedNetworkName());
mdl.selectDataset(model->selectedDatasetName());
mdl.setProject(model->project());
long time = 0;
double err = 0;
//runs feedforward test
QList<QList<double > > errs = mdl.runTest(time, err);
if(errs.isEmpty()) return;
//row and column counts
int tptCnt = errs.length();
int outCnt = errs[0].length();
ui->errorTable->setRowCount(tptCnt);
ui->errorTable->setColumnCount(outCnt);
//generates horizontal headers
QStringList hList;
for(int i = 0; i < outCnt; i++){
if(i == 0)
hList.append("Pt err");
else{
hList.append("Out " + QString::number(i));
hList.append("Out " + QString::number(i) + " err");
}
}
//generates vertical headers
QStringList vList;
for(int i = 0; i < tptCnt; i++){
vList.append("Pt" + QString::number(i+1) + " errs");
}
//sets horizontal and vertical headers
ui->errorTable->setHorizontalHeaderLabels(hList);
ui->errorTable->setVerticalHeaderLabels(vList);
//fills table with data
for(int i = 0; i < tptCnt; i++){
for(int j = 0; j < outCnt; j++){
QTableWidgetItem* item = new QTableWidgetItem();
item->setText(QString::number(errs[i][j]));
ui->errorTable->setItem(i, j, item);
}
}
}
void MainWindow::CreationGraph()
{
/*QTableWidget table1(3,3, NULL);
//form.gameTable->setColumnCount(numbers);
//form.gameTable->setRowCount(numbers);
//table1.setGeometry(QRect(0,0,300,250));
// table1.setItem(1,1,"50");*/
table = new QTableWidget();
//Set table row count 1 and column count 3
table->setRowCount(numbers);
table->setColumnCount(numbers);
table->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
/*//Set Header Label Texts Here
table->setHorizontalHeaderLabels(QString("HEADER 1;HEADER 2;HEADER 3").split(";"));
//Add Table items here
table->setItem(0,0,new QTableWidgetItem("ITEM 1"));
table->setItem(0,1,new QTableWidgetItem("ITEM 2"));
table->setItem(0,2,new QTableWidgetItem("ITEM 3"));*/
//int arra = GetArra();
for (int i = 0; i < numbers; ++i)
{
for (int j = 0; j < numbers; ++j)
{
QTableWidgetItem * item = new QTableWidgetItem(QString::fromLocal8Bit("Твой текст"));
item->setText("0");
table->setItem(i, j, item);
}
}
table->resizeColumnsToContents();
table->show();
ZapAr();
QObject::connect(table, SIGNAL(itemChanged(QTableWidgetItem*)),
this, SLOT(ZapAr() ));
//QTableWidgetItem* itm2;
/*if ()
{
for(int i=0;i<numbers;i++)
for(int j=0;j<numbers;j++)
{
QTableWidgetItem* itm = table -> item(i,j);
arra[i][j] = itm -> text().toInt();
//out<<itmqstr;
}
}*/
}
void PeriodicTableParser::toTableWidget(QTableWidget *tw, const bool directAsNumber)
{
tw->clear();
if(directAsNumber)
{
tw->setColumnCount(9);
tw->setRowCount(1);
tw->horizontalHeader()->hide();
tw->verticalHeader()->hide();
}else
{
tw->setColumnCount(column);
tw->setRowCount(row);
}
tw->setEditTriggers(QAbstractItemView::NoEditTriggers);
tw->setSelectionMode(QAbstractItemView::NoSelection);
tw->setGridStyle(Qt::NoPen);
tw->setShowGrid(true);
if(directAsNumber)
{
int row = 0;
int column = 0;
foreach(Element * el, getSortToNumberListElements())
{
tw->setRowCount(row+1);
QTableWidgetItem *item = new QTableWidgetItem();
item->setTextAlignment(Qt::AlignCenter);
item->setText(QString("%1").arg(el->name));
item->setToolTip(QString("<font size=2 align=left>%1</font>"
"<p align=right>"
"<b>%2</b><br>"
"%3<br>"
"%4<br>"
"<font size=2>%5</font></p>")
.arg(el->number)
.arg(el->name)
.arg(el->longName)
.arg(el->family->name)
.arg(el->mass));
item->setBackgroundColor(QColor(el->family->color));
tw->setItem(row, column, item);
if(++column % tw->columnCount() == 0)
{
column = 0;
row++;
}
}
}else
void MusicLrcSearchTableWidget::createSearchedItem(const MusicSearchedItem &songItem)
{
int count = rowCount();
setRowCount(count + 1);
QHeaderView *headerview = horizontalHeader();
QTableWidgetItem *item = new QTableWidgetItem;
item->setData(MUSIC_CHECK_ROLE, false);
setItem(count, 0, item);
item = new QTableWidgetItem;
item->setToolTip(songItem.m_songName);
item->setText(MusicUtils::Widget::elidedText(font(), item->toolTip(), Qt::ElideRight, headerview->sectionSize(1) - 20));
item->setTextColor(QColor(100, 100, 100));
item->setTextAlignment(Qt::AlignCenter);
setItem(count, 1, item);
item = new QTableWidgetItem;
item->setToolTip(songItem.m_singerName);
item->setText(MusicUtils::Widget::elidedText(font(), item->toolTip(), Qt::ElideRight, headerview->sectionSize(2) - 20));
item->setTextColor(QColor(100, 100, 100));
item->setTextAlignment(Qt::AlignCenter);
setItem(count, 2, item);
item = new QTableWidgetItem(songItem.m_time);
item->setTextColor(QColor(100, 100, 100));
item->setTextAlignment(Qt::AlignCenter);
setItem(count, 3, item);
item = new QTableWidgetItem;
item->setIcon(QIcon(randToGetStrength()));
setItem(count, 4, item);
item = new QTableWidgetItem;
item->setIcon(QIcon(":/tiny/lb_server_type"));
item->setToolTip(songItem.m_type);
setItem(count, 5, item);
item = new QTableWidgetItem;
item->setIcon(QIcon(":/contextMenu/btn_download"));
setItem(count, 6, item);
}
void FiGroupWidget::getGroups()
{
mEditing = false;
mGroupView->erase();
while(mGroupView->columnCount() < 3) mGroupView->insertColumn(0);
QSqlQuery* query = mFilu->getGroups(mMotherId);
if(!query) return;
QTableWidgetItem* item;
while(query->next())
{
// query looks like
// group_id, caption, mothergroup_id
int row = mGroupView->rowCount();
mGroupView->insertRow(row);
item = new QTableWidgetItem;
item->setText(query->value(0).toString());
mGroupView->setItem(row, 0, item);
item = new QTableWidgetItem;
item->setText(query->value(1).toString());
mGroupView->setItem(row, 1, item);
item = new QTableWidgetItem;
item->setText(query->value(2).toString());
mGroupView->setItem(row, 2, item);
}
QSqlRecord rec = query->record();
QStringList header;
for(int i = 0; i < rec.count(); ++i) header << rec.fieldName(i);
mGroupView->setHorizontalHeaderLabels(header);
mGroupView->hideColumn(0);
mGroupView->hideColumn(2);
mGroupView->resizeColumnsToContents();
mGroupView->resizeRowsToContents();
mEditing = true;
}
// Referenz_Namen_Liste laden und im Dialog anzeigen
// ---------------------------------------------------
void admin::getRefnamen()
{
QString y;
QSqlQuery query;
qy = "SELECT idn,dbfield,refnam,ref_en,adifnam FROM refnamen WHERE type != 0 AND idn < 60 ORDER BY idn"; // !! < 60 !!
qDebug() << qy;
query.exec(qy);
QBrush brush(QColor(217,207,196));
row = query.size(); // 34 rows ( qso_datensatz, ab ADIF.2 )
col = query.record().count(); // 5 Spalten
RefTable->setRowCount(row); // TabellenLänge setzen - col ist schon gesetzt
row = 0;
while(query.next()) {
z = 0;
r = 0;
col = 0;
i = 0;
y = query.value(i++).toString();
y += "";
QTableWidgetItem *rowItem = new QTableWidgetItem(tr("%1").arg((r++)*(z++))); //idn
rowItem->setText(y);
RefTable->setVerticalHeaderItem(row,rowItem);
QTableWidgetItem *newItem = new QTableWidgetItem(tr("%1").arg((row)*(col)));//dbFeld
newItem->setText(query.value(i++).toString());
RefTable->setItem(row,col++,newItem);
newItem->setBackground(brush);
newItem = new QTableWidgetItem((tr("%1").arg((row)*(col)))); // ref_name
newItem->setText(query.value(i++).toString());
RefTable->setItem(row,col++,newItem);
newItem = new QTableWidgetItem((tr("%1").arg((row)*(col)))); // ref_en
newItem->setText(query.value(i++).toString());
RefTable->setItem(row,col++,newItem);
newItem = new QTableWidgetItem((tr("%1").arg((row)*(col)))); // adif_name
newItem->setText(query.value(i++).toString());
RefTable->setItem(row,col++,newItem);
row++;
}
}
void ClipboardHistorySelector::SetupClipboardHistoryTable()
{
ui.clipboardItemsTable->setRowCount(0);
ui.clipboardItemsTable->setRowCount(m_ClipboardHistoryItems->count());
for (int row = 0; row < m_ClipboardHistoryItems->count(); row++)
{
QTableWidgetItem *selector = new QTableWidgetItem();
// Keyboard shortcuts are 1-9 then 0 then a-j
selector->setText(KEY_SELECTORS.at(row));
selector->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
ui.clipboardItemsTable->setItem(row, 0, selector);
QString text = m_ClipboardHistoryItems->at(row);
QString display_text(text);
// Replace certain non-printable characters with spaces (to avoid
// drawing boxes when using fonts that don't have glyphs for such
// characters)
QChar *uc = display_text.data();
for (int i = 0; i < (int)text.length(); ++i) {
if ((uc[i] < 0x20 && uc[i] != 0x09)
|| uc[i] == QChar::LineSeparator
|| uc[i] == QChar::ParagraphSeparator
|| uc[i] == QChar::ObjectReplacementCharacter)
uc[i] = QChar(0x0020);
}
// Also replace any tab characters with an arrow glyph
display_text = display_text.replace(QChar('\t'), QChar(0x2192));
QTableWidgetItem *clip = new QTableWidgetItem();
clip->setText(display_text);
clip->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
clip->setData(Qt::UserRole, QVariant(text));
clip->setToolTip(text);
ui.clipboardItemsTable->setItem(row, 1, clip);
}
ui.clipboardItemsTable->setColumnWidth(0, 20);
ui.clipboardItemsTable->resizeRowsToContents();
if ( m_ClipboardHistoryItems->count() > 0 )
ui.clipboardItemsTable->selectRow(0);
}
void ActionsDialog::setupUi()
{
if( objectName().isEmpty() )
setObjectName( QString::fromUtf8( "ActionsDialog" ) );
gridLayout = new QGridLayout( this );
gridLayout->setObjectName( QString::fromUtf8( "gridLayout" ) );
TableWidgetActions = new QTableWidget( this );
TableWidgetActions->setObjectName( QString::fromUtf8( "TableWidgetActions" ) );
TableWidgetActions->setShowGrid( true );
gridLayout->addWidget( TableWidgetActions, 0, 0, 1, 1 );
buttonBox = new QDialogButtonBox( this );
buttonBox->setObjectName( QString::fromUtf8( "buttonBox" ) );
buttonBox->setOrientation( Qt::Horizontal );
buttonBox->setStandardButtons( QDialogButtonBox::Cancel
| QDialogButtonBox::Ok
| QDialogButtonBox::Apply );
gridLayout->addWidget( buttonBox, 1, 0, 1, 1 );
TableWidgetActions->setRowCount( m_actions.count() );
TableWidgetActions->setColumnCount( 2 );
QStringList TableWidgetHorizontalHeaderLabels;
TableWidgetHorizontalHeaderLabels << tr( "Description" ) << tr( "Shortcut" );
TableWidgetActions->setHorizontalHeaderLabels( TableWidgetHorizontalHeaderLabels );
TableWidgetActions->verticalHeader()->hide();
int row = 0;
foreach( QAction * action, m_actions )
{
QTableWidgetItem* TableWidgetItemDesc = new QTableWidgetItem;
TableWidgetItemDesc->setText( action->text() );
TableWidgetActions->setItem( row, 0, TableWidgetItemDesc );
QTableWidgetItem* TableWidgetItemShortcut = new QTableWidgetItem;
TableWidgetItemShortcut->setText( QString( action->shortcut() ) );
TableWidgetActions->setItem( row, 1, TableWidgetItemShortcut );
actionsList.append( action );
++row;
}
void CurveEditor::addPoint(int idx, double x, double y)
{
int i = pTable->rowCount();
pTable->insertRow(i);
pTable->setRowHeight(i, 20);
QTableWidgetItem *item;
item = new QTableWidgetItem;
item->setText(QString::number(idx));
pTable->setItem(i, 0, item);
item = new QTableWidgetItem;
item->setText(QString::number(x));
pTable->setItem(i, 1, item);
item = new QTableWidgetItem;
item->setText(QString::number(y));
pTable->setItem(i, 2, item);
}
void addEntry(KNS::Entry *entry) {
QTableWidgetItem *nameitem = new QTableWidgetItem();
nameitem->setText(entry->name().representation());
QTableWidgetItem *authoritem = new QTableWidgetItem();
authoritem->setText(entry->author().name());
QTableWidgetItem *downloadsitem = new QTableWidgetItem();
downloadsitem->setText(QString::number(entry->downloads()));
QTableWidgetItem *ratingitem = new QTableWidgetItem();
ratingitem->setText(QString::number(entry->rating()));
setItem(m_entries, 0, nameitem);
setItem(m_entries, 1, authoritem);
setItem(m_entries, 2, downloadsitem);
setItem(m_entries, 3, ratingitem);
m_entries++;
}
void ServerDialog::socketDisconnected(QString socket_id)
{
// update the associated socket status to disconnected
QList<QTableWidgetItem *> socket_id_items = ui->tableWidget->findItems(socket_id,Qt::MatchExactly);
if(socket_id_items.size() > 0)
{
QTableWidgetItem * item = socket_id_items[0];
QTableWidgetItem * status = ui->tableWidget->item(item->row(),1);
status->setText("Disconnected");
}
}
