//! [0] //! [1]
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QSplitter *splitter = new QSplitter;
//! [2] //! [3]
QDirModel *model = new QDirModel;
//! [0] //! [2] //! [4] //! [5]
QTreeView *tree = new QTreeView(splitter);
//! [3] //! [6]
tree->setModel(model);
//! [4] //! [6] //! [7]
tree->setRootIndex(model->index(QDir::currentPath()));
//! [7]
QListView *list = new QListView(splitter);
list->setModel(model);
list->setRootIndex(model->index(QDir::currentPath()));
//! [5]
QItemSelectionModel *selection = new QItemSelectionModel(model);
tree->setSelectionModel(selection);
list->setSelectionModel(selection);
//! [8]
splitter->setWindowTitle("Two views onto the same directory model");
splitter->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QDirModel model;
QTreeView tree;
QListView list;
QTableView table;
tree.setModel(&model);
list.setModel(&model);
table.setModel(&model);
tree.setSelectionMode(QAbstractItemView::MultiSelection);
list.setSelectionModel(tree.selectionModel());
table.setSelectionModel(tree.selectionModel());
QObject::connect(&tree,SIGNAL(doubleClicked(QModelIndex)),&list,SLOT(setRootIndex(QModelIndex)));
QObject::connect(&tree,SIGNAL(doubleClicked(QModelIndex)),&table,SLOT(setRootIndex(QModelIndex)));
QSplitter *splitter = new QSplitter;
splitter->addWidget(&tree);
splitter->addWidget(&list);
splitter->addWidget(&table);
splitter->setWindowTitle(QObject::tr("Model/View"));
splitter->show();
return a.exec();
}
int main(int argc, char** argv)
{
QApplication application(argc,argv);
// Create Splitters
QSplitter *hSplit = new QSplitter(Qt::Vertical);
QSplitter *vSplit1 = new QSplitter(hSplit);
QSplitter *vSplit2 = new QSplitter(hSplit);
// Create the scene
Scene* s = new Scene();
// Instantiate the viewers.
Viewer side (s,0,vSplit1);
Viewer top (s,1,vSplit1, &side);
Viewer front (s,2,vSplit2, &side);
Viewer persp (s,3,vSplit2, &side);
hSplit->setWindowTitle("multiView");
// Set main QSplitter as the main widget.
hSplit->show();
return application.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QFont font("ZYSong18030",12);
a.setFont(font);
//主分割窗口
QSplitter *splitterMain =new QSplitter(Qt::Horizontal,0);
QTextEdit *textLeft =new QTextEdit(QObject::tr("Left Widget"),splitterMain);
textLeft->setAlignment(Qt::AlignCenter);
//右部分割窗口
QSplitter *splitterRight =new QSplitter(Qt::Vertical,splitterMain);
splitterRight->setOpaqueResize(false);
QTextEdit *textUp =new QTextEdit(QObject::tr("Top Widget"),splitterRight);
textUp->setAlignment(Qt::AlignCenter);
QTextEdit *textBottom =new QTextEdit(QObject::tr("Bottom Widget"),splitterRight);
textBottom->setAlignment(Qt::AlignCenter);
splitterMain->setStretchFactor(1,1);
splitterMain->setWindowTitle(QObject::tr("Splitter"));
splitterMain->show();
//MainWindow w;
//w.show();
return a.exec();
}
void KateViewManager::splitViewSpace( KateViewSpace* vs, // = 0
Qt::Orientation o )// = Qt::Horizontal
{
// emergency: fallback to activeViewSpace, and if still invalid, abort
if (!vs) vs = activeViewSpace();
if (!vs) return;
// get current splitter, and abort if null
QSplitter *currentSplitter = qobject_cast<QSplitter*>(vs->parentWidget());
if (!currentSplitter) return;
// index where to insert new splitter/viewspace
const int index = currentSplitter->indexOf( vs );
// create new viewspace
KateViewSpace* vsNew = new KateViewSpace( this );
// only 1 children -> we are the root container. So simply set the orientation
// and add the new view space, then correct the sizes to 50%:50%
if (currentSplitter->count() == 1)
{
if( currentSplitter->orientation() != o )
currentSplitter->setOrientation( o );
QList<int> sizes = currentSplitter->sizes();
sizes << (sizes.first() - currentSplitter->handleWidth() ) / 2;
sizes[0] = sizes[1];
currentSplitter->insertWidget( index, vsNew );
currentSplitter->setSizes( sizes );
}
else
{
// create a new QSplitter and replace vs with the splitter. vs and newVS are
// the new children of the new QSplitter
QSplitter* newContainer = new QSplitter( o );
newContainer->setOpaqueResize( KGlobalSettings::opaqueResize() );
QList<int> currentSizes = currentSplitter->sizes();
newContainer->addWidget( vs );
newContainer->addWidget( vsNew );
currentSplitter->insertWidget( index, newContainer );
newContainer->show();
// fix sizes of children of old and new splitter
currentSplitter->setSizes( currentSizes );
QList<int> newSizes = newContainer->sizes();
newSizes[0] = (newSizes[0] + newSizes[1] - newContainer->handleWidth()) / 2;
newSizes[1] = newSizes[0];
newContainer->setSizes( newSizes );
}
m_viewSpaceList.append( vsNew );
activeViewSpace()->setActive( false );
vsNew->setActive( true, true );
vsNew->show();
createView ((KTextEditor::Document*)activeView()->document());
updateViewSpaceActions ();
}
int main( int argc, char **argv )
{
QApplication app( argc, argv );
QTreeView *tree = new QTreeView();
QListView *list = new QListView();
QTableView *table = new QTableView();
QSplitter splitter;
splitter.addWidget(tree);
splitter.addWidget(list);
splitter.addWidget(table);
QStandardItemModel model( 5, 2 );
for( int r=0; r<5; r++ )
{
for( int c=0; c<2; c++)
{
QStandardItem *item = new QStandardItem(QString("Row:%0, Column:%1").arg(r).arg(c));
if(c == 0)
{
for(int i=0; i<3; i++)
{
QStandardItem *child = new QStandardItem(QString("Item %0").arg(i));
child->setEditable(false);
item->appendRow(child);
}
}
model.setItem(r, c, item);
}
}
model.setHorizontalHeaderItem(0, new QStandardItem("Foo"));
model.setHorizontalHeaderItem(1, new QStandardItem("Bar-Baz"));
tree->setModel(&model);
list->setModel(&model);
table->setModel(&model);
list->setSelectionModel(tree->selectionModel());
table->setSelectionModel(tree->selectionModel());
table->setSelectionBehavior(QAbstractItemView::SelectRows);
table->setSelectionMode(QAbstractItemView::SingleSelection);
splitter.show();
MainWindow w;
w.show();
return app.exec();
}
void Test_TreeView_MVC()
{
//mvc data
TA_Base_App::Node* pNodeRoot = NULL;
TA_Base_App::Node* pNodeRootRoot = NULL;
TA_Base_App::Node* pNodeOrExpression = NULL;
TA_Base_App::Node* pNodeAndExpression = NULL;
TA_Base_App::Node* pNodeNotExpression = NULL;
TA_Base_App::Node* pNodeOperator = NULL;
pNodeRoot = new TA_Base_App::Node(TA_Base_App::NodeData::Root, "root");
pNodeRootRoot = new TA_Base_App::Node(TA_Base_App::NodeData::Root, "rootroot");
pNodeOrExpression = new TA_Base_App::Node(TA_Base_App::NodeData::OrExpression, "A");
pNodeAndExpression = new TA_Base_App::Node(TA_Base_App::NodeData::AndExpression, "A_A");
pNodeNotExpression = new TA_Base_App::Node(TA_Base_App::NodeData::NotExpression, "A_A_A");
pNodeOperator = new TA_Base_App::Node(TA_Base_App::NodeData::Operator, "A_A_A_A");
pNodeRoot->m_pParentNode = NULL;
pNodeRoot->m_pChildrenNodeLst.push_back(pNodeRootRoot);
pNodeRootRoot->m_pParentNode = pNodeRoot;
pNodeRootRoot->m_pChildrenNodeLst.push_back(pNodeOrExpression);
pNodeOrExpression->m_pParentNode = pNodeRootRoot;
pNodeOrExpression->m_pChildrenNodeLst.push_back(pNodeAndExpression);
pNodeAndExpression->m_pParentNode = pNodeOrExpression;
pNodeAndExpression->m_pChildrenNodeLst.push_back(pNodeNotExpression);
pNodeNotExpression->m_pParentNode = pNodeAndExpression;
pNodeNotExpression->m_pChildrenNodeLst.push_back(pNodeOperator);
pNodeOperator->m_pParentNode = pNodeNotExpression;
pNodeOperator->m_pChildrenNodeLst.clear();
//model
TA_Base_App::BooleanModel* booleanModel = new TA_Base_App::BooleanModel();
booleanModel->setRootNode(pNodeRoot);
pNodeRoot = NULL;
//mvc view
QSplitter* splitter = new QSplitter();//two widget
QTreeView* treeViewTmp = new QTreeView(splitter);//
//mvc
treeViewTmp->setModel((QAbstractItemModel *)booleanModel);
//treeViewTmp->setAlternatingRowColors(true);
treeViewTmp->setRootIndex(booleanModel->index(0, 0, QModelIndex()));
splitter->setWindowTitle("mvc tree view test");
splitter->show();
}
int main(int argc, char** argv)
{
// Read command lines arguments.
QApplication application(argc,argv);
// Create Splitters
QSplitter *hSplit = new QSplitter(Qt::Horizontal);
QSplitter *vSplit1 = new QSplitter(Qt::Vertical,hSplit);
QSplitter *vSplit2 = new QSplitter(Qt::Vertical,vSplit1);
hSplit->resize(1280,720);
DataLive::tp_shared_ptr _pData( new DataLive() );
// Instantiate the viewers.
Viewer global_view(string("global_view"), _pData, vSplit1, NULL);
Viewer rgb_view(string("rgb_view"), _pData, vSplit1, &global_view);
Viewer camera_view(string("camera_view"), _pData, vSplit1, &global_view);
Viewer depth_view (string("depth_view"), _pData, vSplit1, &global_view);
hSplit->addWidget(&global_view);
hSplit->addWidget(vSplit1);
hSplit->setStretchFactor(0, 3);
hSplit->setStretchFactor(1, 1);
vSplit1->addWidget(&rgb_view);
vSplit1->addWidget(vSplit2);
vSplit2->addWidget(&depth_view);
vSplit2->addWidget(&camera_view);
#if QT_VERSION < 0x040000
// Set the viewer as the application main widget.
application.setMainWidget(&viewer);
#else
hSplit->setWindowTitle("Kinect Multi-view");
#endif
try{
// Make the viewer window visible on screen.
hSplit->show();
// Run main loop.
return application.exec();
}
catch ( btl::utility::CError& e ) {
if ( std::string const* mi = boost::get_error_info< btl::utility::CErrorInfo > ( e ) ) {
std::cerr << "Error Info: " << *mi << std::endl;
}
}
catch ( std::runtime_error& e ){
PRINTSTR( e.what() );
}
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QSplitter splitter;
splitter.addWidget(new StaticWidget());
splitter.addWidget(new StaticWidget());
splitter.resize(600, 400);
splitter.show();
return app.exec();
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(interview);
QApplication app(argc, argv);
QSplitter page;
QAbstractItemModel *data = new Model(1000, 10, &page);
QItemSelectionModel *selections = new QItemSelectionModel(data);
QTableView *table = new QTableView;
table->setModel(data);
table->setSelectionModel(selections);
table->horizontalHeader()->setMovable(true);
table->verticalHeader()->setMovable(true);
// Set StaticContents to enable minimal repaints on resizes.
table->viewport()->setAttribute(Qt::WA_StaticContents);
page.addWidget(table);
QTreeView *tree = new QTreeView;
tree->setModel(data);
tree->setSelectionModel(selections);
tree->setUniformRowHeights(true);
tree->header()->setStretchLastSection(false);
tree->viewport()->setAttribute(Qt::WA_StaticContents);
// Disable the focus rect to get minimal repaints when scrolling on Mac.
tree->setAttribute(Qt::WA_MacShowFocusRect, false);
page.addWidget(tree);
QListView *list = new QListView;
list->setModel(data);
list->setSelectionModel(selections);
list->setViewMode(QListView::IconMode);
list->setSelectionMode(QAbstractItemView::ExtendedSelection);
list->setAlternatingRowColors(false);
list->viewport()->setAttribute(Qt::WA_StaticContents);
list->setAttribute(Qt::WA_MacShowFocusRect, false);
page.addWidget(list);
page.setWindowIcon(QPixmap(":/images/interview.png"));
page.setWindowTitle("Interview");
page.show();
return app.exec();
}
void Test_FileSystem_MVC()
{
QSplitter* splitter = new QSplitter;//two widget
QFileSystemModel* model = new QFileSystemModel;
QTreeView* tree = new QTreeView(splitter);//left tree view
QListView* list = new QListView(splitter);//right list view
splitter->setWindowTitle("Two vies onto the same file system model");
model->setRootPath(QDir::currentPath());
tree->setModel(model);//set model for view
tree->setRootIndex(model->index(QDir::currentPath()));
list->setModel(model);
list->setRootIndex(model->index(QDir::currentPath()));
list->setSelectionModel(tree->selectionModel());
splitter->show();
}
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QSplitter splitter;
QTreeView *tree = new QTreeView(&splitter);
QListView *list = new QListView(&splitter);
QFileSystemModel *model = new QFileSystemModel(&app);
model->setRootPath(QDir::root().path());
tree->setModel(model);
list->setModel(model);
list->setRootIndex(model->index("."));
splitter.show();
return app.exec();
}
int main(int argc, char *argv[])
{
KAboutData aboutData(
"tutorial1",
0,
ki18n("Tutorial 1"),
"1.0",
ki18n("Displays a KMessageBox popup"),
KAboutData::License_GPL,
ki18n("(c) 2007"),
ki18n("Some text..."),
"http://tutorial.com/",
"*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
KApplication app;
QSplitter* splitter = new QSplitter();
QDirModel* model = new QDirModel;
QTreeView* tree = new QTreeView(splitter);
tree->setModel(model);
tree->resize(100, 800);
QFrame* frame = new QFrame(splitter);
QBoxLayout* boxLayout = new QVBoxLayout(frame);
QWidget* searchBar = new Pecera::SearchBar();
QWidget* terminal = createTerminalWidget(frame);
boxLayout->addWidget(searchBar);
boxLayout->addWidget(terminal);
frame->resize(600, 500);
//terminal->show();
splitter->resize(700, 500);
splitter->show();
return app.exec();
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QDirModel mainModel;
QTreeView *treeView = new QTreeView;
QTableView *tableView = new QTableView;
QSplitter *mainSplitter = new QSplitter;
treeView->setModel(&mainModel);
tableView->setModel(&mainModel);
QObject::connect(treeView,SIGNAL(clicked(QModelIndex)),tableView,SLOT(setRootIndex(QModelIndex)));
QObject::connect(tableView,SIGNAL(activated(QModelIndex)),treeView,SLOT(setCurrentIndex(QModelIndex)));
QObject::connect(tableView,SIGNAL(activated(QModelIndex)),tableView,SLOT(setRootIndex(QModelIndex)));
mainSplitter->addWidget(treeView);
mainSplitter->addWidget(tableView);
mainSplitter->setGeometry(430,340,400,400);
mainSplitter->show();
return a.exec();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
// cria um objeto "splitter" para compartilhar widgets:
QSplitter *splitter = new QSplitter(Qt::Horizontal); // horizontal e o default...
// cria um "model" usando o "QDirModel"
QDirModel *model = new QDirModel(&app); // será deletado
// na destrutora de QApplication (QObject)
// model->setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
// model->setNameFilters(QStringList() << "cursoQt");
// Neste exemplo,
// O "model" será configurado para pegar dados
// a partir de determinado(s) drive(s) ou diretório(s).
// E serão criadas três "views" (uma "tree", uma "table", e uma "list" )
// relacionadas ao mesmo "model";
// Cada "view" exibe os dados de uma determinada maneira;
// 1- ==== a primeira "view" é uma "tree":
QTreeView *tree = new QTreeView(splitter);
tree->setModel(model);
// O DirModel já oferece um "RootIndex" a partir do qual
// cada "view" exibe drives, diretórios e arquivos abaixo dele.
// No Windows o "RootIndex" default exibirá
// a relacão de todos os drives;
// para outros Sistemas apenas o root ('/').
// Mas podemos alterar o "RootIndex" de cada view.
// Um exemplo: partindo do diretório atual:
// tree->setRootIndex(model->index(QDir::currentPath()));
#ifdef Q_OS_WIN
QString rootNdx("C:/cursoQt");
#else
QString rootNdx("/home/user_name/cursoQt");
#endif
// tree->setRootIndex(model->index(rootNdx));
// MAS, temos a função que develve o root do SO:
// outro exemplo: partindo do diretorio "root" ( "/" ou "C:/"):
// tree->setRootIndex(model->index(QDir::rootPath()));
// ou ainda, um diretório específico:
// tree->setRootIndex(model->index("/cursoqt"));
// tree->setRootIndex(model->index("/cursoqt"));
/*
// outro exemplo: partindo de determinado drive:
QFileInfoList fiList = QDir::drives();
foreach( const QFileInfo & fi, fiList )
{
if ( fi.filePath()=="D:/" ) // apenas o drive "D:/"
{
tree->setRootIndex(model->index(fi.filePath()));
break;
}
}
*/
// 2- ==== a segunda "view" é uma "table"
QTableView *table = new QTableView(splitter);
table->setModel(model);
// table->setRootIndex(...); // idem
// 3- ==== a terceira "view" é uma "list":
QListView *list = new QListView(splitter);
list->setModel(model);
//list->setRootIndex(model->index(rootNdx)); // idem
// configura e exibe a "splitter"
splitter->setWindowTitle("00_dir - 3 'views' usando o mesmo 'model' (diretórios)");
int width=800;
splitter->resize(width,500);
// largura de cada "view"
QList< int > cols;
cols << int(width* 0.45) << int(width*0.45) << int(width*0.1);
splitter->setSizes(cols);
splitter->setChildrenCollapsible(false); // impede que cada banda colapse totalmente
splitter->show();
int ret = app.exec();
delete splitter; // porque não alocou o splitter na PILHA ????
return ret;
}
