[table] working headers

nixview/data_models/table_model.py

@@ -1,6 +1,11 @@
-from PyQt5.QtCore import QAbstractTableModel, QModelIndex, Qt, QSize, QVariant
+from IPython.terminal.embed import embed
+from nixview.util.file_handler import FileHandler
+from PyQt5.QtCore import QAbstractTableModel, Qt
 import numpy as np
 
+from nixview.util.enums import NodeType
+
+from IPython import embed
 
 class TableModel (QAbstractTableModel):
 
@@ -9,6 +14,11 @@ class TableModel (QAbstractTableModel):
         self._file_handler = file_handler
         self._data_view = data_view
         self._page = page
+        self._dim_count = data_view.dimension_count
+        self._item = self._data_view.item
+        self._dimension_descriptors = self._file_handler.request_dimensions(self._data_view.item.block_id, self._data_view.item.id)
+        self._dimension_tooltips = [self.dimension_tool_tip(i) for i in range(self._dim_count)]
+        self._data_tooltip = self.create_data_tooltip()
         self._cols = self._data_view.full_shape[1] if len(self._data_view.full_shape) > 1 else 1
         self._rows = self._data_view.full_shape[0]
         self.insertColumns(0, self._cols)
@@ -16,6 +26,61 @@ class TableModel (QAbstractTableModel):
         self._slice = [0 for i in range(len(self._data_view.full_shape))]
         if len(self._data_view.full_shape) > 2:
             self._slice[-1] = self._page
+        self.createHeader()
+
+    def create_data_tooltip(self):
+        label = self._item.label if self._item.label is not None else ""
+        unit = "[%s]" % self._item.unit if self._item.unit is not None else ""
+        return "%s %s" % (label, unit)
+
+    def rowCount(self, parent):
+        return self._rows
+
+    def columnCount(self, parent):
+        return self._cols
+
+    def dimension_tool_tip(self, index):
+        label = self._dimension_descriptors[index].label if self._dimension_descriptors[index].label is not None else ""
+        unit = "[%s]" % self._dimension_descriptors[index].unit if self._dimension_descriptors[index].unit is not None else ""
+        return "%s %s" % (label, unit)
+
+    def convert_axis_to_string(self, axis):
+        is_numeric = False
+        try:
+            float(axis[0])
+            is_numeric = True
+        except:
+            pass
+        if is_numeric:
+            axis = np.round(np.asarray(axis, dtype=float), 5)
+            return list(map(str, axis))
+        else:
+            return axis
+
+    def createHeaderDataArray(self):
+        if self._dim_count == 1:
+            temp = self._file_handler.request_axis(self._data_view.item.block_id,
+                                                   self._data_view.item.id, 0,
+                                                   self.rowCount(None))
+            self._vheader = self.convert_axis_to_string(temp)
+            self._hheader = ["1"]
+        elif self._dim_count > 1:
+            temp = self._file_handler.request_axis(self._data_view.item.block_id,
+                                                   self._data_view.item.id, 0, 
+                                                   self.rowCount(None))
+            self._vheader = self.convert_axis_to_string(temp)
+            temp = self._file_handler.request_axis(self._data_view.item.block_id, 
+                                                   self._data_view.item.id, 1, 
+                                                   self.columnCount(None))
+            self._hheader = self.convert_axis_to_string(temp)
+
+    def createHeader(self):
+        if self._data_view.item.entity_type == NodeType.DataArray:
+            self.createHeaderDataArray()
+        else:
+            self._vheader = np.arange(self.rowCount(None))
+            self._hheader = np.arange(self.columnCount(None))
+
         """
         if (array.getDimension(1).dimensionType() == nix::DimensionType::Set) {
             v_labels = array.getDimension(1).asSetDimension().labels();
@@ -26,17 +91,12 @@ class TableModel (QAbstractTableModel):
             }
         }
         """
-        
-    def rowCount(self, parent):
-        return self._rows
-
-    def columnCount(self, parent):
-        return self._cols
 
     def data(self, index, role):
-        if not index.isValid() or role != Qt.DisplayRole:
+        if not index.isValid() or (role != Qt.DisplayRole and role != Qt.ToolTipRole):
             return None
-
+        if role == Qt.ToolTipRole:
+            return self._data_tooltip
         d = ""
         if (index.row() < self._rows) and (index.column() < self._cols):
             self._slice[0] = index.row()
@@ -46,4 +106,18 @@ class TableModel (QAbstractTableModel):
 
         return str(np.round(d, 5))
 
+    def headerData(self, section, orientation, role=Qt.DisplayRole):
+        if role != Qt.DisplayRole and role != Qt.ToolTipRole:
+            return super().headerData(section, orientation, role)
+
+        if role == Qt.DisplayRole:
+            if orientation == Qt.Vertical:
+                return self._vheader[section]
+            else:
+                return self._hheader[section]
 
+        if role == Qt.ToolTipRole:
+            if orientation == Qt.Vertical:
+                return self._dimension_tooltips[0]
+            else:
+                return self._dimension_tooltips[1] if self._dim_count > 1 else self._data_tooltip

nixview/ui/mainwindow.py

@@ -38,8 +38,15 @@ class NixView(QMainWindow):
     def on_item_selected(self, current):
         self._current_item = current
         current_item_type = current._node_descriptor.entity_type
-        enable = current_item_type == NodeType.MultiTag or current_item_type == NodeType.DataArray or current_item_type == NodeType.Tag
+        self.enable_plot_view(current_item_type)
+        self.enable_table_view(current_item_type)
+
+    def enable_plot_view(self, entity_type):
+        enable = entity_type == NodeType.MultiTag or entity_type == NodeType.DataArray or entity_type == NodeType.Tag
         self._plot_action.setEnabled(enable)
+
+    def enable_table_view(self, entity_type):
+        enable = entity_type == NodeType.DataArray or entity_type == NodeType.DataFrame
         self._table_action.setEnabled(enable)
 
     def create_actions(self):

nixview/util/dataview.py

@@ -13,6 +13,7 @@ class DataView():
         self._fetched_data = np.zeros(len(self._full_shape), dtype=int)
         self._count = None
         self._cut_dim = None
+        self._dim_count = len(self._full_shape)
         self.init_buffer()
         self.request_more()
 
@@ -68,10 +69,18 @@ class DataView():
     def full_shape(self):
         return self._full_shape
 
+    @property
+    def dimension_count(self):
+        return self._dim_count
+
     @property
     def current_shape(self):
         return self._fetched_data
-    
+
+    @property
+    def item(self):
+        return self._item_descriptor
+
     def __str__(self) -> str:
         r = self._item_descriptor.name + " " + str(self._item_descriptor.entity_type)
         r += " buffer size: "  + str(self._buffer.shape) if self._buffer is not None else "" + "\n"