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)));
}
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);
}
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);
}
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&))));
}
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;
}
void ModelDescriptorListWidget::setModel(QAbstractItemModel *model)
{
QSortFilterProxyModel *proxyModel = qobject_cast<QSortFilterProxyModel *>(QTreeView::model());
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
expandAll();
}
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();
}
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();
}
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();
}
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);
}
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();
}
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
}
/** 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)));
}
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)) );
}
CaptureDialog::CaptureDialog(CaptureContext *ctx, OnCaptureMethod captureCallback,
OnInjectMethod injectCallback, QWidget *parent)
: QFrame(parent), ui(new Ui::CaptureDialog), m_Ctx(ctx)
{
ui->setupUi(this);
// setup FlowLayout for options group
{
QLayout *oldLayout = ui->optionsGroup->layout();
QObjectList options = ui->optionsGroup->children();
options.removeOne((QObject *)oldLayout);
delete oldLayout;
FlowLayout *optionsFlow = new FlowLayout(ui->optionsGroup, -1, 3, 3);
optionsFlow->setFixedGrid(true);
for(QObject *o : options)
optionsFlow->addWidget(qobject_cast<QWidget *>(o));
ui->optionsGroup->setLayout(optionsFlow);
}
ui->envVar->setEnabled(false);
m_ProcessModel = new QStandardItemModel(0, 3, this);
m_ProcessModel->setHeaderData(0, Qt::Horizontal, tr("Name"));
m_ProcessModel->setHeaderData(1, Qt::Horizontal, tr("PID"));
m_ProcessModel->setHeaderData(2, Qt::Horizontal, tr("Window Title"));
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setSourceModel(m_ProcessModel);
// filter on all columns
proxy->setFilterKeyColumn(-1);
// allow updating the underlying model
proxy->setDynamicSortFilter(true);
ui->processList->setModel(proxy);
ui->processList->setAlternatingRowColors(true);
// sort by PID by default
ui->processList->sortByColumn(1, Qt::AscendingOrder);
// TODO Vulkan Layer
ui->vulkanLayerWarn->setVisible(false);
m_CaptureCallback = captureCallback;
m_InjectCallback = injectCallback;
setSettings(CaptureSettings());
updateGlobalHook();
}
void InboundConnectionsTab::setObjectBaseName(const QString &baseName)
{
QSortFilterProxyModel *proxy = new QSortFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(ObjectBroker::model(baseName + '.' + "inboundConnections"));
m_ui->inboundConnectionView->setModel(proxy);
m_ui->inboundConnectionView->sortByColumn(0, Qt::AscendingOrder);
m_ui->inboundConnectionSearchLine->setProxy(proxy);
}
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 EnumsTab::setObjectBaseName(const QString &baseName)
{
QSortFilterProxyModel *proxy = new KRecursiveFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(ObjectBroker::model(baseName + '.' + "enums"));
m_ui->enumView->setModel(proxy);
m_ui->enumView->sortByColumn(0, Qt::AscendingOrder);
m_ui->enumView->header()->setResizeMode(QHeaderView::ResizeToContents);
m_ui->enumSearchLine->setProxy(proxy);
}
void tst_ModelTest::stringListModel()
{
QStringListModel model;
QSortFilterProxyModel proxy;
ModelTest t1(&model);
ModelTest t2(&proxy);
proxy.setSourceModel(&model);
model.setStringList(QStringList() << "2" << "3" << "1");
model.setStringList(QStringList() << "a" << "e" << "plop" << "b" << "c" );
proxy.setDynamicSortFilter(true);
proxy.setFilterRegExp(QRegExp("[^b]"));
}
CMessageDock::CMessageDock(QWidget *parent)
: QWidget(parent)
, m_countOfErrorMessages(0)
, m_countOfWarningMessages(0)
, m_countOfInfomationMessages(0)
{
QVBoxLayout* layout = new QVBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
layout->setSpacing(0);
layout->addWidget(m_toolBar = new QToolBar(this));
layout->addWidget(m_listWidget = new QTreeView(this));
QStandardItemModel* model = new QStandardItemModel();
QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel();
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(true);
proxyModel->setFilterKeyColumn(CategoryColumn);
m_listWidget->setRootIsDecorated(false);
m_listWidget->setSortingEnabled(true);
m_listWidget->setModel(proxyModel);
m_listWidget->setEditTriggers(QTreeView::NoEditTriggers);
m_listWidget->setIndentation(0);
m_listWidget->setAlternatingRowColors(true);
model->invisibleRootItem()->insertColumns(0, ColumnCount);
model->setHeaderData(CategoryColumn, Qt::Horizontal, tr("Category"));
model->setHeaderData(FileNameColumn, Qt::Horizontal, tr("File"));
model->setHeaderData(LineNoColumn, Qt::Horizontal, tr("Line"));
model->setHeaderData(DescriptionColumn, Qt::Horizontal, tr("Description"));
m_listWidget->setColumnWidth(CategoryColumn, 16 + 10/*何の値だろう？*/);
m_listWidget->setColumnWidth(FileNameColumn, m_listWidget->fontMetrics().width(QLatin1Char('9')) * 20);
m_listWidget->setColumnWidth(LineNoColumn, m_listWidget->fontMetrics().width(QLatin1Char('9')) * 5);
connect(m_listWidget, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(doubleClickedList(const QModelIndex &)));
m_toolBar->setStyleSheet("QToolBar{border:none}");
m_toolBar->setIconSize(QSize(16, 16));
m_toolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
m_visibledErrorAction = m_toolBar->addAction(QIcon(":/images/tango/small/dialog-error.png"), "");
m_toolBar->addSeparator();
m_visibledWarningAction = m_toolBar->addAction(QIcon(":/images/icons/small/software-update-urgent-yellow.png"), "");
m_toolBar->addSeparator();
m_visibledInfomationAction = m_toolBar->addAction(QIcon(":/images/tango/small/dialog-information.png"), "");
m_visibledErrorAction->setCheckable(true);
m_visibledErrorAction->setChecked(true);
m_visibledWarningAction->setCheckable(true);
m_visibledWarningAction->setChecked(true);
m_visibledInfomationAction->setCheckable(true);
m_visibledInfomationAction->setChecked(true);
connect(m_visibledErrorAction, SIGNAL(triggered()), this, SLOT(onUpdateCategoryVisibled()));
connect(m_visibledWarningAction, SIGNAL(triggered()), this, SLOT(onUpdateCategoryVisibled()));
connect(m_visibledInfomationAction, SIGNAL(triggered()), this, SLOT(onUpdateCategoryVisibled()));
updateMessagesCount();
}
MainWidget::MainWidget( MainWindow * parent ) :
QWidget( parent ), mMainWindow( parent )
{
QVBoxLayout *layout = new QVBoxLayout( this );
QSplitter *splitter = new QSplitter( Qt::Vertical, this );
layout->addWidget( splitter );
// Accounts
Akonadi::AgentInstanceModel *model = new Akonadi::AgentInstanceModel( this );
m_resourcesView = new QListView( splitter );
m_resourcesView->setModel( model );
connect( m_resourcesView, SIGNAL( clicked( const QModelIndex& ) ),
SLOT( slotCurrentResourceChanged( const QModelIndex& ) ) );
splitter->addWidget( m_resourcesView );
// Filter the collection to only show the blogs
Akonadi::AgentFilterProxyModel* proxy = new Akonadi::AgentFilterProxyModel( this );
proxy->addMimeTypeFilter( "application/x-vnd.kde.microblog" );
proxy->setSourceModel( model );
m_resourcesView->setModel( proxy );
// Bottom part
KVBox* box = new KVBox( splitter );
// Folders
m_tabBar = new AkonadiTabBar( box );
connect( m_tabBar, SIGNAL( currentChanged( const Akonadi::Collection& ) ),
SLOT( slotCurrentTabChanged( const Akonadi::Collection& ) ) );
mMessageList = new QTreeView( box );
mMessageList->setRootIsDecorated( false );
mMessageList->setDragEnabled( false );
mMessageList->setSelectionMode( QAbstractItemView::ExtendedSelection );
mMessageList->setSortingEnabled( true );
MicroblogDelegate *delegate = new MicroblogDelegate( mMessageList, this );
mMessageList->setItemDelegate( delegate );
mMessageModel = new BlogModel( this );
QSortFilterProxyModel *proxyModel = new QSortFilterProxyModel( this );
proxyModel->setSortRole( Qt::EditRole );
proxyModel->setDynamicSortFilter( true );
proxyModel->setSourceModel( mMessageModel );
mMessageList->setModel( proxyModel );
splitter->addWidget( box );
splitter->setSizes( QList<int>() << 30 << 470 );
}
void QmitkModuleView::CreateQtPartControl(QWidget *parent)
{
QHBoxLayout* layout = new QHBoxLayout();
layout->setMargin(0);
parent->setLayout(layout);
tableView = new QTableView(parent);
QmitkModuleTableModel* tableModel = new QmitkModuleTableModel(tableView);
QSortFilterProxyModel* sortProxyModel = new QSortFilterProxyModel(tableView);
sortProxyModel->setSourceModel(tableModel);
sortProxyModel->setDynamicSortFilter(true);
tableView->setModel(sortProxyModel);
tableView->verticalHeader()->hide();
tableView->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
tableView->setSelectionMode(QAbstractItemView::ExtendedSelection);
tableView->setTextElideMode(Qt::ElideMiddle);
tableView->setSortingEnabled(true);
tableView->sortByColumn(0, Qt::AscendingOrder);
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
// Fixed size for "Id" column
tableView->horizontalHeader()->setResizeMode(0, QHeaderView::ResizeToContents);
// Fixed size for "Version" column
tableView->horizontalHeader()->setResizeMode(2, QHeaderView::ResizeToContents);
#else
tableView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
tableView->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
#endif
tableView->horizontalHeader()->setStretchLastSection(true);
tableView->horizontalHeader()->setCascadingSectionResizes(true);
layout->addWidget(tableView);
if (viewState)
{
berry::IMemento::Pointer tableHeaderState = viewState->GetChild("tableHeader");
if (tableHeaderState)
{
QString key;
tableHeaderState->GetString("qsettings-key", key);
if (!key.isEmpty())
{
QSettings settings;
QByteArray ba = settings.value(key).toByteArray();
tableView->horizontalHeader()->restoreState(ba);
}
}
}
}
MimeTypesWidget::MimeTypesWidget(QWidget *parent)
: QWidget(parent), ui(new Ui::MimeTypesWidget)
{
ui->setupUi(this);
QSortFilterProxyModel *proxy = new KRecursiveFilterProxyModel(this);
proxy->setDynamicSortFilter(true);
proxy->setSourceModel(ObjectBroker::model("com.kdab.GammaRay.MimeTypeModel"));
ui->mimeTypeView->setModel(proxy);
new DeferredResizeModeSetter(ui->mimeTypeView->header(), 0, QHeaderView::ResizeToContents);
new DeferredResizeModeSetter(ui->mimeTypeView->header(), 1, QHeaderView::ResizeToContents);
ui->mimeTypeView->sortByColumn(0, Qt::AscendingOrder);
ui->searchLine->setProxy(proxy);
}
void GraphHierarchiesEditor::setModel(tlp::GraphHierarchiesModel *model) {
_model = model;
QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel(_ui->hierarchiesTree);
proxyModel->setSourceModel(model);
proxyModel->setDynamicSortFilter(false);
_ui->hierarchiesTree->setModel(proxyModel);
_ui->hierarchiesTree->header()->resizeSection(0, 100);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
_ui->hierarchiesTree->header()->setSectionResizeMode(0, QHeaderView::Interactive);
#else
_ui->hierarchiesTree->header()->setResizeMode(0, QHeaderView::Interactive);
#endif
connect(_ui->hierarchiesTree->selectionModel(),
SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)),
this, SLOT(currentChanged(const QModelIndex&, const QModelIndex&)));
}
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);
}
CopyInputDialog::CopyInputDialog(QWidget* parent)
: QDialog(parent)
{
setWindowTitle(i18n("Copy Input"));
QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
QWidget *mainWidget = new QWidget(this);
QVBoxLayout *mainLayout = new QVBoxLayout;
setLayout(mainLayout);
mainLayout->addWidget(mainWidget);
QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
okButton->setDefault(true);
okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
connect(buttonBox, &QDialogButtonBox::accepted, this, &CopyInputDialog::accept);
connect(buttonBox, &QDialogButtonBox::rejected, this, &CopyInputDialog::reject);
mainLayout->addWidget(buttonBox);
setWindowModality(Qt::WindowModal);
_ui = new Ui::CopyInputDialog();
_ui->setupUi(mainWidget);
connect(_ui->selectAllButton, &QPushButton::clicked, this, &Konsole::CopyInputDialog::selectAll);
connect(_ui->deselectAllButton, &QPushButton::clicked, this, &Konsole::CopyInputDialog::deselectAll);
_ui->filterEdit->setClearButtonEnabled(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, &QLineEdit::textChanged, filterProxyModel, &QSortFilterProxyModel::setFilterFixedString);
_ui->sessionList->setModel(filterProxyModel);
_ui->sessionList->setColumnHidden(0, true); // Hide number column
_ui->sessionList->header()->hide();
}
