QgsBrowserDockWidget::QgsBrowserDockWidget( QWidget * parent ) :
QDockWidget( parent ), mModel( NULL )
{
setWindowTitle( tr( "Browser" ) );
mBrowserView = new QgsBrowserTreeView( this );
QToolButton* refreshButton = new QToolButton( this );
refreshButton->setIcon( QgisApp::instance()->getThemeIcon( "mActionDraw.png" ) );
// remove this to save space
refreshButton->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
refreshButton->setText( tr( "Refresh" ) );
refreshButton->setToolTip( tr( "Refresh" ) );
refreshButton->setAutoRaise( true );
connect( refreshButton, SIGNAL( clicked() ), this, SLOT( refresh() ) );
QToolButton* addLayersButton = new QToolButton( this );
addLayersButton->setIcon( QgisApp::instance()->getThemeIcon( "mActionAddLayer.png" ) );
// remove this to save space
addLayersButton->setToolButtonStyle( Qt::ToolButtonTextBesideIcon );
addLayersButton->setText( tr( "Add Selection" ) );
addLayersButton->setToolTip( tr( "Add Selected Layers" ) );
addLayersButton->setAutoRaise( true );
connect( addLayersButton, SIGNAL( clicked() ), this, SLOT( addSelectedLayers() ) );
QToolButton* collapseButton = new QToolButton( this );
collapseButton->setIcon( QgisApp::instance()->getThemeIcon( "mActionCollapseTree.png" ) );
collapseButton->setToolTip( tr( "Collapse All" ) );
collapseButton->setAutoRaise( true );
connect( collapseButton, SIGNAL( clicked() ), mBrowserView, SLOT( collapseAll() ) );
QVBoxLayout* layout = new QVBoxLayout();
QHBoxLayout* hlayout = new QHBoxLayout();
layout->setContentsMargins( 0, 0, 0, 0 );
layout->setSpacing( 0 );
hlayout->setContentsMargins( 0, 0, 0, 0 );
hlayout->setSpacing( 5 );
hlayout->setAlignment( Qt::AlignLeft );
hlayout->addSpacing( 5 );
hlayout->addWidget( refreshButton );
hlayout->addSpacing( 5 );
hlayout->addWidget( addLayersButton );
hlayout->addStretch( );
hlayout->addWidget( collapseButton );
layout->addLayout( hlayout );
layout->addWidget( mBrowserView );
QWidget* innerWidget = new QWidget( this );
innerWidget->setLayout( layout );
setWidget( innerWidget );
connect( mBrowserView, SIGNAL( customContextMenuRequested( const QPoint & ) ), this, SLOT( showContextMenu( const QPoint & ) ) );
connect( mBrowserView, SIGNAL( doubleClicked( const QModelIndex& ) ), this, SLOT( addLayerAtIndex( const QModelIndex& ) ) );
}
EngineExplorer::EngineExplorer(QWidget* parent)
: QDialog(parent),
m_engine(0),
m_sourceCount(0),
m_requestingSource(false),
m_expandButton(new QPushButton(i18n("Expand All"), this)),
m_collapseButton(new QPushButton(i18n("Collapse All"), this))
{
#ifdef FOUND_SOPRANO
(void) qRegisterMetaType<Soprano::Node>();
#endif
setWindowTitle(i18n("Plasma Engine Explorer"));
QWidget* mainWidget = new QWidget(this);
QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
buttonBox->addButton(m_expandButton, QDialogButtonBox::ActionRole);
buttonBox->addButton(m_collapseButton, QDialogButtonBox::ActionRole);
buttonBox->addButton(QDialogButtonBox::Close);
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addWidget(mainWidget);
layout->addWidget(buttonBox);
setLayout(layout);
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
setupUi(mainWidget);
m_engineManager = Plasma::PluginLoader::self();
m_dataModel = new QStandardItemModel(this);
const QIcon pix = QIcon::fromTheme("plasma");
const int size = IconSize(KIconLoader::Dialog);
m_title->setPixmap(pix.pixmap(size, size));
connect(m_engines, SIGNAL(activated(QString)), this, SLOT(showEngine(QString)));
connect(m_sourceRequesterButton, SIGNAL(clicked(bool)), this, SLOT(requestSource()));
connect(m_serviceRequesterButton, SIGNAL(clicked(bool)), this, SLOT(requestServiceForSource()));
m_data->setModel(m_dataModel);
m_data->setWordWrap(true);
m_searchLine->setTreeView(m_data);
m_searchLine->setPlaceholderText(i18n("Search"));
listEngines();
m_engines->setFocus();
connect(m_collapseButton, SIGNAL(clicked()), m_data, SLOT(collapseAll()));
connect(m_expandButton, SIGNAL(clicked()), m_data, SLOT(expandAll()));
enableButtons(false);
addAction(KStandardAction::quit(qApp, SLOT(quit()), this));
connect(m_data, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(showDataContextMenu(QPoint)));
m_data->setContextMenuPolicy(Qt::CustomContextMenu);
connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(cleanUp()));
}
void TestListView::onListTestsFinished(void) {
// sanity check
Q_ASSERT_X(m_runner, Q_FUNC_INFO, "null test runner");
if ( m_runner == 0 )
return;
// clear any previous data (necessary here?)
clear();
// foreach program
const int numPrograms = m_runner->programCount();
for ( int i = 0; i < numPrograms; ++i ) {
TestProgram* program = m_runner->programAt(i);
Q_ASSERT_X(program, Q_FUNC_INFO, "null test program");
// create top-level item for program
QTreeWidgetItem* programItem = new QTreeWidgetItem;
programItem->setData(0, Qt::DisplayRole, program->programName());
programItem->setData(0, Qt::UserRole, QVariant::fromValue(program));
// programItem->setCheckState(0, Qt::Checked);
// foreach test suite
const int numSuites = program->suiteCount();
for ( int j = 0; j < numSuites; ++j ) {
TestSuite* suite = program->suiteAt(j);
Q_ASSERT_X(suite, Q_FUNC_INFO, "null test suite");
// create item for suite
QTreeWidgetItem* suiteItem = new QTreeWidgetItem(programItem);
suiteItem->setData(0, Qt::DisplayRole, suite->name());
suiteItem->setData(0, Qt::UserRole, QVariant::fromValue(suite));
// suiteItem->setCheckState(0, Qt::Checked);
// foreach test case
const int numTests = suite->testCount();
for ( int k = 0; k < numTests; ++k ) {
TestCase* test = suite->testAt(k);
Q_ASSERT_X(test, Q_FUNC_INFO, "null test case");
// create item for test
QTreeWidgetItem* testItem = new QTreeWidgetItem(suiteItem);
testItem->setData(0, Qt::DisplayRole, test->name());
testItem->setData(0, Qt::UserRole, QVariant::fromValue(test));
// testItem->setCheckState(0, Qt::Checked);
}
}
// add program item to table
addTopLevelItem(programItem);
}
// start with all items collapsed
collapseAll();
}
void TableOfContents::contextMenuEvent(QContextMenuEvent *event)
{
QMenu *menu = new QMenu(this);
// Add menu options
QAction *collapseAction = new QAction(tr("Collapse All"), menu);
QAction *expandAction = new QAction(tr("Expand All"), menu);
menu->addAction(collapseAction);
connect(collapseAction, SIGNAL(triggered()), m_TreeView, SLOT(collapseAll()));
menu->addAction(expandAction);
connect(expandAction, SIGNAL(triggered()), m_TreeView, SLOT(expandAll()));
menu->exec(mapToGlobal(event->pos()));
}
void GalleryTreeView::slotCheckSelection(const QModelIndex &selected)
{
clearFocus();
collapseAll();
if (selected.isValid()) {
emit signalSelected(true);
// Expand the whole tree up
for (QModelIndex count = selected; count.isValid(); count = count.parent())
expand(count);
} else {
emit signalSelected(false);
}
}
// ---
VSWSCDynContentDataList::VSWSCDynContentDataList (QWidget* parent, Qt::WindowFlags f)
: QWidget (parent, f),
_model (NULL)
{
// The list of dynamic content is a tree
// because in every year, and every month, and in every day....
// several measures could have been gathered.
_listOfDynContent = new VSWSCDynContentDataListTree;
_listOfDynContent -> setAnimated (true);
// The list of buttons...
_buttons = new VSWSCDataListButtons;
// The list of the players and the buttons to manage them are
// linked together in a Vertical Layout...
QVBoxLayout* listDContentLayout = new QVBoxLayout;
listDContentLayout -> setContentsMargins (__NOMARGINS);
listDContentLayout -> setSpacing (__NOSPACING);
listDContentLayout -> addWidget (_buttons);
listDContentLayout -> addWidget (_listOfDynContent);
// Connect the data list buttons with method of either the three
// view or this object...
connect (_buttons, SIGNAL (collapseAllSignal ()), _listOfDynContent, SLOT (collapseAll ()));
connect (_buttons, SIGNAL (extendAllSignal ()), _listOfDynContent, SLOT (expandAll ()));
connect (_buttons, SIGNAL (actualizeContentSignal ()), this, SLOT (actualizeContentAction ()));
connect (_buttons, SIGNAL (actualizeContentSignal (const QString&, const QString&)),
this, SLOT (actualizeContentAction (const QString&, const QString&)));
// Connect action that can happen in the tree view
// Mainly when an object is selected...
// In this case, a new signal is emitted to be capture
// by the statistic data object and then actualize the info related with the dynamic data...
connect (_listOfDynContent, SIGNAL (dynContentSelectedSignal (const QString&, const QString&, const QString&, const QString&)),
this, SLOT (dynContentSelectedAction (const QString&, const QString&, const QString&, const QString&)));
connect (_listOfDynContent, SIGNAL (addDynamicContentSignal (const QString&, const QString&, const QString&, const QString&)),
this, SLOT (addDynamicContentAction (const QString&, const QString&, const QString&, const QString&)));
connect (_listOfDynContent, SIGNAL (deleteDynamicContentSignal (const QString&, const QString&, const QString&, const QString&)),
this, SLOT (deleteDynamicContentAction (const QString&, const QString&, const QString&, const QString&)));
connect (_listOfDynContent, SIGNAL (modifyDynamicContentSignal (const QString&, const QString&, const QString&, const QString&)),
this, SLOT (modifyDynamicContentAction (const QString&, const QString&, const QString&, const QString&)));
connect (_listOfDynContent, SIGNAL (noDetailDataSelectedSignal ()),
this, SLOT (noDetailDataSelectedAction ()));
connect (_listOfDynContent, SIGNAL (detailDataSelectedSignal ()),
this, SLOT (detailDataSelectedAction ()));
setLayout (listDContentLayout);
}
void TreeWidget::filterString(QString string)
{
expandAll();
QList<QTreeWidgetItem*> _allItems = allItems();
if (string.isEmpty()) {
foreach(QTreeWidgetItem * item, _allItems)
item->setHidden(false);
for (int i = 0; i < topLevelItemCount(); i++) {
topLevelItem(i)->setHidden(false);
}
if (m_showMode == ItemsCollapsed) {
collapseAll();
}
}
else {
foreach(QTreeWidgetItem * item, _allItems) {
item->setHidden(!item->text(0).contains(string, Qt::CaseInsensitive));
item->setExpanded(true);
}
for (int i = 0; i < topLevelItemCount(); i++) {
topLevelItem(i)->setHidden(false);
}
QTreeWidgetItem* firstItem = topLevelItem(0);
QTreeWidgetItem* belowItem = itemBelow(firstItem);
int topLvlIndex = 0;
while (firstItem) {
if (firstItem->text(0).contains(string, Qt::CaseInsensitive)) {
firstItem->setHidden(false);
}
else if (!firstItem->parent() && !belowItem) {
firstItem->setHidden(true);
}
else if (!belowItem) {
break;
}
else if (!firstItem->parent() && !belowItem->parent()) {
firstItem->setHidden(true);
}
topLvlIndex++;
firstItem = topLevelItem(topLvlIndex);
belowItem = itemBelow(firstItem);
}
}
void PropertyEditor::slotSorting(bool sort)
{
if (sort == m_sorting)
return;
storeExpansionState();
m_sorting = sort;
collapseAll();
{
UpdateBlocker ub(this);
clearView();
m_treeBrowser->setRootIsDecorated(sort);
fillView();
applyExpansionState();
applyFilter();
}
updateActionsState();
}
void ItemBoxTreeWidget::contextMenuEvent(QContextMenuEvent *e)
{
QTreeWidgetItem *item = itemAt(e->pos());
if(!item) {
return;
}
const bool scratchpad_menu = item != 0
&& item->parent() != 0
&& topLevelRole(item->parent()) == SCRATCHPAD_ITEM;
QMenu menu;
menu.addAction(tr("Expand all"), this, SLOT(expandAll()));
menu.addAction(tr("Collapse all"), this, SLOT(collapseAll()));
menu.addSeparator();
QAction *listModeAction = menu.addAction(tr("List View"));
QAction *iconModeAction = menu.addAction(tr("Icon View"));
listModeAction->setCheckable(true);
iconModeAction->setCheckable(true);
QActionGroup *viewModeGroup = new QActionGroup(&menu);
viewModeGroup->addAction(listModeAction);
viewModeGroup->addAction(iconModeAction);
if (m_iconMode) {
iconModeAction->setChecked(true);
} else {
listModeAction->setChecked(true);
}
connect(listModeAction, SIGNAL(triggered()), SLOT(slotListMode()));
connect(iconModeAction, SIGNAL(triggered()), SLOT(slotIconMode()));
if (scratchpad_menu) {
menu.addSeparator();
menu.addAction(tr("Remove"), itemWidget(item, 0), SLOT(removeCurrentItem()));
if (!m_iconMode) {
menu.addAction(tr("Edit name"), itemWidget(item, 0), SLOT(editCurrentItem()));
}
}
e->accept();
// menu.exec(mapToGlobal(e->pos()));
// m_core->handleContextMenuEventOnCategory(item->text(0), mapToGlobal(e->pos()), &menu);
m_core->handleContextMenuEventOnCategory(item->data(0, Qt::UserRole).toString(), mapToGlobal(e->pos()), &menu);
}
void MetadataSelector::selectAll()
{
collapseAll();
QTreeWidgetItemIterator it(this, QTreeWidgetItemIterator::NotChecked);
while (*it)
{
MetadataSelectorItem* const item = dynamic_cast<MetadataSelectorItem*>(*it);
if (item)
{
item->setCheckState(0, Qt::Checked);
}
++it;
}
expandAll();
}
void PropertyEditor::slotViewTriggered(QAction *action)
{
storeExpansionState();
collapseAll();
{
UpdateBlocker ub(this);
clearView();
int idx = 0;
if (action == m_treeAction) {
m_currentBrowser = m_treeBrowser;
idx = m_treeIndex;
} else if (action == m_buttonAction) {
m_currentBrowser = m_buttonBrowser;
idx = m_buttonIndex;
}
fillView();
m_stackedWidget->setCurrentIndex(idx);
applyExpansionState();
applyFilter();
}
updateActionsState();
}
BookmarksSideBar::BookmarksSideBar(QupZilla* mainClass, QWidget* parent)
: QWidget(parent)
, m_isRefreshing(false)
, ui(new Ui::BookmarksSideBar)
, p_QupZilla(mainClass)
, m_bookmarksModel(mApp->bookmarksModel())
{
ui->setupUi(this);
ui->bookmarksTree->setViewType(BookmarksTree::SideBarView);
ui->bookmarksTree->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->bookmarksTree->setDragDropReceiver(true, m_bookmarksModel);
ui->bookmarksTree->setMimeType(QLatin1String("application/qupzilla.treewidgetitem.bookmarks"));
ui->expandAll->setIcon(QIcon::fromTheme("view-sort-ascending", QIcon(":/icons/faenza/expand.png")));
ui->collapseAll->setIcon(QIcon::fromTheme("view-sort-descending", QIcon(":/icons/faenza/collapse.png")));
ui->bookmarksTree->setDefaultItemShowMode(TreeWidget::ItemsExpanded);
connect(ui->bookmarksTree, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
connect(ui->bookmarksTree, SIGNAL(itemControlClicked(QTreeWidgetItem*)), this, SLOT(itemControlClicked(QTreeWidgetItem*)));
connect(ui->bookmarksTree, SIGNAL(itemMiddleButtonClicked(QTreeWidgetItem*)), this, SLOT(itemControlClicked(QTreeWidgetItem*)));
connect(ui->bookmarksTree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)), this, SLOT(itemDoubleClicked(QTreeWidgetItem*)));
connect(ui->search, SIGNAL(textChanged(QString)), ui->bookmarksTree, SLOT(filterString(QString)));
connect(ui->collapseAll, SIGNAL(clicked()), ui->bookmarksTree, SLOT(collapseAll()));
connect(ui->expandAll, SIGNAL(clicked()), ui->bookmarksTree, SLOT(expandAll()));
connect(m_bookmarksModel, SIGNAL(bookmarkAdded(BookmarksModel::Bookmark)), this, SLOT(addBookmark(BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(bookmarkDeleted(BookmarksModel::Bookmark)), this, SLOT(removeBookmark(BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(bookmarkEdited(BookmarksModel::Bookmark,BookmarksModel::Bookmark)),
this, SLOT(bookmarkEdited(BookmarksModel::Bookmark,BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(folderAdded(QString)), this, SLOT(addFolder(QString)));
connect(m_bookmarksModel, SIGNAL(folderDeleted(QString)), this, SLOT(removeFolder(QString)));
connect(m_bookmarksModel, SIGNAL(folderRenamed(QString,QString)), this, SLOT(renameFolder(QString,QString)));
connect(m_bookmarksModel, SIGNAL(folderParentChanged(QString,bool)), this, SLOT(changeFolderParent(QString,bool)));
connect(m_bookmarksModel, SIGNAL(bookmarkParentChanged(QString,QByteArray,int,QUrl,QString,QString)),
this, SLOT(changeBookmarkParent(QString,QByteArray,int,QUrl,QString,QString)));
QTimer::singleShot(0, this, SLOT(refreshTable()));
}
// a context menu action was selected
void UserMenuTree::slotPopupActivated(int id)
{
KILE_DEBUG() << "popup activated with id: " << id;
switch (id ) {
case POPUP_INSERT_ABOVE: insertMenuItem (m_popupItem, false); break;
case POPUP_INSERT_BELOW: insertMenuItem (m_popupItem, true); break;
case POPUP_SEPARATOR_ABOVE: insertSeparator(m_popupItem, false); break;
case POPUP_SEPARATOR_BELOW: insertSeparator(m_popupItem, true); break;
case POPUP_SUBMENU_ABOVE: insertSubmenu (m_popupItem, false); break;
case POPUP_SUBMENU_BELOW: insertSubmenu (m_popupItem, true); break;
case POPUP_INTO_SUBMENU: insertIntoSubmenu(m_popupItem, UserMenuData::Text); break;
case POPUP_SEPARATOR_INTO_SUBMENU: insertIntoSubmenu(m_popupItem, UserMenuData::Separator); break;
case POPUP_SUBMENU_INTO_SUBMENU: insertIntoSubmenu(m_popupItem, UserMenuData::Submenu); break;
case POPUP_DELETE_ITEM: itemDelete(m_popupItem); break;
case POPUP_DELETE_TREE: deleteMenuTree(); break;
case POPUP_COLLAPSE_ITEM: m_popupItem->setExpanded(false); break;
case POPUP_EXPAND_ITEM: m_popupItem->setExpanded(true); break;
case POPUP_COLLAPSE_TREE: collapseAll(); break;
case POPUP_EXPAND_TREE: expandAll(); break;
case POPUP_ITEM_INFO: itemInfo(m_popupItem); break;
}
}
HistoryView::HistoryView(QWidget* parent)
: QTreeView(parent)
, m_history(mApp->history())
, m_filterModel(new HistoryFilterModel(m_history->model()))
{
setModel(m_filterModel);
setAllColumnsShowFocus(true);
setUniformRowHeights(true);
setSelectionMode(QAbstractItemView::ExtendedSelection);
m_header = new HeaderView(this);
setHeader(m_header);
m_header->setDefaultSectionSizes(QList<double>() << 0.4 << 0.35 << 0.10 << 0.08);
m_header->setSectionHidden(4, true);
connect(this, SIGNAL(activated(QModelIndex)), this, SLOT(itemActivated(QModelIndex)));
connect(this, SIGNAL(pressed(QModelIndex)), this, SLOT(itemPressed(QModelIndex)));
connect(m_filterModel, SIGNAL(expandAllItems()), this, SLOT(expandAll()));
connect(m_filterModel, SIGNAL(collapseAllItems()), this, SLOT(collapseAll()));
}
FavoriteTreeView::FavoriteTreeView(QWidget * parent)
:QTreeView(parent)
{
mModel = new FavoriteModel();
setModel(mModel);
setEditTriggers(QAbstractItemView::EditKeyPressed);
setSortingEnabled(true);
header()->hide();
mRenameAction = new QAction(tr("Rename"),this);
mDeleteAction= new QAction(tr("Delete"),this);
mCollapseAction = new QAction(tr("Collapse all"), this);
connect(mRenameAction,SIGNAL(triggered()),this,SLOT(renameFavorite()));
connect(mDeleteAction,SIGNAL(triggered()),this,SLOT(deleteFavorite()));
connect(mCollapseAction,SIGNAL(triggered()),this,SLOT(collapseAll()));
connect(this,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(doubleClickedReceived(QModelIndex)));
connect(this,SIGNAL(clicked(QModelIndex)),this,SLOT(clickedReceived(QModelIndex)));
mModel->load(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + QDir::separator() + "favorite.json");
}
QReportTreeManager::QReportTreeManager(QWidget *parent, QReportDocumentDesigner *designer, QReport *report, bool readOnly) :
QTreeWidget(parent),
_designer(designer),
_report(report),
_readOnly(readOnly),
nodeDataTable(0),
nodeParameters(0)
{
header()->setVisible(false);
_contextMenu = new QMenu(this);
initActions();
initTreeItems();
retranslateUi();
connect(this, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
this, SLOT(slot_currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
connect(actionExpandAll, SIGNAL(triggered()), this, SLOT(expandAll()));
connect(actionCollapseAll, SIGNAL(triggered()), this, SLOT(collapseAll()));
QMetaObject::connectSlotsByName(this);
}
BranchesTree::BranchesTree(QWidget *parent) : QTreeWidget(parent),
branchIcon(QString::fromUtf8(":/icons/resources/branch.png")),
masterBranchIcon(QString::fromUtf8(":/icons/resources/branch_master.png")),
tagIcon(QString::fromUtf8(":/icons/resources/tag.png"))
{
setContextMenuPolicy(Qt::CustomContextMenu);
QObject::connect(this, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
this, SLOT(changeBranch(QTreeWidgetItem*, int)));
QObject::connect(this, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(contextMenu(QPoint)));
collapseAllAction = new QAction(tr("Collapse all"), this);
QObject::connect(collapseAllAction, SIGNAL(triggered()),
this, SLOT(collapseAll()));
expandAllAction = new QAction(tr("Expand all"), this);
QObject::connect(expandAllAction, SIGNAL(triggered()),
this, SLOT(expandAll()));
checkoutAction = new QAction(tr("Checkout"), this);
QObject::connect(checkoutAction, SIGNAL(triggered()),
this, SLOT(checkout()));
removeTagAction = new QAction(tr("Remove"), this);
QObject::connect(removeTagAction, SIGNAL(triggered()),
this, SLOT(removeTag()));
this->setRootIsDecorated(false);
this->setIndentation(10);
QPalette p = this->palette();
p.setColor(QPalette::Base, p.color(QPalette::Window));
this->setPalette(p);
}
// ---
VSWSCReleasesDataList::VSWSCReleasesDataList (QWidget* parent, Qt::WindowFlags f)
: QWidget (parent, f),
_model (NULL)
{
// Sets the model to review...
_listOfReleases = new VSWSCReleasesDataListTree;
_listOfReleases -> setAnimated (true);
// The list of buttons...
_buttons = new VSWSCDataListButtons;
// The list of the releases and the buttons to manage them are
// linked together in a Vertical Layout...
QVBoxLayout* listReleasesLayout = new QVBoxLayout;
listReleasesLayout -> setContentsMargins (__NOMARGINS);
listReleasesLayout -> setSpacing (__NOSPACING);
listReleasesLayout -> addWidget (_buttons);
listReleasesLayout -> addWidget (_listOfReleases);
// Connect the data list buttons with method of either the three
// view or this object...
connect (_buttons, SIGNAL (collapseAllSignal ()), _listOfReleases, SLOT (collapseAll ()));
connect (_buttons, SIGNAL (extendAllSignal ()), _listOfReleases, SLOT (expandAll ()));
connect (_buttons, SIGNAL (actualizeContentSignal ()), this, SLOT (actualizeContentAction ()));
connect (_buttons, SIGNAL (actualizeContentSignal (const QString&, const QString&)),
this, SLOT (actualizeContentAction (const QString&, const QString&)));
// Connect action that can happen in the tree view
// Mainly when an object is selected...
// In this case, a new signal is emitted to be capture
// by the relese data object and then actualize the info related with the release...
connect (_listOfReleases, SIGNAL (releaseSelectedSignal (const QString&, const QString&)),
this, SLOT (releaseSelectedAction (const QString&, const QString&)));
setLayout (listReleasesLayout);
}
void TestLevelTreeView::updateAll(void) {
collapseAll();
expandAll();
}
MainWindow::MainWindow(QWidget* parent, QString imageFilename) : QMainWindow(parent),
mUi(new Ui::MainWindow),
mContextMenu(this) {
mUi->setupUi(this);
//setup context menu for the treeview
mContextMenu.addAction(mUi->actionImport);
mContextMenu.addAction(mUi->actionExport);
mContextMenu.addSeparator();
mContextMenu.addAction(mUi->actionRename);
mContextMenu.addAction(mUi->actionDelete);
mContextMenu.addSeparator();
mContextMenu.addAction(mUi->actionEditProperties);
//setup context menu for the header
mHeaderContextMenu.addAction(mUi->actionColumnName);
mHeaderContextMenu.addAction(mUi->actionColumnSize);
mHeaderContextMenu.addAction(mUi->actionColumnPermissions);
mHeaderContextMenu.addAction(mUi->actionColumnAlias);
mHeaderContextMenu.addAction(mUi->actionColumnDateAccessed);
mHeaderContextMenu.addAction(mUi->actionColumnDateCreated);
mHeaderContextMenu.addAction(mUi->actionColumnDateModified);
mHeaderContextMenu.addAction(mUi->actionColumnUser);
mHeaderContextMenu.addAction(mUi->actionColumnGroup);
//get YaffsManager instance and create model
mYaffsManager = YaffsManager::getInstance();
newModel();
updateWindowTitle();
QHeaderView* headerView = mUi->treeView->header();
headerView->setContextMenuPolicy(Qt::CustomContextMenu);
headerView->setResizeMode(YaffsItem::NAME, QHeaderView::Stretch);
headerView->setResizeMode(YaffsItem::SIZE, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::PERMISSIONS, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::ALIAS, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::DATE_ACCESSED, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::DATE_CREATED, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::DATE_MODIFIED, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::USER, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::GROUP, QHeaderView::ResizeToContents);
#ifdef QT_DEBUG
headerView->setResizeMode(YaffsItem::OBJECTID, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::PARENTID, QHeaderView::ResizeToContents);
headerView->setResizeMode(YaffsItem::HEADERPOS, QHeaderView::ResizeToContents);
#endif //QT_DEBUG
mUi->treeView->hideColumn(YaffsItem::DATE_CREATED);
mUi->treeView->hideColumn(YaffsItem::DATE_ACCESSED);
mUi->actionColumnName->setEnabled(false);
mUi->actionColumnName->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::NAME));
mUi->actionColumnSize->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::SIZE));
mUi->actionColumnPermissions->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::PERMISSIONS));
mUi->actionColumnAlias->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::ALIAS));
mUi->actionColumnDateAccessed->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::DATE_ACCESSED));
mUi->actionColumnDateCreated->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::DATE_CREATED));
mUi->actionColumnDateModified->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::DATE_MODIFIED));
mUi->actionColumnUser->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::USER));
mUi->actionColumnGroup->setChecked(!mUi->treeView->isColumnHidden(YaffsItem::GROUP));
connect(headerView, SIGNAL(customContextMenuRequested(QPoint)), SLOT(on_treeViewHeader_customContextMenuRequested(QPoint)));
connect(mUi->actionExpandAll, SIGNAL(triggered()), mUi->treeView, SLOT(expandAll()));
connect(mUi->actionCollapseAll, SIGNAL(triggered()), mUi->treeView, SLOT(collapseAll()));
connect(mUi->treeView, SIGNAL(selectionChanged()), SLOT(on_treeView_selectionChanged()));
if (imageFilename.length() > 0) {
show();
openImage(imageFilename);
} else {
mUi->statusBar->showMessage(windowTitle() + " v" + VERSION);
}
mFastbootDialog = NULL;
setupActions();
}
MainWindow::MainWindow(DVRServerRepository *serverRepository, QWidget *parent)
: QMainWindow(parent), m_serverRepository(serverRepository), m_trayIcon(0)
{
Q_ASSERT(m_serverRepository);
bcApp->mainWindow = this;
connect(bcApp->eventDownloadManager(), SIGNAL(eventVideoDownloadAdded(EventVideoDownload*)),
this, SLOT(showDownloadsWindow()));
setUnifiedTitleAndToolBarOnMac(true);
resize(1100, 750);
createMenu();
updateTrayIcon();
setObjectName("MainWindow");
statusBar()->addPermanentWidget(new StatusBandwidthWidget(statusBar()));
statusBar()->addWidget(new StatusBarServerAlert(m_serverRepository, statusBar()));
#ifdef Q_OS_MAC
statusBar()->setSizeGripEnabled(false);
if (style()->inherits("QMacStyle"))
statusBar()->setFixedHeight(24);
#endif
/* Experimental toolbar */
m_mainToolbar = new QToolBar(tr("Main"));
m_mainToolbar->setMovable(false);
m_mainToolbar->setIconSize(QSize(16, 16));
m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/cassette.png")), tr("Events"), this, SLOT(showEventsWindow()));
m_expandAllServersAction = m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/expand-all.png")), tr("Expand All Servers"));
m_collapseAllServersAction = m_mainToolbar->addAction(QIcon(QLatin1String(":/icons/collapse-all.png")), tr("Collapse All Servers"));
addToolBar(Qt::TopToolBarArea, m_mainToolbar);
/* Splitters */
m_leftSplit = new MacSplitter(Qt::Horizontal);
m_centerSplit = new MacSplitter(Qt::Vertical);
/* Live view */
m_liveView = new LiveViewWindow(serverRepository, this);
/* Recent events */
QWidget *eventsWidget = createRecentEvents();
/* Layouts */
m_leftSplit->addWidget(createSourcesList());
m_leftSplit->addWidget(m_centerSplit);
m_leftSplit->setStretchFactor(1, 1);
m_leftSplit->setCollapsible(0, false);
m_leftSplit->setCollapsible(1, false);
m_centerSplit->addWidget(m_liveView);
m_centerSplit->addWidget(eventsWidget);
m_centerSplit->setStretchFactor(0, 1);
m_centerSplit->setCollapsible(0, false);
m_centerSplit->setCollapsible(1, false);
/* Set center widget */
QWidget *center = new QWidget;
QBoxLayout *centerLayout = new QVBoxLayout(center);
centerLayout->setMargin(0);
centerLayout->setSpacing(0);
centerLayout->addWidget(m_leftSplit, 1);
setCentralWidget(center);
#ifdef Q_OS_WIN
/* There is no top border on the statusbar on Windows, and we need one. */
if (style()->inherits("QWindowsStyle"))
{
QFrame *line = new QFrame;
line->setFrameStyle(QFrame::Plain | QFrame::HLine);
QPalette p = line->palette();
p.setColor(QPalette::WindowText, QColor(171, 175, 183));
line->setPalette(p);
line->setFixedHeight(1);
centerLayout->addWidget(line);
}
#endif
QSettings settings;
bcApp->liveView->setBandwidthMode(settings.value(QLatin1String("ui/liveview/bandwidthMode")).toInt());
restoreGeometry(settings.value(QLatin1String("ui/main/geometry")).toByteArray());
if (!m_centerSplit->restoreState(settings.value(QLatin1String("ui/main/centerSplit")).toByteArray()))
{
m_centerSplit->setSizes(QList<int>() << 1000 << 130);
}
if (!m_leftSplit->restoreState(settings.value(QLatin1String("ui/main/leftSplit")).toByteArray()))
{
#ifdef Q_OS_MAC
m_leftSplit->setSizes(QList<int>() << 210 << 1000);
#else
m_leftSplit->setSizes(QList<int>() << 190 << 1000);
#endif
}
m_leftSplit->setHandleWidth(2);
m_centerSplit->setHandleWidth(2);
QString lastLayout = settings.value(QLatin1String("ui/cameraArea/lastLayout"), tr("Default")).toString();
m_liveView->setLayout(lastLayout);
connect(m_liveView, SIGNAL(layoutChanged(QString)), SLOT(liveViewLayoutChanged(QString)));
connect(m_leftSplit, SIGNAL(splitterMoved(int,int)), SLOT(updateToolbarWidth()));
updateToolbarWidth();
connect(bcApp, SIGNAL(sslConfirmRequired(DVRServer*,QList<QSslError>,QSslConfiguration)),
SLOT(sslConfirmRequired(DVRServer*,QList<QSslError>,QSslConfiguration)));
connect(bcApp, SIGNAL(queryLivePaused()), SLOT(queryLivePaused()));
connect(m_serverRepository, SIGNAL(serverAdded(DVRServer*)), SLOT(onServerAdded(DVRServer*)));
foreach (DVRServer *s, m_serverRepository->servers())
onServerAdded(s);
connect(qApp, SIGNAL(aboutToQuit()), SLOT(saveSettings()));
m_sourcesList->setFocus(Qt::OtherFocusReason);
connect(m_expandAllServersAction, SIGNAL(triggered()), m_sourcesList, SLOT(expandAll()));
connect(m_collapseAllServersAction, SIGNAL(triggered()), m_sourcesList, SLOT(collapseAll()));
retranslateUI();
if (settings.value(QLatin1String("ui/saveSession"), false).toBool())
m_liveView->restoreSession();
}
QMenu* QgsAppLayerTreeViewMenuProvider::createContextMenu()
{
QMenu* menu = new QMenu;
QgsLayerTreeViewDefaultActions* actions = mView->defaultActions();
QModelIndex idx = mView->currentIndex();
if ( !idx.isValid() )
{
// global menu
menu->addAction( actions->actionAddGroup( menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionExpandTree.png" ), tr( "&Expand All" ), mView, SLOT( expandAll() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionCollapseTree.png" ), tr( "&Collapse All" ), mView, SLOT( collapseAll() ) );
// TODO: update drawing order
}
else if ( QgsLayerTreeNode* node = mView->layerTreeModel()->index2node( idx ) )
{
// layer or group selected
if ( QgsLayerTree::isGroup( node ) )
{
menu->addAction( actions->actionZoomToGroup( mCanvas, menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ),
tr( "&Set Group CRS" ), QgisApp::instance(), SLOT( legendGroupSetCRS() ) );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) );
menu->addAction( actions->actionAddGroup( menu ) );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsMapLayer* layer = QgsLayerTree::toLayer( node )->layer();
menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) );
menu->addAction( actions->actionShowInOverview( menu ) );
if ( layer && layer->type() == QgsMapLayer::RasterLayer )
{
menu->addAction( tr( "&Zoom to Best Scale (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) );
QgsRasterLayer* rasterLayer = qobject_cast<QgsRasterLayer *>( layer );
if ( rasterLayer && rasterLayer->rasterType() != QgsRasterLayer::Palette )
menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
// duplicate layer
QAction* duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
// set layer scale visibility
menu->addAction( tr( "&Set Layer Scale Visibility" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) );
// set layer crs
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ), tr( "&Set Layer CRS" ), QgisApp::instance(), SLOT( setLayerCRS() ) );
// assign layer crs to project
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp::instance(), SLOT( setProjectCRSFromLayer() ) );
// style-related actions
if ( layer && mView->selectedLayerNodes().count() == 1 )
{
QMenu* menuStyleManager = new QMenu( tr( "Styles" ) );
QgisApp* app = QgisApp::instance();
menuStyleManager->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menuStyleManager->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
}
menuStyleManager->addSeparator();
QgsMapLayerStyleGuiUtils::instance()->addStyleManagerActions( menuStyleManager, layer );
menu->addMenu( menuStyleManager );
}
menu->addSeparator();
if ( layer && layer->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( layer );
QAction *toggleEditingAction = QgisApp::instance()->actionToggleEditing();
QAction *saveLayerEditsAction = QgisApp::instance()->actionSaveActiveLayerEdits();
QAction *allEditsAction = QgisApp::instance()->actionAllEdits();
// attribute table
menu->addAction( QgsApplication::getThemeIcon( "/mActionOpenTable.png" ), tr( "&Open Attribute Table" ),
QgisApp::instance(), SLOT( attributeTable() ) );
// allow editing
int cap = vlayer->dataProvider()->capabilities();
if ( cap & QgsVectorDataProvider::EditingCapabilities )
{
if ( toggleEditingAction )
{
menu->addAction( toggleEditingAction );
toggleEditingAction->setChecked( vlayer->isEditable() );
}
if ( saveLayerEditsAction && vlayer->isModified() )
{
menu->addAction( saveLayerEditsAction );
}
}
if ( allEditsAction->isEnabled() )
menu->addAction( allEditsAction );
// disable duplication of memory layers
if ( vlayer->storageType() == "Memory storage" && mView->selectedLayerNodes().count() == 1 )
duplicateLayersAction->setEnabled( false );
// save as vector file
menu->addAction( tr( "Save As..." ), QgisApp::instance(), SLOT( saveAsFile() ) );
menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) );
if ( !vlayer->isEditable() && vlayer->dataProvider()->supportsSubsetString() )
menu->addAction( tr( "&Filter..." ), QgisApp::instance(), SLOT( layerSubsetString() ) );
menu->addAction( actions->actionShowFeatureCount( menu ) );
menu->addSeparator();
}
else if ( layer && layer->type() == QgsMapLayer::RasterLayer )
{
menu->addAction( tr( "Save As..." ), QgisApp::instance(), SLOT( saveAsRasterFile() ) );
menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) );
}
else if ( layer && layer->type() == QgsMapLayer::PluginLayer && mView->selectedLayerNodes().count() == 1 )
{
// disable duplication of plugin layers
duplicateLayersAction->setEnabled( false );
}
addCustomLayerActions( menu, layer );
if ( layer && QgsProject::instance()->layerIsEmbedded( layer->id() ).isEmpty() )
menu->addAction( tr( "&Properties" ), QgisApp::instance(), SLOT( layerProperties() ) );
if ( node->parent() != mView->layerTreeModel()->rootGroup() )
menu->addAction( actions->actionMakeTopLevel( menu ) );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
}
}
else
{
// symbology item?
}
return menu;
}
QMenu *QgsAppLayerTreeViewMenuProvider::createContextMenu()
{
QMenu *menu = new QMenu;
QgsLayerTreeViewDefaultActions *actions = mView->defaultActions();
QModelIndex idx = mView->currentIndex();
if ( !idx.isValid() )
{
// global menu
menu->addAction( actions->actionAddGroup( menu ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionExpandTree.svg" ) ), tr( "&Expand All" ), mView, SLOT( expandAll() ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionCollapseTree.svg" ) ), tr( "&Collapse All" ), mView, SLOT( collapseAll() ) );
menu->addSeparator();
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_MAPLAYER_MIME ) )
{
QAction *actionPasteLayerOrGroup = new QAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionEditPaste.svg" ) ), tr( "Paste Layer/Group" ), menu );
connect( actionPasteLayerOrGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::pasteLayer );
menu->addAction( actionPasteLayerOrGroup );
}
// TODO: update drawing order
}
else if ( QgsLayerTreeNode *node = mView->layerTreeModel()->index2node( idx ) )
{
// layer or group selected
if ( QgsLayerTree::isGroup( node ) )
{
menu->addAction( actions->actionZoomToGroup( mCanvas, menu ) );
menu->addAction( tr( "Copy Group" ), QgisApp::instance(), SLOT( copyLayer() ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_MAPLAYER_MIME ) )
{
QAction *actionPasteLayerOrGroup = new QAction( tr( "Paste Layer/Group" ), menu );
connect( actionPasteLayerOrGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::pasteLayer );
menu->addAction( actionPasteLayerOrGroup );
}
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
menu->addSeparator();
menu->addAction( actions->actionAddGroup( menu ) );
QAction *removeAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionRemoveLayer.svg" ) ), tr( "&Remove Group…" ), QgisApp::instance(), SLOT( removeLayer() ) );
removeAction->setEnabled( removeActionEnabled() );
menu->addSeparator();
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionSetCRS.png" ) ),
tr( "&Set Group CRS…" ), QgisApp::instance(), SLOT( legendGroupSetCrs() ) );
menu->addAction( tr( "&Set Group WMS Data…" ), QgisApp::instance(), SLOT( legendGroupSetWmsData() ) );
menu->addSeparator();
menu->addAction( actions->actionMutuallyExclusiveGroup( menu ) );
menu->addAction( actions->actionCheckAndAllChildren( menu ) );
menu->addAction( actions->actionUncheckAndAllChildren( menu ) );
if ( !( mView->selectedNodes( true ).count() == 1 && idx.row() == 0 ) )
{
menu->addAction( actions->actionMoveToTop( menu ) );
}
menu->addSeparator();
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
menu->addSeparator();
QMenu *menuExportGroup = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAsDefinitionGroup = new QAction( tr( "Save as Layer Definition File…" ), menuExportGroup );
connect( actionSaveAsDefinitionGroup, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportGroup->addAction( actionSaveAsDefinitionGroup );
menu->addMenu( menuExportGroup );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );
if ( layer && layer->isSpatial() )
{
menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) );
if ( vlayer )
{
QAction *actionZoomSelected = actions->actionZoomToSelection( mCanvas, menu );
actionZoomSelected->setEnabled( !vlayer->selectedFeatures().isEmpty() );
menu->addAction( actionZoomSelected );
}
menu->addAction( actions->actionShowInOverview( menu ) );
}
if ( vlayer )
menu->addAction( actions->actionShowFeatureCount( menu ) );
QAction *actionCopyLayer = new QAction( tr( "Copy Layer" ), menu );
connect( actionCopyLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::copyLayer );
menu->addAction( actionCopyLayer );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
if ( rlayer )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionZoomActual.svg" ) ), tr( "&Zoom to Native Resolution (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) );
if ( rlayer->rasterType() != QgsRasterLayer::Palette )
menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
addCustomLayerActions( menu, layer );
if ( layer && layer->type() == QgsMapLayer::VectorLayer && static_cast<QgsVectorLayer *>( layer )->providerType() == QLatin1String( "virtual" ) )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionAddVirtualLayer.svg" ) ), tr( "Edit Virtual Layer…" ), QgisApp::instance(), SLOT( addVirtualLayer() ) );
}
menu->addSeparator();
// duplicate layer
QAction *duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionDuplicateLayer.svg" ) ), tr( "&Duplicate Layer" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
QAction *removeAction = menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionRemoveLayer.svg" ) ), tr( "&Remove Layer…" ), QgisApp::instance(), SLOT( removeLayer() ) );
removeAction->setEnabled( removeActionEnabled() );
menu->addSeparator();
if ( node->parent() != mView->layerTreeModel()->rootGroup() )
menu->addAction( actions->actionMoveOutOfGroup( menu ) );
if ( !( mView->selectedNodes( true ).count() == 1 && idx.row() == 0 ) )
{
menu->addAction( actions->actionMoveToTop( menu ) );
}
QAction *checkAll = actions->actionCheckAndAllParents( menu );
if ( checkAll )
menu->addAction( checkAll );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
menu->addSeparator();
if ( vlayer )
{
QAction *toggleEditingAction = QgisApp::instance()->actionToggleEditing();
QAction *saveLayerEditsAction = QgisApp::instance()->actionSaveActiveLayerEdits();
QAction *allEditsAction = QgisApp::instance()->actionAllEdits();
// attribute table
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionOpenTable.svg" ) ), tr( "&Open Attribute Table" ),
QgisApp::instance(), SLOT( attributeTable() ) );
// allow editing
int cap = vlayer->dataProvider()->capabilities();
if ( cap & QgsVectorDataProvider::EditingCapabilities )
{
if ( toggleEditingAction )
{
menu->addAction( toggleEditingAction );
toggleEditingAction->setChecked( vlayer->isEditable() );
toggleEditingAction->setEnabled( true );
}
if ( saveLayerEditsAction && vlayer->isModified() )
{
menu->addAction( saveLayerEditsAction );
}
}
if ( allEditsAction->isEnabled() )
menu->addAction( allEditsAction );
// disable duplication of memory layers
if ( vlayer->storageType() == QLatin1String( "Memory storage" ) && mView->selectedLayerNodes().count() == 1 )
duplicateLayersAction->setEnabled( false );
if ( vlayer->dataProvider()->supportsSubsetString() )
{
QAction *action = menu->addAction( tr( "&Filter…" ), QgisApp::instance(), SLOT( layerSubsetString() ) );
action->setEnabled( !vlayer->isEditable() );
}
}
menu->addSeparator();
if ( layer && layer->isSpatial() )
{
// set layer scale visibility
menu->addAction( tr( "&Set Layer Scale Visibility…" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) );
if ( !layer->isInScaleRange( mCanvas->scale() ) )
menu->addAction( tr( "Zoom to &Visible Scale" ), QgisApp::instance(), SLOT( zoomToLayerScale() ) );
QMenu *menuSetCRS = new QMenu( tr( "Set CRS" ), menu );
// set layer crs
QAction *actionSetLayerCrs = new QAction( tr( "Set Layer CRS…" ), menuSetCRS );
connect( actionSetLayerCrs, &QAction::triggered, QgisApp::instance(), &QgisApp::setLayerCrs );
menuSetCRS->addAction( actionSetLayerCrs );
// assign layer crs to project
QAction *actionSetProjectCrs = new QAction( tr( "Set &Project CRS from Layer" ), menuSetCRS );
connect( actionSetProjectCrs, &QAction::triggered, QgisApp::instance(), &QgisApp::setProjectCrsFromLayer );
menuSetCRS->addAction( actionSetProjectCrs );
menu->addMenu( menuSetCRS );
}
menu->addSeparator();
if ( vlayer )
{
// save as vector file
QMenu *menuExportVector = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAs = new QAction( tr( "Save Features As…" ), menuExportVector );
connect( actionSaveAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile(); } );
menuExportVector->addAction( actionSaveAs );
QAction *actionSaveSelectedFeaturesAs = new QAction( tr( "Save Selected Features As…" ), menuExportVector );
connect( actionSaveSelectedFeaturesAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile( nullptr, true ); } );
actionSaveSelectedFeaturesAs->setEnabled( vlayer->selectedFeatureCount() > 0 );
menuExportVector->addAction( actionSaveSelectedFeaturesAs );
QAction *actionSaveAsDefinitionLayer = new QAction( tr( "Save as Layer Definition File…" ), menuExportVector );
connect( actionSaveAsDefinitionLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportVector->addAction( actionSaveAsDefinitionLayer );
if ( vlayer->isSpatial() )
{
QAction *actionSaveStyle = new QAction( tr( "Save as QGIS Layer Style File…" ), menuExportVector );
connect( actionSaveStyle, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveStyleFile(); } );
menuExportVector->addAction( actionSaveStyle );
}
menu->addMenu( menuExportVector );
}
else if ( rlayer )
{
QMenu *menuExportRaster = new QMenu( tr( "Export" ), menu );
QAction *actionSaveAs = new QAction( tr( "Save As…" ), menuExportRaster );
QAction *actionSaveAsDefinitionLayer = new QAction( tr( "Save as Layer Definition File…" ), menuExportRaster );
QAction *actionSaveStyle = new QAction( tr( "Save as QGIS Layer Style File…" ), menuExportRaster );
connect( actionSaveAs, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveAsFile(); } );
menuExportRaster->addAction( actionSaveAs );
connect( actionSaveAsDefinitionLayer, &QAction::triggered, QgisApp::instance(), &QgisApp::saveAsLayerDefinition );
menuExportRaster->addAction( actionSaveAsDefinitionLayer );
connect( actionSaveStyle, &QAction::triggered, QgisApp::instance(), [ = ] { QgisApp::instance()->saveStyleFile(); } );
menuExportRaster->addAction( actionSaveStyle );
menu->addMenu( menuExportRaster );
}
else if ( layer && layer->type() == QgsMapLayer::PluginLayer && mView->selectedLayerNodes().count() == 1 )
{
// disable duplication of plugin layers
duplicateLayersAction->setEnabled( false );
}
menu->addSeparator();
// style-related actions
if ( layer && mView->selectedLayerNodes().count() == 1 )
{
menu->addSeparator();
QMenu *menuStyleManager = new QMenu( tr( "Styles" ), menu );
QgisApp *app = QgisApp::instance();
menuStyleManager->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menuStyleManager->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
}
menuStyleManager->addSeparator();
QgsMapLayerStyleGuiUtils::instance()->addStyleManagerActions( menuStyleManager, layer );
if ( vlayer )
{
const QgsSingleSymbolRenderer *singleRenderer = dynamic_cast< const QgsSingleSymbolRenderer * >( vlayer->renderer() );
if ( !singleRenderer && vlayer->renderer() && vlayer->renderer()->embeddedRenderer() )
{
singleRenderer = dynamic_cast< const QgsSingleSymbolRenderer * >( vlayer->renderer()->embeddedRenderer() );
}
if ( singleRenderer && singleRenderer->symbol() )
{
//single symbol renderer, so add set color/edit symbol actions
menuStyleManager->addSeparator();
QgsColorWheel *colorWheel = new QgsColorWheel( menuStyleManager );
colorWheel->setColor( singleRenderer->symbol()->color() );
QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, menuStyleManager, menuStyleManager );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setVectorSymbolColor );
//store the layer id in action, so we can later retrieve the corresponding layer
colorAction->setProperty( "layerId", vlayer->id() );
menuStyleManager->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsApplication::colorSchemeRegistry()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction *recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menuStyleManager, QStringLiteral( "symbology" ), menuStyleManager );
recentColorAction->setProperty( "layerId", vlayer->id() );
recentColorAction->setDismissOnColorSelection( false );
menuStyleManager->addAction( recentColorAction );
connect( recentColorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setVectorSymbolColor );
}
menuStyleManager->addSeparator();
QAction *editSymbolAction = new QAction( tr( "Edit Symbol…" ), menuStyleManager );
//store the layer id in action, so we can later retrieve the corresponding layer
editSymbolAction->setProperty( "layerId", vlayer->id() );
connect( editSymbolAction, &QAction::triggered, this, &QgsAppLayerTreeViewMenuProvider::editVectorSymbol );
menuStyleManager->addAction( editSymbolAction );
}
}
menu->addMenu( menuStyleManager );
}
else
{
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
}
if ( layer && QgsProject::instance()->layerIsEmbedded( layer->id() ).isEmpty() )
menu->addAction( tr( "&Properties…" ), QgisApp::instance(), SLOT( layerProperties() ) );
}
}
else if ( QgsLayerTreeModelLegendNode *node = mView->layerTreeModel()->index2legendNode( idx ) )
{
if ( QgsSymbolLegendNode *symbolNode = dynamic_cast< QgsSymbolLegendNode * >( node ) )
{
// symbology item
if ( symbolNode->flags() & Qt::ItemIsUserCheckable )
{
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionShowAllLayers.svg" ) ), tr( "&Show All Items" ),
symbolNode, SLOT( checkAllItems() ) );
menu->addAction( QgsApplication::getThemeIcon( QStringLiteral( "/mActionHideAllLayers.svg" ) ), tr( "&Hide All Items" ),
symbolNode, SLOT( uncheckAllItems() ) );
menu->addSeparator();
}
if ( symbolNode->symbol() )
{
QgsColorWheel *colorWheel = new QgsColorWheel( menu );
colorWheel->setColor( symbolNode->symbol()->color() );
QgsColorWidgetAction *colorAction = new QgsColorWidgetAction( colorWheel, menu, menu );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, &QgsColorWidgetAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setSymbolLegendNodeColor );
//store the layer id and rule key in action, so we can later retrieve the corresponding
//legend node, if it still exists
colorAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
colorAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
menu->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsApplication::colorSchemeRegistry()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction *recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menu, QStringLiteral( "symbology" ), menu );
recentColorAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
recentColorAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
recentColorAction->setDismissOnColorSelection( false );
menu->addAction( recentColorAction );
connect( recentColorAction, &QgsColorSwatchGridAction::colorChanged, this, &QgsAppLayerTreeViewMenuProvider::setSymbolLegendNodeColor );
}
menu->addSeparator();
}
QAction *editSymbolAction = new QAction( tr( "Edit Symbol…" ), menu );
//store the layer id and rule key in action, so we can later retrieve the corresponding
//legend node, if it still exists
editSymbolAction->setProperty( "layerId", symbolNode->layerNode()->layerId() );
editSymbolAction->setProperty( "ruleKey", symbolNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString() );
connect( editSymbolAction, &QAction::triggered, this, &QgsAppLayerTreeViewMenuProvider::editSymbolLegendNodeSymbol );
menu->addAction( editSymbolAction );
}
}
return menu;
}
int QTreeView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QAbstractItemView::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: expanded((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
case 1: collapsed((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
case 2: hideColumn((*reinterpret_cast< int(*)>(_a[1]))); break;
case 3: showColumn((*reinterpret_cast< int(*)>(_a[1]))); break;
case 4: expand((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
case 5: collapse((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
case 6: resizeColumnToContents((*reinterpret_cast< int(*)>(_a[1]))); break;
case 7: sortByColumn((*reinterpret_cast< int(*)>(_a[1]))); break;
case 8: expandAll(); break;
case 9: collapseAll(); break;
case 10: expandToDepth((*reinterpret_cast< int(*)>(_a[1]))); break;
case 11: columnResized((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
case 12: columnCountChanged((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 13: columnMoved(); break;
case 14: reexpand(); break;
case 15: rowsRemoved((*reinterpret_cast< const QModelIndex(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
case 16: d_func()->_q_endAnimatedOperation(); break;
case 17: d_func()->_q_modelAboutToBeReset(); break;
case 18: d_func()->_q_sortIndicatorChanged((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< Qt::SortOrder(*)>(_a[2]))); break;
default: ;
}
_id -= 19;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< int*>(_v) = autoExpandDelay(); break;
case 1: *reinterpret_cast< int*>(_v) = indentation(); break;
case 2: *reinterpret_cast< bool*>(_v) = rootIsDecorated(); break;
case 3: *reinterpret_cast< bool*>(_v) = uniformRowHeights(); break;
case 4: *reinterpret_cast< bool*>(_v) = itemsExpandable(); break;
case 5: *reinterpret_cast< bool*>(_v) = isSortingEnabled(); break;
case 6: *reinterpret_cast< bool*>(_v) = isAnimated(); break;
case 7: *reinterpret_cast< bool*>(_v) = allColumnsShowFocus(); break;
case 8: *reinterpret_cast< bool*>(_v) = wordWrap(); break;
case 9: *reinterpret_cast< bool*>(_v) = isHeaderHidden(); break;
case 10: *reinterpret_cast< bool*>(_v) = expandsOnDoubleClick(); break;
}
_id -= 11;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setAutoExpandDelay(*reinterpret_cast< int*>(_v)); break;
case 1: setIndentation(*reinterpret_cast< int*>(_v)); break;
case 2: setRootIsDecorated(*reinterpret_cast< bool*>(_v)); break;
case 3: setUniformRowHeights(*reinterpret_cast< bool*>(_v)); break;
case 4: setItemsExpandable(*reinterpret_cast< bool*>(_v)); break;
case 5: setSortingEnabled(*reinterpret_cast< bool*>(_v)); break;
case 6: setAnimated(*reinterpret_cast< bool*>(_v)); break;
case 7: setAllColumnsShowFocus(*reinterpret_cast< bool*>(_v)); break;
case 8: setWordWrap(*reinterpret_cast< bool*>(_v)); break;
case 9: setHeaderHidden(*reinterpret_cast< bool*>(_v)); break;
case 10: setExpandsOnDoubleClick(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 11;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 11;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 11;
}
#endif // QT_NO_PROPERTIES
return _id;
}
MainWindow::MainWindow(QApplication &app, ElementDatabase& db)
: QMainWindow(),
Ui::MainWindow(),
mApp(&app),
mCompleter(NULL),
mLangPath(":/lang"),
mInputData(db),
mDB(&db),
mDataVisualizer(this, db)
{
mApp->installTranslator(&mTranslator);
#ifdef DEBUG
if ( ! mLangPath.exists() )
std::cerr << "Unable to determine language directory !" << std::endl;
#endif
setupUi(this);
mFormulaDefaultPalette = ntrFormula->palette();
tblResult->setModel(&mModel);
// action setup (menu bar)
menuFile = new QMenu(menubar);
menuTools = new QMenu(menubar);
menuLang = new QMenu(menubar);
menuHelp = new QMenu(menubar);
addActions();
connect(actionQuit, SIGNAL(triggered()), &app, SLOT(quit()));
connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
connect(actionAbout_Qt, SIGNAL(triggered()), &app, SLOT(aboutQt()));
connect(actionAbout, SIGNAL(triggered()), this, SLOT(about()));
connect(actionVisualizeData, SIGNAL(triggered()), &mDataVisualizer, SLOT(show()));
connect(actionUseSystemLocale, SIGNAL(triggered()), this, SLOT(useSystemLocaleTriggered()));
selectDefaultLang();
actionUseSystemLocale->trigger();
// action setup result table
connect(actionExpandAll, SIGNAL(triggered()), this, SLOT(expandAll()));
connect(actionCollapseAll, SIGNAL(triggered()), this, SLOT(collapseAll()));
connect(actionSelectAll, SIGNAL(triggered()), tblResult, SLOT(selectAll()));
connect(actionCopySelection, SIGNAL(triggered()), this, SLOT(copyResultTableSelection()));
connect(tblResult, SIGNAL(expanded(const QModelIndex&)), this, SLOT(expandItem(const QModelIndex&)));
connect(tblResult, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(expandItem(const QModelIndex&)));
// populate list of all known GUI input fields
mFormEntries.append(FormEntry(ntrFormula, "currentText", lblFormula));
mFormEntries.append(FormEntry(ntrDensity, "value", lblDensity));
mFormEntries.append(FormEntry(ntrXrayEn, "value", lblXrayEn));
mFormEntries.append(FormEntry(ntrNeutronWl, "value", lblNeutronWl));
saveInitialInput();
// button connectors
connect(btnClear, SIGNAL(clicked()), this, SLOT(resetInput()));
connect(btnAddAlias, SIGNAL(clicked()), this, SLOT(addAlias()));
connect(btnCalc, SIGNAL(clicked()), this, SLOT(doCalc()));
if (ntrFormula->lineEdit()) {
mCompleter = new FormulaCompleter(db, ntrFormula->lineEdit(), btnCalc);
connect(ntrFormula->lineEdit(), SIGNAL(returnPressed()), btnCalc, SLOT(animateClick()));
}
connect(ntrDensity, SIGNAL(editingFinished()), btnCalc, SLOT(animateClick()));
connect(ntrXrayEn, SIGNAL(editingFinished()), btnCalc, SLOT(animateClick()));
connect(ntrNeutronWl, SIGNAL(editingFinished()), btnCalc, SLOT(animateClick()));
connect(lblFormattedFormula, SIGNAL(linkActivated(const QString&)),
this, SLOT(showElementData(const QString&)));
connect(&mDataVisualizer, SIGNAL(elementLinkActivated(const QString&)),
this, SLOT(showElementData(const QString&)));
}
QMenu* QgsAppLayerTreeViewMenuProvider::createContextMenu()
{
QMenu* menu = new QMenu;
QgsLayerTreeViewDefaultActions* actions = mView->defaultActions();
QModelIndex idx = mView->currentIndex();
if ( !idx.isValid() )
{
// global menu
menu->addAction( actions->actionAddGroup( menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionExpandTree.svg" ), tr( "&Expand All" ), mView, SLOT( expandAll() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionCollapseTree.svg" ), tr( "&Collapse All" ), mView, SLOT( collapseAll() ) );
// TODO: update drawing order
}
else if ( QgsLayerTreeNode* node = mView->layerTreeModel()->index2node( idx ) )
{
// layer or group selected
if ( QgsLayerTree::isGroup( node ) )
{
menu->addAction( actions->actionZoomToGroup( mCanvas, menu ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ),
tr( "&Set Group CRS" ), QgisApp::instance(), SLOT( legendGroupSetCRS() ) );
menu->addAction( actions->actionRenameGroupOrLayer( menu ) );
menu->addAction( tr( "&Set Group WMS data" ), QgisApp::instance(), SLOT( legendGroupSetWMSData() ) );
menu->addAction( actions->actionMutuallyExclusiveGroup( menu ) );
if ( mView->selectedNodes( true ).count() >= 2 )
menu->addAction( actions->actionGroupSelected( menu ) );
if ( QgisApp::instance()->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menu->addAction( tr( "Paste Style" ), QgisApp::instance(), SLOT( applyStyleToGroup() ) );
}
menu->addAction( tr( "Save As Layer Definition File..." ), QgisApp::instance(), SLOT( saveAsLayerDefinition() ) );
menu->addAction( actions->actionAddGroup( menu ) );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );
menu->addAction( actions->actionZoomToLayer( mCanvas, menu ) );
menu->addAction( actions->actionShowInOverview( menu ) );
if ( rlayer )
{
menu->addAction( QgsApplication::getThemeIcon( "/mActionZoomActual.svg" ), tr( "&Zoom to Native Resolution (100%)" ), QgisApp::instance(), SLOT( legendLayerZoomNative() ) );
if ( rlayer->rasterType() != QgsRasterLayer::Palette )
menu->addAction( tr( "&Stretch Using Current Extent" ), QgisApp::instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
menu->addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
// duplicate layer
QAction* duplicateLayersAction = menu->addAction( QgsApplication::getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
if ( layer && layer->isSpatial() )
{
// set layer scale visibility
menu->addAction( tr( "&Set Layer Scale Visibility" ), QgisApp::instance(), SLOT( setLayerScaleVisibility() ) );
if ( !layer->isInScaleRange( mCanvas->scale() ) )
menu->addAction( tr( "Zoom to &Visible Scale" ), QgisApp::instance(), SLOT( zoomToLayerScale() ) );
// set layer crs
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ), tr( "Set Layer CRS" ), QgisApp::instance(), SLOT( setLayerCRS() ) );
// assign layer crs to project
menu->addAction( QgsApplication::getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp::instance(), SLOT( setProjectCRSFromLayer() ) );
}
// style-related actions
if ( layer && mView->selectedLayerNodes().count() == 1 )
{
QMenu *menuStyleManager = new QMenu( tr( "Styles" ), menu );
QgisApp *app = QgisApp::instance();
menuStyleManager->addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
if ( app->clipboard()->hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
{
menuStyleManager->addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
}
menuStyleManager->addSeparator();
QgsMapLayerStyleGuiUtils::instance()->addStyleManagerActions( menuStyleManager, layer );
if ( vlayer )
{
const QgsSingleSymbolRendererV2* singleRenderer = dynamic_cast< const QgsSingleSymbolRendererV2* >( vlayer->rendererV2() );
if ( !singleRenderer && vlayer->rendererV2()->embeddedRenderer() )
{
singleRenderer = dynamic_cast< const QgsSingleSymbolRendererV2* >( vlayer->rendererV2()->embeddedRenderer() );
}
if ( singleRenderer && singleRenderer->symbol() )
{
//single symbol renderer, so add set color/edit symbol actions
menuStyleManager->addSeparator();
QgsColorWheel* colorWheel = new QgsColorWheel( menuStyleManager );
colorWheel->setColor( singleRenderer->symbol()->color() );
QgsColorWidgetAction* colorAction = new QgsColorWidgetAction( colorWheel, menuStyleManager, menuStyleManager );
colorAction->setDismissOnColorSelection( false );
connect( colorAction, SIGNAL( colorChanged( const QColor& ) ), this, SLOT( setVectorSymbolColor( const QColor& ) ) );
//store the layer id in action, so we can later retrieve the corresponding layer
colorAction->setProperty( "layerId", vlayer->id() );
menuStyleManager->addAction( colorAction );
//add recent colors action
QList<QgsRecentColorScheme *> recentSchemes;
QgsColorSchemeRegistry::instance()->schemes( recentSchemes );
if ( !recentSchemes.isEmpty() )
{
QgsColorSwatchGridAction* recentColorAction = new QgsColorSwatchGridAction( recentSchemes.at( 0 ), menuStyleManager, "symbology", menuStyleManager );
recentColorAction->setProperty( "layerId", vlayer->id() );
recentColorAction->setDismissOnColorSelection( false );
menuStyleManager->addAction( recentColorAction );
connect( recentColorAction, SIGNAL( colorChanged( const QColor& ) ), this, SLOT( setVectorSymbolColor( const QColor& ) ) );
}
menuStyleManager->addSeparator();
QAction* editSymbolAction = new QAction( tr( "Edit Symbol..." ), menuStyleManager );
//store the layer id in action, so we can later retrieve the corresponding layer
editSymbolAction->setProperty( "layerId", vlayer->id() );
connect( editSymbolAction, SIGNAL( triggered() ), this, SLOT( editVectorSymbol() ) );
menuStyleManager->addAction( editSymbolAction );
}
}
menu->addMenu( menuStyleManager );
}
void TorrentTabFilesWidget::on_FilesView__customContextMenuRequested (const QPoint& pos)
{
const auto itm = Core::Instance ()->GetProxy ()->GetIconThemeManager ();
QMenu menu;
const auto& selected = GetSelectedIndexes ();
const auto& openable = Util::Filter (selected,
[] (const QModelIndex& idx)
{
const auto progress = idx.data (TorrentFilesModel::RoleProgress).toDouble ();
return idx.model ()->rowCount (idx) ||
std::abs (progress - 1) < std::numeric_limits<double>::epsilon ();
});
if (!openable.isEmpty ())
{
const auto& openActName = openable.size () == 1 ?
tr ("Open file") :
tr ("Open %n file(s)", 0, openable.size ());
const auto openAct = menu.addAction (openActName);
openAct->setIcon (itm->GetIcon ("document-open"));
new Util::SlotClosure<Util::DeleteLaterPolicy>
{
[openable, this]
{
for (const auto& idx : openable)
CurrentFilesModel_->HandleFileActivated (ProxyModel_->mapToSource (idx));
},
openAct,
SIGNAL (triggered ()),
openAct
};
menu.addSeparator ();
}
const auto& cachedRoots = Util::Map (selected,
[] (const QModelIndex& idx)
{
return qMakePair (idx, idx.data (TorrentFilesModel::RoleFullPath).toString ());
});
const auto& priorityRoots = Util::Map (Util::Filter (cachedRoots,
[&cachedRoots] (const QPair<QModelIndex, QString>& idxPair)
{
return std::none_of (cachedRoots.begin (), cachedRoots.end (),
[&idxPair] (const QPair<QModelIndex, QString>& existing)
{
return idxPair.first != existing.first &&
idxPair.second.startsWith (existing.second);
});
}),
[] (const QPair<QModelIndex, QString>& idxPair)
{
return idxPair.first
.sibling (idxPair.first.row (), TorrentFilesModel::ColumnPriority);
});
if (!priorityRoots.isEmpty ())
{
const auto subMenu = menu.addMenu (tr ("Change priority"));
const QList<QPair<int, QString>> descrs
{
{ 0, tr ("File is not downloaded.") },
{ 1, tr ("Normal priority, download order depends on availability.") },
{ 2, tr ("Pieces are preferred over the pieces with same availability.") },
{ 3, tr ("Empty pieces are preferred just as much as partial pieces.") },
{ 4, tr ("Empty pieces are preferred over partial pieces with the same availability.") },
{ 5, tr ("Same as previous.") },
{ 6, tr ("Pieces are considered to have highest availability.") },
{ 7, tr ("Maximum file priority.") }
};
for (const auto& descr : descrs)
{
const auto prio = descr.first;
const auto act = subMenu->addAction (QString::number (prio) + " " + descr.second);
new Util::SlotClosure<Util::DeleteLaterPolicy>
{
[this, prio, openable]
{
for (const auto& idx : openable)
ProxyModel_->setData (idx, prio);
},
act,
SIGNAL (triggered ()),
act
};
}
}
menu.addAction (tr ("Expand all"), Ui_.FilesView_, SLOT (expandAll ()));
menu.addAction (tr ("Collapse all"), Ui_.FilesView_, SLOT (collapseAll ()));
menu.exec (Ui_.FilesView_->viewport ()->mapToGlobal (pos));
}
VSPTree::VSPTree( QString appPath, QString argument) :
m_applicationPath( appPath ),
m_settings( appPath + "/VSPTree.ini", QSettings::IniFormat )
{
QDir dir(PATH32);
QDir dir2(PATH64);
if ( dir.exists() )
{
m_profilerpath = PATH32;
}
else if ( dir2.exists() )
{
m_profilerpath = PATH64;
}
else
{
QMessageBox::critical(NULL,"Standalone Debugger not installed", "C:\\Program Files (x86)\\Microsoft Visual Studio 11.0\\Team Tools\\Performance Tools\\ does not exist");
}
QStringList env = QProcess::systemEnvironment();
env.replaceInStrings(QRegExp("^PATH=(.*)", Qt::CaseInsensitive), QString("PATH=\\1;") + m_profilerpath);
m_process.setEnvironment(env);
if ( m_settings.contains("m_lastExe") )
{
m_lastExe = m_settings.value("m_lastExe").toString();
}
if ( m_settings.contains("m_lastVSP") )
{
m_lastVSP = m_settings.value("m_lastVSP").toString();
}
if ( m_settings.contains("m_lastArguments") )
{
m_lastArguments = m_settings.value("m_lastArguments").toString();
}
m_editorPath = "";
if ( m_settings.contains("m_editorPath") )
{
m_editorPath = m_settings.value("m_editorPath").toString();
}
m_editorArguments = "<filename> -n<linenum>";
if ( m_settings.contains("m_editorArguments") )
{
m_editorArguments = m_settings.value("m_editorArguments").toString();
}
m_log = new QTextEdit();
m_log->setReadOnly(true);
connect (&m_process, SIGNAL(readyReadStandardOutput()),this, SLOT(StdOutLog()));
connect (&m_process, SIGNAL(readyReadStandardError()),this, SLOT(StdErrorLog()));
menubar = this->menuBar();
QMenu* fileMenu = menubar->addMenu("File");
QAction* openAct = fileMenu->addAction("Open VSP");
connect(openAct, SIGNAL(triggered()), this, SLOT(LoadVSPClicked()));
QAction* exitAct = fileMenu->addAction("Exit");
connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
QMenu* profilerMenu = menubar->addMenu("Profiler");
QAction* startProfilingAct = profilerMenu->addAction("Start Profiler Service");
connect(startProfilingAct, SIGNAL(triggered()), this, SLOT(StartProfiling()));
QAction* ProfileAct = profilerMenu->addAction("Profile Application");
connect(ProfileAct, SIGNAL(triggered()), this, SLOT(Profile()));
QAction* stopProfilingAct = profilerMenu->addAction("Stop Profiler Service");
connect(stopProfilingAct, SIGNAL(triggered()), this, SLOT(StopProfiling()));
QMenu* OptionsMenu = menubar->addMenu("Options");
QAction* setTextEditor = OptionsMenu->addAction("Set Text Editor");
connect(setTextEditor, SIGNAL(triggered()), this, SLOT(setTextEditor()));
m_tabWidget = new QTabWidget();
m_callTreeWidget = new QTreeWidget();
m_flatCallTreeWidget = new QTreeWidget();
m_functionSummaryTreeWidget = new QTreeWidget();
m_tabWidget->addTab(m_callTreeWidget,"CallTree");
m_tabWidget->addTab(m_flatCallTreeWidget,"CallTreeFlat");
m_tabWidget->addTab(m_functionSummaryTreeWidget,"FunctionSummary");
m_tabWidget->addTab(m_log,"Log");
m_callTreeMenu = new QMenu();
QAction* openFileAct = m_callTreeMenu->addAction("Open File");
connect(openFileAct, SIGNAL(triggered()), this, SLOT(openFile()));
QAction* expandAllAct = m_callTreeMenu->addAction("Expand All");
connect(expandAllAct, SIGNAL(triggered()), m_callTreeWidget, SLOT(expandAll()));
QAction* collapseAllAct = m_callTreeMenu->addAction("Collapse All");
connect(collapseAllAct, SIGNAL(triggered()), m_callTreeWidget, SLOT(collapseAll()));
m_flatCallTreeMenu = new QMenu();
m_flatCallTreeMenu->addAction(openFileAct);
QAction* FindInTreeAct = m_flatCallTreeMenu->addAction("Find In Tree");
connect(FindInTreeAct, SIGNAL(triggered()), this, SLOT(FindInTree()));
//threads
connect( &m_thread, SIGNAL( output( QString ) ), this, SLOT( Log( QString ) ) );
connect( &m_thread, SIGNAL( finished() ), this, SLOT( workDone() ) );
this->setCentralWidget(m_tabWidget);
this->setWindowTitle(VERSION);
this->resize(640,480);
this->show();
if ( !argument.isEmpty() )
{
LoadVSP(argument);
}
}
ThunderPanel::ThunderPanel(QWidget *parent) :
QWidget(parent),
ui(new Ui::ThunderPanel),
my_quickViewMode(true),
my_filterModel(new QSortFilterProxyModel),
my_model(new QStandardItemModel),
my_contextMenu(new QMenu(this))
{
ui->setupUi(this);
ui->filterPanel->hide();
QAction *action = new QAction (QIcon(":/resources/images/movie.png"),
tr("Preview"), this);
connect (action, SIGNAL(triggered()), SLOT(slotPreviewThisTask()));
my_contextMenu->addAction(action);
action = new QAction (tr("Download"), this);
connect (action, SIGNAL(triggered()), SLOT(slotDownloadThisTask()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (QIcon(":/resources/images/user-trash.png"),
tr("Remove selected tasks"), this);
connect (action, SIGNAL(triggered()), SLOT(slotRemoveTheseTasks()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (tr("Copy download address"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopyDownloadAddress()));
my_contextMenu->addSeparator();
my_contextMenu->addAction(action);
action = new QAction (tr("Copy source address"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopySourceAddress()));
my_contextMenu->addAction(action);
action = new QAction (tr("Copy task name"), this);
connect (action, SIGNAL(triggered()), SLOT(slotCopyTaskName()));
my_contextMenu->addAction(action);
my_contextMenu->addSeparator();
action = new QAction (tr("Collapse all"), this);
connect (action, SIGNAL(triggered()), ui->treeView, SLOT(collapseAll()));
my_contextMenu->addAction(action);
action = new QAction (tr("Expand all"), this);
connect (action, SIGNAL(triggered()), ui->treeView, SLOT(expandAll()));
my_contextMenu->addAction(action);
action = new QAction (tr("Resize Columns"), this);
connect (action, SIGNAL(triggered()), this, SLOT(slotResizeAllColumnsOfTreeView()));
my_contextMenu->addAction(action);
connect (ui->treeView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(slotShowContextMenu(QPoint)));
my_model->setHorizontalHeaderLabels(QStringList()
<< tr("Size")
<< tr("Name"));
my_filterModel->setSourceModel(my_model);
ui->treeView->setModel(my_model);
ui->treeView->resizeColumnToContents(0);
connect (ui->treeView, SIGNAL(expanded(QModelIndex)), SLOT(slotResizeFirstColumnOfTreeView()));
}
void QCSXCAD::BuildToolBar()
{
QToolBar *mainTB = addToolBar(tr("General"));
mainTB->setObjectName("General_ToolBar");
QSize TBIconSize(16,16);
mainTB->setIconSize(TBIconSize);
if (QCSX_Settings.GetEdit())
mainTB->addAction(QIcon(":/images/filenew.png"),tr("New"),this,SLOT(New()));
if (QCSX_Settings.GetEdit())
mainTB->addAction(QIcon(":/images/down.png"),tr("Import"),this,SLOT(ImportGeometry()));
mainTB->addAction(QIcon(":/images/up.png"),tr("Export"),this,SLOT(ExportGeometry()));
QToolBar *ItemTB = addToolBar(tr("Item View"));
ItemTB->setIconSize(TBIconSize);
ItemTB->setObjectName("Item_View_ToolBar");
ItemTB->addAction(tr("CollapseAll"),CSTree,SLOT(collapseAll()));
ItemTB->addAction(tr("ExpandAll"),CSTree,SLOT(expandAll()));
ItemTB->addAction(QIcon(":/images/bulb.png"),tr("ShowAll"),this,SLOT(ShowAll()));
ItemTB->addAction(QIcon(":/images/bulb_off.png"),tr("HideAll"),this,SLOT(HideAll()));
QToolBar *newObjct = NULL;
QAction* newAct = NULL;
if (QCSX_Settings.GetEdit())
{
newObjct = addToolBar(tr("add new Primitive"));
newObjct->setObjectName("New_Primitive_ToolBar");
newAct = newObjct->addAction(tr("Box"),this,SLOT(NewBox()));
newAct->setToolTip(tr("add new Box"));
newAct = newObjct->addAction(tr("MultiBox"),this,SLOT(NewMultiBox()));
newAct->setToolTip(tr("add new Multi-Box"));
newAct = newObjct->addAction(tr("Sphere"),this,SLOT(NewSphere()));
newAct->setToolTip(tr("add new Sphere"));
newAct = newObjct->addAction(tr("Cylinder"),this,SLOT(NewCylinder()));
newAct->setToolTip(tr("add new Cylinder"));
newAct = newObjct->addAction(tr("Polygon"),this,SLOT(NewPolygon()));
newAct->setToolTip(tr("add new Polygon"));
newAct = newObjct->addAction(tr("User Defined"),this,SLOT(NewUserDefined()));
newAct->setToolTip(tr("add new User Definied Primitive"));
newObjct = addToolBar(tr("add new Property"));
newObjct->setObjectName("New_Property_ToolBar");
newAct = newObjct->addAction(tr("Material"),this,SLOT(NewMaterial()));
newAct->setToolTip(tr("add new Material-Property"));
newAct = newObjct->addAction(tr("Metal"),this,SLOT(NewMetal()));
newAct->setToolTip(tr("add new Metal-Property"));
newAct = newObjct->addAction(tr("Excitation"),this,SLOT(NewExcitation()));
newAct->setToolTip(tr("add new Excitation-Property"));
newAct = newObjct->addAction(tr("ProbeBox"),this,SLOT(NewChargeBox()));
newAct->setToolTip(tr("add new Probe-Box-Property"));
newAct = newObjct->addAction(tr("ResBox"),this,SLOT(NewResBox()));
newAct->setToolTip(tr("add new Res-Box-Property"));
newAct = newObjct->addAction(tr("DumpBox"),this,SLOT(NewDumpBox()));
newAct->setToolTip(tr("add new Dump-Box-Property"));
}
newObjct = addToolBar(tr("Zoom"));
newObjct->setIconSize(TBIconSize);
newObjct->setObjectName("Zoom_ToolBar");
newAct = newObjct->addAction(QIcon(":/images/viewmagfit.png"),tr("Zoom fit"),this,SLOT(BestView()));
newAct->setToolTip("Zoom to best fit all objects");
viewPlane[0] = newObjct->addAction(GridEditor->GetNormName(0),this,SLOT(setYZ()));
viewPlane[0]->setToolTip(tr("Switch to y-z-plane view (x-normal)"));
viewPlane[1] = newObjct->addAction(GridEditor->GetNormName(1),this,SLOT(setZX()));
viewPlane[1]->setToolTip(tr("Switch to z-x-plane view (y-normal)"));
viewPlane[2] = newObjct->addAction(GridEditor->GetNormName(2),this,SLOT(setXY()));
viewPlane[2]->setToolTip(tr("Switch to x-y-plane view (z-normal)"));
addToolBarBreak();
QActionGroup* ActViewGrp = new QActionGroup(this);
newAct = newObjct->addAction(tr("2D"),this,SLOT(View2D()));
newAct->setToolTip(tr("Switch to 2D view mode"));
ActViewGrp->addAction(newAct);
newAct->setCheckable(true);
newAct = newObjct->addAction(tr("3D"),this,SLOT(View3D()));
newAct->setToolTip(tr("Switch to 3D view mode"));
ActViewGrp->addAction(newAct);
newAct->setCheckable(true);
m_PPview = newObjct->addAction(tr("PP"));
m_PPview->setToolTip(tr("Toggle parallel projection view mode"));
QObject::connect(m_PPview,SIGNAL(toggled(bool)),this,SLOT(SetParallelProjection(bool)));
m_PPview->setCheckable(true);
if (QCSX_Settings.GetEdit())
addToolBar(GridEditor->BuildToolbar());
}
