void PortListView::performDrag() {
QModelIndexList indexes = selectedIndexes();
QString mimeText;
foreach (QModelIndex index, indexes) {
// if the index is not valid
if (!index.isValid())
continue;
// add the port name of the indexed item to mime data
mimeText += index.model()->data(index, Qt::DisplayRole).toString();
mimeText += ";";
}
// set the mime data
QMimeData* mimeData = new QMimeData();
mimeData->setText(mimeText);
QDrag* drag = new QDrag(this);
drag->setMimeData(mimeData);
if (drag->exec(Qt::MoveAction) == Qt::MoveAction) {
// inform the model that the dragged items could be removed
emit removeItems(indexes);
}
}
PlaylistPanel::PlaylistPanel() {
setupUi(this);
// Random and such
connect(MPD::instance(), SIGNAL(randomUpdated(bool)), randomButton, SLOT(setChecked(bool)));
connect(MPD::instance(), SIGNAL(repeatUpdated(bool)), repeatButton, SLOT(setChecked(bool)));
connect(Config::instance(), SIGNAL(autoAddSongsChanged(bool)), dynamicButton, SLOT(setChecked(bool)));
connect(randomButton, SIGNAL(toggled(bool)), MPD::instance(), SLOT(setRandom(bool)));
connect(repeatButton, SIGNAL(toggled(bool)), MPD::instance(), SLOT(setRepeat(bool)));
dynamicButton->setChecked(Config::instance()->autoAddSongs());
connect(dynamicButton, SIGNAL(toggled(bool)), Config::instance(), SLOT(setAutoAddSongs(bool)));
// Button clicks
connect(cropButton, SIGNAL(clicked()), playlistView, SLOT(cropItems()));
connect(removeButton, SIGNAL(clicked()), playlistView, SLOT(removeItems()));
connect(saveAsButton, SIGNAL(clicked()), playlistView, SLOT(savePlaylist()));
connect(clearButton, SIGNAL(clicked()), MPD::instance(), SLOT(clearPlaylist()));
connect(shuffleButton, SIGNAL(clicked()), MPD::instance(), SLOT(shufflePlaylist()));
// Toggle actions
connect(playlistView, SIGNAL(toggleActions(bool)), removeButton, SLOT(setEnabled(bool)));
connect(playlistView, SIGNAL(toggleActions(bool)), cropButton, SLOT(setEnabled(bool)));
// Filter
connect(filter, SIGNAL(textChanged(const QString &)), this, SLOT(updateFilter(const QString &)));
}
void CSListView::reinitItems(ListItem< StatusItem >* items)
{
EnableWindow(m_handle, FALSE);
removeItems();
initItems(items);
EnableWindow(m_handle, TRUE);
}
void QGalleryTrackerResultSetPrivate::syncFinish(const int rIndex, const int iIndex)
{
const int rCount = rCache.count - rIndex;
const int iCount = iCache.count - iIndex;
bool itemChanged = false;
if (rCount > 0)
removeItems(rIndex, iIndex, rCount);
else
rCache.offset = rCache.count;
if (currentIndex >= iCache.cutoff && currentIndex < iCache.count) {
currentRow = iCache.values.constBegin() + (currentIndex * tableWidth);
itemChanged = true;
}
if (iCount > 0)
insertItems(rIndex + rCount, iIndex, iCount);
else
iCache.cutoff = iCache.count;
if (itemChanged)
emit q_func()->currentItemChanged();
flags |= SyncFinished;
}
TrackOrganiser::TrackOrganiser(QWidget *parent)
: SongDialog(parent, "TrackOrganiser", QSize(800, 500))
, schemeDlg(0)
, autoSkip(false)
, paused(false)
, updated(false)
, alwaysUpdate(false)
{
iCount++;
setButtons(Ok|Cancel);
setCaption(i18n("Organize Files"));
setAttribute(Qt::WA_DeleteOnClose);
QWidget *mainWidet = new QWidget(this);
setupUi(mainWidet);
setMainWidget(mainWidet);
configFilename->setIcon(Icons::self()->configureIcon);
setButtonGuiItem(Ok, GuiItem(i18n("Rename"), "edit-rename"));
connect(this, SIGNAL(update()), MPDConnection::self(), SLOT(update()));
progress->setVisible(false);
files->setItemDelegate(new BasicItemDelegate(files));
files->setAlternatingRowColors(false);
files->setContextMenuPolicy(Qt::ActionsContextMenu);
files->setSelectionMode(QAbstractItemView::ExtendedSelection);
removeAct=new Action(i18n("Remove From List"), files);
removeAct->setEnabled(false);
files->addAction(removeAct);
connect(files, SIGNAL(itemSelectionChanged()), SLOT(controlRemoveAct()));
connect(removeAct, SIGNAL(triggered()), SLOT(removeItems()));
}
FwPrimitiveGroup::~FwPrimitiveGroup()
{
removeItems();
if(m_parent)
{
m_parent->m_groups.removeOne(this);
}
}
void HistoryView::keyPressEvent(QKeyEvent* event)
{
if (event->key() == Qt::Key_Delete) {
removeItems();
event->accept();
}
QTreeView::keyPressEvent(event);
}
void
Package::removeItems(const Package &listPkg) {
const Item *pItem;
int32_t i;
for(pItem=listPkg.items, i=0; i<listPkg.itemCount; ++pItem, ++i) {
removeItems(pItem->name);
}
}
/* create menus bar */
void MainWindow::createMenuBar()
{
// File Menu
fileMenu = menuBar()->addMenu(tr("&File"));
newMenuAct = fileMenu->addAction(tr("&New Net"));
newMenuAct->setIcon(QIcon::fromTheme("window-new"));
newMenuAct->setShortcut(QKeySequence("Ctrl+N"));
connect(newMenuAct, SIGNAL(triggered()), tabWidget, SLOT(createNew()));
openMenuAct = fileMenu->addAction(tr("&Open Net"));
openMenuAct->setIcon(QIcon::fromTheme("folder-open"));
openMenuAct->setShortcut(QKeySequence("Ctrl+O"));
connect(openMenuAct, SIGNAL(triggered()), this, SLOT(open()));
fileMenu->addSeparator();
saveMenuAct = fileMenu->addAction(tr("&Save"));
saveMenuAct->setIcon(QIcon::fromTheme("document-save"));
saveMenuAct->setShortcut(QKeySequence("Ctrl+S"));
connect(saveMenuAct, SIGNAL(triggered()), tabWidget, SLOT(save()));
exportMenuAct = fileMenu->addAction(tr("&Export"));
//exportMenuAct->setIcon(QIcon(QPixmap("")));
exportMenuAct->setShortcut(QKeySequence("Ctrl+E"));
connect(exportMenuAct, SIGNAL(triggered()), tabWidget, SLOT(exportNet()));
fileMenu->addSeparator();
quitMenuAct = fileMenu->addAction(tr("&Exit"));
quitMenuAct->setIcon(QIcon::fromTheme("application-exit"));
quitMenuAct->setShortcut(QKeySequence("Ctrl+Q"));
connect(quitMenuAct, SIGNAL(triggered()), this, SLOT(close()));
// Petri Net Menu
editMenu = menuBar()->addMenu(tr("&Edit"));
undoMenuAct = editMenu->addAction(tr("&Undo"));
undoMenuAct->setIcon(QIcon::fromTheme("edit-undo"));
undoMenuAct->setShortcut(QKeySequence("Ctrl+Z"));
undoMenuAct->setEnabled(false);
connect(undoMenuAct, SIGNAL(triggered()), tabWidget, SLOT(undo()));
connect(tabWidget, SIGNAL(canUndoChange (bool)), undoMenuAct, SLOT(setEnabled (bool)));
redoMenuAct = editMenu->addAction(tr("&Redo"));
redoMenuAct->setIcon(QIcon::fromTheme("edit-redo"));
redoMenuAct->setShortcut(QKeySequence("Ctrl+Shift+Z"));
redoMenuAct->setEnabled(false);
connect(redoMenuAct, SIGNAL(triggered()), tabWidget, SLOT(redo()));
connect(tabWidget, SIGNAL(canRedoChange (bool)), redoMenuAct, SLOT(setEnabled (bool)));
editMenu->addSeparator();
removeMenuAct = editMenu->addAction(tr("&Delete"));
removeMenuAct->setIcon(QIcon::fromTheme("edit-delete"));
removeMenuAct->setShortcut(QKeySequence("Del"));
connect(removeMenuAct, SIGNAL(triggered ()), tabWidget, SLOT(removeItems ()));
// help menu
helpMenu = menuBar()->addMenu(tr("&Help"));
aboutMenuAct = helpMenu->addAction(tr("&About"));
aboutMenuAct->setIcon(QIcon::fromTheme("help-about"));
aboutMenuAct->setShortcut(QKeySequence("Ctrl+B"));
connect(aboutMenuAct, SIGNAL(triggered()), this, SLOT(about()));
}
void GraphicsWorkflow::initialize() {
if ( _currentgroup != NULL ) {
unGroup();
removeItems();
setScene(NULL);
}
SceneWorkflow *scene = new SceneWorkflow(this);
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
setScene(scene);
Q_CHECK_PTR(scene);
// scene->setSceneRect(0,0,800,600);
}
void ArchiveListWidget::addArchives(QList<ArchivePtr > archives)
{
clear();
std::sort(archives.begin(), archives.end(), ArchiveCompare);
foreach (ArchivePtr archive, archives)
{
ArchiveListItem *item = new ArchiveListItem(archive);
connect(item, SIGNAL(requestDelete()), this, SLOT(removeItems()));
connect(item, SIGNAL(requestInspect()), this, SLOT(inspectItem()));
connect(item, SIGNAL(requestRestore()), this, SLOT(restoreItem()));
connect(item, SIGNAL(requestGoToJob()), this, SLOT(goToJob()));
this->insertItem(this->count(), item);
this->setItemWidget(item, item->widget());
}
void Themes::on_del_clicked()
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,QStringLiteral("start"));
selectedItems=selectionModel->selectedRows();
QList<int> ids;
int index=0;
const int &loop_size=selectedItems.size();
while(index<loop_size)
{
ids << transferModel.data(selectedItems.at(index),Qt::UserRole).toULongLong();
index++;
}
if(ids.size()>0)
emit removeItems(ids);
}
HistoryManager::HistoryManager(QupZilla* mainClass, QWidget* parent)
: QWidget(parent)
, ui(new Ui::HistoryManager)
, p_QupZilla(mainClass)
{
ui->setupUi(this);
connect(ui->historyTree, SIGNAL(openLink(QUrl, HistoryView::OpenBehavior)), this, SLOT(openLink(QUrl, HistoryView::OpenBehavior)));
connect(ui->deleteB, SIGNAL(clicked()), ui->historyTree, SLOT(removeItems()));
connect(ui->clearAll, SIGNAL(clicked()), this, SLOT(clearHistory()));
connect(ui->optimizeDb, SIGNAL(clicked(QPoint)), this, SLOT(optimizeDb()));
ui->historyTree->setFocus();
}
void Themes::on_del_clicked()
{
ULTRACOPIER_DEBUGCONSOLE(DebugLevel_Notice,"start");
selectedItems=selectionModel->selectedRows();
ids.clear();
index=0;
loop_size=selectedItems.size();
while(index<loop_size)
{
ids << transferModel.data(selectedItems.at(index),Qt::UserRole).toULongLong();
index++;
}
if(ids.size()>0)
emit removeItems(ids);
}
bool QgsComposerMapOverviewStack::readXml( const QDomElement &elem, const QDomDocument &doc )
{
removeItems();
//read overview stack
QDomNodeList mapOverviewNodeList = elem.elementsByTagName( "ComposerMapOverview" );
for ( int i = 0; i < mapOverviewNodeList.size(); ++i )
{
QDomElement mapOverviewElem = mapOverviewNodeList.at( i ).toElement();
QgsComposerMapOverview* mapOverview = new QgsComposerMapOverview( mapOverviewElem.attribute( "name" ), mComposerMap );
mapOverview->readXml( mapOverviewElem, doc );
mItems.append( mapOverview );
}
return true;
}
void BackupListWidget::keyPressEvent(QKeyEvent *event)
{
switch(event->key())
{
case Qt::Key_Delete:
case Qt::Key_Backspace:
removeItems();
break;
case Qt::Key_Escape:
if(!selectedItems().isEmpty())
clearSelection();
else
QListWidget::keyPressEvent(event);
break;
default:
QListWidget::keyPressEvent(event);
}
}
void ExitTile::examine(Player* p){
if(locked){
p->setMessageIn(Player::MESSAGE_SLOT_INFORMATION,MenuText::TILE_EXIT_EXAMINE_LOCK);
}
else if(numKeys == 3){
p->addToScore(SCORE);
stringstream str;
str << MenuText::TILE_EXIT_SCORE_PREFIX << SCORE << MenuText::TILE_EXIT_SCORE_SUFFIX;
p->setMessageIn(Player::MESSAGE_SLOT_INFORMATION,str.str());
p->setMessageIn(Player::MESSAGE_SLOT_ACTION,MenuText::TILE_EXIT_LOCKING);
locked = true;
roomLayout[END_GAME_X][END_GAME_Y] = END_GAME_CHAR_LOCK;
symbol = END_GAME_CHAR_LOCK;
removeItems();
}
else{
p->setMessageIn(Player::MESSAGE_SLOT_INFORMATION,MenuText::TILE_EXIT_NOT_ENOUGH_KEYS);
}
}
void QGalleryTrackerResultSetPrivate::syncReplace(
const int rIndex, const int rCount, const int iIndex, const int iCount)
{
bool itemChanged = false;
if (rCount > 0)
removeItems(rIndex, iIndex, rCount);
if (currentIndex >= iCache.cutoff && currentIndex < iCache.cutoff + iCount) {
currentRow = iCache.values.constBegin() + (currentIndex * tableWidth);
itemChanged = true;
}
if (iCount > 0)
insertItems(rIndex + rCount, iIndex, iCount);
if (itemChanged)
emit q_func()->currentItemChanged();
}
void HistoryView::contextMenuEvent(QContextMenuEvent* event)
{
const QModelIndex index = indexAt(event->pos());
if (!index.isValid() || index.data(HistoryModel::IsTopLevelRole).toBool()) {
return;
}
m_clickedIndex = index;
QMenu menu;
menu.addAction(tr("Open link in current tab"), this, SLOT(openLinkInCurrentTab()));
menu.addAction(tr("Open link in new tab"), this, SLOT(openLinkInNewTab()));
menu.addSeparator();
menu.addAction(tr("Copy title"), this, SLOT(copyTitle()));
menu.addAction(tr("Copy address"), this, SLOT(copyAddress()));
menu.addSeparator();
menu.addAction(tr("Remove"), this, SLOT(removeItems()));
// Prevent choosing first option with double rightclick
QPoint pos = viewport()->mapToGlobal(event->pos());
QPoint p(pos.x(), pos.y() + 1);
menu.exec(p);
}
ProjectBuildSetWidget::ProjectBuildSetWidget( QWidget* parent )
: QWidget( parent ), m_view( 0 ),
m_ui( new Ui::ProjectBuildSetWidget )
{
m_ui->setupUi( this );
m_ui->addItemButton->setIcon( KIcon( "list-add" ) );
connect( m_ui->addItemButton, SIGNAL( clicked() ),
this, SLOT( addItems() ) );
m_ui->removeItemButton->setIcon( KIcon( "list-remove" ) );
connect( m_ui->removeItemButton, SIGNAL( clicked() ),
this, SLOT( removeItems() ) );
m_ui->upButton->setIcon( KIcon( "go-up" ) );
connect( m_ui->upButton, SIGNAL( clicked() ),
SLOT( moveUp() ) );
m_ui->downButton->setIcon( KIcon( "go-down" ) );
connect( m_ui->downButton, SIGNAL( clicked() ),
SLOT( moveDown() ) );
m_ui->topButton->setIcon( KIcon( "go-top" ) );
connect( m_ui->topButton, SIGNAL( clicked() ),
SLOT( moveToTop() ) );
m_ui->bottomButton->setIcon( KIcon( "go-bottom" ) );
connect( m_ui->bottomButton, SIGNAL( clicked() ),
SLOT( moveToBottom() ) );
m_ui->itemView->horizontalHeader()->setStretchLastSection(true);
m_ui->itemView->verticalHeader()->setVisible(false);
m_ui->itemView->setContextMenuPolicy( Qt::CustomContextMenu );
connect( m_ui->itemView, SIGNAL( customContextMenuRequested( const QPoint& ) ),
SLOT(showContextMenu(const QPoint&) ) );
layout()->setMargin(0);
}
QgsLayoutItemMapItemStack::~QgsLayoutItemMapItemStack()
{
removeItems();
}
~ScriptModelTreeBonsaiCutter(){ removeItems();}
RgDialog::RgDialog(QWidget *parent)
: SongDialog(parent, "RgDialog", QSize(800, 400))
, state(State_Idle)
, totalToScan(0)
, tagReader(0)
, autoScanTags(false)
{
iCount++;
setButtons(User1|Ok|Cancel);
setCaption(i18n("ReplayGain"));
setAttribute(Qt::WA_DeleteOnClose);
QWidget *mainWidget = new QWidget(this);
QBoxLayout *layout=new QBoxLayout(QBoxLayout::TopToBottom, mainWidget);
combo = new QComboBox(this);
view = new QTreeWidget(this);
statusLabel = new QLabel(this);
statusLabel->setVisible(false);
progress = new QProgressBar(this);
progress->setVisible(false);
combo->addItem(i18n("Show All Tracks"), true);
combo->addItem(i18n("Show Untagged Tracks"), false);
view->setRootIsDecorated(false);
view->setAllColumnsShowFocus(true);
view->setItemDelegate(new BasicItemDelegate(view));
view->setAlternatingRowColors(false);
view->setContextMenuPolicy(Qt::ActionsContextMenu);
view->setSelectionMode(QAbstractItemView::ExtendedSelection);
removeAct=new Action(i18n("Remove From List"), view);
removeAct->setEnabled(false);
view->addAction(removeAct);
QTreeWidgetItem *hdr = view->headerItem();
hdr->setText(COL_ARTIST, i18n("Artist"));
hdr->setText(COL_ALBUM, i18n("Album"));
hdr->setText(COL_TITLE, i18n("Title"));
hdr->setText(COL_ALBUMGAIN, i18n("Album Gain"));
hdr->setText(COL_TRACKGAIN, i18n("Track Gain"));
hdr->setText(COL_ALBUMPEAK, i18n("Album Peak"));
hdr->setText(COL_TRACKPEAK, i18n("Track Peak"));
QHeaderView *hv=view->header();
setResizeMode(hv, COL_ARTIST, QHeaderView::ResizeToContents);
setResizeMode(hv, COL_ALBUM, QHeaderView::ResizeToContents);
setResizeMode(hv, COL_TITLE, QHeaderView::Stretch);
setResizeMode(hv, COL_ALBUMGAIN, QHeaderView::Fixed);
setResizeMode(hv, COL_TRACKGAIN, QHeaderView::Fixed);
setResizeMode(hv, COL_ALBUMPEAK, QHeaderView::Fixed);
setResizeMode(hv, COL_TRACKPEAK, QHeaderView::Fixed);
hv->setStretchLastSection(false);
layout->setMargin(0);
layout->addWidget(combo);
layout->addWidget(view);
layout->addWidget(statusLabel);
layout->addWidget(progress);
setMainWidget(mainWidget);
setButtonGuiItem(Ok, StdGuiItem::save());
setButtonGuiItem(Cancel, StdGuiItem::close());
setButtonGuiItem(User1, GuiItem(i18n("Scan"), "edit-find"));
enableButton(Ok, false);
enableButton(User1, false);
qRegisterMetaType<Tags::ReplayGain>("Tags::ReplayGain");
connect(combo, SIGNAL(currentIndexChanged(int)), SLOT(toggleDisplay()));
connect(view, SIGNAL(itemSelectionChanged()), SLOT(controlRemoveAct()));
connect(removeAct, SIGNAL(triggered()), SLOT(removeItems()));
italic=font();
italic.setItalic(true);
JobController::self()->setMaxActive(1);
}
//Sorts tree items according to user input
void BC_Bulletin::sortItems(int sortOption)
{
//Sort tree items in chronoloical order (oldest first)
if(sortOption == 0)
{
//Remove items from both trees
removeItems(2);
//Sort items in both trees by operator defined in Item.h and FSWItem.h, respectively
std::sort(treeItems.begin(), treeItems.end(), sortByTimeCFDP());
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByTimeFSW());
//Replace items in both trees
replaceItems(2);
}
//Sort tree items in chronological order (newest first)
else if(sortOption == 1)
{
removeItems(2);
std::sort(treeItems.begin(), treeItems.end(), sortByTimeCFDP2());
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByTimeFSW2());
replaceItems(2);
}
//Sort tree items by file size (CFDP only) (smallest first)
else if(sortOption == 2)
{
removeItems(0);
std::sort(treeItems.begin(), treeItems.end(), sortBySize());
replaceItems(0);
}
//Sort tree items by file size (CFDP only) (largest first)
else if(sortOption == 3)
{
removeItems(0);
std::sort(treeItems.begin(), treeItems.end(), sortBySize2());
replaceItems(0);
}
//Sort tree items by command (FSW only) (lowest APID first)
else if(sortOption == 4)
{
removeItems(1);
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByCommand());
replaceItems(1);
}
//Sort tree items by command (FSW only) (highest APID first)
else if(sortOption == 5)
{
removeItems(1);
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByCommand2());
replaceItems(1);
}
//Sort tree items by status (Successful, unsuccessful, in progress)
else if(sortOption == 6)
{
removeItems(2);
std::sort(treeItems.begin(), treeItems.end(), sortByStatusCFDP());
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByStatusFSW());
replaceItems(2);
}
//Sort tree items by status (In progress, unsuccessful, successful)
else if(sortOption == 7)
{
removeItems(2);
std::sort(treeItems.begin(), treeItems.end(), sortByStatusCFDP2());
std::sort(fswTreeItems.begin(), fswTreeItems.end(), sortByStatusFSW2());
replaceItems(2);
}
}
vector<PItem> Equipment::removeAllItems(WCreature c) {
return removeItems(getItems(), c);
}
QgsComposerMapItemStack::~QgsComposerMapItemStack()
{
removeItems();
}
/* create tool bar */
void MainWindow::createToolBar ()
{
newToolButton = new QToolButton;
newToolButton->setIconSize(QSize(50, 50));
newToolButton->setIcon(QIcon::fromTheme("window-new"));
newToolButton->setToolTip(tr("Create a new Petri Net <span style=\"color:gray;\">Ctrl+N</span>"));
connect(newToolButton, SIGNAL(clicked()), tabWidget, SLOT(createNew()));
openToolButton = new QToolButton;
openToolButton->setIconSize(QSize(50, 50));
openToolButton->setIcon(QIcon::fromTheme("folder-open"));
openToolButton->setToolTip(tr("Open a Petri Net document <span style=\"color:gray;\">Ctrl+O</span>"));
connect(openToolButton, SIGNAL(clicked()), this, SLOT(open()));
saveToolButton = new QToolButton;
saveToolButton->setIconSize(QSize(50, 50));
saveToolButton->setIcon(QIcon::fromTheme("document-save"));
saveToolButton->setToolTip(tr("Save the current Petri Net <span style=\"color:gray;\">Ctrl+S</span>"));
connect(saveToolButton, SIGNAL(clicked()), tabWidget, SLOT(save()));
undoToolButton = new QToolButton;
undoToolButton->setIconSize(QSize(50, 50));
undoToolButton->setIcon(QIcon::fromTheme("edit-undo"));
undoToolButton->setToolTip(tr("Undo the last action <span style=\"color:gray;\">Ctrl+Z</span>"));
undoToolButton->setEnabled(false);
connect(undoToolButton, SIGNAL(clicked()), tabWidget, SLOT(undo ()));
connect(tabWidget, SIGNAL(canUndoChange (bool)), undoToolButton, SLOT(setEnabled (bool)));
redoToolButton = new QToolButton;
redoToolButton->setIconSize(QSize(50, 50));
redoToolButton->setIcon(QIcon::fromTheme("edit-redo"));
redoToolButton->setToolTip(tr("Redo the last undone action <span style=\"color:gray;\">Ctrl+Shif+Z</span>"));
redoToolButton->setEnabled(false);
connect(redoToolButton, SIGNAL(clicked()), tabWidget, SLOT(redo ()));
connect(tabWidget, SIGNAL(canRedoChange(bool)), redoToolButton, SLOT(setEnabled (bool)));
removeToolButton = new QToolButton;
removeToolButton->setIconSize(QSize(50, 50));
removeToolButton->setIcon(QIcon::fromTheme("edit-delete"));
removeToolButton->setToolTip(tr("Remove the selected items <span style=\"color:gray;\">Del</span> "));
connect(removeToolButton, SIGNAL(clicked()), tabWidget, SLOT(removeItems ()));
cursorToolButton = new QToolButton;
cursorToolButton->setIconSize(QSize(50, 50));
cursorToolButton->setCheckable(true);
cursorToolButton->setIcon(QIcon(QPixmap(":/images/cursor.png")));
cursorToolButton->setToolTip(tr("Normal cursor"));
addPlaceToolButton = new QToolButton;
addPlaceToolButton->setIconSize(QSize(50, 50));
addPlaceToolButton->setCheckable(true);
addPlaceToolButton->setIcon(QIcon(QPixmap(":/images/place.png")));
addPlaceToolButton->setToolTip(tr("Add places"));
addTransToolButton = new QToolButton;
addTransToolButton->setIconSize(QSize(50, 50));
addTransToolButton->setCheckable(true);
addTransToolButton->setIcon(QIcon(QPixmap(":/images/transition.png")));
addTransToolButton->setToolTip(tr("Add transitions"));
drawArcToolButton = new QToolButton;
drawArcToolButton->setIconSize(QSize(50, 50));
drawArcToolButton->setCheckable(true);
drawArcToolButton->setIcon(QIcon(QPixmap(":/images/arc.png")));
drawArcToolButton->setToolTip(tr("Draw Polylines Arcs"));
addTokenToolButton = new QToolButton;
addTokenToolButton->setIconSize(QSize(50, 50));
addTokenToolButton->setCheckable(true);
addTokenToolButton->setIcon(QIcon(QPixmap(":/images/token+.png")));
addTokenToolButton->setToolTip(tr("Add Tokens"));
subTokenToolButton = new QToolButton;
subTokenToolButton->setIconSize(QSize(50, 50));
subTokenToolButton->setCheckable(true);
subTokenToolButton->setIcon(QIcon(QPixmap(":/images/token-.png")));
subTokenToolButton->setToolTip(tr("Delete Tokens"));
animateToolButton = new QToolButton;
animateToolButton->setIconSize(QSize(50, 50));
animateToolButton->setCheckable(true);
animateToolButton->setIcon(QIcon(QPixmap(":/images/animate.png")));
animateToolButton->setToolTip(tr("Animate the current drawen net"));
buttonGroup = new QButtonGroup (this);
buttonGroup->setExclusive(true);
buttonGroup->addButton(cursorToolButton, normalMode);
buttonGroup->addButton(addPlaceToolButton, addPlaceMode);
buttonGroup->addButton(addTransToolButton, addTransMode);
buttonGroup->addButton(drawArcToolButton, drawArcMode);
buttonGroup->addButton(animateToolButton, animationMode);
buttonGroup->addButton(addTokenToolButton, addToken);
buttonGroup->addButton(subTokenToolButton, subToken);
connect(buttonGroup, SIGNAL(buttonClicked (int)),
this, SLOT(buttonGroupClicked(int)));
// default mode = normal mode
cursorToolButton->setChecked (true);
toolBar = new QToolBar;
toolBar->addWidget(newToolButton);
toolBar->addWidget(openToolButton);
toolBar->addWidget(saveToolButton);
toolBar->addSeparator ();
toolBar->addWidget(undoToolButton);
toolBar->addWidget(redoToolButton);
toolBar->addSeparator ();
toolBar->addWidget(removeToolButton);
toolBar->addWidget(cursorToolButton);
toolBar->addSeparator ();
toolBar->addWidget(addPlaceToolButton);
toolBar->addWidget(addTransToolButton);
toolBar->addWidget(drawArcToolButton);
toolBar->addSeparator ();
toolBar->addWidget(addTokenToolButton);
toolBar->addWidget(subTokenToolButton);
toolBar->addSeparator ();
toolBar->addWidget(animateToolButton);
toolBar->setAllowedAreas(Qt::TopToolBarArea | Qt::LeftToolBarArea | Qt::RightToolBarArea);
addToolBar(Qt::LeftToolBarArea, toolBar);
}
