void ActionsEditor::editShortcut() {
QTableWidgetItem * i = actionsTable->item( actionsTable->currentRow(), COL_SHORTCUT );
if (i) {
ShortcutGetter d(this);
QString result = d.exec( i->text() );
if (!result.isNull()) {
QString accelText = QKeySequence(result).toString(QKeySequence::PortableText);
i->setText(accelText);
if (hasConflicts()) qApp->beep();
}
}
}
// context menu for table
void PublicTalks::showContextMenu(const QPoint &pos)
{
qDebug() << "context menu" << pos.x() << pos.y();
QMenu myMenu;
myMenu.addAction(tr("Show Details..."));
QTableWidgetItem *item = etable->itemAt(pos);
if (!item) {
qDebug() << "empty area";
return;
}
if (item->column() != 1 || item->row() == 0) return;
if (item->text() == "") return;
bool speaker = (item->row() == 1);
QAction* selectedItem = myMenu.exec(QCursor::pos());
if (selectedItem) {
if (item) {
emit contextMenuShowPerson(item->text(),speaker);
}
}
}
void TrWidget::slotCopy()
{
#if 0
QList<QTableWidgetSelectionRange> ranges = m_table->selectedRanges();
QString str;
qDebug() << "slotCopy:" << ranges.size();
for(int i = 0; i < ranges.size(); i++)
{
if(i > 0) str += "\n";
str += copySelectedRange(ranges.at(i));
}
qDebug() << str;
QApplication::clipboard()->setText(str);
#endif
QString str;
QTableWidgetItem *item;
QTableWidgetSelectionRange range = selectedRange();
qDebug() << "rowCount:" << range.rowCount();
qDebug() << "columnCount:" << range.columnCount();
for(int row = 0; row < range.rowCount(); row++)
{
if(row > 0){
str += "\n";
}
for(int col = 0; col < range.columnCount(); col++)
{
if(col > 0) str += "\t";
item = m_table->item(range.topRow() + row, range.leftColumn() + col);
if(item->text().contains('\n')){
str += QString("\"%1\"").arg(item->text());
}else{
str += item->text();
}
}
}
qDebug() << str;
QApplication::clipboard()->setText(str);
}
void PluginManager::currentCellChanged( int row , int )
{
if( ui->tableWidget->rowCount() <= row )
return ;
QTableWidgetItem *item = ui->tableWidget->item( row , 0 );
SPlugin *plugin = loadedPlugins.value( item->text() );
if( startedPlugins.contains( plugin ) )
{
ui->enable_btn->setText( tr("Stop") );
ui->enable_btn->setIcon( SMasterIcons::icon( QSize(48,48) , "media-playback-stop.png" ) );
}
else
{
ui->enable_btn->setText( tr("Start") );
ui->enable_btn->setIcon( SMasterIcons::icon( QSize(48,48) , "media-playback-start.png" ) );
}
ui->plugin_name->setText( item->text() );
}
/****************************************************************************
**
** 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
}
void FlarmAliasList::slot_CellChanged( int row, int column )
{
QTableWidgetItem* item = list->item ( row, column );
if( item == static_cast<QTableWidgetItem *>(0) || row < 0 || column < 0 )
{
// Item can be a Null pointer, if a row has been removed.
return;
}
if( column == 0 )
{
// Converts the Flarm identifier to upper case.
item->setText( item->text().trimmed().toUpper() );
list->resizeColumnToContents( 0 );
}
else
{
// Limits alias name to MaxAliasLength characters.
item->setText( item->text().trimmed().left(MaxAliasLength) );
}
}
int LoadTable::getLoadedNodesNumber () const
{
int loadedNumb = 0;
QTableWidgetItem *cellX = 0, *cellY = 0;
for ( int i = 0; i < rowCount(); ++i ) {
cellX = item( i, 0 );
cellY = item( i, 1 );
if ( (cellX && cellX->text().toDouble() != 0) ||
(cellY && cellY->text().toDouble() != 0) )
++loadedNumb;
}
return loadedNumb;
}
void
MainWindow::removeSelectedSegment()
{
QList<QTableWidgetItem *> sel = ui->segmentsTable->selectedItems();
if (sel.isEmpty())
return;
QTableWidgetItem * item = sel.front();
qDebug() << "Removing segment" << item->row() << "with label" << item->text();
model->removeSegment(item->row());
ui->segmentsTable->removeRow(item->row());
}
void CaptureInterfacesDialog::on_compileBPF_clicked()
{
QList<QTableWidgetItem*> selected = ui->tbInterfaces->selectedItems();
if (selected.length() < 1) {
return;
}
QStringList *interfaces = new QStringList();
for (int row = 0; row < ui->tbInterfaces->rowCount(); row++)
{
QTableWidgetItem *it = ui->tbInterfaces->item(row, INTERFACE);
if (selected.contains(it)) {
QString str = it->text();
interfaces->append(it->text());
}
}
QString filter = ui->allFilterComboBox->currentText();
CompiledFilterOutput *cfo = new CompiledFilterOutput(this, interfaces, filter);
cfo->show();
}
/* Called to save data to the configuration file. */
void SettingsPagePointDataLoading::slot_save()
{
QStringList files;
if( m_fileTable->item( 0, 0 )->checkState() == Qt::Checked )
{
// All files are selected.
files << "All";
}
else
{
// Store only checked file items.
for( int i = 1; i < m_fileTable->rowCount(); i++ )
{
QTableWidgetItem* item = m_fileTable->item( i, 0 );
if( item->checkState() == Qt::Checked )
{
files << item->text();
}
}
}
QStringList oldFiles = GeneralConfig::instance()->getOpenAipPoiFileList();
// save the new file list
GeneralConfig::instance()->setOpenAipPoiFileList( files );
// Check, if file list has been modified
if( oldFiles.size() != files.size() )
{
// List size is different, emit signal.
emit fileListChanged();
}
else
{
// The list size is equal, we have to check every single list element.
// Note that the lists are always sorted.
for( int i = 0; i < files.size(); i++ )
{
if( files.at(i) != oldFiles.at(i) )
{
// File names are different, emit signal.
emit fileListChanged();
break;
}
}
}
close();
}
QString MasterKeysTable::selectedRowName()
{
QList<QTableWidgetItem*> items = d->tableView->selectedItems();
if(items.isEmpty())
return QString();
int rowNr = items.first()->row();
QTableWidgetItem* item = d->tableView->item(rowNr, 1);
return item->text();
}
void TrackEditor::done(int result)
{
//ok
if (result == QDialog::Accepted) {
tracks->clear();
for (int row = 0; row < tableWidget->rowCount(); ++row) {
QString title = tableWidget->item(row, 0)->text();
QTableWidgetItem *item = tableWidget->item(row, 1);
int duration = item ? item->text().toInt() : 0;
tracks->append(Track(title, duration));
}
}
QDialog::done(result);
}
void ExtendedTableWidget::dropEvent(QDropEvent *event)
{
QTableWidgetItem *item = itemAt(event->pos());
if ((item) && (PhoneNumber::phone_re().exactMatch(item->text()))) {
QString userid_from = QString::fromLatin1(event->mimeData()->data(XUSERID_MIMETYPE));
QString channel_from = QString::fromLatin1(event->mimeData()->data(CHANNEL_MIMETYPE));
if (event->mimeData()->hasFormat(CHANNEL_MIMETYPE)) {
event->acceptProposedAction();
b_engine->actionCall("transfer",
"chan:" + userid_from + ":" + channel_from,
"ext:" + item->text());
} else if (event->mimeData()->hasFormat(XPHONEID_MIMETYPE)) {
event->acceptProposedAction();
b_engine->actionCall("originate",
"user:"******"ext:" + item->text());
} else {
event->ignore();
}
} else {
event->ignore();
}
}
void PluginManager::stop_start_CurrentItem()
{
int index = ui->tableWidget->currentRow();
if( index < 0 )
return ;
QTableWidgetItem *item = ui->tableWidget->item( index , 0 );
SPlugin *plugin = loadedPlugins.value( item->text() );
if( plugin->isStarted() )
plugin->stop();
else
plugin->start();
}
//-----------------------------------------------------------------------------
//! when the user presses the menu key while selecting from channels
//! (see SelectFromChannels) and then presses the enter key this will
//-----------------------------------------------------------------------------
void tSiriusController::TuneToHighlightedChannelFromChannelsTable(const QModelIndex& index)
{
if( m_pChannelsDialog && m_pChannelsTable )
{
// on the touch screen, it seems touching an item doesn't set it to the focused item before activate is called
// so we need to set this index to the current index so TuneToHighlightedChannelAndAcceptFromChannelsTable()
// grabs the focus item and tunes to it.
QTableWidgetItem *pItem = m_pChannelsTable->item(index.row(), 0);
int channel = pItem->text().toInt();
TuneChannelAbsolute( channel );
m_pChannelsDialog->close();
}
}
//----------------------------------------------------------------------------------------------
void CaseView::OnCellChanged(int p_row, int p_column)
{
if(p_column == 0)
return;
stringstream stream;
float val;
QTableWidgetItem* item = ui.tblGameState->item(p_row, p_column);
stream.str(string(item->text().toLocal8Bit()));
stream >> val;
ShallowFeaturesEx &sfeatures = ShallowFeaturesEx(); //m_currentCase->GameState()->ShallowFeatures();
sfeatures[p_row] = val;
}
QString ColumnarTableWidget::textForColumn(int row,int col) const {
QTableWidgetItem * item = this->item(row,col);
QString str;
if (item) {
str = item->text();
}
else {
QLabel * label = qobject_cast<QLabel *>(this->cellWidget(row,col));
if (label) {
str = label->text();
}
}
return removeSpan(str);
}
void CBlacklist::AssignValue( bool bToTable, int nRowIndex )
{
QTableWidgetItem* pItem = NULL;
if ( bToTable ) {
pItem = new QTableWidgetItem( ui->edtName->text( ) );
ui->tableBlacklist->setItem( nRowIndex, 0, pItem );
pItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
pItem = new QTableWidgetItem( ui->edtType->text( ) );
ui->tableBlacklist->setItem( nRowIndex, 1, pItem );
pItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
pItem = new QTableWidgetItem( ui->edtExplain->text( ) );
ui->tableBlacklist->setItem( nRowIndex, 2, pItem );
pItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
} else {
pItem = ui->tableBlacklist->item( nRowIndex, 0 );
if ( NULL == pItem ) {
return;
}
ui->edtName->setText( pItem->text( ) );
pItem = ui->tableBlacklist->item( nRowIndex, 1 );
if ( NULL == pItem ) {
return;
}
ui->edtType->setText( pItem->text( ) );
pItem = ui->tableBlacklist->item( nRowIndex, 2 );
if ( NULL == pItem ) {
return;
}
ui->edtExplain->setText( pItem->text( ) );
}
}
void EmploiDuTemps::afficheInfos(int row, int column){
if(ui->tableWidget->item(row, column)){ //si la case contient une programmation
try {
ui->stackedWidget->setHidden(false);
QTableWidgetItem* item = ui->tableWidget->item(row, column);
if(item->background()== QBrush(QColor(191,117,255))){
//l'item est un evt
ui->stackedWidget->setCurrentIndex(0);
const Programmation* evt = ProgrammationManager::getInstance().trouverEvenement(item->whatsThis());
ui->labelDescr->setText(evt->getEvenement()->getDescription());
ui->labelLieu->setText(evt->getEvenement()->getLieu());
ui->labelNom->setText(evt->getEvenement()->getNom());
ui->labelDate->setText(evt->getDate().toString(Qt::SystemLocaleShortDate));
ui->labelDuree->setText(evt->getDuree().stringDuree());
ui->labelType->setText(evt->getEvenement()->getType());
ui->labelHor->setText(evt->getTime().toString("HH:mm"));
}
else if (item->background()==QBrush(QColor(85,255,127))){
//l'item est une tache
ui->stackedWidget->setCurrentIndex(1);
Tache* t = ProjetManager::getInstance().trouverTache(item->whatsThis());
ui->labelId->setText(t->getId());
ui->labelTitre_2->setText(t->getTitre());
ui->labelProjet->setText(t->getProjet()->getNom());
ui->labelDate_2->setText(ui->tableWidget->horizontalHeaderItem(column)->text());
ui->labelHor_2->setText(item->text().section(" ",0,0));
ui->labelDuree_2->setText("\n\n"+item->text().section("durée : ",1,1));
}
}catch(CalendarException e){
QMessageBox::warning(this, "Erreur", e.getInfo());
}
}
else //si la case est vide
ui->stackedWidget->setHidden(true);
}
void FunctionDialog::addParam()
{
QTableWidgetItem *type;
type = new QTableWidgetItem();
/*Get entered text for type*/
type->setText(m_ui->enterParamType->text());
QTableWidgetItem *name;
name = new QTableWidgetItem();
/*Get entered text for name*/
name->setText(m_ui->enterParamName->text());
/*Check to see if both blanks are filled in*/
if(type->text().isEmpty())
{
QMessageBox::warning(this, "Missing Field", "Please enter the parameter's type.\n", QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
m_ui->enterParamType->setFocus();
return;
}
else if(name->text().isEmpty())
{
QMessageBox::warning(this, "Entry Error", "Please enter the parameter's name.\n", QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
m_ui->enterParamName->setFocus();
return;
}
else
{
/*Add type and name to table*/
m_numParam++;
m_ui->paramTable->setRowCount(m_numParam +1);
m_ui->paramTable->setItem(m_numParam, 0, type);
m_ui->paramTable->setItem(m_numParam, 1, name);
}
/*Clear line edits and prepare for new entries*/
m_ui->enterParamType->clear();
m_ui->enterParamName->clear();
m_ui->enterParamType->setFocus();
}
void MainWindow::on_pushButton_clicked()
{
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
QString str;
QTableWidgetItem* itm = ui->tableWidget->item( i, j );
if (itm)
{
str = itm->text();
input[i][j]=str.toInt();
output[i][j]=input[i][j];
}
else output[i][j]=input[i][j]=0;
}
}
if(solve(0,0))
{ ui->label->setText("YES");
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
QTableWidgetItem *itab;
itab = new QTableWidgetItem; // add this line
QString s = QString::number(output[i][j]);
itab->setText(s);
if(input[i][j]!=0)
{
itab->setForeground(QColor::fromRgb(255,0,0)); //make this item red.
}
ui->tableWidget->setItem(i, j, itab);
}
}
}
else ui->label->setText("NO");
/*
QTableWidgetItem *itab;
itab = new QTableWidgetItem; // add this line
QString s = QString::number(j);
itab->setText(s);
ui->tableWidget->setItem(i, j, itab);
*/
//delete(itab);
}
void FieldEditPanel::OnValueChanged(int row, int column)
{
/* ignore extra row for addition */
if(row >= (int)m_ref.GetField().value.size())
return;
QTableWidgetItem *item = m_value_table->item(row, column);
if(column == FieldValueNameColumn)
m_ref.GetField().value[row].name = item->text().toStdString();
else if(column == FieldValueValueColumn)
{
soc_word_t& fval = m_ref.GetField().value[row].value;
soc_word_t new_val = item->data(Qt::DisplayRole).toUInt();
/* avoid infinite recursion by calling UpdateWarning() when
* only the icon changes which would trigger this callback again */
if(fval != new_val)
{
fval = new_val;
UpdateWarning(row);
}
}
else if(column == FieldValueDescColumn)
m_ref.GetField().value[row].desc = item->text().toStdString();
emit OnModified(true);
}
void UICloudProfileDetailsWidget::sltTableChanged(QTableWidgetItem *pItem)
{
/* Make sure item is valid: */
AssertPtrReturnVoid(pItem);
const int iRow = pItem->row();
AssertReturnVoid(iRow >= 0);
/* Skip if one of items isn't yet created.
* This can happen when 1st is already while 2nd isn't yet. */
QTableWidgetItem *pItemK = m_pTableWidget->item(iRow, 0);
QTableWidgetItem *pItemV = m_pTableWidget->item(iRow, 1);
if (!pItemK || !pItemV)
return;
/* Push changes back: */
const QString strKey = pItemK->text();
const QString strValue = pItemV->text();
m_newData.m_data[strKey] = qMakePair(strValue, m_newData.m_data.value(strKey).second);
/* Revalidate: */
revalidate(m_pTableWidget);
/* Update button states: */
updateButtonStates();
}
void TimeWidget::applyFilter()
{
for(int i = 0; i < table->rowCount(); ++i)
{
QTableWidgetItem *item = table->item(i, 0); //assuming that column 0 is the name column
if(NULL != item && item->text().contains(filter.trimmed()))
{
table->setRowHidden(i, false);
}
else
{
table->setRowHidden(i, true);
}
}
}
void dataeditfrm::seladdress()
{
QString tmpstr = "";
addrselectfrm *saddrfrm = new addrselectfrm;
QTableWidgetItem * item = tabsuppliers->item(tabsuppliers->currentRow(), 0);
if(item->text() != "")
saddrfrm->txtsearch->setText(item->text().section(";", 0, 0));
saddrfrm->init();
if(saddrfrm->exec())
{
QString answer = saddrfrm->getaddress().replace("<BR>",";");
QStringList fields = answer.split(":#:");
QTableWidgetItem *item_1 = new QTableWidgetItem;
item_1->setText(fields[0]);
tabsuppliers->setItem(tabsuppliers->currentRow(), 0, item_1);
QTableWidgetItem *item_2 = new QTableWidgetItem;
item_2->setText(fields[1]);
tabsuppliers->setItem(tabsuppliers->currentRow(), 1, item_2);
}
delete saddrfrm;
// QMessageBox::information ( 0, tr ( "Error during update..." ), "test" );
}
void PropertiesDialog::saveShortcuts()
{
QMap<QString, QAction*> actions = QTerminalApp::Instance()->getWindowList()[0]->leaseActions();
QList< QString > shortcutKeys = actions.keys();
int shortcutCount = shortcutKeys.count();
shortcutsWidget->setRowCount( shortcutCount );
for( int x=0; x < shortcutCount; x++ )
{
QString keyValue = shortcutKeys.at(x);
QAction *keyAction = actions[keyValue];
QTableWidgetItem *item = shortcutsWidget->item(x, 1);
QKeySequence sequence = QKeySequence(item->text());
QString sequenceString = sequence.toString();
QList<QKeySequence> shortcuts;
foreach (sequenceString, item->text().split('|'))
shortcuts.append(QKeySequence(sequenceString));
keyAction->setShortcuts(shortcuts);
}
Properties::Instance()->saveSettings();
}
QVector<double> KernelTable::getMatrix()
{
QVector<double> matrix;
int rows = tableWidget->rowCount();
int columns = tableWidget->columnCount();
for (int i = 0; i != rows; ++i)
for (int j = 0; j != columns; ++j) {
QTableWidgetItem *item = tableWidget->item(i, j);
double item_value = 0;
if (item != 0)
item_value = item->text().toDouble();
matrix.push_back(item_value);
}
return matrix;
}
void MemorySearch::openMemory() {
auto items = m_ui.results->selectedItems();
if (items.empty()) {
return;
}
QTableWidgetItem* item = items[0];
uint32_t address = item->text().toUInt(nullptr, 16);
MemoryView* memView = new MemoryView(m_controller);
memView->jumpToAddress(address);
connect(m_controller, &GameController::gameStopped, memView, &QWidget::close);
memView->setAttribute(Qt::WA_DeleteOnClose);
memView->show();
}
void MainWindow::selectionChanged() {
QList<NetNode*> selectedNodes;
QList<QTableWidgetItem*> items = ui->tableWidget->selectedItems();
for(int i=0; i<items.size(); i++) {
QTableWidgetItem* item = items[i];
if(item->column() == 0) {
NetNode* node = network->getNode(item->text());
selectedNodes.push_back(node);
}
}
netgraphics->updateSelection(selectedNodes);
}
void Localizador::on_pbEliminar_clicked()
{
if (ui->tableWidget->rowCount()==1 )
{
ui->lblTamanio->setText("0");
}
else
{
QTableWidgetItem *item;
item=ui->tableWidget->item(ui->tableWidget->currentRow(),2);
tamanio=tamanio - item->text().toFloat();
ui->lblTamanio->setText(QString::number(tamanio));
}
ui->tableWidget->removeRow(ui->tableWidget->currentRow());
}
