ConnectionsTab::ConnectionsTab(PropertyWidget *parent)
: QWidget(parent)
, ui(new Ui::ConnectionsTab)
{
m_interface = ObjectBroker::object<ConnectionsExtensionInterface *>(
parent->objectBaseName() + ".connectionsExtension");
ui->setupUi(this);
ui->inboundView->header()->setObjectName("inboundViewHeader");
ui->outboundView->header()->setObjectName("outboundViewHeader");
QSortFilterProxyModel *proxy = new ConnectionsClientProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(ObjectBroker::model(parent->objectBaseName() + ".inboundConnections"));
ui->inboundView->setModel(proxy);
ui->inboundView->sortByColumn(0, Qt::AscendingOrder);
new SearchLineController(ui->inboundSearchLine, proxy);
connect(ui->inboundView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(inboundContextMenu(QPoint)));
proxy = new ConnectionsClientProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(ObjectBroker::model(parent->objectBaseName() + ".outboundConnections"));
ui->outboundView->setModel(proxy);
ui->outboundView->sortByColumn(0, Qt::AscendingOrder);
new SearchLineController(ui->outboundSearchLine, proxy);
connect(ui->outboundView, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(outboundContextMenu(QPoint)));
}
void djvIconLibraryTest::run(const QStringList & args)
{
QWidget * window = new QWidget;
IconLibraryModel * model = new IconLibraryModel(context(), window);
QSortFilterProxyModel * proxyModel = new QSortFilterProxyModel(window);
proxyModel->setSourceModel(model);
proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
proxyModel->sort(0, Qt::AscendingOrder);
QTreeView * view = new QTreeView;
view->setRootIsDecorated(false);
view->setIconSize(context()->iconLibrary()->defaultSize());
view->setModel(proxyModel);
view->setSortingEnabled(true);
view->header()->resizeSections(QHeaderView::ResizeToContents);
view->header()->setSortIndicator(0, Qt::AscendingOrder);
djvSearchBox * searchBox = new djvSearchBox(context());
QVBoxLayout * layout = new QVBoxLayout(window);
layout->addWidget(searchBox);
layout->addWidget(view);
connect(
searchBox,
SIGNAL(textChanged(const QString &)),
proxyModel,
SLOT(setFilterFixedString(const QString &)));
window->resize(400, 600);
window->show();
}
void MainWindow::initLangs() {
// Clean combobox with languages
int langsCount = ui->comboBoxLang->count();
if (langsCount > 0)
for (int i = langsCount; i >= 0; i--) {
ui->comboBoxLang->removeItem(0);
}
QList<QString> languages;
languages = getLangugagelist();
QString lang;
foreach(lang, languages)
if (getLangName(lang) == "")
ui->comboBoxLang->addItem(lang, lang);
else
ui->comboBoxLang->addItem(getLangName(lang), lang);
// sort language list
QSortFilterProxyModel* proxy = new QSortFilterProxyModel(ui->comboBoxLang);
proxy->setSourceModel(ui->comboBoxLang->model());
ui->comboBoxLang->model()->setParent(proxy);
ui->comboBoxLang->setModel(proxy);
ui->comboBoxLang->model()->sort(0);
}
void SettingsDialog::initLangs() {
QSettings settings(QSettings::IniFormat, QSettings::UserScope,
SETTING_ORGANIZATION, SETTING_APPLICATION);
QString datapath = settings.value("Tesseract/DataPath").toString();
datapath += "tessdata";
TessTools tt;
QList<QString> languages = tt.getLanguages(datapath);
// Clean combobox with languages
int langsCount = cbLang->count();
if (langsCount > 0)
for (int i = langsCount; i >= 0; i--) {
cbLang->removeItem(0);
}
QString lang;
foreach(lang, languages)
if (getLangName(lang) == "")
cbLang->addItem(lang, lang);
else
cbLang->addItem(getLangName(lang), lang);
// sort language list
QSortFilterProxyModel* proxy = new QSortFilterProxyModel(cbLang);
proxy->setSourceModel(cbLang->model());
cbLang->model()->setParent(proxy);
cbLang->setModel(proxy);
cbLang->model()->sort(0);
}
ConfList::ConfList(XletConference *parent)
: QWidget(), m_manager(parent)
{
QVBoxLayout *vBox = new QVBoxLayout(this);
QHBoxLayout *hBox = new QHBoxLayout();
// this contains the data, unordered
m_model = new ConfListModel(this);
m_model->setObjectName("conflist_model");
QTimer * timer_display = new QTimer(this);
connect(timer_display, SIGNAL(timeout()),
m_model, SLOT(updateConfTime()));
timer_display->start(1000);
// this maps the indexes between the sorted view and the unordered model
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(m_model);
proxyModel->setDynamicSortFilter(true); /* sorts right on insertion, instead
of half a second after the window has appeared */
// this displays the sorted data
ConfListView *view = new ConfListView(this);
view->setModel(proxyModel);
view->hideColumn(ConfListModel::ID);
view->hideColumn(ConfListModel::MODERATED);
view->sortByColumn(ConfListModel::NAME, Qt::AscendingOrder);
hBox->addStretch(1);
hBox->addWidget(view, 8);
hBox->addStretch(1);
vBox->addLayout(hBox);
setLayout(vBox);
}
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");
}
QuickInspectorWidget::QuickInspectorWidget(QWidget* parent) :
QWidget(parent),
ui(new Ui::QuickInspectorWidget)
{
ObjectBroker::registerClientObjectFactoryCallback<QuickInspectorInterface*>(createQuickInspectorClient);
m_interface = ObjectBroker::object<QuickInspectorInterface*>();
connect(m_interface, SIGNAL(sceneRendered(QImage)), this, SLOT(sceneRendered(QImage)));
ui->setupUi(this);
ui->windowComboBox->setModel(ObjectBroker::model("com.kdab.GammaRay.QuickWindowModel"));
connect(ui->windowComboBox, SIGNAL(currentIndexChanged(int)), m_interface, SLOT(selectWindow(int)));
if (ui->windowComboBox->currentIndex() >= 0)
m_interface->selectWindow(ui->windowComboBox->currentIndex());
QSortFilterProxyModel *proxy = new QuickClientItemModel(this);
proxy->setSourceModel(ObjectBroker::model("com.kdab.GammaRay.QuickItemModel"));
proxy->setDynamicSortFilter(true);
ui->itemTreeView->setModel(proxy);
ui->itemTreeSearchLine->setProxy(proxy);
QItemSelectionModel* selectionModel = ObjectBroker::selectionModel(proxy);
ui->itemTreeView->setSelectionModel(selectionModel);
connect(selectionModel, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SLOT(itemSelectionChanged(QItemSelection)));
new QuickItemTreeWatcher(ui->itemTreeView);
new DeferredResizeModeSetter(ui->itemTreeView->header(), 0, QHeaderView::ResizeToContents);
ui->itemPropertyWidget->setObjectBaseName("com.kdab.GammaRay.QuickItem");
m_sceneImage = new QLabel;
ui->sceneView->setWidget(m_sceneImage);
ui->sceneView->setBackgroundRole(QPalette::Dark);
}
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();
}
int main(int argc, char *argv[])
{
qmlRegisterType<Recorder>("harbour.recorder", 1, 0, "Recorder");
qmlRegisterType<DirectoryModel>("harbour.recorder", 1, 0, "DirectoryModel");
auto app = SailfishApp::application(argc, argv);
QCoreApplication::setOrganizationName("harbour-recorder");
QCoreApplication::setOrganizationDomain("www.corne.info");
QCoreApplication::setApplicationName("Recorder");
auto view = SailfishApp::createView();
auto context = view->rootContext();
Recorder recorder;
context->setContextProperty("recorder", &recorder);
RecordingsModel sourceModel;
sourceModel.setRecorder(&recorder);
QSortFilterProxyModel recordingsModel;
recordingsModel.setSourceModel(&sourceModel);
recordingsModel.setSortRole(RecordingsModel::Modified);
recordingsModel.setDynamicSortFilter(true);
recordingsModel.sort(0, Qt::DescendingOrder);
context->setContextProperty("recordingsModel", &recordingsModel);
view->setSource(SailfishApp::pathTo("qml/harbour-recorder.qml"));
view->show();
return app->exec();
}
void tst_ModelTest::testInsertThroughProxy()
{
DynamicTreeModel *model = new DynamicTreeModel(this);
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setSourceModel(model);
new ModelTest(proxy, this);
ModelInsertCommand *insertCommand = new ModelInsertCommand(model, this);
insertCommand->setNumCols(4);
insertCommand->setStartRow(0);
insertCommand->setEndRow(9);
// Parent is QModelIndex()
insertCommand->doCommand();
insertCommand = new ModelInsertCommand(model, this);
insertCommand->setNumCols(4);
insertCommand->setAncestorRowNumbers(QList<int>() << 5);
insertCommand->setStartRow(0);
insertCommand->setEndRow(9);
insertCommand->doCommand();
ModelMoveCommand *moveCommand = new ModelMoveCommand(model, this);
moveCommand->setNumCols(4);
moveCommand->setStartRow(0);
moveCommand->setEndRow(0);
moveCommand->setDestRow(9);
moveCommand->setDestAncestors(QList<int>() << 5);
moveCommand->doCommand();
}
void Mailbox::initial(IMailProcessor& mailProcessor, MailboxModel* model, InboxType type, KeyhoteeMainWindow* parentKehoteeMainW)
{
_type = type;
_sourceModel = model;
_mailProcessor = &mailProcessor;
//enable sorting the mailbox
QSortFilterProxyModel* proxyModel = new MailSortFilterProxyModel();
proxyModel->setSourceModel(model);
ui->inbox_table->setModel(proxyModel);
//ui->inbox_table->sortByColumn(0, Qt::AscendingOrder);
//ui->inbox_table->setModel( model );
ui->inbox_table->setShowGrid(false);
ui->inbox_table->horizontalHeader()->resizeSection(MailboxModel::To, 120);
ui->inbox_table->horizontalHeader()->resizeSection(MailboxModel::Subject, 300);
ui->inbox_table->horizontalHeader()->resizeSection(MailboxModel::DateReceived, 140);
ui->inbox_table->horizontalHeader()->resizeSection(MailboxModel::From, 120);
ui->inbox_table->horizontalHeader()->resizeSection(MailboxModel::DateSent, 120);
if (_type == Inbox)
{
ui->inbox_table->horizontalHeader()->hideSection(MailboxModel::Status);
ui->inbox_table->horizontalHeader()->hideSection(MailboxModel::DateSent);
}
if (_type == Sent)
{
ui->inbox_table->horizontalHeader()->swapSections(MailboxModel::To, MailboxModel::From);
ui->inbox_table->horizontalHeader()->swapSections(MailboxModel::DateReceived, MailboxModel::DateSent);
ui->inbox_table->horizontalHeader()->hideSection(MailboxModel::DateReceived);
}
if (_type == Drafts)
{
ui->inbox_table->horizontalHeader()->swapSections(MailboxModel::To, MailboxModel::From);
ui->inbox_table->horizontalHeader()->swapSections(MailboxModel::DateReceived, MailboxModel::DateSent);
ui->inbox_table->horizontalHeader()->hideSection(MailboxModel::DateReceived);
ui->inbox_table->horizontalHeader()->hideSection(MailboxModel::Status);
}
ui->inbox_table->horizontalHeader()->setSectionsMovable(true);
ui->inbox_table->horizontalHeader()->setSortIndicatorShown(false);
ui->inbox_table->horizontalHeader()->setSectionsClickable(true);
ui->inbox_table->horizontalHeader()->setHighlightSections(true);
//connect signals for the new selection model (created by setModel call)
QItemSelectionModel* inbox_selection_model = ui->inbox_table->selectionModel();
connect(inbox_selection_model, &QItemSelectionModel::selectionChanged, this, &Mailbox::onSelectionChanged);
connect(inbox_selection_model, &QItemSelectionModel::currentChanged, this, &Mailbox::showCurrentMail);
connect(ui->inbox_table, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(onDoubleClickedItem(QModelIndex)));
connect(reply_mail, &QAction::triggered, this, &Mailbox::onReplyMail);
connect(reply_all_mail, &QAction::triggered, this, &Mailbox::onReplyAllMail);
connect(forward_mail, &QAction::triggered, this, &Mailbox::onForwardMail);
connect(delete_mail, &QAction::triggered, this, &Mailbox::onDeleteMail);
// hidden Coin Attachment Column
ui->inbox_table->hideColumn(MailboxModel::Money);
// hidden Chat Column
ui->inbox_table->hideColumn(MailboxModel::Chat);
}
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 MpcImportWindow::createDialogContent()
{
ui->setupUi(dialog);
//Signals
connect(&StelApp::getInstance(), SIGNAL(languageChanged()), this, SLOT(retranslate()));
connect(ui->closeStelWindow, SIGNAL(clicked()), this, SLOT(close()));
connect(ui->TitleBar, SIGNAL(movedTo(QPoint)), this, SLOT(handleMovedTo(QPoint)));
connect(ui->pushButtonAcquire, SIGNAL(clicked()),
this, SLOT(acquireObjectData()));
connect(ui->pushButtonAbortDownload, SIGNAL(clicked()),
this, SLOT(abortDownload()));
connect(ui->pushButtonAdd, SIGNAL(clicked()), this, SLOT(addObjects()));
connect(ui->pushButtonDiscard, SIGNAL(clicked()),
this, SLOT(discardObjects()));
connect(ui->pushButtonBrowse, SIGNAL(clicked()), this, SLOT(selectFile()));
connect(ui->comboBoxBookmarks, SIGNAL(currentIndexChanged(QString)),
this, SLOT(bookmarkSelected(QString)));
connect(ui->radioButtonFile, SIGNAL(toggled(bool)),
ui->frameFile, SLOT(setVisible(bool)));
connect(ui->radioButtonURL, SIGNAL(toggled(bool)),
ui->frameURL, SLOT(setVisible(bool)));
connect(ui->radioButtonAsteroids, SIGNAL(toggled(bool)),
this, SLOT(switchImportType(bool)));
connect(ui->radioButtonComets, SIGNAL(toggled(bool)),
this, SLOT(switchImportType(bool)));
connect(ui->pushButtonMarkAll, SIGNAL(clicked()),
this, SLOT(markAll()));
connect(ui->pushButtonMarkNone, SIGNAL(clicked()),
this, SLOT(unmarkAll()));
connect(ui->pushButtonSendQuery, SIGNAL(clicked()),
this, SLOT(sendQuery()));
connect(ui->lineEditQuery, SIGNAL(returnPressed()),
this, SLOT(sendQuery()));
connect(ui->pushButtonAbortQuery, SIGNAL(clicked()),
this, SLOT(abortQuery()));
connect(ui->lineEditQuery, SIGNAL(textEdited(QString)),
this, SLOT(resetNotFound()));
//connect(ui->lineEditQuery, SIGNAL(editingFinished()), this, SLOT(sendQuery()));
connect(countdownTimer, SIGNAL(timeout()), this, SLOT(updateCountdown()));
QSortFilterProxyModel * filterProxyModel = new QSortFilterProxyModel(this);
filterProxyModel->setSourceModel(candidateObjectsModel);
filterProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
ui->listViewObjects->setModel(filterProxyModel);
connect(ui->lineEditSearch, SIGNAL(textChanged(const QString&)),
filterProxyModel, SLOT(setFilterFixedString(const QString&)));
loadBookmarks();
updateTexts();
resetCountdown();
resetDialog();
}
ActionInspectorWidget::ActionInspectorWidget(QWidget *parent)
: QWidget(parent)
{
QAbstractItemModel *actionModel = ObjectBroker::model("com.kdab.GammaRay.ActionModel");
QSortFilterProxyModel *searchFilterProxy = new KRecursiveFilterProxyModel(this);
searchFilterProxy->setSourceModel(actionModel);
searchFilterProxy->setDynamicSortFilter(true);
m_proxy = searchFilterProxy;
QVBoxLayout *vbox = new QVBoxLayout(this);
KFilterProxySearchLine *objectSearchLine = new KFilterProxySearchLine(this);
objectSearchLine->setProxy(searchFilterProxy);
vbox->addWidget(objectSearchLine);
QTreeView *objectTreeView = new QTreeView(this);
objectTreeView->setModel(searchFilterProxy);
objectTreeView->setSortingEnabled(true);
objectTreeView->sortByColumn(ActionModel::ShortcutsPropColumn);
objectTreeView->setRootIsDecorated(false);
vbox->addWidget(objectTreeView);
connect(objectTreeView, SIGNAL(doubleClicked(QModelIndex)), SLOT(triggerAction(QModelIndex)));
mObjectTreeView = objectTreeView;
}
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();
}
NoteBrowser::NoteBrowser(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
{
m_model = new NotesModel( this );
QSortFilterProxyModel * sortingModel = new QSortFilterProxyModel( this );
sortingModel->setSourceModel( m_model );
sortingModel->setSortRole( m_model->roleForProperty( NAO::created() ) );
sortingModel->setDynamicSortFilter( true );
sortingModel->sort( 0, Qt::DescendingOrder );
m_view = new NotesView( this );
m_view->setModel( sortingModel );
connect( m_view, SIGNAL(doubleClicked(QModelIndex)),
this, SLOT(slotNoteSelected(QModelIndex)) );
Nepomuk2::Query::ResourceTypeTerm typeTerm( Nepomuk2::Types::Class( PIMO::Note() ) );
Nepomuk2::Query::ComparisonTerm compTerm( NAO::created(), Nepomuk2::Query::Term() );
compTerm.setSortWeight( 1, Qt::DescendingOrder );
m_query = typeTerm && compTerm;
//FIXME: Figure out why this stupid layout is required!
QHBoxLayout* layout = new QHBoxLayout( this );
layout->setMargin( 0 );
layout->setSpacing( 0 );
layout->addWidget( m_view );
}
FeatureTable::FeatureTable(FeatureClass* pFeatureClass, GraphicLayer* pFeatureLayer, QWidget* pParent) :
QTableView(pParent),
mpFeatureLayer(pFeatureLayer)
{
setContextMenuPolicy(Qt::CustomContextMenu);
// Allow multiple uncontiguous selections.
setSelectionBehavior(QAbstractItemView::SelectRows);
setSelectionMode(QAbstractItemView::ExtendedSelection);
// Alphanumerically sort string types.
setSortingEnabled(true);
QSortFilterProxyModel* pProxyModel = new AlphaNumericSortFilterProxyModel();
pProxyModel->setSourceModel(pFeatureClass);
pProxyModel->setDynamicSortFilter(true);
setModel(pProxyModel);
// Want to select rows in the table, when features are selected from the view's layer.
mpFeatureLayer.addSignal(SIGNAL_NAME(GraphicLayer, ObjectsSelected), Slot(this, &FeatureTable::selectRows));
// Want to select graphic objects in the view, when rows are selected in the table.
// However do not want the above connection to be utilized when the graphic objects are selected, so instead of
// overriding the selectionChanged method, a new slot is introduced which will prevent any duplicate graphic object
// selection/deselection.
if (selectionModel() != NULL)
{
VERIFYNR(connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), this,
SLOT(selectGraphicObjects(const QItemSelection&, const QItemSelection&))));
}
SpeedLimitsDlg::SpeedLimitsDlg(bt::TorrentInterface* current, Core* core, QWidget* parent)
: QDialog(parent), core(core), current(current)
{
setupUi(this);
setWindowIcon(QIcon::fromTheme("kt-speed-limits"));
setWindowTitle(i18n("Speed Limits"));
model = new SpeedLimitsModel(core, this);
QSortFilterProxyModel* pm = new QSortFilterProxyModel(this);
pm->setSourceModel(model);
pm->setSortRole(Qt::UserRole);
m_speed_limits_view->setModel(pm);
m_speed_limits_view->setItemDelegate(new SpinBoxDelegate(this));
m_speed_limits_view->setUniformRowHeights(true);
m_speed_limits_view->setSortingEnabled(true);
m_speed_limits_view->sortByColumn(0, Qt::AscendingOrder);
m_speed_limits_view->header()->setSortIndicatorShown(true);
m_speed_limits_view->header()->setClickable(true);
m_speed_limits_view->setAlternatingRowColors(true);
QPushButton* apply_btn = m_buttonBox->button(QDialogButtonBox::Apply);
apply_btn->setEnabled(false);
connect(model, &SpeedLimitsModel::enableApply, apply_btn, &QPushButton::setEnabled);
connect(apply_btn, &QPushButton::clicked, this, &SpeedLimitsDlg::apply);
connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
m_upload_rate->setValue(Settings::maxUploadRate());
m_download_rate->setValue(Settings::maxDownloadRate());
connect(m_upload_rate, SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)));
connect(m_download_rate, SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)));
connect(m_filter, SIGNAL(textChanged(QString)), pm, SLOT(setFilterFixedString(QString)));
loadState();
// if current is specified, select it and scroll to it
if (current)
{
kt::QueueManager* qman = core->getQueueManager();
int idx = 0;
QList<bt::TorrentInterface*>::iterator itr = qman->begin();
while (itr != qman->end())
{
if (*itr == current)
break;
idx++;
itr++;
}
if (itr != qman->end())
{
QItemSelectionModel* sel = m_speed_limits_view->selectionModel();
QModelIndex midx = pm->mapFromSource(model->index(idx, 0));
QModelIndex midx2 = pm->mapFromSource(model->index(idx, 4));
sel->select(QItemSelection(midx, midx2), QItemSelectionModel::Select);
m_speed_limits_view->scrollTo(midx);
}
}
}
GraphViewerWidget::GraphViewerWidget(QWidget *parent)
: QWidget(parent),
mWidget(new GraphWidget(this))
{
mModel = ObjectBroker::model("com.kdab.GammaRay.ObjectVisualizerModel");
QSortFilterProxyModel *objectFilter = new KRecursiveFilterProxyModel(this);
objectFilter->setSourceModel(mModel);
objectFilter->setDynamicSortFilter(true);
QVBoxLayout *vbox = new QVBoxLayout;
KFilterProxySearchLine *objectSearchLine = new KFilterProxySearchLine(this);
objectSearchLine->setProxy(objectFilter);
vbox->addWidget(objectSearchLine);
QTreeView *objectTreeView = new QTreeView(this);
objectTreeView->setModel(objectFilter);
objectTreeView->setSortingEnabled(true);
vbox->addWidget(objectTreeView);
mObjectTreeView = objectTreeView;
QWidget *treeViewWidget = new QWidget(this);
treeViewWidget->setLayout(vbox);
QSplitter *splitter = new QSplitter(this);
splitter->addWidget(treeViewWidget);
splitter->addWidget(mWidget);
QHBoxLayout *hbox = new QHBoxLayout(this);
hbox->addWidget(splitter);
QMetaObject::invokeMethod(this, "delayedInit", Qt::QueuedConnection);
}
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
//! [0] //! [1]
QTreeView *treeView = new QTreeView;
//! [0]
MyItemModel *model = new MyItemModel(this);
treeView->setModel(model);
//! [1]
//! [2]
MyItemModel *sourceModel = new MyItemModel(this);
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(sourceModel);
treeView->setModel(proxyModel);
//! [2]
//! [3]
treeView->setSortingEnabled(true);
//! [3]
//! [4]
proxyModel->sort(2, Qt::AscendingOrder);
//! [4] //! [5]
proxyModel->setFilterRegExp(QRegExp(".png", Qt::CaseInsensitive,
QRegExp::FixedString));
proxyModel->setFilterKeyColumn(1);
//! [5]
}
void ModelDescriptorListWidget::setModel(QAbstractItemModel *model)
{
QSortFilterProxyModel *proxyModel = qobject_cast<QSortFilterProxyModel *>(QTreeView::model());
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
expandAll();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QObject *parent = &app;
QStringList numbers;
numbers << "One" << "Two" << "Three" << "Four" << "Five";
QAbstractItemModel *stringListModel = new QStringListModel(numbers, parent);
//! [0]
QSortFilterProxyModel *filterModel = new QSortFilterProxyModel(parent);
filterModel->setSourceModel(stringListModel);
//! [0]
QWidget *window = new QWidget;
//! [1]
QListView *filteredView = new QListView;
filteredView->setModel(filterModel);
//! [1]
filteredView->setWindowTitle("Filtered view onto a string list model");
QLineEdit *patternEditor = new QLineEdit;
QObject::
connect(patternEditor, SIGNAL(textChanged(const QString &)),
filterModel, SLOT(setFilterRegExp(const QString &)));
QVBoxLayout *layout = new QVBoxLayout(window);
layout->addWidget(filteredView);
layout->addWidget(patternEditor);
window->show();
return app.exec();
}
/** Constructor */
GxsIdChooser::GxsIdChooser(QWidget *parent)
: QComboBox(parent), mFlags(IDCHOOSER_ANON_DEFAULT)
{
mBase = new RsGxsUpdateBroadcastBase(rsIdentity, this);
connect(mBase, SIGNAL(fillDisplay(bool)), this, SLOT(fillDisplay(bool)));
/* Initialize ui */
setSizeAdjustPolicy(QComboBox::AdjustToContents);
mFirstLoad = true;
mAllowedCount = 0 ;
mDefaultId.clear() ;
/* Enable sort with own role */
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setSourceModel(model());
proxy->setDynamicSortFilter(false);
model()->setParent(proxy);
setModel(proxy);
proxy->setSortRole(ROLE_SORT);
/* Connect signals */
connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(myCurrentIndexChanged(int)));
connect(this, SIGNAL(activated(int)), this, SLOT(indexActivated(int)));
}
void run_ui()
{
qmlRegisterType<QMLManager>("org.subsurfacedivelog.mobile", 1, 0, "QMLManager");
qmlRegisterType<QMLProfile>("org.subsurfacedivelog.mobile", 1, 0, "QMLProfile");
QQmlApplicationEngine engine;
engine.addImportPath("qrc://imports");
DiveListModel diveListModel;
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel(0);
sortModel->setSourceModel(&diveListModel);
sortModel->setDynamicSortFilter(true);
sortModel->setSortRole(DiveListModel::DiveDateRole);
sortModel->sort(0, Qt::DescendingOrder);
QQmlContext *ctxt = engine.rootContext();
ctxt->setContextProperty("diveModel", sortModel);
engine.load(QUrl(QStringLiteral("qrc:///qml/main.qml")));
qqWindowObject = engine.rootObjects().value(0);
if (!qqWindowObject) {
fprintf(stderr, "can't create window object\n");
exit(1);
}
QQuickWindow *qml_window = qobject_cast<QQuickWindow *>(qqWindowObject);
qml_window->setIcon(QIcon(":/subsurface-mobile-icon"));
qqWindowObject->setProperty("messageText", QVariant("Subsurface mobile startup"));
#if !defined(Q_OS_ANDROID)
qml_window->setHeight(1200);
qml_window->setWidth(800);
#endif
qml_window->show();
qApp->exec();
}
GraphViewer::GraphViewer(ProbeInterface *probe, QWidget *parent)
: QWidget(parent),
mWidget(new GraphWidget(this)),
mProbeIface(probe)
{
QSortFilterProxyModel *objectFilter = new KRecursiveFilterProxyModel(this);
objectFilter->setSourceModel(probe->objectTreeModel());
objectFilter->setDynamicSortFilter(true);
QVBoxLayout *vbox = new QVBoxLayout;
KFilterProxySearchLine *objectSearchLine = new KFilterProxySearchLine(this);
objectSearchLine->setProxy(objectFilter);
vbox->addWidget(objectSearchLine);
QTreeView *objectTreeView = new QTreeView(this);
objectTreeView->setModel(objectFilter);
objectTreeView->setSortingEnabled(true);
vbox->addWidget(objectTreeView);
connect(objectTreeView->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
SLOT(handleRowChanged(QModelIndex)));
mObjectTreeView = objectTreeView;
QWidget *treeViewWidget = new QWidget(this);
treeViewWidget->setLayout(vbox);
QSplitter *splitter = new QSplitter(this);
splitter->addWidget(treeViewWidget);
splitter->addWidget(mWidget);
QHBoxLayout *hbox = new QHBoxLayout(this);
hbox->addWidget(splitter);
QMetaObject::invokeMethod(this, "delayedInit", Qt::QueuedConnection);
}
CopyInputDialog::CopyInputDialog(QWidget* parent)
: KDialog(parent)
{
setCaption(i18n("Copy Input"));
setButtons(KDialog::Ok | KDialog::Cancel);
setWindowModality(Qt::WindowModal);
_ui = new Ui::CopyInputDialog();
_ui->setupUi(mainWidget());
connect(_ui->selectAllButton, SIGNAL(clicked()), this, SLOT(selectAll()));
connect(_ui->deselectAllButton, SIGNAL(clicked()), this, SLOT(deselectAll()));
_ui->filterEdit->setClearButtonShown(true);
_ui->filterEdit->setFocus();
_model = new CheckableSessionModel(parent);
_model->setCheckColumn(1);
_model->setSessions(SessionManager::instance()->sessions());
QSortFilterProxyModel* filterProxyModel = new QSortFilterProxyModel(this);
filterProxyModel->setDynamicSortFilter(true);
filterProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
filterProxyModel->setSourceModel(_model);
filterProxyModel->setFilterKeyColumn(-1);
connect(_ui->filterEdit, SIGNAL(textChanged(QString)),
filterProxyModel, SLOT(setFilterFixedString(QString)));
_ui->sessionList->setModel(filterProxyModel);
_ui->sessionList->setColumnHidden(0, true); // Hide number column
_ui->sessionList->header()->hide();
}
PluginManagerWidget::PluginManagerWidget(QWidget *parent)
: QWidget(parent)
, m_ui(new Ui::PluginManagerWidget)
{
m_ui->setupUi(this);
QStandardItemModel *model = new QStandardItemModel(this);
for (const QString& name : PluginLoader::instance().availablePlugins())
{
model->appendRow(new QStandardItem(PluginLoader::instance().plugin(name)->icon(),
name));
}
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel(this);
proxyModel->setSourceModel(model);
model->sort(0, Qt::AscendingOrder);
m_ui->PluginList->setModel(model);
m_ui->PluginList->setItemDelegate(new PluginWidgetDelegate(m_ui->PluginList));
m_ui->PluginList->setSelectionMode(QAbstractItemView::SingleSelection);
m_ui->PluginList->setEditTriggers(QAbstractItemView::NoEditTriggers);
connect(m_ui->PluginList,
SIGNAL(clicked(const QModelIndex&)),
this,
SLOT(onIndexChanged(const QModelIndex&)));
const QModelIndex& index =model->index(0, 0);
m_ui->PluginList->selectionModel()->select(index, QItemSelectionModel::Select);
onIndexChanged(index);
}
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)) );
}
TagFilter::TagFilter(QWidget *parent) : QWidget(parent)
{
ui.setupUi(this);
QSortFilterProxyModel *filter = new QSortFilterProxyModel();
filter->setSourceModel(TagFilterModel::instance());
connect(ui.filterTag, SIGNAL(textChanged(QString)), filter, SLOT(setFilterFixedString(QString)));
ui.tagView->setModel(filter);
}
SourceFilesHandler::SourceFilesHandler()
{
setObjectName(QLatin1String("SourceFilesModel"));
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setObjectName(QLatin1String("SourceFilesProxyModel"));
proxy->setSourceModel(this);
m_proxyModel = proxy;
}
