from    QT              import QtWidgets, QT

class _With_Table_Widget_ (QtWidgets.QWidget) :

    Header = None

    def __init__ (self, parent = None) :
        super ().__init__ (parent)
        self._box = QtWidgets.QVBoxLayout    (self)
        if self.Header :
            header    = QtWidgets.QLabel     (self.Header)
            self._box.addWidget              (header)
        self._view = QtWidgets.QTableWidget  (0, len (self.Columns))
        self._view.setHorizontalHeaderLabels (self.Columns)
        self._box.addWidget                  (self._view)
        self._view.setAlternatingRowColors   (True)
        self._view.setSelectionBehavior (QtWidgets.QAbstractItemView.SelectRows)
        self._view.verticalHeader ().hide    ()
        self.selection_model = self._view.selectionModel ()
        self.selection_model.currentChanged.connect (self._current_changed)
        self._current_row    = None
    # end def __init__
    
    def _add_read_only_string (self, row, col, text) :
        item  = QtWidgets.QTableWidgetItem   (text)
        flags = item.flags() & ~QT.ItemIsEditable
        item.setFlags                       (flags)
        self._view.setItem                  (row, col, item)
    # end def _add_read_only_string

    def _update_read_only_string (self, row, col, text) :
        item = self._view.item (row, col)
        if not item :
            self._add_read_only_string (row, col, text)
        else :
            model = self._view.model ()
            index = model.index      (row, col)
            model.setData            (index, text)
    # end def _update_read_only_string
    
    def _current_changed (self, new_index, old_index) :
        row = new_index.row ()
        if row != self._current_row :
            self._current_row = row
    # end def _current_changed
    
    def save_settings (self, settings) :
        settings.beginGroup (self.settings_group)
        settings.setValue   ("column-width",   self.column_width   ())
        if False and self.selection_model :
            selection = [  self.model.item_path (i) 
                        for i in self.selectionModel ().selectedRows ()
                        ]
            settings.setValue   ("selection",      selection)
        settings.endGroup   ()
    # end def save_settings

    def restore_settings (self, settings) :
        settings.beginGroup        (self.settings_group)
        self.restore_column_width  (settings.value ("column-width"  ))
        if False and self.selection_model :
            self.restore_selection  (settings.value ("selection"     ))
        settings.endGroup          ()        
    # end def restore_settings
            

    def column_width (self) :
        result = []
        for i in range (self._view.columnCount ()) :
            result.append (self._view.columnWidth (i))
        return result
    # end def column_width
    
    def restore_column_width (self, width) :
        for i, w in enumerate (width or ()) :
            self._view.setColumnWidth (i, int (w))
    # end def restore_column_width
    
    def restore_selection (self, selected) :
        sm = self.view.selectionModel ()
        sm.reset ()
        model           = self.view.model ()
        if model and selected :
            iv_index = model.invalid_index
            for path_to_selected in selected :
                parent_index = iv_index
                try :
                    for pp in path_to_selected :
                        index        = model.index (pp, 0, parent_index)
                        parent_index = index
                    sm.select (index, sm.__class__.Select | sm.__class__.Rows)
                except :
                    pass
    # end def restore_selection
    
# end class _With_Table_Widget_