void TreeView::copy() {
auto indexes = treeView()->selectionModel()->selectedIndexes();
if (indexes.isEmpty()) {
return;
}
qSort(indexes.begin(), indexes.end(), [](const QModelIndex &a, const QModelIndex &b) -> bool {
if (a.parent() == b.parent()) {
return a.row() < b.row() || (a.row() == b.row() && a.column() < b.column());
} else {
return a < b;
}
});
QString text;
QModelIndex last;
foreach (const auto &index, indexes) {
if (last.parent() != index.parent() || last.row() != index.row()) {
if (!text.isEmpty()) {
text += '\n';
}
last = index;
} else {
text += '\t';
}
text += index.data().toString();
}
QApplication::clipboard()->setText(text);
}
void InputCell::mouseDoubleClickEvent(QMouseEvent *)
{
// PORT >>if(treeView()->hasMouse())
if(treeView()->testAttribute(Qt::WA_UnderMouse))
{
setClosed(!closed_);
}
}
//-------------------------------------------
MyKGanttView::MyKGanttView( QWidget *parent )
: NodeGanttViewBase( parent ),
m_manager( 0 )
{
kDebug(planDbg())<<"------------------- create MyKGanttView -----------------------";
GanttItemModel *gm = new GanttItemModel( this );
setItemModel( gm );
treeView()->createItemDelegates( gm );
QList<int> show;
show << NodeModel::NodeName
<< NodeModel::NodeCompleted
<< NodeModel::NodeStartTime
<< NodeModel::NodeEndTime;
treeView()->setDefaultColumns( show );
for ( int i = 0; i < model()->columnCount(); ++i ) {
if ( ! show.contains( i ) ) {
treeView()->hideColumn( i );
}
}
setConstraintModel( new KGantt::ConstraintModel( this ) );
KGantt::ProxyModel *m = static_cast<KGantt::ProxyModel*>( ganttProxyModel() );
m->setRole( KGantt::ItemTypeRole, KGantt::ItemTypeRole ); // To provide correct format
m->setRole( KGantt::StartTimeRole, Qt::EditRole ); // To provide correct format
m->setRole( KGantt::EndTimeRole, Qt::EditRole ); // To provide correct format
m->setColumn( KGantt::ItemTypeRole, NodeModel::NodeType );
m->setColumn( KGantt::StartTimeRole, NodeModel::NodeStartTime );
m->setColumn( KGantt::EndTimeRole, NodeModel::NodeEndTime );
m->setColumn( KGantt::TaskCompletionRole, NodeModel::NodeCompleted );
KGantt::DateTimeGrid *g = static_cast<KGantt::DateTimeGrid*>( grid() );
g->setDayWidth( 30 );
// TODO: extend QLocale/KGantt to support formats for hourly time display
// see bug #349030
// removed custom code here
connect( model(), SIGNAL(nodeInserted(Node*)), this, SLOT(slotNodeInserted(Node*)) );
}
void TreeView::populateContextMenu(QMenu *menu) {
if (!treeView_->selectionModel()->selectedIndexes().isEmpty()) {
menu->addSeparator();
menu->addAction(tr("Copy"), this, SLOT(copy()), QKeySequence::Copy);
}
menu->addSeparator();
menu->addAction(tr("Select All"), treeView(), SLOT(selectAll()), QKeySequence::SelectAll);
menu->addSeparator();
menu->addAction(openSearchAction_);
menu->addAction(findNextAction_);
menu->addAction(findPreviousAction_);
}
/*! \brief resets the input cell. Removes all output data and
* restores the initial state.
*/
void InputCell::clear()
{
if(evaluated_)
{
output_->clear();
evaluated_ = false;
// PORT >> layout_->remove(output_);
layout_->removeWidget(output_);
}
//input_->setReadOnly(false);
input_->setReadOnly(true);
input_->clear();
treeView()->setClosed(false); //Notis this
setClosed(true);
}
bool TreeView::eventFilter(QObject *watched, QEvent *event) {
if (watched == treeView()->viewport()) {
if (event->type() == QEvent::Wheel) {
auto wheelEvent = static_cast<QWheelEvent *>(event);
if (wheelEvent->orientation() == Qt::Vertical && wheelEvent->modifiers() & Qt::ControlModifier) {
if (wheelEvent->delta() > 0) {
zoomIn(1 + wheelEvent->delta() / 360);
} else {
zoomOut(1 - wheelEvent->delta() / 360);
}
return true;
}
}
}
return QDockWidget::eventFilter(watched, event);
}
NS_IMETHODIMP
nsTreeBoxObject::SetDocument(nsIDocument* aDocument)
{
// this should only be called with a null document, which indicates
// that we're being torn down.
NS_ASSERTION(aDocument == nsnull, "SetDocument called with non-null document");
// Drop the view's ref to us.
nsCOMPtr<nsISupports> suppView;
GetPropertyAsSupports(NS_LITERAL_STRING("view").get(), getter_AddRefs(suppView));
nsCOMPtr<nsITreeView> treeView(do_QueryInterface(suppView));
if (treeView) {
nsCOMPtr<nsITreeSelection> sel;
treeView->GetSelection(getter_AddRefs(sel));
if (sel)
sel->SetTree(nsnull);
treeView->SetTree(nsnull); // Break the circular ref between the view and us.
}
return nsBoxObject::SetDocument(aDocument);
}
void NodeGanttViewBase::saveContext( QDomElement &settings ) const
{
kDebug(planDbg());
treeView()->saveContext( model()->columnMap(), settings );
QDomElement e = settings.ownerDocument().createElement( "ganttchart" );
settings.appendChild( e );
e.setAttribute( "show-dependencies", m_ganttdelegate->showTaskLinks );
e.setAttribute( "show-taskname", m_ganttdelegate->showTaskName );
e.setAttribute( "show-resourcenames", m_ganttdelegate->showResources );
e.setAttribute( "show-completion", m_ganttdelegate->showProgress );
e.setAttribute( "show-criticalpath", m_ganttdelegate->showCriticalPath );
e.setAttribute( "show-criticaltasks", m_ganttdelegate->showCriticalTasks );
e.setAttribute( "show-positivefloat", m_ganttdelegate->showPositiveFloat );
e.setAttribute( "show-schedulingerror", m_ganttdelegate->showSchedulingError );
e.setAttribute( "show-timeconstraint", m_ganttdelegate->showTimeConstraint );
e.setAttribute( "show-negativefloat", m_ganttdelegate->showNegativeFloat );
GanttViewBase::saveContext( e );
m_printOptions.saveContext( e );
}
bool NodeGanttViewBase::loadContext( const KoXmlElement &settings )
{
treeView()->loadContext( model()->columnMap(), settings );
KoXmlElement e = settings.namedItem( "ganttchart" ).toElement();
if ( ! e.isNull() ) {
m_ganttdelegate->showTaskLinks = (bool)( e.attribute( "show-dependencies", "0" ).toInt() );
m_ganttdelegate->showTaskName = (bool)( e.attribute( "show-taskname", "0" ).toInt() );
m_ganttdelegate->showResources = (bool)( e.attribute( "show-resourcenames", "0" ).toInt() );
m_ganttdelegate->showProgress = (bool)( e.attribute( "show-completion", "0" ).toInt() );
m_ganttdelegate->showCriticalPath = (bool)( e.attribute( "show-criticalpath", "0" ).toInt() );
m_ganttdelegate->showCriticalTasks = (bool)( e.attribute( "show-criticaltasks", "0" ).toInt() );
m_ganttdelegate->showPositiveFloat = (bool)( e.attribute( "show-positivefloat", "0" ).toInt() );
m_ganttdelegate->showSchedulingError = (bool)( e.attribute( "show-schedulingerror", "0" ).toInt() );
m_ganttdelegate->showTimeConstraint = (bool)( e.attribute( "show-timeconstraint", "0" ).toInt() );
m_ganttdelegate->showNegativeFloat = (bool)( e.attribute( "show-negativefloat", "0" ).toInt() );
GanttViewBase::loadContext( e );
m_printOptions.loadContext( e );
}
return true;
}
//____________________________________________________
ListDemoWidget::ListDemoWidget( void )
{
// main widget
GtkWidget* mainWidget( gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ) );
gtk_box_set_spacing( GTK_BOX( mainWidget ), 5 );
setWidget( mainWidget );
// setup
setName( "Lists" );
setComments( "Shows the appearance of lists and trees" );
setIconName( "view-list-tree" );
realize();
// vertical pane
GtkWidget* vpaned( gtk_paned_new( GTK_ORIENTATION_VERTICAL ) );
gtk_widget_show( vpaned );
gtk_box_pack_start( GTK_BOX( mainWidget ), vpaned, true, true, 0 );
// simple list
{
GtkListStore* model( gtk_list_store_new( 1, G_TYPE_STRING ) );
const char* columns[] =
{
"First Item",
"Second Item",
"Third Item"
};
for( unsigned int i=0; i<3; i++ )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, columns[i], -1 );
}
GtkWidget* treeView( gtk_tree_view_new_with_model( GTK_TREE_MODEL( model ) ) );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( treeView ), false );
gtk_widget_show( treeView );
// renderer
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "", renderer, "text", 0, NULL ) );
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
// scrolled window
GtkWidget* scrolledWindow( gtk_scrolled_window_new( 0L, 0L ) );
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_SHADOW_IN );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add( GTK_CONTAINER( scrolledWindow ), treeView );
gtk_widget_show( scrolledWindow );
gtk_paned_pack1( GTK_PANED( vpaned ), scrolledWindow, true, true );
}
// tree
{
GtkTreeStore* model( gtk_tree_store_new ( 2, G_TYPE_STRING, G_TYPE_STRING ) );
const char* titleColumns[] =
{
"First Item",
"Second Item",
"Third Item"
};
const char* descriptionColumns[] =
{
"First Description",
"Second Description",
"Third Description"
};
const char* subTitleColumns[] =
{
"First Subitem",
"Second Subitem",
"Third Subitem"
};
const char* subDescriptionColumns[] =
{
"First Subitem Description",
"Second Subitem Description",
"Third Subitem Description"
};
for( unsigned int i=0; i<3; i++ )
{
GtkTreeIter iter;
gtk_tree_store_append( model, &iter, 0L );
gtk_tree_store_set( model, &iter, 0, titleColumns[i], 1, descriptionColumns[i], -1 );
// append children
if( i == 1 )
{
for( unsigned int i=0; i<2; i++ )
{
GtkTreeIter subiter;
gtk_tree_store_append( model, &subiter, &iter );
gtk_tree_store_set( model, &subiter, 0, subTitleColumns[i], 1, subDescriptionColumns[i], -1 );
}
} else if( i == 2 ) {
GtkTreeIter subiter;
gtk_tree_store_append( model, &subiter, &iter );
gtk_tree_store_set( model, &subiter, 0, subTitleColumns[2], 1, subDescriptionColumns[2], -1 );
for( unsigned int i=0; i<2; i++ )
{
GtkTreeIter thirditer;
gtk_tree_store_append( model, &thirditer, &subiter );
gtk_tree_store_set( model, &thirditer, 0, subTitleColumns[i], 1, subDescriptionColumns[i], -1 );
}
}
}
GtkWidget* treeView( gtk_tree_view_new_with_model( GTK_TREE_MODEL( model ) ) );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( treeView ), true );
gtk_widget_show( treeView );
// renderers
{
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "Title", renderer, "text", 0, NULL ) );
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
}
{
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "Description", renderer, "text", 1, NULL ) );
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
}
// scrolled window
GtkWidget* scrolledWindow( gtk_scrolled_window_new( 0L, 0L ) );
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_SHADOW_IN );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add( GTK_CONTAINER( scrolledWindow ), treeView );
gtk_widget_show( scrolledWindow );
gtk_paned_pack2( GTK_PANED( vpaned ), scrolledWindow, true, true );
}
}
void TreeView::setDocumentFont(const QFont &font) {
treeView()->setFont(font);
}
const QFont &TreeView::documentFont() const {
return treeView()->font();
}
