new sequence viewer, static column and row

git-svn-id: https://dng.biozentrum.unibas.ch/svn/openstructure/trunk@2174 5a81b35b-ba03-0410-adc8-b2c5c5119f08

modules/gui/src/sequence/sequence_table_view.cc

@@ -51,90 +51,165 @@ SequenceTableView::SequenceTableView(QAbstractItemModel * model)
         "margin-bottom: 0px;"
         "margin-left: 0px;"
         "margin-right: 0px;"
-    "}"
-    "QTableView::item:hover {"
-        "background-color: #EEEEEE;"
-    "}"
-    "QTableView::item:selected:active{"
-        "background-color: #7ff963;"
-    "}"
-    "QTableView::item:selected:!active {"
-        "background-color: #47ce27;"
     "}");
 
   this->verticalHeader()->hide();
-  this->horizontalHeader()->setStyleSheet(
-        "QHeaderView::section {"
-           "padding-bottom: 0px;"
-           "padding-top: 0px;"
-           "padding-left: 0px;"
-           "padding-right: 0px;"
-           "margin: 0px;"
-        "}"
-      );
-
-  column_not_move_ = new QTableView(this);
-
-  column_not_move_->setModel(this->model());
-  column_not_move_->setFocusPolicy(Qt::NoFocus);
-  column_not_move_->verticalHeader()->hide();
-  column_not_move_->horizontalHeader()->setResizeMode(QHeaderView::Fixed);
-
-  this->viewport()->stackUnder(column_not_move_);
-
-  column_not_move_->setSelectionModel(this->selectionModel());
+  this->horizontalHeader()->hide();
+
+  this->setShowGrid(false);
+
+  this->setHorizontalScrollMode(ScrollPerPixel);
+  this->setVerticalScrollMode(ScrollPerPixel);
+
+  connect(this->horizontalHeader(),SIGNAL(sectionResized(int,int,int)), this, SLOT(ResizeWidth(int,int,int)));
+  connect(this->verticalHeader(),SIGNAL(sectionResized(int,int,int)), this, SLOT(ResizeHeight(int,int,int)));
+
+  delegate_ = new SequenceDelegate(qobject_cast<SequenceModel*>(this->model()),this);
+
+  this->InitStaticRow();
+  this->InitStaticColumn();
+//  this->viewport()->stackUnder(static_row_);
+  this->InitStaticField();
+//  this->viewport()->stackUnder(static_field_);
+ }
+
+void SequenceTableView::InitStaticColumn()
+{
+  static_column_ = new QTableView(this);
+
+  static_column_->setModel(this->model());
+  static_column_->setFocusPolicy(Qt::NoFocus);
+  static_column_->verticalHeader()->hide();
+  static_column_->horizontalHeader()->hide();
+
+  //this->viewport()->stackUnder(static_column_);
+
+  static_column_->setSelectionModel(this->selectionModel());
   for(int col=1; col<this->model()->columnCount(); col++){
-   column_not_move_->setColumnHidden(col, true);
+   static_column_->setColumnHidden(col, true);
   }
 
-  column_not_move_->setColumnWidth(0, this->columnWidth(0) );
+  static_column_->setColumnWidth(0, this->columnWidth(0) );
 
-  column_not_move_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-  column_not_move_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-  column_not_move_->show();
-  column_not_move_->setStyleSheet("QTableView { border: 0px;"
-                                 "background-color: #dbdbdb;"
+  static_column_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_column_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_column_->show();
+  static_column_->setStyleSheet("QTableView { border: 0px;"
+                                 "background-color: #ff0000;"
                                  "selection-background-color: #EEEEEE}"
                                  "QTableView::item{ border: none;"
                                  "padding: 0px; border-width: 0px; margin: 0px;}");
-  column_not_move_->setShowGrid(false);
+  static_column_->setShowGrid(false);
 
-  column_not_move_->horizontalHeader()->setStyleSheet(this->horizontalHeader()->styleSheet());
+  static_column_->setVerticalScrollMode(ScrollPerPixel);
 
-  this->setShowGrid(false);
+  connect(static_column_->verticalScrollBar(), SIGNAL(valueChanged(int)), this->verticalScrollBar(), SLOT(setValue(int)));
+  connect(verticalScrollBar(), SIGNAL(valueChanged(int)), static_column_->verticalScrollBar(), SLOT(setValue(int)));
 
-  this->updateNotMoveColumn();
+  this->updateStaticColumn();
+}
 
-  this->setHorizontalScrollMode(ScrollPerPixel);
-  this->setVerticalScrollMode(ScrollPerPixel);
-  column_not_move_->setVerticalScrollMode(ScrollPerPixel);
+void SequenceTableView::InitStaticRow()
+{
+  static_row_ = new QTableView(this);
 
-  connect(this->horizontalHeader(),SIGNAL(sectionResized(int,int,int)), this, SLOT(ResizeWidth(int,int,int)));
-  connect(this->verticalHeader(),SIGNAL(sectionResized(int,int,int)), this, SLOT(ResizeHeight(int,int,int)));
+  static_row_->setModel(this->model());
+  static_row_->setFocusPolicy(Qt::NoFocus);
+  static_row_->horizontalHeader()->hide();
+  static_row_->verticalHeader()->hide();
 
-  connect(column_not_move_->verticalScrollBar(), SIGNAL(valueChanged(int)), this->verticalScrollBar(), SLOT(setValue(int)));
-  connect(verticalScrollBar(), SIGNAL(valueChanged(int)), column_not_move_->verticalScrollBar(), SLOT(setValue(int)));
+  static_row_->setSelectionModel(this->selectionModel());
+  for(int row=1; row<this->model()->rowCount(); row++){
+    static_row_->setRowHidden(row, true);
+  }
 
-  delegate_ = new SequenceDelegate(qobject_cast<SequenceModel*>(this->model()),this);
- }
+  static_row_->setRowHeight(0, this->rowHeight(0));
+
+  static_row_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_row_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_row_->show();
+  static_row_->setStyleSheet("QTableView { border: 0px;"
+                                 "background-color: #00ff00;"
+                                 "selection-background-color: #EEEEEE}"
+                                 "QTableView::item{ border: none;"
+                                 "padding: 0px; border-width: 0px; margin: 0px;}");
+  static_row_->setShowGrid(false);
+
+  static_row_->setHorizontalScrollMode(ScrollPerPixel);
+
+  connect(static_row_->horizontalScrollBar(), SIGNAL(valueChanged(int)), this->horizontalScrollBar(), SLOT(setValue(int)));
+  connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), static_row_->horizontalScrollBar(), SLOT(setValue(int)));
+
+  this->updateStaticRow();
+}
+
+void SequenceTableView::InitStaticField(){
+  static_field_ = new QTableView(this);
 
+  static_field_->setModel(this->model());
+  static_field_->setFocusPolicy(Qt::NoFocus);
+  static_field_->horizontalHeader()->hide();
+  static_field_->verticalHeader()->hide();
+
+  static_field_->setSelectionModel(this->selectionModel());
+  for(int row=1; row<this->model()->rowCount(); row++){
+    static_field_->setRowHidden(row, true);
+  }
+  for(int col=1; col<this->model()->columnCount(); col++){
+    static_field_->setColumnHidden(col, true);
+  }
+
+  static_field_->setRowHeight(0, this->rowHeight(0));
+  static_field_->setColumnWidth(0, this->columnWidth(0));
+
+  static_field_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_field_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  static_field_->show();
+  static_field_->setStyleSheet("QTableView { border: 0px;"
+                                 "background-color: #0000ff;"
+                                 "selection-background-color: #EEEEEE}"
+                                 "QTableView::item{ border: none;"
+                                 "padding: 0px; border-width: 0px; margin: 0px;}");
+  static_field_->setShowGrid(false);
+
+  static_field_->setHorizontalScrollMode(ScrollPerPixel);
+  static_field_->setVerticalScrollMode(ScrollPerPixel);
+
+  connect(static_field_->horizontalScrollBar(), SIGNAL(valueChanged(int)), this->horizontalScrollBar(), SLOT(setValue(int)));
+  connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), static_field_->horizontalScrollBar(), SLOT(setValue(int)));
+  connect(static_field_->verticalScrollBar(), SIGNAL(valueChanged(int)), this->verticalScrollBar(), SLOT(setValue(int)));
+  connect(verticalScrollBar(), SIGNAL(valueChanged(int)), static_field_->verticalScrollBar(), SLOT(setValue(int)));
+
+  this->updateStaticField();
+}
 void SequenceTableView::ResizeWidth(int index, int, int size)
 {
   if(index == 0){
-    column_not_move_->setColumnWidth(0,size);
-    updateNotMoveColumn();
+    static_column_->setColumnWidth(0,size);
+    static_field_->setColumnWidth(0,size);
+    this->updateStaticColumn();
+    this->updateStaticField();
   }
+  static_row_->setRowHeight(index,size);
 }
 
 void SequenceTableView::ResizeHeight(int index, int, int size)
 {
-  column_not_move_->setRowHeight(index, size);
+  static_column_->setRowHeight(index, size);
+  if(index == 0){
+    static_row_->setRowHeight(0,size);
+    static_field_->setRowHeight(0,size);
+    this->updateStaticRow();
+    this->updateStaticField();
+  }
 }
 
 void SequenceTableView::resizeEvent(QResizeEvent * event)
 {
   QTableView::resizeEvent(event);
-  updateNotMoveColumn();
+  this->updateStaticColumn();
+  this->updateStaticRow();
+  this->updateStaticField();
 }
 
 QModelIndex SequenceTableView::moveCursor(CursorAction action, Qt::KeyboardModifiers modifiers)
@@ -142,46 +217,105 @@ QModelIndex SequenceTableView::moveCursor(CursorAction action, Qt::KeyboardModif
   QModelIndex current = QTableView::moveCursor(action, modifiers);
 
   if(action == MoveLeft && current.column()>0
-     && this->visualRect(current).topLeft().x() < column_not_move_->columnWidth(0) ){
-   const int new_value = horizontalScrollBar()->value() + this->visualRect(current).topLeft().x() - column_not_move_->columnWidth(0);
+     && this->visualRect(current).topLeft().x() < static_column_->columnWidth(0) ){
+   const int new_value = horizontalScrollBar()->value() + this->visualRect(current).topLeft().x() - static_column_->columnWidth(0);
    horizontalScrollBar()->setValue(new_value);
   }
+
+
+  if(action == MoveUp && current.row()>0
+     && this->visualRect(current).bottomLeft().y() < static_row_->rowHeight(0) ){
+   const int new_value = verticalScrollBar()->value() + this->visualRect(current).bottomRight().y() - static_row_->rowHeight(0);
+   verticalScrollBar()->setValue(new_value);
+  }
+
   return current;
 }
 
 void SequenceTableView::scrollTo(const QModelIndex & index, ScrollHint hint){
-  if(index.column()>0){
+  if(index.column()>0 && index.row()>0){
     QTableView::scrollTo(index, hint);
   }
 }
 
-void SequenceTableView::updateNotMoveColumn()
+void SequenceTableView::updateStaticColumn()
 {
   int x = this->verticalHeader()->width()+this->frameWidth();
   int y = this->frameWidth();
   int w = this->columnWidth(0);
   int h = this->viewport()->height()+this->horizontalHeader()->height();
-  column_not_move_->setGeometry(x,y,w,h);
+  static_column_->setGeometry(x,y,w,h);
+}
+
+void SequenceTableView::updateStaticRow(){
+  int x = this->verticalHeader()->width()+this->frameWidth();
+  int y = this->horizontalHeader()->height()+this->frameWidth();
+  int w = this->viewport()->width()+this->verticalHeader()->width();
+  int h = this->rowHeight(0);
+  static_row_->setGeometry(x,y,w,h);
+}
+
+void SequenceTableView::updateStaticField(){
+  int x = this->verticalHeader()->width()+this->frameWidth();
+  int y = this->horizontalHeader()->height()+this->frameWidth();
+  int w = this->columnWidth(0);
+  int h = this->rowHeight(0);
+  static_field_->setGeometry(x,y,w,h);
 }
 
 void SequenceTableView::columnCountChanged(const QModelIndex& index, int old_count, int new_count){
   if(old_count >= 0 && old_count <= new_count){
     if(old_count == 0)old_count = 1;
     for(int col=old_count; col<=new_count; col++){
-      column_not_move_->setColumnHidden(col, true);
+      static_column_->setColumnHidden(col, true);
+      static_field_->setColumnHidden(col,true);
       this->setItemDelegateForColumn(col, delegate_);
     }
+    this->setItemDelegateForRow(0, new QItemDelegate(this));
   }
 }
 
+void SequenceTableView::rowCountChanged(const QModelIndex& index, int old_count, int new_count){
+  if(old_count >= 0 && old_count <= new_count){
+    if(old_count == 0){
+      old_count = 1;
+    }
+    for(int row=old_count; row<=new_count; row++){
+      static_row_->setRowHidden(row, true);
+      static_field_->setRowHidden(row,true);
+    }
+  }
+}
+
+
 void SequenceTableView::resizeColumnsToContents(){
   QTableView::resizeColumnsToContents();
-  column_not_move_->setColumnWidth(0,this->columnWidth(0));
-  updateNotMoveColumn();
+  static_column_->setColumnWidth(0,this->columnWidth(0));
+  static_field_->setColumnWidth(0,this->columnWidth(0));
+  for(int i = 0; i < this->model()->columnCount(); i++){
+    static_row_->setColumnWidth(i,this->columnWidth(i));
+  }
+  this->updateStaticColumn();
+  this->updateStaticField();
+}
+
+void SequenceTableView::resizeRowsToContents(){
+  QTableView::resizeRowsToContents();
+  static_row_->setRowHeight(0,this->rowHeight(0));
+  static_field_->setRowHeight(0,this->rowHeight(0));
+  for(int i = 0; i < this->model()->columnCount(); i++){
+    static_column_->setRowHeight(i,this->rowHeight(i));
+  }
+  this->updateStaticRow();
+  this->updateStaticField();
 }
 
 QTableView* SequenceTableView::GetFirstRow(){
-  return column_not_move_;
+  return static_row_;
+}
+
+QTableView* SequenceTableView::GetFirstColumn(){
+  return static_column_;
 }
 
 void SequenceTableView::mouseDoubleClickEvent(QMouseEvent *event)

modules/gui/src/sequence/sequence_table_view.hh

@@ -36,12 +36,15 @@ class DLLEXPORT_OST_GUI SequenceTableView : public QTableView {
   Q_OBJECT
 public:
   SequenceTableView(QAbstractItemModel * model);
+  QTableView* GetFirstRow();
+  QTableView* GetFirstColumn();
   ~SequenceTableView();
 
 public slots:
   void columnCountChanged(const QModelIndex& index, int old_count, int new_count);
+  void rowCountChanged(const QModelIndex& index, int old_count, int new_count);
   void resizeColumnsToContents();
-  QTableView* GetFirstRow();
+  void resizeRowsToContents();
 
 protected:
   virtual void mouseDoubleClickEvent(QMouseEvent* event);
@@ -51,14 +54,21 @@ protected:
   void scrollTo (const QModelIndex & index, ScrollHint hint = EnsureVisible);
 
 private slots:
+  void InitStaticColumn();
+  void InitStaticRow();
+  void InitStaticField();
   void ResizeWidth(int index, int, int size);
   void ResizeHeight(int index, int, int size);
 
 private:
-  QTableView* column_not_move_;
+  QTableView* static_column_;
+  QTableView* static_row_;
+  QTableView* static_field_;
   SequenceDelegate* delegate_;
   QModelIndex last_double_click_;
-  void updateNotMoveColumn();
+  void updateStaticColumn();
+  void updateStaticRow();
+  void updateStaticField();
 };
 
 }}

modules/gui/src/sequence/sequence_viewer.cc

@@ -55,13 +55,14 @@ SequenceViewerV2::SequenceViewerV2(QWidget* parent): Widget(NULL,parent)
   layout->addWidget(seq_table_view_);
   this->setLayout(layout);
   connect(model_,SIGNAL(columnsInserted(const QModelIndex&, int, int)),seq_table_view_,SLOT(columnCountChanged(const QModelIndex&, int, int)));
+  connect(model_,SIGNAL(rowsInserted(const QModelIndex&, int, int)),seq_table_view_,SLOT(rowCountChanged(const QModelIndex&, int, int)));
 
   seq_table_view_->horizontalHeader()->setMinimumSectionSize(2);
   seq_table_view_->verticalHeader()->setMinimumSectionSize(2);
   seq_table_view_->setSelectionMode(QAbstractItemView::ExtendedSelection);
   connect(seq_table_view_->selectionModel(), SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), this, SLOT(SelectionModelChanged(const QItemSelection&, const QItemSelection&)));
   connect(seq_table_view_,SIGNAL(doubleClicked(const QModelIndex&)),model_,SLOT(DoubleClicked(const QModelIndex&)));
-  connect(seq_table_view_->GetFirstRow(),SIGNAL(doubleClicked(const QModelIndex&)),this,SLOT(DoubleClicked(const QModelIndex&)));
+  connect(seq_table_view_->GetFirstColumn(),SIGNAL(doubleClicked(const QModelIndex&)),this,SLOT(DoubleClicked(const QModelIndex&)));
 }
 
 void SequenceViewerV2::NodeAdded(const gfx::GfxNodeP& n)