EngineListView::EngineListView( GLWidget *glWidget, QWidget *parent ) : QListView(parent), d(new EngineListViewPrivate)
{
d->glWidget = glWidget;
EngineItemModel *m = new EngineItemModel(d->glWidget, this);
if(model())
{
delete model();
}
// This should sort the engine names for user views
// It should also update dynamically as people edit names
// Somehow it doesn't work right from the start!
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel(this);
sortModel->setSourceModel(m);
setModel(sortModel);
sortModel->setSortCaseSensitivity(Qt::CaseInsensitive);
sortModel->setSortLocaleAware(true);
sortModel->setDynamicSortFilter(true);
sortModel->sort(0, Qt::AscendingOrder);
connect(this, SIGNAL(clicked(QModelIndex)),
this, SLOT(selectEngine(QModelIndex)));
// This might work for having the proxy model emit the signal, but let's keep it as-is
connect(m, SIGNAL(dataChanged(QModelIndex, QModelIndex)),
glWidget, SLOT(update()));
// improves display performance
setUniformItemSizes(true);
setAlternatingRowColors(true); // looks better
}
void MethodsTab::setObjectBaseName(const QString &baseName)
{
m_objectBaseName = baseName;
auto clientModel = new ClientMethodModel(this);
clientModel->setSourceModel(ObjectBroker::model(baseName + '.' + "methods"));
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(clientModel);
proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
proxy->setSortRole(ObjectMethodModelRole::MethodSortRole);
m_ui->methodView->setModel(proxy);
m_ui->methodView->sortByColumn(0, Qt::AscendingOrder);
m_ui->methodView->setSelectionModel(ObjectBroker::selectionModel(proxy));
m_ui->methodView->header()->setResizeMode(QHeaderView::ResizeToContents);
new SearchLineController(m_ui->methodSearchLine, proxy);
connect(m_ui->methodView, SIGNAL(doubleClicked(QModelIndex)),
SLOT(methodActivated(QModelIndex)));
connect(m_ui->methodView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(methodContextMenu(QPoint)));
m_ui->methodLog->setModel(ObjectBroker::model(baseName + '.' + "methodLog"));
m_interface = ObjectBroker::object<MethodsExtensionInterface *>(baseName + ".methodsExtension");
new PropertyBinder(m_interface, "hasObject", m_ui->methodLog, "visible");
}
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
QFrame frame;
QVBoxLayout verticalLayout;
QLineEdit filterText;
ProblemsTableModel submissions;
// add data here
QSortFilterProxyModel proxy;
proxy.setSortCaseSensitivity(Qt::CaseInsensitive);
proxy.setFilterCaseSensitivity(Qt::CaseInsensitive);
proxy.setSourceModel(&submissions);
// sort and filter by "Full name" column
proxy.setFilterKeyColumn(2);
QTableView tableView;
tableView.setModel(&proxy);
tableView.setSortingEnabled(true);
verticalLayout.addWidget(&filterText);
verticalLayout.addWidget(&tableView);
frame.setLayout(&verticalLayout);
QObject::connect(&filterText, &QLineEdit::textChanged, &proxy, &QSortFilterProxyModel::setFilterFixedString);
frame.show();
return app.exec();
}
UProcessView::UProcessView(QWidget *parent /*= 0*/)
:QTableView(parent)
,killProcessAction_(0)
,selectColumnAction_(0)
{
//设置Model。
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel(this);
UProcessModel *processModel = new UProcessModel(this);
connect(this,SIGNAL(processTerminated(unsigned int)),processModel,SLOT(refresh()));
proxyModel->setSourceModel(processModel);
proxyModel->setDynamicSortFilter(true);
proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
setModel(proxyModel);
setSortingEnabled(true);
setSelectionBehavior(QAbstractItemView::SelectRows);
horizontalHeader()->setStretchLastSection(true);
verticalHeader()->hide();
setSelectionMode(QAbstractItemView::SingleSelection);
setContextMenuPolicy(Qt::ActionsContextMenu);
setupActions();
setupConnections();
}
MainWidget::MainWidget( MainWindow* parent )
: QWidget( parent ), mMainWindow( parent )
{
// Layout
QHBoxLayout *layout = new QHBoxLayout( this );
QSplitter *topSplitter = new QSplitter( Qt::Vertical, this );
layout->addWidget( topSplitter );
QSplitter *splitter = new QSplitter( Qt::Horizontal, this );
topSplitter->addWidget( splitter );
/*
* Views
*/
// Calendar listview
mCollectionList = new Akonadi::CollectionView();
splitter->addWidget( mCollectionList );
// Event listview
mIncidenceList = new QTreeView( this );
mIncidenceList->setDragEnabled( this );
mIncidenceList->setRootIsDecorated( false );
splitter->addWidget( mIncidenceList );
// Event view
mIncidenceViewer = new CalendarSupport::IncidenceViewer( this );
topSplitter->addWidget( mIncidenceViewer );
/*
* Models
*/
// Calendar model
mCollectionModel = new Akonadi::CollectionModel( this );
mCollectionProxyModel = new Akonadi::CollectionFilterProxyModel( this );
mCollectionProxyModel->setSourceModel( mCollectionModel );
mCollectionProxyModel->addMimeTypeFilter( QString::fromLatin1( "text/calendar" ) );
// display collections sorted
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel( this );
sortModel->setDynamicSortFilter( true );
sortModel->setSortCaseSensitivity( Qt::CaseInsensitive );
sortModel->setSourceModel( mCollectionProxyModel );
// Calendar view (list of incidences)
mIncidenceModel = new CalendarSupport::KCalModel( this );
/*
* Connexion between views and models
*/
mIncidenceList->setModel( mIncidenceModel );
mCollectionList->setModel( sortModel );
/*
* React to user orders
*/
connect( mCollectionList, SIGNAL(clicked(Akonadi::Collection)),
SLOT(collectionClicked(Akonadi::Collection)) );
connect( mIncidenceList, SIGNAL(clicked(QModelIndex)), SLOT(itemActivated(QModelIndex)) );
}
static QSortFilterProxyModel* wrapInProxyModel(QAbstractItemModel* model)
{
QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel(model);
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
proxyModel->setFilterKeyColumn(-1);
return proxyModel;
}
void PropertiesTab::setObjectBaseName(const QString &baseName)
{
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
QAbstractItemModel *model = ObjectBroker::model(baseName + '.' + "properties");
proxy->setSourceModel(model);
m_ui->propertyView->setModel(proxy);
m_ui->propertyView->sortByColumn(0, Qt::AscendingOrder);
new DeferredResizeModeSetter(
m_ui->propertyView->header(), 0, QHeaderView::ResizeToContents);
m_ui->propertySearchLine->setProxy(proxy);
m_ui->propertyView->setItemDelegate(new PropertyEditorDelegate(this));
connect(m_ui->propertyView, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(propertyContextMenu(QPoint)));
EditableTypesModel *typesModel = new EditableTypesModel(this);
proxy = new QSortFilterProxyModel(this);
proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
proxy->setSourceModel(typesModel);
proxy->sort(0);
m_ui->newPropertyType->setModel(proxy);
connect(m_ui->newPropertyType, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateNewPropertyValueEditor()));
updateNewPropertyValueEditor();
connect(m_ui->newPropertyName, SIGNAL(textChanged(QString)),
this, SLOT(validateNewProperty()));
validateNewProperty();
connect(m_ui->newPropertyButton, SIGNAL(clicked()),
this, SLOT(addNewProperty()));
m_interface = ObjectBroker::object<PropertiesExtensionInterface*>(baseName + ".propertiesExtension");
new PropertyBinder(m_interface, "canAddProperty", m_ui->newPropertyBar, "visible");
m_ui->propertyView->header()->setSectionHidden(1, !m_interface->hasPropertyValues());
m_ui->propertyView->setRootIsDecorated(m_interface->hasPropertyValues());
connect(m_interface, SIGNAL(hasPropertyValuesChanged()), this, SLOT(hasValuesChanged()));
}
void KPDialog::setupPane()
{
kDebug() << "Setting up";
// Setup the core model
Akonadi::Session *session = new Akonadi::Session( "KPApplet", m_folderListWidget );
Akonadi::Monitor *monitor = new Akonadi::Monitor( m_folderListWidget );
monitor->setCollectionMonitored( Akonadi::Collection::root() );
monitor->fetchCollection( true );
monitor->setMimeTypeMonitored( "message/rfc822", true );
monitor->itemFetchScope().fetchFullPayload(true);
Akonadi::EntityTreeModel *entityModel = new Akonadi::EntityTreeModel( session, monitor, m_folderListWidget );
entityModel->setItemPopulationStrategy( Akonadi::EntityTreeModel::LazyPopulation );
// Create the collection view
m_folderListView = new Akonadi::EntityTreeView( 0, m_folderListWidget );
m_folderListView->setSelectionMode( QAbstractItemView::ExtendedSelection );
// Setup the message folders collection...
Akonadi::EntityFilterProxyModel *collectionFilter = new Akonadi::EntityFilterProxyModel( m_folderListWidget );
collectionFilter->setSourceModel( entityModel );
//collectionFilter->addMimeTypeInclusionFilter( "message/rfc822" );
collectionFilter->addMimeTypeInclusionFilter( Akonadi::Collection::mimeType() );
collectionFilter->setHeaderSet( Akonadi::EntityTreeModel::CollectionTreeHeaders );
// ... with statistics...
Akonadi::StatisticsToolTipProxyModel *statisticsProxyModel = new Akonadi::StatisticsToolTipProxyModel( m_folderListWidget );
statisticsProxyModel->setSourceModel( collectionFilter );
// ... and sortable
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel( m_folderListWidget );
sortModel->setDynamicSortFilter( true );
sortModel->setSortCaseSensitivity( Qt::CaseInsensitive );
sortModel->setSourceModel( statisticsProxyModel );
// Use the model
m_folderListView->setModel( sortModel );
entityModel->setRootCollection(Akonadi::Collection::root());
// Now make the message list multi-tab pane
m_messagePane = new MessageList::Pane( entityModel, m_folderListView->selectionModel(), m_messageListWidget );
//connect( m_messagePane, SIGNAL(messageSelected(Akonadi::Item)),
// this, SLOT(slotMessageSelected(Akonadi::Item)) );
}
KDEProviderWidget::KDEProviderWidget(QWidget* parent)
: IProjectProviderWidget(parent)
{
setLayout(new QVBoxLayout());
m_projects = new QListView(this);
QHBoxLayout* topLayout = new QHBoxLayout(this);
KFilterProxySearchLine* filterLine = new KFilterProxySearchLine(this);
KDEProjectsModel* model = new KDEProjectsModel(this);
KDEProjectsReader* reader = new KDEProjectsReader(model, model);
connect(reader, SIGNAL(downloadDone()), reader, SLOT(deleteLater()));
connect(m_projects, SIGNAL(clicked(QModelIndex)), this, SLOT(projectIndexChanged(QModelIndex)));
topLayout->addWidget(filterLine);
QPushButton* settings=new QPushButton(KIcon("configure"), i18n("Settings"), this);
settings->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
connect(settings, SIGNAL(clicked()), SLOT(showSettings()));
topLayout->addWidget(settings);
layout()->addItem(topLayout);
layout()->addWidget(m_projects);
m_dialog = new KConfigDialog(this, "settings", KDEProviderSettings::self());
m_dialog->setFaceType(KPageDialog::Auto);
QWidget* page = new QWidget(m_dialog);
Ui::KDEConfig configUi;
configUi.setupUi(page);
configUi.kcfg_gitProtocol->setProperty("kcfg_property", QByteArray("currentText"));
m_dialog->addPage(page, i18n("General") );
connect(m_dialog, SIGNAL(settingsChanged(QString)), this, SLOT(loadSettings()));
QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
proxyModel->sort(0);
proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
m_projects->setModel(proxyModel);
m_projects->setEditTriggers(QAbstractItemView::NoEditTriggers);
filterLine->setProxy(proxyModel);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
m_ui(new Ui::MainWindow)
{
m_ui->setupUi(this);
m_undoStack = new QUndoStack(this);
m_tableModel = std::make_shared<StatsTableModel>();
QSortFilterProxyModel * proxySort = new QSortFilterProxyModel();
proxySort->setSourceModel(m_tableModel.get());
m_ui->tableData->setAlternatingRowColors(true);
m_ui->tableData->setSortingEnabled(true);
m_ui->tableData->setModel(proxySort);
proxySort->setSortCaseSensitivity(Qt::CaseInsensitive);
m_ui->newDocument->setShortcut(QKeySequence(QKeySequence::New));
m_ui->openDocument->setShortcut(QKeySequence(QKeySequence::Open));
m_ui->saveDocument->setShortcut(QKeySequence(QKeySequence::Save));
m_ui->saveDocumentAs->setShortcut(QKeySequence(QKeySequence::SaveAs));
m_ui->actionInsertRow->setShortcut(QKeySequence(QKeySequence(Qt::Key_Insert)));
m_ui->actionDeleteRow->setShortcut(QKeySequence(QKeySequence::Delete));
m_undoAction = m_undoStack->createUndoAction(this, tr("&Undo"));
m_undoAction->setShortcuts(QKeySequence::Undo);
m_redoAction = m_undoStack->createRedoAction(this, tr("&Redo"));
m_redoAction->setShortcuts(QKeySequence::Redo);
m_ui->menu->addAction(m_undoAction);
m_ui->menu->addAction(m_redoAction);
connect(m_tableModel.get(), SIGNAL(editRow(int, QString, int)), this, SLOT(onEditRow(int, QString, int)));
m_document.reset(new StatsDocument(this, *m_tableModel));
}
RecipientDialog::RecipientDialog(QWidget* parent, QAbstractListModel* model) :
QDialog(parent)
{
setModal( true );
setWindowTitle( i18n("Select Recipient") );
// Add the layout to the widget
QVBoxLayout* dialogLayout = new QVBoxLayout(this);
// Add the nickname list widget
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel(this);
sortModel->setSortCaseSensitivity(Preferences::self()->sortCaseInsensitive() ? Qt::CaseInsensitive : Qt::CaseSensitive);
sortModel->setSourceModel(model);
sortModel->sort(0, Qt::AscendingOrder);
QListView* nicknameList = new QListView(this);
nicknameList->setUniformItemSizes(true);
nicknameList->setModel(sortModel);
nicknameInput = new KLineEdit(this);
dialogLayout->addWidget(nicknameList);
dialogLayout->addWidget(nicknameInput);
connect(nicknameList, &QListView::clicked, this, &RecipientDialog::newNicknameSelected);
connect(nicknameList, &QListView::doubleClicked, this, &RecipientDialog::newNicknameSelectedQuit);
QDialogButtonBox* buttonBox = new QDialogButtonBox(this);
dialogLayout->addWidget(buttonBox);
QPushButton* button = buttonBox->addButton(QDialogButtonBox::Ok);
button->setToolTip(i18n("Select nickname and close the window"));
button->setIcon(SmallIcon("dialog-ok"));
button->setShortcut(Qt::CTRL | Qt::Key_Return);
button->setDefault(true);
button = buttonBox->addButton(QDialogButtonBox::Cancel);
button->setToolTip(i18n("Close the window without changes"));
button->setIcon(SmallIcon("dialog-cancel"));
KWindowConfig::restoreWindowSize(windowHandle(), KConfigGroup(KSharedConfig::openConfig(), "DCCRecipientDialog"));
connect(buttonBox, &QDialogButtonBox::accepted, this, &RecipientDialog::slotOk);
connect(buttonBox, &QDialogButtonBox::rejected, this, &RecipientDialog::slotCancel);
}
LogBrowser::LogBrowser(QWidget *parent)
: QWidget(parent)
, m_nextID(0)
, m_actorFilterActive(false)
, m_actorFilterCheck(0)
{
m_log = new LogModel(this);
m_log->setResultType(Log::MostRecentSubjects);
QSortFilterProxyModel *filter = new QSortFilterProxyModel(this);
filter->setSourceModel(m_log);
filter->setSortCaseSensitivity(Qt::CaseInsensitive);
filter->setDynamicSortFilter(true);
filter->setFilterKeyColumn(0);
QLineEdit *searchBox = new QLineEdit(this);
searchBox->setPlaceholderText(tr("Search"));
connect(searchBox, SIGNAL(textEdited(QString)), filter, SLOT(setFilterFixedString(QString)));
QListView *view = new QListView(this);
view->setResizeMode(QListView::Adjust);
connect(view, SIGNAL(activated(QModelIndex)), this, SLOT(handleActivation(QModelIndex)));
m_logView = view;
m_logView->setModel(filter);
QVBoxLayout *layout = new QVBoxLayout(this);
m_filterLayout = new QHBoxLayout(this);
layout->addWidget(searchBox);
layout->addLayout(m_filterLayout);
layout->addWidget(m_logView);
m_actionMapper = new QSignalMapper(this);
connect(m_actionMapper, SIGNAL(mapped(int)), this, SLOT(applyFilter(int)));
DataModel::Event emptyEvent;
addEventFilter(DataModel::EventList() << emptyEvent, "All")->setChecked(true);
}
void PropertiesTab::setObjectBaseName(const QString &baseName)
{
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
QAbstractItemModel *model = ObjectBroker::model(baseName + '.' + "properties");
proxy->setSourceModel(model);
m_ui->propertyView->setModel(proxy);
m_ui->propertyView->sortByColumn(0, Qt::AscendingOrder);
new DeferredResizeModeSetter(
m_ui->propertyView->header(), 0, QHeaderView::ResizeToContents);
m_ui->propertySearchLine->setProxy(proxy);
m_ui->propertyView->setItemDelegate(new PropertyEditorDelegate(this));
connect(m_ui->propertyView, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(propertyContextMenu(QPoint)));
#if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0)
connect(m_ui->propertyView, SIGNAL(doubleClicked(QModelIndex)),
SLOT(onDoubleClick(QModelIndex)));
#endif
EditableTypesModel *typesModel = new EditableTypesModel(this);
proxy = new QSortFilterProxyModel(this);
proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
proxy->setSourceModel(typesModel);
proxy->sort(0);
m_ui->newPropertyType->setModel(proxy);
connect(m_ui->newPropertyType, SIGNAL(currentIndexChanged(int)),
this, SLOT(updateNewPropertyValueEditor()));
updateNewPropertyValueEditor();
connect(m_ui->newPropertyName, SIGNAL(textChanged(QString)),
this, SLOT(validateNewProperty()));
validateNewProperty();
connect(m_ui->newPropertyButton, SIGNAL(clicked()),
this, SLOT(addNewProperty()));
m_interface =
ObjectBroker::object<PropertiesExtensionInterface*>(baseName + ".propertiesExtension");
}
MainWindow::MainWindow(DB *db, AudioModel * audio, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
mDB(db)
{
ui->setupUi(this);
QSqlQueryModel *model = new QSqlQueryModel(this);
model->setQuery(db->work_table_query(), db->get());
ui->workDetail->setDB(db);
//QSortFilterProxyModel * sortable = new WorksSortFilterProxyModel(model);
QSortFilterProxyModel * sortable = new QSortFilterProxyModel(model);
sortable->setSourceModel(model);
sortable->setSortCaseSensitivity(Qt::CaseInsensitive);
ui->allWorks->setSessionNumber(db->current_session());
ui->allWorks->setModel(sortable);
MixerPanelView * mixer = ui->mixer;
connect(mixer, &MixerPanelView::playerValueChangedDouble, audio, &AudioModel::playerSetValueDouble);
connect(mixer, &MixerPanelView::playerValueChangedInt, audio, &AudioModel::playerSetValueInt);
connect(mixer, &MixerPanelView::playerValueChangedBool, audio, &AudioModel::playerSetValueBool);
connect(mixer, &MixerPanelView::playerTriggered, audio, &AudioModel::playerTrigger);
connect(mixer, &MixerPanelView::masterValueChangedDouble, audio, &AudioModel::masterSetValueDouble);
connect(mixer, &MixerPanelView::masterValueChangedInt, audio, &AudioModel::masterSetValueInt);
connect(mixer, &MixerPanelView::masterValueChangedBool, audio, &AudioModel::masterSetValueBool);
connect(mixer, &MixerPanelView::masterTriggered, audio, &AudioModel::masterTrigger);
connect(audio, &AudioModel::playerValueChangedDouble, mixer, &MixerPanelView::playerSetValueDouble);
connect(audio, &AudioModel::playerValueChangedInt, mixer, &MixerPanelView::playerSetValueInt);
connect(audio, &AudioModel::playerValueChangedBool, mixer, &MixerPanelView::playerSetValueBool);
connect(audio, &AudioModel::masterValueChangedDouble, mixer, &MixerPanelView::masterSetValueDouble);
connect(audio, &AudioModel::masterValueChangedInt, mixer, &MixerPanelView::masterSetValueInt);
connect(audio, &AudioModel::masterValueChangedBool, mixer, &MixerPanelView::masterSetValueBool);
connect(audio, &AudioModel::jumpUpdated, mixer, &MixerPanelView::jumpUpdate);
connect(audio, &AudioModel::jumpsCleared, mixer, &MixerPanelView::jumpsClear);
connect(audio, &AudioModel::jumpCleared, mixer, &MixerPanelView::jumpClear);
connect(ui->allWorks, &WorksTableView::workSelected, this, &MainWindow::selectWork);
ui->topSplitter->setStretchFactor(0,0);
ui->topSplitter->setStretchFactor(1,1);
ui->leftSplitter->setStretchFactor(0,1);
ui->leftSplitter->setStretchFactor(1,0);
//remove the close button for the 'all works' tab
ui->workViews->tabBar()->tabButton(0, QTabBar::RightSide)->resize(0, 0);
QToolButton * newTabButton = new QToolButton(ui->workViews);
newTabButton->setText("+");
ui->workViews->setCornerWidget(newTabButton);
mFilterCollection = new WorkFilterModelCollection(db, this);
connect(audio, &AudioModel::masterValueChangedDouble, mFilterCollection, &WorkFilterModelCollection::masterSetValueDouble);
//XXX do history
connect(newTabButton, &QToolButton::clicked, [this]() { addFilterTab(); });
connect(ui->workViews, &QTabWidget::tabCloseRequested, [this] (int index) {
ui->workViews->removeTab(index);
});
//we always want the visible selection to be what gets loaded if we hit load
connect(ui->workViews, &QTabWidget::currentChanged, [this] (int index) {
QWidget * tab = ui->workViews->widget(index);
if (!tab)
return;
if (tab == ui->allWorksTab) {
ui->allWorks->emitSelected();
return;
}
WorkFilterView * fv = dynamic_cast<WorkFilterView *>(tab);
if (fv) {
fv->emitSelected();
return;
}
});
QTimer::singleShot(0, this, SLOT(readSettings()));
TagModel * tagmodel = new TagModel(mDB, this);
tagmodel->showAllTags(true);
ui->tags->setModel(tagmodel);
connect(ui->tags, &TagsView::newTagRequested, tagmodel, &TagModel::createTag);
connect(tagmodel, &TagModel::errorCreatingTag, [this](QString errorString) {
QMessageBox::warning(this, "Error Creating Tag", errorString);
});
connect(ui->tags, &TagsView::tagDeleteRequested, tagmodel, &TagModel::deleteTags);
}
void IntroPage::createLayout()
{
QSortFilterProxyModel * mdl = new QSortFilterProxyModel;
mdl->setDynamicSortFilter(true);
mdl->setSourceModel(new UDevSerialPortModel);
mdl->setSortRole(Qt::DisplayRole);
mdl->setSortCaseSensitivity(Qt::CaseInsensitive);
mdl->sort(0, Qt::AscendingOrder);
m_cbxType = new WizardComboBox();
QLabel * lblType = new QLabel(tr("Dive Computer &Driver:"));
lblType->setBuddy(m_cbxType);
m_cbxModel = new WizardComboBox();
m_lblModel = new QLabel(tr("Dive Computer &Model:"));
m_lblModel->setBuddy(m_cbxModel);
m_cbxDevice = new WizardComboBox();
m_cbxDevice->setModel(mdl);
m_lblDevice = new QLabel(tr("&Serial Port:"));
m_lblDevice->setBuddy(m_cbxDevice);
m_txtParams = new QLineEdit(this);
m_txtParams->setHidden(true);
m_txtSerial = new QLineEdit(this);
m_txtSerial->setHidden(true);
m_txtManuf = new QLineEdit(this);
m_txtManuf->setHidden(true);
m_txtModel = new QLineEdit(this);
m_txtModel->setHidden(true);
QPushButton * btnParams = new QPushButton(tr("Configure Connection"));
btnParams->setToolTip(tr("Edit Driver Arguments"));
connect(btnParams, SIGNAL(clicked()), this, SLOT(btnParamsClicked()));
std::list<plugin_manifest_t>::const_iterator it;
for (it = m_registry->plugins().begin(); it != m_registry->plugins().end(); it++)
{
std::list<driver_manifest_t>::const_iterator itd;
for (itd = it->plugin_drivers.begin(); itd != it->plugin_drivers.end(); itd++)
m_cbxType->addItem(QString::fromStdString(itd->driver_desc), QVariant(QString::fromStdString(itd->driver_name)));
}
updateModels(0);
connect(m_cbxType, SIGNAL(currentIndexChanged(int)), this, SLOT(updateModels(int)));
QGridLayout * gbox = new QGridLayout();
gbox->addWidget(lblType, 0, 0);
gbox->addWidget(m_cbxType, 0, 1);
gbox->addWidget(m_lblModel, 1, 0);
gbox->addWidget(m_cbxModel, 1, 1);
gbox->addWidget(m_lblDevice, 2, 0);
gbox->addWidget(m_cbxDevice, 2, 1);
gbox->setColumnStretch(1, 1);
QHBoxLayout * hbox = new QHBoxLayout();
hbox->addStretch();
hbox->addWidget(btnParams);
QVBoxLayout * vbox = new QVBoxLayout();
vbox->addLayout(gbox);
vbox->addStretch();
vbox->addLayout(hbox);
setLayout(vbox);
}
PropertiesDialog::PropertiesDialog(QWidget *parent, Okular::Document *doc)
: KPageDialog( parent ), m_document( doc ), m_fontPage( 0 ),
m_fontModel( 0 ), m_fontInfo( 0 ), m_fontProgressBar( 0 ),
m_fontScanStarted( false )
{
setFaceType( Tabbed );
setCaption( i18n( "Unknown File" ) );
setButtons( Ok );
// PROPERTIES
QFrame *page = new QFrame();
KPageWidgetItem *item = addPage( page, i18n( "&Properties" ) );
item->setIcon( KIcon( "document-properties" ) );
// get document info
const Okular::DocumentInfo info = doc->documentInfo();
QFormLayout *layout = new QFormLayout( page );
// mime name based on mimetype id
QString mimeName = info.get( Okular::DocumentInfo::MimeType ).section( '/', -1 ).toUpper();
setCaption( i18n( "%1 Properties", mimeName ) );
int valMaxWidth = 100;
/* obtains the properties list, conveniently ordered */
QStringList orderedProperties;
orderedProperties << Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::FilePath )
<< Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::PagesSize )
<< Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::DocumentSize );
for (Okular::DocumentInfo::Key ks = Okular::DocumentInfo::Title;
ks <= Okular::DocumentInfo::Keywords;
ks = Okular::DocumentInfo::Key( ks+1 ) )
{
orderedProperties << Okular::DocumentInfo::getKeyString( ks );
}
foreach( const QString &ks, info.keys()) {
if ( !orderedProperties.contains( ks ) ) {
orderedProperties << ks;
}
}
for ( QStringList::Iterator it = orderedProperties.begin();
it != orderedProperties.end();
++it )
{
const QString key = *it;
const QString titleString = info.getKeyTitle( key );
const QString valueString = info.get( key );
if ( titleString.isNull() || valueString.isNull() )
continue;
// create labels and layout them
QWidget *value = NULL;
if ( key == Okular::DocumentInfo::getKeyString( Okular::DocumentInfo::MimeType ) ) {
/// for mime type fields, show icon as well
value = new QWidget( page );
/// place icon left of mime type's name
QHBoxLayout *hboxLayout = new QHBoxLayout( value );
hboxLayout->setMargin( 0 );
/// retrieve icon and place it in a QLabel
KMimeType::Ptr mimeType = KMimeType::mimeType( valueString );
KSqueezedTextLabel *squeezed;
if (!mimeType.isNull()) {
/// retrieve icon and place it in a QLabel
QLabel *pixmapLabel = new QLabel( value );
hboxLayout->addWidget( pixmapLabel, 0 );
pixmapLabel->setPixmap( KIconLoader::global()->loadMimeTypeIcon( mimeType->iconName(), KIconLoader::Small ) );
/// mime type's name and label
squeezed = new KSqueezedTextLabel( i18nc( "mimetype information, example: \"PDF Document (application/pdf)\"", "%1 (%2)", mimeType->comment(), valueString ), value );
} else {
/// only mime type name
squeezed = new KSqueezedTextLabel( valueString, value );
}
squeezed->setTextInteractionFlags( Qt::TextSelectableByMouse );
hboxLayout->addWidget( squeezed, 1 );
} else {
/// default for any other document information
KSqueezedTextLabel *label = new KSqueezedTextLabel( valueString, page );
label->setTextInteractionFlags( Qt::TextSelectableByMouse );
value = label;
}
layout->addRow( new QLabel( i18n( "%1:", titleString ) ), value);
// refine maximum width of 'value' labels
valMaxWidth = qMax( valMaxWidth, fontMetrics().width( valueString ) );
}
// FONTS
QVBoxLayout *page2Layout = 0;
if ( doc->canProvideFontInformation() ) {
// create fonts tab and layout it
QFrame *page2 = new QFrame();
m_fontPage = addPage(page2, i18n("&Fonts"));
m_fontPage->setIcon( KIcon( "preferences-desktop-font" ) );
page2Layout = new QVBoxLayout(page2);
page2Layout->setMargin(marginHint());
page2Layout->setSpacing(spacingHint());
// add a tree view
QTreeView *view = new QTreeView(page2);
view->setContextMenuPolicy(Qt::CustomContextMenu);
connect(view, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showFontsMenu(QPoint)));
page2Layout->addWidget(view);
view->setRootIsDecorated(false);
view->setAlternatingRowColors(true);
view->setSortingEnabled( true );
// creating a proxy model so we can sort the data
QSortFilterProxyModel *proxymodel = new QSortFilterProxyModel(view);
proxymodel->setDynamicSortFilter( true );
proxymodel->setSortCaseSensitivity( Qt::CaseInsensitive );
m_fontModel = new FontsListModel(view);
proxymodel->setSourceModel(m_fontModel);
view->setModel(proxymodel);
view->sortByColumn( 0, Qt::AscendingOrder );
m_fontInfo = new QLabel( this );
page2Layout->addWidget( m_fontInfo );
m_fontInfo->setText( i18n( "Reading font information..." ) );
m_fontInfo->hide();
m_fontProgressBar = new QProgressBar( this );
page2Layout->addWidget( m_fontProgressBar );
m_fontProgressBar->setRange( 0, 100 );
m_fontProgressBar->setValue( 0 );
m_fontProgressBar->hide();
}
// current width: left columnt + right column + dialog borders
int width = layout->minimumSize().width() + valMaxWidth + 2 * marginHint() + spacingHint() + 30;
if ( page2Layout )
width = qMax( width, page2Layout->sizeHint().width() + marginHint() + spacingHint() + 31 );
// stay inside the 2/3 of the screen width
QRect screenContainer = KGlobalSettings::desktopGeometry( this );
width = qMin( width, 2*screenContainer.width()/3 );
resize(width, 1);
connect( pageWidget(), SIGNAL(currentPageChanged(KPageWidgetItem*,KPageWidgetItem*)),
this, SLOT(pageChanged(KPageWidgetItem*,KPageWidgetItem*)) );
}
//-----------------------------------------------------------------------------
// Function: ModelParameterEditor()
//-----------------------------------------------------------------------------
ModelParameterEditor::ModelParameterEditor(QSharedPointer<Component> component, LibraryInterface* handler,
QSharedPointer<ParameterFinder> parameterFinder, QSharedPointer<ExpressionFormatter> expressionFormatter,
QWidget *parent):
ItemEditor(component, handler, parent),
view_(0),
model_(0)
{
QSharedPointer<EditableTableView> parametersView(new EditableTableView(this));
parametersView->verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
parametersView->verticalHeader()->show();
view_ = new ColumnFreezableTable(1, parametersView, this);
QSharedPointer<IPXactSystemVerilogParser> expressionParser(new IPXactSystemVerilogParser(parameterFinder));
model_ = new ModelParameterModel(component->getModelParameters(), component->getChoices(), expressionParser,
parameterFinder, expressionFormatter, this);
ComponentParameterModel* componentParametersModel = new ComponentParameterModel(parameterFinder, this);
componentParametersModel->setExpressionParser(expressionParser);
ParameterCompleter* parameterCompleter = new ParameterCompleter(this);
parameterCompleter->setModel(componentParametersModel);
connect(model_, SIGNAL(contentChanged()),
this, SIGNAL(contentChanged()), Qt::UniqueConnection);
connect(model_, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
this, SLOT(modelDataChanged(const QModelIndex&)), Qt::UniqueConnection);
connect(model_, SIGNAL(errorMessage(const QString&)),
this, SIGNAL(errorMessage(const QString&)), Qt::UniqueConnection);
connect(model_, SIGNAL(noticeMessage(const QString&)),
this, SIGNAL(noticeMessage(const QString&)), Qt::UniqueConnection);
connect(view_, SIGNAL(addItem(const QModelIndex&)),
model_, SLOT(onAddItem(const QModelIndex&)), Qt::UniqueConnection);
connect(view_, SIGNAL(removeItem(const QModelIndex&)),
model_, SLOT(onRemoveItem(const QModelIndex&)), Qt::UniqueConnection);
const QString compPath = ItemEditor::handler()->getDirectoryPath(*ItemEditor::component()->getVlnv());
QString defPath = QString("%1/modelParamList.csv").arg(compPath);
ModelParameterEditorHeaderView* modelParameterHorizontalHeader =
new ModelParameterEditorHeaderView(Qt::Horizontal, this);
view_->setHorizontalHeader(modelParameterHorizontalHeader);
view_->horizontalHeader()->setSectionsClickable(true);
view_->horizontalHeader()->setStretchLastSection(true);
view_->setDefaultImportExportPath(defPath);
view_->setAllowImportExport(true);
// set view to be sortable
view_->setSortingEnabled(true);
// set the delegate to edit the usage column
view_->setDelegate(new ModelParameterDelegate(component->getChoices(), parameterCompleter, parameterFinder,
expressionFormatter, this));
connect(view_->itemDelegate(), SIGNAL(increaseReferences(QString)),
this, SIGNAL(increaseReferences(QString)), Qt::UniqueConnection);
connect(view_->itemDelegate(), SIGNAL(decreaseReferences(QString)),
this, SIGNAL(decreaseReferences(QString)), Qt::UniqueConnection);
connect(model_, SIGNAL(decreaseReferences(QString)),
this, SIGNAL(decreaseReferences(QString)), Qt::UniqueConnection);
connect(view_->itemDelegate(), SIGNAL(openReferenceTree(QString)),
this, SIGNAL(openReferenceTree(QString)), Qt::UniqueConnection);
// items can not be dragged
view_->setItemsDraggable(false);
QSortFilterProxyModel* sortingProxy = new QSortFilterProxyModel(this);
// set source model for proxy
sortingProxy->setSourceModel(model_);
// set proxy to be the source for the view
view_->setModel(sortingProxy);
// Set case-insensitive sorting.
sortingProxy->setSortCaseSensitivity(Qt::CaseInsensitive);
// sort the view
view_->sortByColumn(0, Qt::AscendingOrder);;
view_->setColumnHidden(ModelParameterColumns::ID, true);
// display a label on top the table
SummaryLabel* summaryLabel = new SummaryLabel(tr("Model parameters"), this);
// create the layout, add widgets to it
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(summaryLabel, 0, Qt::AlignCenter);
layout->addWidget(view_);
layout->setContentsMargins(0, 0, 0, 0);
refresh();
}
SelectionGenesWidget::SelectionGenesWidget(const UserSelection::STDataFrame &data,
QWidget *parent, Qt::WindowFlags f)
: QWidget(parent, f)
, m_ui(new Ui::genesSelectionWidget())
{
m_ui->setupUi(this);
m_ui->searchField->setClearButtonEnabled(true);
m_ui->searchField->setFixedSize(CELL_PAGE_SUB_MENU_LINE_EDIT_SIZE);
m_ui->searchField->setStyleSheet(CELL_PAGE_SUB_MENU_LINE_EDIT_STYLE);
// data model
const int columns = 2;
const int rows = data.genes.size();
QStandardItemModel *model = new QStandardItemModel(rows,columns, this);
model->setHorizontalHeaderItem(0, new QStandardItem(QString("Gene")));
model->setHorizontalHeaderItem(1, new QStandardItem(QString("Count")));
// populate
for (uword i = 0; i < data.counts.n_cols; ++i) {
const QString gene = data.genes.at(i);
const float count = sum(data.counts.col(i));
const QString count_str = QString::number(count);
QStandardItem *gene_item = new QStandardItem(gene);
gene_item->setData(gene, Qt::UserRole);
gene_item->setData(gene, Qt::DisplayRole);
model->setItem(i, 0, gene_item);
QStandardItem *count_item = new QStandardItem(count_str);
count_item->setData(count, Qt::UserRole);
count_item->setData(count_str, Qt::DisplayRole);
model->setItem(i, 1, count_item);
}
// sorting model
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setSourceModel(model);
proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
proxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
proxy->setSortRole(Qt::UserRole);
m_ui->tableview->setModel(proxy);
// settings for the table
m_ui->tableview->setSortingEnabled(true);
m_ui->tableview->setShowGrid(true);
m_ui->tableview->setWordWrap(true);
m_ui->tableview->setAlternatingRowColors(true);
m_ui->tableview->sortByColumn(0, Qt::AscendingOrder);
m_ui->tableview->setFrameShape(QFrame::StyledPanel);
m_ui->tableview->setFrameShadow(QFrame::Sunken);
m_ui->tableview->setGridStyle(Qt::SolidLine);
m_ui->tableview->setCornerButtonEnabled(false);
m_ui->tableview->setLineWidth(1);
m_ui->tableview->setSelectionBehavior(QAbstractItemView::SelectRows);
m_ui->tableview->setSelectionMode(QAbstractItemView::NoSelection);
m_ui->tableview->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_ui->tableview->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
m_ui->tableview->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
m_ui->tableview->horizontalHeader()->setSortIndicatorShown(true);
m_ui->tableview->verticalHeader()->hide();
m_ui->tableview->model()->submit(); // support for caching (speed up)
// Connect the search field signal
connect(m_ui->searchField,
&QLineEdit::textChanged,
proxy,
&QSortFilterProxyModel::setFilterFixedString);
// allow to copy the content of the table
m_ui->tableview->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_ui->tableview, &QTableView::customContextMenuRequested,
this, &SelectionGenesWidget::customMenuRequested);
}
