New CharacterModel (changes name and uses QAbstractItemModel instead of QStandardItemModel)

manuskript/enums.py

@@ -9,7 +9,7 @@ from enum import Enum
 #def enum(**enums):
     #return type(str('Enum'), (), enums)
 
-class Perso(Enum):
+class Character(Enum):
     name = 0
     ID = 1
     importance = 2
@@ -21,8 +21,6 @@ class Perso(Enum):
     summaryPara = 8
     summaryFull = 9
     notes = 10
-    infoName = 11
-    infoData = 12
     
 class Plot(Enum):
     name = 0

manuskript/functions.py

@@ -121,9 +121,9 @@ def outlineItemColors(item):
     # POV
     colors["POV"] = QColor(Qt.transparent)
     POV = item.data(Outline.POV.value)
-    for i in range(mw.mdlPersos.rowCount()):
+    for i in range(mw.mdlCharacter.rowCount()):
-        if mw.mdlPersos.ID(i) == POV:
+        if mw.mdlCharacter.ID(i) == POV:
-            colors["POV"] = iconColor(mw.mdlPersos.icon(i))
+            colors["POV"] = iconColor(mw.mdlCharacter.icon(i))
 
     # Label
     lbl = item.data(Outline.label.value)

manuskript/mainWindow.py

@@ -9,13 +9,13 @@ from PyQt5.QtWidgets import QMainWindow, QHeaderView, qApp, QMenu, QActionGroup,
     QLabel
 
 from manuskript import settings
-from manuskript.enums import Perso, Subplot, Plot, World
+from manuskript.enums import Character, Subplot, Plot, World
 from manuskript.functions import AUC, wordCount, appPath
 from manuskript.loadSave import loadStandardItemModelXML, loadFilesFromZip
 from manuskript.loadSave import saveFilesToZip
 from manuskript.loadSave import saveStandardItemModelXML
+from manuskript.models.characterModel import characterModel
 from manuskript.models.outlineModel import outlineModel
-from manuskript.models.persosModel import persosModel
 from manuskript.models.plotModel import plotModel
 from manuskript.models.worldModel import worldModel
 from manuskript.settingsWindow import settingsWindow
@@ -144,15 +144,18 @@ class MainWindow(QMainWindow, Ui_MainWindow):
     # PERSOS
     ###############################################################################
 
-    def changeCurrentPerso(self, trash=None):
+    def changeCurrentCharacter(self, trash=None):
+        """
 
-        index = self.lstPersos.currentPersoIndex()
+        @return:
-
+        """
-        if not index.isValid():
+        c = self.lstCharacters.currentCharacter()
+        if not c:
             self.tabPlot.setEnabled(False)
             return
 
         self.tabPersos.setEnabled(True)
+        index = c.index()
 
         for w in [
             self.txtPersoName,
@@ -169,27 +172,24 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             w.setCurrentModelIndex(index)
 
         # Button color
-        self.mdlPersos.updatePersoColor(index)
+        self.updateCharacterColor(c.ID())
 
-        # Perso Infos
+        # Character Infos
         self.tblPersoInfos.setRootIndex(index)
 
-        if self.mdlPersos.rowCount(index):
+        if self.mdlCharacter.rowCount(index):
             self.updatePersoInfoView()
 
     def updatePersoInfoView(self):
-        # Hide columns
+        self.tblPersoInfos.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
-        for i in range(self.mdlPersos.columnCount()):
+        self.tblPersoInfos.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
-            self.tblPersoInfos.hideColumn(i)
-        self.tblPersoInfos.showColumn(Perso.infoName.value)
-        self.tblPersoInfos.showColumn(Perso.infoData.value)
-
-        self.tblPersoInfos.horizontalHeader().setSectionResizeMode(
-                Perso.infoName.value, QHeaderView.ResizeToContents)
-        self.tblPersoInfos.horizontalHeader().setSectionResizeMode(
-                Perso.infoData.value, QHeaderView.Stretch)
         self.tblPersoInfos.verticalHeader().hide()
 
+    def updateCharacterColor(self, ID):
+        c = self.mdlCharacter.getCharacterByID(ID)
+        color = c.color().name()
+        self.btnPersoColor.setStyleSheet("background:{};".format(color))
+
     ###############################################################################
     # PLOTS
     ###############################################################################
@@ -340,7 +340,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         self.saveTimerNoChanges.setSingleShot(True)
         self.mdlFlatData.dataChanged.connect(self.startTimerNoChanges)
         self.mdlOutline.dataChanged.connect(self.startTimerNoChanges)
-        self.mdlPersos.dataChanged.connect(self.startTimerNoChanges)
+        self.mdlCharacter.dataChanged.connect(self.startTimerNoChanges)
         self.mdlPlots.dataChanged.connect(self.startTimerNoChanges)
         self.mdlWorld.dataChanged.connect(self.startTimerNoChanges)
         # self.mdlPersosInfos.dataChanged.connect(self.startTimerNoChanges)
@@ -467,8 +467,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         files.append((saveStandardItemModelXML(self.mdlFlatData),
                       "flatModel.xml"))
-        files.append((saveStandardItemModelXML(self.mdlPersos),
+        # files.append((saveStandardItemModelXML(self.mdlCharacter),
-                      "perso.xml"))
+        #               "perso.xml"))
         files.append((saveStandardItemModelXML(self.mdlWorld),
                       "world.xml"))
         files.append((saveStandardItemModelXML(self.mdlLabels),
@@ -491,7 +491,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
     def loadEmptyDatas(self):
         self.mdlFlatData = QStandardItemModel(self)
-        self.mdlPersos = persosModel(self)
+        self.mdlCharacter = characterModel(self)
         # self.mdlPersosProxy = persosProxyModel(self)
         # self.mdlPersosInfos = QStandardItemModel(self)
         self.mdlLabels = QStandardItemModel(self)
@@ -513,7 +513,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             errors.append("flatModel.xml")
 
         if "perso.xml" in files:
-            loadStandardItemModelXML(self.mdlPersos,
+            loadStandardItemModelXML(self.mdlCharacter,
                                      files["perso.xml"], fromString=True)
         else:
             errors.append("perso.xml")
@@ -570,7 +570,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
     def makeUIConnections(self):
         "Connections that have to be made once only, event when new project is loaded."
-        self.lstPersos.currentItemChanged.connect(self.changeCurrentPerso, AUC)
+        self.lstCharacters.currentItemChanged.connect(self.changeCurrentCharacter, AUC)
 
         self.txtPlotFilter.textChanged.connect(self.lstPlots.setFilter, AUC)
         self.lstPlots.currentItemChanged.connect(self.changeCurrentPlot, AUC)
@@ -622,29 +622,29 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             widget.setCurrentModelIndex(self.mdlFlatData.index(0, col))
 
         # Persos
-        self.lstPersos.setPersosModel(self.mdlPersos)
+        self.lstCharacters.setCharactersModel(self.mdlCharacter)
-        self.tblPersoInfos.setModel(self.mdlPersos)
+        self.tblPersoInfos.setModel(self.mdlCharacter)
 
-        self.btnAddPerso.clicked.connect(self.mdlPersos.addPerso, AUC)
+        self.btnAddPerso.clicked.connect(self.mdlCharacter.addCharacter, AUC)
-        self.btnRmPerso.clicked.connect(self.mdlPersos.removePerso, AUC)
+        self.btnRmPerso.clicked.connect(self.lstCharacters.removeCharacter, AUC)
-        self.btnPersoColor.clicked.connect(self.mdlPersos.chosePersoColor, AUC)
+        self.btnPersoColor.clicked.connect(self.lstCharacters.choseCharacterColor, AUC)
 
-        self.btnPersoAddInfo.clicked.connect(self.mdlPersos.addPersoInfo, AUC)
+        self.btnPersoAddInfo.clicked.connect(self.lstCharacters.addCharacterInfo, AUC)
-        self.btnPersoRmInfo.clicked.connect(self.mdlPersos.removePersoInfo, AUC)
+        self.btnPersoRmInfo.clicked.connect(self.lstCharacters.removeCharacterInfo, AUC)
 
         for w, c in [
-            (self.txtPersoName, Perso.name.value),
+            (self.txtPersoName, Character.name.value),
-            (self.sldPersoImportance, Perso.importance.value),
+            (self.sldPersoImportance, Character.importance.value),
-            (self.txtPersoMotivation, Perso.motivation.value),
+            (self.txtPersoMotivation, Character.motivation.value),
-            (self.txtPersoGoal, Perso.goal.value),
+            (self.txtPersoGoal, Character.goal.value),
-            (self.txtPersoConflict, Perso.conflict.value),
+            (self.txtPersoConflict, Character.conflict.value),
-            (self.txtPersoEpiphany, Perso.epiphany.value),
+            (self.txtPersoEpiphany, Character.epiphany.value),
-            (self.txtPersoSummarySentence, Perso.summarySentence.value),
+            (self.txtPersoSummarySentence, Character.summarySentence.value),
-            (self.txtPersoSummaryPara, Perso.summaryPara.value),
+            (self.txtPersoSummaryPara, Character.summaryPara.value),
-            (self.txtPersoSummaryFull, Perso.summaryFull.value),
+            (self.txtPersoSummaryFull, Character.summaryFull.value),
-            (self.txtPersoNotes, Perso.notes.value)
+            (self.txtPersoNotes, Character.notes.value)
         ]:
-            w.setModel(self.mdlPersos)
+            w.setModel(self.mdlCharacter)
             w.setColumn(c)
         self.tabPersos.setEnabled(False)
 
@@ -672,10 +672,10 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         self.tabPlot.setEnabled(False)
         self.mdlPlots.updatePlotPersoButton()
-        self.mdlPersos.dataChanged.connect(self.mdlPlots.updatePlotPersoButton)
+        self.mdlCharacter.dataChanged.connect(self.mdlPlots.updatePlotPersoButton)
         self.lstOutlinePlots.setPlotModel(self.mdlPlots)
         self.lstOutlinePlots.setShowSubPlot(True)
-        self.plotPersoDelegate = outlinePersoDelegate(self.mdlPersos, self)
+        self.plotPersoDelegate = outlinePersoDelegate(self.mdlCharacter, self)
         self.lstPlotPerso.setItemDelegate(self.plotPersoDelegate)
         self.plotDelegate = plotDelegate(self)
         self.lstSubPlots.setItemDelegateForColumn(Subplot.meta.value, self.plotDelegate)
@@ -702,18 +702,18 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         # Outline
         self.treeRedacOutline.setModel(self.mdlOutline)
-        self.treeOutlineOutline.setModelPersos(self.mdlPersos)
+        self.treeOutlineOutline.setModelCharacters(self.mdlCharacter)
         self.treeOutlineOutline.setModelLabels(self.mdlLabels)
         self.treeOutlineOutline.setModelStatus(self.mdlStatus)
 
-        self.redacMetadata.setModels(self.mdlOutline, self.mdlPersos,
+        self.redacMetadata.setModels(self.mdlOutline, self.mdlCharacter,
                                      self.mdlLabels, self.mdlStatus)
-        self.outlineItemEditor.setModels(self.mdlOutline, self.mdlPersos,
+        self.outlineItemEditor.setModels(self.mdlOutline, self.mdlCharacter,
                                          self.mdlLabels, self.mdlStatus)
 
         self.treeOutlineOutline.setModel(self.mdlOutline)
         # self.redacEditor.setModel(self.mdlOutline)
-        self.storylineView.setModels(self.mdlOutline, self.mdlPersos, self.mdlPlots)
+        self.storylineView.setModels(self.mdlOutline, self.mdlCharacter, self.mdlPlots)
 
         self.treeOutlineOutline.selectionModel().selectionChanged.connect(lambda:
                                                                           self.outlineItemEditor.selectionChanged(
@@ -735,10 +735,10 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         # Debug
         self.mdlFlatData.setVerticalHeaderLabels(["Infos générales", "Summary"])
         self.tblDebugFlatData.setModel(self.mdlFlatData)
-        self.tblDebugPersos.setModel(self.mdlPersos)
+        self.tblDebugPersos.setModel(self.mdlCharacter)
-        self.tblDebugPersosInfos.setModel(self.mdlPersos)
+        self.tblDebugPersosInfos.setModel(self.mdlCharacter)
         self.tblDebugPersos.selectionModel().currentChanged.connect(
-                lambda: self.tblDebugPersosInfos.setRootIndex(self.mdlPersos.index(
+                lambda: self.tblDebugPersosInfos.setRootIndex(self.mdlCharacter.index(
                         self.tblDebugPersos.selectionModel().currentIndex().row(),
                         Perso.name.value)), AUC)
 

manuskript/models/characterModel.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python
+# --!-- coding: utf8 --!--
+from PyQt5.QtCore import QModelIndex, Qt, QAbstractItemModel, QVariant
+from PyQt5.QtGui import QIcon, QPixmap, QColor
+
+from manuskript.functions import randomColor, iconColor, mainWindow
+from manuskript.enums import Character as C
+
+
+class characterModel(QAbstractItemModel):
+
+    def __init__(self, parent):
+        QAbstractItemModel.__init__(self, parent)
+
+        self.characters = []
+
+###############################################################################
+# QAbstractItemModel subclassed
+###############################################################################
+
+    def rowCount(self, parent=QModelIndex()):
+        if parent.isValid():
+            c = parent.internalPointer()
+            return len(c.infos)
+        else:
+            return len(self.characters)
+
+    def columnCount(self, parent=QModelIndex()):
+        if parent.isValid():
+            # Returns characters infos
+            return 2
+        else:
+            return 1
+
+    def data(self, index, role=Qt.DisplayRole):
+        c = index.internalPointer()
+        if type(c) == Character:
+            if role == Qt.DisplayRole:
+                if index.column() in c._data:
+                    return c._data[index.column()]
+                else:
+                    return QVariant()
+
+        elif type(c) == CharacterInfo:
+            if role == Qt.DisplayRole or role == Qt.EditRole:
+                if index.column() == 0:
+                    return c.description
+                elif index.column() == 1:
+                    return c.value
+
+    def setData(self, index, value, role=Qt.EditRole):
+        c = index.internalPointer()
+        if type(c) == Character:
+            if role == Qt.EditRole:
+                # We update only if data is different
+                if index.column() not in c._data or c._data[index.column()] != value:
+                    c._data[index.column()] = value
+                    self.dataChanged.emit(index, index)
+                    return True
+
+        elif type(c) == CharacterInfo:
+            if role == Qt.EditRole:
+                if index.column() == 0:
+                    c.description = value
+                elif index.column() == 1:
+                    c.value = value
+                self.dataChanged.emit(index, index)
+                return True
+
+        return False
+
+    def index(self, row, column, parent=QModelIndex()):
+        if not parent.isValid():
+            return self.createIndex(row, column, self.characters[row])
+
+        else:
+            c = parent.internalPointer()
+            if row < len(c.infos):
+                return self.createIndex(row, column, c.infos[row])
+            else:
+                return QModelIndex()
+
+    def indexFromItem(self, item, column=0):
+        if not item:
+            return QModelIndex()
+
+        row = self.characters.index(item)
+        col = column
+        return self.createIndex(row, col, item)
+
+    def parent(self, index):
+        if not index.isValid():
+            return QModelIndex()
+
+        child = index.internalPointer()
+
+        if type(child) == Character:
+            return QModelIndex()
+
+        elif type(child) == CharacterInfo:
+            return child.character.index()
+
+    def flags(self, index):
+        if index.parent().isValid():
+            return QAbstractItemModel.flags(self, index) | Qt.ItemIsEditable
+        else:
+            return QAbstractItemModel.flags(self, index)
+
+###############################################################################
+# CHARACTER QUERRIES
+###############################################################################
+
+    def character(self, row):
+        return self.characters[row]
+
+    def name(self, row):
+        return self.character(row).name()
+
+    def icon(self, row):
+        return self.character(row).icon
+
+    def ID(self, row):
+        return self.character(row).ID()
+
+    def importance(self, row):
+        return self.character(row).importance()
+
+###############################################################################
+# MODEL QUERRIES
+###############################################################################
+
+    def getCharactersByImportance(self):
+        """
+        Lists characters by importance.
+
+        @return: array of array of ´character´, by importance.
+        """
+        r = [[], [], []]
+        for c in self.characters:
+            r[2-int(c.importance())].append(c)
+        return r
+
+    def getCharacterByID(self, ID):
+        for c in self.characters:
+            if c.ID() == ID:
+                return c
+        return None
+
+###############################################################################
+# ADDING / REMOVING
+###############################################################################
+
+    def addCharacter(self):
+        """
+        Creates a new character
+        @return: nothing
+        """
+        c = Character(model=self, name=self.tr("New character"))
+        self.beginInsertRows(QModelIndex(), len(self.characters), len(self.characters))
+        self.characters.append(c)
+        self.endInsertRows()
+
+    def removeCharacter(self, ID):
+        """
+        Removes character whose ID is ID...
+        @param ID: the ID of the character to remove
+        @return: nothing
+        """
+        c = self.getCharacterByID(ID)
+        self.beginRemoveRows(QModelIndex(), self.characters.index(c), self.characters.index(c))
+        self.characters.remove(c)
+
+###############################################################################
+# CHARACTER INFOS
+###############################################################################
+
+    def headerData(self, section, orientation, role=Qt.DisplayRole):
+        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
+            if section == 0:
+                return self.tr("Name")
+            elif section == 1:
+                return self.tr("Value")
+            else:
+                return C(section).name
+
+    def addCharacterInfo(self, ID):
+        c = self.getCharacterByID(ID)
+        self.beginInsertRows(c.index(), len(c.infos), len(c.infos))
+        c.infos.append(CharacterInfo(c, description="Description", value="Value"))
+        self.endInsertRows()
+
+        mainWindow().updatePersoInfoView()
+
+    def removeCharacterInfo(self, ID):
+        c = self.getCharacterByID(ID)
+
+        rm = []
+        for idx in mainWindow().tblPersoInfos.selectedIndexes():
+            if not idx.row() in rm:
+                rm.append(idx.row())
+
+        rm.sort()
+        rm.reverse()
+        for r in rm:
+            self.beginRemoveRows(c.index(), r, r)
+            c.infos.pop(r)
+            self.endRemoveRows()
+
+###############################################################################
+# CHARACTER
+###############################################################################
+
+class Character():
+    def __init__(self, model, name):
+        self._model = model
+
+        self._data = {}
+        self._data[C.name.value] = name
+        self.assignUniqueID()
+        self.assignRandomColor()
+        self._data[C.importance.value] = "0"
+
+        self.infos = []
+
+    def name(self):
+        return self._data[C.name.value]
+
+    def importance(self):
+        return self._data[C.importance.value]
+
+    def ID(self):
+        return self._data[C.ID.value]
+
+    def index(self, column=0):
+        return self._model.indexFromItem(self, column)
+
+    def assignRandomColor(self):
+        """
+        Assigns a random color the the character.
+        """
+        color = randomColor(QColor(Qt.white))
+        self.setColor(color)
+
+    def setColor(self, color):
+        """
+        Sets the character's color
+        @param color: QColor.
+        """
+        px = QPixmap(32, 32)
+        px.fill(color)
+        self.icon = QIcon(px)
+        try:
+            self._model.dataChanged.emit(self.index(), self.index())
+        except:
+            # If it is the initialisation, won't be able to emit
+            pass
+
+    def color(self):
+        """
+        Returns character's color in QColor
+        @return: QColor
+        """
+        return iconColor(self.icon)
+
+    def assignUniqueID(self, parent=QModelIndex()):
+        """Assigns an unused character ID."""
+        vals = []
+        for c in self._model.characters:
+            vals.append(c.ID())
+
+        k = 0
+        while k in vals:
+            k += 1
+
+        self._data[C.ID.value] = k
+
+class CharacterInfo():
+    def __init__(self, character, description="", value=""):
+        self.description = description
+        self.value = value
+        self.character = character

manuskript/models/outlineModel.py

@@ -855,7 +855,7 @@ class outlineItem():
         for c in columns:
 
             if c == Outline.POV.value:
-                searchIn = mainWindow.mdlPersos.getPersoNameByID(self.POV())
+                searchIn = mainWindow.mdlCharacter.getPersoNameByID(self.POV())
 
             elif c == Outline.status.value:
                 searchIn = mainWindow.mdlStatus.item(toInt(self.status()), 0).text()

manuskript/models/persosModel.py

@@ -1,183 +0,0 @@
-#!/usr/bin/env python
-# --!-- coding: utf8 --!--
-from PyQt5.QtCore import QModelIndex, Qt
-from PyQt5.QtGui import QStandardItemModel, QStandardItem, QColor, QPixmap, QIcon
-from PyQt5.QtWidgets import QColorDialog
-
-from manuskript.enums import Perso
-from manuskript.enums import Plot
-from manuskript.functions import iconColor
-from manuskript.functions import mainWindow
-from manuskript.functions import randomColor
-from manuskript.functions import toInt
-
-
-class persosModel(QStandardItemModel):
-    
-    def __init__(self, parent):
-        QStandardItemModel.__init__(self, 0, 3, parent)
-        self.setHorizontalHeaderLabels([i.name for i in Perso])
-        self.mw = mainWindow()
-        # self._proxy = plotsProxyModel()
-        # self._proxy.setSourceModel(self)
-
-###############################################################################
-# PERSOS QUERRIES
-###############################################################################
-
-    def name(self, row):
-        return self.item(row, Perso.name.value).text()
-    
-    def icon(self, row):
-        return self.item(row, Perso.name.value).icon()
-    
-    def ID(self, row):
-        return self.item(row, Perso.ID.value).text()
-    
-    def importance(self, row):
-        return self.item(row, Perso.importance.value).text()
-
-###############################################################################
-# MODEL QUERRIES
-###############################################################################
-
-    def getPersosByImportance(self):
-        persos = [[], [], []]
-        for i in range(self.rowCount()):
-            importance = self.item(i, Perso.importance.value).text()
-            ID = self.item(i, Perso.ID.value).text()
-            persos[2-toInt(importance)].append(ID)
-        return persos
-    
-    def getPersoNameByID(self, ID):
-        index = self.getIndexFromID(ID)
-        if index.isValid():
-            return self.name(index.row())
-        return ""
-    
-    def getIndexFromID(self, ID):
-        for i in range(self.rowCount()):
-            _ID = self.item(i, Perso.ID.value).text()
-            if _ID == ID or toInt(_ID) == ID:
-                return self.index(i, 0)
-        return QModelIndex()
-    
-    def getPersoColorByID(self, ID):
-        idx = self.getIndexFromID(ID)
-        return self.getPersoColorName(idx)
-    
-    def getPersoColorName(self, index):
-        icon = self.item(index.row()).icon()
-        return iconColor(icon).name() if icon else ""
-        
-    def currentListIndex(self):
-        i = self.mw.lstPersos.currentIndex()
-        if i .isValid():
-            return i
-        else:
-            return None
-        
-    def currentPersoIndex(self):
-        return self.mw.lstPersos.currentPersoIndex()
-
-###############################################################################
-# ADDING / REMOVING
-###############################################################################
-    
-    def addPerso(self):
-        """Creates a perso by adding a row in mdlPersos
-        and a column in mdlPersosInfos with same ID"""
-        p = QStandardItem(self.tr("New character"))
-        self.setPersoColor(p, randomColor(QColor(Qt.white)))
-        
-        pid = self.getUniqueID()
-        self.appendRow([p, QStandardItem(pid), QStandardItem("0")])
-            
-    def getUniqueID(self, parent=QModelIndex()):
-        """Returns an unused perso ID (row 1)."""
-        vals = []
-        for i in range(self.rowCount(parent)):
-            index = self.index(i, Perso.ID.value, parent)
-            if index.isValid() and index.data():
-                vals.append(int(index.data()))
-
-        k = 0
-        while k in vals:
-            k += 1
-        return str(k)
-        
-    def removePerso(self):
-        index = self.currentPersoIndex()
-        self.takeRow(index.row())
-        
-    def setPersoColor(self, item, color):
-        px = QPixmap(32, 32)
-        px.fill(color)
-        item.setIcon(QIcon(px))
-        
-    def chosePersoColor(self):
-        idx = self.currentPersoIndex()
-        item = self.item(idx.row(), Perso.name.value)
-        if item:
-            color = iconColor(item.icon())
-        else:
-            color = Qt.white
-        self.colorDialog = QColorDialog(color, self.mw)
-        color = self.colorDialog.getColor(color)
-        if color.isValid():
-            self.setPersoColor(item, color)
-            self.updatePersoColor(idx)
-
-###############################################################################
-# UI
-###############################################################################
-
-    def updatePersoColor(self, idx):
-        # idx = self.currentPersoIndex()
-        color = self.getPersoColorName(idx)
-        self.mw.btnPersoColor.setStyleSheet("background:{};".format(color))
-        
-###############################################################################
-# PERSO INFOS
-###############################################################################
-
-    def headerData(self, section, orientation, role=Qt.DisplayRole):
-        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
-            if section == Perso.infoName.value:
-                return self.tr("Name")
-            elif section == Perso.infoData.value:
-                return self.tr("Value")
-            else:
-                return Perso(section).name
-        else:
-            return QStandardItemModel.headerData(self, section, orientation, role)
-
-    def addPersoInfo(self):
-        perso = self.itemFromIndex(self.currentPersoIndex())
-        row = perso.rowCount()
-        perso.setChild(row, Perso.infoName.value, QStandardItem(""))
-        perso.setChild(row, Perso.infoData.value, QStandardItem(""))
-        
-        self.mw.updatePersoInfoView()
-        
-    def removePersoInfo(self):
-        perso = self.itemFromIndex(self.currentPersoIndex())
-        
-        rm = []
-        for idx in self.mw.tblPersoInfos.selectedIndexes():
-            if not idx.row() in rm:
-                rm.append(idx.row())
-        
-        rm.sort()
-        rm.reverse()
-        for r in rm:
-            perso.takeRow(r)
-            
-    def listPersoInfos(self, index):
-        infos = []
-        for i in range(self.rowCount(index)):
-            name = self.data(index.child(i, Perso.infoName.value))
-            val = self.data(index.child(i, Perso.infoData.value))
-            infos.append((name, val))
-            
-        return infos

manuskript/models/plotModel.py

@@ -212,13 +212,13 @@ class plotModel(QStandardItemModel):
             menu.addMenu(m)
 
         mpr = QSignalMapper(menu)
-        for i in range(self.mw.mdlPersos.rowCount()):
+        for i in range(self.mw.mdlCharacter.rowCount()):
-            a = QAction(self.mw.mdlPersos.name(i), menu)
+            a = QAction(self.mw.mdlCharacter.name(i), menu)
-            a.setIcon(self.mw.mdlPersos.icon(i))
+            a.setIcon(self.mw.mdlCharacter.icon(i))
             a.triggered.connect(mpr.map)
-            mpr.setMapping(a, int(self.mw.mdlPersos.ID(i)))
+            mpr.setMapping(a, int(self.mw.mdlCharacter.ID(i)))
 
-            imp = toInt(self.mw.mdlPersos.importance(i))
+            imp = toInt(self.mw.mdlCharacter.importance(i))
 
             menus[2 - imp].addAction(a)
 

manuskript/models/references.py

@@ -11,7 +11,7 @@ import re
 from PyQt5.QtWidgets import qApp
 
 from manuskript.enums import Outline
-from manuskript.enums import Perso
+from manuskript.enums import Character
 from manuskript.enums import Plot
 from manuskript.enums import Subplot
 from manuskript.functions import mainWindow
@@ -104,7 +104,7 @@ def infos(ref):
         if item.POV():
             POV = "<a href='{ref}'>{text}</a>".format(
                     ref=persoReference(item.POV()),
-                    text=mainWindow().mdlPersos.getPersoNameByID(item.POV()))
+                    text=mainWindow().mdlCharacter.getCharacterByID(item.POV()).name())
 
         # The status of the scene
         status = item.status()
@@ -175,7 +175,7 @@ def infos(ref):
 
     # A character
     elif _type == PersoLetter:
-        m = mainWindow().mdlPersos
+        m = mainWindow().mdlCharacter
         index = m.getIndexFromID(_ref)
         name = m.name(index.row())
 
@@ -272,7 +272,7 @@ def infos(ref):
                                       Plot.result.value))
 
         # Characters
-        pM = mainWindow().mdlPersos
+        pM = mainWindow().mdlCharacter
         item = m.item(index.row(), Plot.persos.value)
         characters = ""
         if item:
@@ -412,7 +412,7 @@ def shortInfos(ref):
 
         infos["type"] = PersoLetter
 
-        m = mainWindow().mdlPersos
+        m = mainWindow().mdlCharacter
         item = m.item(int(_ref), Perso.name.value)
         if item:
             infos["title"] = item.text()
@@ -516,7 +516,7 @@ def refToLink(ref):
                 text = item.title()
 
         elif _type == PersoLetter:
-            m = mainWindow().mdlPersos
+            m = mainWindow().mdlCharacter
             text = m.item(int(_ref), Perso.name.value).text()
 
         elif _type == PlotLetter:
@@ -620,11 +620,12 @@ def open(ref):
 
     if _type == PersoLetter:
         mw = mainWindow()
+        # FIXME
         item = mw.lstPersos.getItemByID(_ref)
 
         if item:
             mw.tabMain.setCurrentIndex(mw.TabPersos)
-            mw.lstPersos.setCurrentItem(item)
+            mw.lstCharacters.setCurrentItem(item)
             return True
 
         print("Ref not found")

manuskript/ui/cheatSheet.py

@@ -4,7 +4,7 @@ from PyQt5.QtCore import pyqtSignal, Qt, QTimer, QRect
 from PyQt5.QtGui import QBrush, QCursor, QPalette, QFontMetrics
 from PyQt5.QtWidgets import QWidget, QListWidgetItem, QToolTip, QStyledItemDelegate, QStyle
 
-from manuskript.enums import Perso
+from manuskript.enums import Character
 from manuskript.enums import Plot
 from manuskript.functions import lightBlue
 from manuskript.functions import mainWindow
@@ -36,7 +36,7 @@ class cheatSheet(QWidget, Ui_cheatSheet):
         self.line.hide()
 
         self.outlineModel = None
-        self.persoModel = None
+        self.characterModel = None
         self.plotModel = None
         self.worldModel = None
 
@@ -53,12 +53,12 @@ class cheatSheet(QWidget, Ui_cheatSheet):
     def setModels(self):
         mw = mainWindow()
         self.outlineModel = mw.mdlOutline
-        self.persoModel = mw.mdlPersos
+        self.characterModel = mw.mdlCharacter
         self.plotModel = mw.mdlPlots
         self.worldModel = mw.mdlWorld
 
         self.outlineModel.dataChanged.connect(self.populateTimer.start)
-        self.persoModel.dataChanged.connect(self.populateTimer.start)
+        self.characterModel.dataChanged.connect(self.populateTimer.start)
         self.plotModel.dataChanged.connect(self.populateTimer.start)
         self.worldModel.dataChanged.connect(self.populateTimer.start)
 
@@ -75,15 +75,12 @@ class cheatSheet(QWidget, Ui_cheatSheet):
             self.list.hide()
 
     def populate(self):
-        if self.persoModel:
+        if self.characterModel:
             d = []
 
-            for r in range(self.persoModel.rowCount()):
+            for c in self.characterModel.characters:
-                name = self.persoModel.item(r, Perso.name.value).text()
+                imp = [self.tr("Minor"), self.tr("Secondary"), self.tr("Main")][int(c.importance())]
-                ID = self.persoModel.item(r, Perso.ID.value).text()
+                d.append((c.name(), c.ID(), imp))
-                imp = self.persoModel.item(r, Perso.importance.value).text()
-                imp = [self.tr("Minor"), self.tr("Secondary"), self.tr("Main")][int(imp)]
-                d.append((name, ID, imp))
 
             self.data[(self.tr("Characters"), Ref.PersoLetter)] = d
 

manuskript/ui/editors/editorWidget.py

@@ -173,7 +173,7 @@ class editorWidget(QWidget, Ui_editorWidget_ui):
 
         elif item and item.isFolder() and self.folderView == "outline":
             self.stack.setCurrentIndex(3)
-            self.outlineView.setModelPersos(mainWindow().mdlPersos)
+            self.outlineView.setModelCharacters(mainWindow().mdlCharacter)
             self.outlineView.setModelLabels(mainWindow().mdlLabels)
             self.outlineView.setModelStatus(mainWindow().mdlStatus)
             self.outlineView.setModel(self.mw.mdlOutline)

manuskript/ui/mainWindow.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'manuskript/ui/mainWindow.ui'
 #
-# Created: Wed Mar  2 00:30:17 2016
+# Created: Thu Mar  3 13:40:20 2016
 #      by: PyQt5 UI code generator 5.2.1
 #
 # WARNING! All changes made in this file will be lost!
@@ -337,12 +337,12 @@ class Ui_MainWindow(object):
         self.groupBox.setObjectName("groupBox")
         self.verticalLayout_8 = QtWidgets.QVBoxLayout(self.groupBox)
         self.verticalLayout_8.setObjectName("verticalLayout_8")
-        self.lstPersos = persoTreeView(self.groupBox)
+        self.lstCharacters = characterTreeView(self.groupBox)
-        self.lstPersos.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.lstCharacters.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.lstPersos.setDragEnabled(True)
+        self.lstCharacters.setDragEnabled(True)
-        self.lstPersos.setObjectName("lstPersos")
+        self.lstCharacters.setObjectName("lstCharacters")
-        self.lstPersos.headerItem().setText(0, "1")
+        self.lstCharacters.headerItem().setText(0, "1")
-        self.verticalLayout_8.addWidget(self.lstPersos)
+        self.verticalLayout_8.addWidget(self.lstCharacters)
         self.horizontalLayout_14 = QtWidgets.QHBoxLayout()
         self.horizontalLayout_14.setObjectName("horizontalLayout_14")
         self.btnAddPerso = QtWidgets.QPushButton(self.groupBox)
@@ -1166,7 +1166,7 @@ class Ui_MainWindow(object):
 
         self.retranslateUi(MainWindow)
         self.stack.setCurrentIndex(1)
-        self.tabMain.setCurrentIndex(6)
+        self.tabMain.setCurrentIndex(2)
         self.tabSummary.setCurrentIndex(0)
         self.tabPersos.setCurrentIndex(0)
         self.tabPlot.setCurrentIndex(0)
@@ -1303,18 +1303,18 @@ class Ui_MainWindow(object):
         self.actCompile.setShortcut(_translate("MainWindow", "F6"))
         self.actToolFrequency.setText(_translate("MainWindow", "&Frequency Analyzer"))
 
-from manuskript.ui.views.storylineView import storylineView
+from manuskript.ui.search import search
-from manuskript.ui.views.textEditView import textEditView
-from manuskript.ui.views.lineEditView import lineEditView
-from manuskript.ui.views.treeView import treeView
-from manuskript.ui.editors.mainEditor import mainEditor
-from manuskript.ui.views.basicItemView import basicItemView
-from manuskript.ui.views.persoTreeView import persoTreeView
-from manuskript.ui.views.plotTreeView import plotTreeView
-from manuskript.ui.views.outlineView import outlineView
-from manuskript.ui.views.metadataView import metadataView
 from manuskript.ui.cheatSheet import cheatSheet
 from manuskript.ui.views.textEditCompleter import textEditCompleter
-from manuskript.ui.sldImportance import sldImportance
+from manuskript.ui.views.lineEditView import lineEditView
 from manuskript.ui.welcome import welcome
-from manuskript.ui.search import search
+from manuskript.ui.views.characterTreeView import characterTreeView
+from manuskript.ui.sldImportance import sldImportance
+from manuskript.ui.views.plotTreeView import plotTreeView
+from manuskript.ui.views.basicItemView import basicItemView
+from manuskript.ui.views.outlineView import outlineView
+from manuskript.ui.views.metadataView import metadataView
+from manuskript.ui.views.treeView import treeView
+from manuskript.ui.editors.mainEditor import mainEditor
+from manuskript.ui.views.storylineView import storylineView
+from manuskript.ui.views.textEditView import textEditView

manuskript/ui/mainWindow.ui

@@ -124,7 +124,7 @@
            <enum>QTabWidget::Rounded</enum>
           </property>
           <property name="currentIndex">
-           <number>6</number>
+           <number>2</number>
           </property>
           <property name="documentMode">
            <bool>true</bool>
@@ -714,7 +714,7 @@
                </property>
                <layout class="QVBoxLayout" name="verticalLayout_8">
                 <item>
-                 <widget class="persoTreeView" name="lstPersos">
+                 <widget class="characterTreeView" name="lstCharacters">
                   <property name="horizontalScrollBarPolicy">
                    <enum>Qt::ScrollBarAlwaysOff</enum>
                   </property>
@@ -2396,9 +2396,9 @@ QListView::item:hover {
    <container>1</container>
   </customwidget>
   <customwidget>
-   <class>persoTreeView</class>
+   <class>characterTreeView</class>
    <extends>QTreeWidget</extends>
-   <header>manuskript.ui.views.persoTreeView.h</header>
+   <header>manuskript.ui.views.characterTreeView.h</header>
   </customwidget>
   <customwidget>
    <class>cheatSheet</class>

manuskript/ui/views/basicItemView.py

@@ -14,8 +14,8 @@ class basicItemView(QWidget, Ui_basicItemView):
         self.txtSummaryFull.setColumn(Outline.summaryFull.value)
         self.txtGoal.setColumn(Outline.setGoal.value)
 
-    def setModels(self, mdlOutline, mdlPersos, mdlLabels, mdlStatus):
+    def setModels(self, mdlOutline, mdlCharacter, mdlLabels, mdlStatus):
-        self.cmbPOV.setModels(mdlPersos, mdlOutline)
+        self.cmbPOV.setModels(mdlCharacter, mdlOutline)
         self.txtSummarySentence.setModel(mdlOutline)
         self.txtSummaryFull.setModel(mdlOutline)
         self.txtGoal.setModel(mdlOutline)

manuskript/ui/views/characterTreeView.py

@@ -2,12 +2,16 @@
 # --!-- coding: utf8 --!--
 from PyQt5.QtCore import QSize, QModelIndex, Qt
 from PyQt5.QtGui import QPixmap, QColor, QIcon, QBrush
-from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem
+from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QColorDialog
 
-from manuskript.enums import Perso
+from manuskript.enums import Character
+from manuskript.functions import iconColor, mainWindow
 
 
-class persoTreeView(QTreeWidget):
+class characterTreeView(QTreeWidget):
+    """
+    A QTreeWidget that displays characters from a characterModel in respect of their importance.
+    """
     def __init__(self, parent=None):
         QTreeWidget.__init__(self, parent)
         self._model = None
@@ -24,7 +28,7 @@ class persoTreeView(QTreeWidget):
         self._rootItem = QTreeWidgetItem()
         self.insertTopLevelItem(0, self._rootItem)
 
-    def setPersosModel(self, model):
+    def setCharactersModel(self, model):
         self._model = model
         self._model.dataChanged.connect(self.updateMaybe)
         self._model.rowsInserted.connect(self.updateMaybe2)
@@ -39,11 +43,11 @@ class persoTreeView(QTreeWidget):
         if topLeft.parent() != QModelIndex():
             return
 
-        if topLeft.column() <= Perso.name.value <= bottomRight.column():
+        if topLeft.column() <= Character.name.value <= bottomRight.column():
             # Update name
             self.updateNames()
 
-        elif topLeft.column() <= Perso.importance.value <= bottomRight.column():
+        elif topLeft.column() <= Character.importance.value <= bottomRight.column():
             # Importance changed
             self.updateItems()
 
@@ -56,16 +60,17 @@ class persoTreeView(QTreeWidget):
         for i in range(self.topLevelItemCount()):
             item = self.topLevelItem(i)
 
-            for c in range(item.childCount()):
+            for child in range(item.childCount()):
-                sub = item.child(c)
+                sub = item.child(child)
                 ID = sub.data(0, Qt.UserRole)
-                if ID:
+                if ID is not None:
                     # Update name
-                    name = self._model.getPersoNameByID(ID)
+                    c = self._model.getCharacterByID(ID)
+                    name = c.name()
                     sub.setText(0, name)
                     # Update icon
                     px = QPixmap(32, 32)
-                    color = QColor(self._model.getPersoColorByID(ID))
+                    color = c.color()
                     px.fill(color)
                     sub.setIcon(0, QIcon(px))
 
@@ -78,10 +83,12 @@ class persoTreeView(QTreeWidget):
 
         self._updating = True
         self.clear()
-        persos = self._model.getPersosByImportance()
+        characters = self._model.getCharactersByImportance()
 
         h = [self.tr("Main"), self.tr("Secondary"), self.tr("Minor")]
+
         for i in range(3):
+            # Create category item
             cat = QTreeWidgetItem(self, [h[i]])
             cat.setBackground(0, QBrush(QColor(Qt.blue).lighter(190)))
             cat.setForeground(0, QBrush(Qt.darkBlue))
@@ -92,36 +99,67 @@ class persoTreeView(QTreeWidget):
             self.addTopLevelItem(cat)
             # cat.setChildIndicatorPolicy(cat.DontShowIndicator)
 
-            for ID in persos[i]:
+            for c in characters[i]:
-                name = self._model.getPersoNameByID(ID)
+                name = c.name()
+                # Check if name passes filter
                 if not self._filter.lower() in name.lower():
                     continue
+
                 item = QTreeWidgetItem(cat, [name])
-                item.setData(0, Qt.UserRole, ID)
+                item.setData(0, Qt.UserRole, c.ID())
                 px = QPixmap(32, 32)
-                color = QColor(self._model.getPersoColorByID(ID))
+                color = QColor(c.color())
                 px.fill(color)
                 item.setIcon(0, QIcon(px))
 
-                if ID == self._lastID:
+                if c.ID() == self._lastID:
                     self.setCurrentItem(item)
 
         self.expandAll()
         self._updating = False
 
-    def getItemByID(self, ID):
+    def removeCharacter(self):
-        for t in range(self.topLevelItemCount()):
+        """
-            for i in range(self.topLevelItem(t).childCount()):
+        Removes selected character.
-                item = self.topLevelItem(t).child(i)
+        """
-                if item.data(0, Qt.UserRole) == ID:
+        ID = self.currentCharacterID()
-                    return item
+        if ID:
+            self._model.removeCharacter(ID)
 
-    def currentPersoIndex(self):
+    def choseCharacterColor(self):
+        ID = self.currentCharacterID()
+        c = self._model.getCharacterByID(ID)
+        if c:
+            color = iconColor(c.icon)
+        else:
+            color = Qt.white
+        self.colorDialog = QColorDialog(color, mainWindow())
+        color = self.colorDialog.getColor(color)
+        if color.isValid():
+            c.setColor(color)
+            mainWindow().updateCharacterColor(ID)
+
+    def addCharacterInfo(self):
+        self._model.addCharacterInfo(self.currentCharacterID())
+
+    def removeCharacterInfo(self):
+        self._model.removeCharacterInfo(self.currentCharacterID(),
+                                        )
+
+    def currentCharacterID(self):
         ID = None
         if self.currentItem():
             ID = self.currentItem().data(0, Qt.UserRole)
 
-        return self._model.getIndexFromID(ID)
+        return ID
+
+    def currentCharacter(self):
+        """
+        Returns the selected character
+        @return: Character
+        """
+        ID = self.currentCharacterID()
+        return self._model.getCharacterByID(ID)
 
     def mouseDoubleClickEvent(self, event):
         item = self.currentItem()

manuskript/ui/views/cmbOutlinePersoChoser.py

@@ -18,9 +18,9 @@ class cmbOutlinePersoChoser(QComboBox):
         self._updating = False
         self._various = False
 
-    def setModels(self, mdlPersos, mdlOutline):
+    def setModels(self, mdlCharacter, mdlOutline):
-        self.mdlPersos = mdlPersos
+        self.mdlCharacters = mdlCharacter
-        self.mdlPersos.dataChanged.connect(self.updateItems)
+        self.mdlCharacters.dataChanged.connect(self.updateItems)
         self.mdlOutline = mdlOutline
         self.mdlOutline.dataChanged.connect(self.update)
         self.updateItems()
@@ -37,14 +37,14 @@ class cmbOutlinePersoChoser(QComboBox):
             self.setItemData(self.count() - 1, QBrush(QColor(Qt.blue).lighter(190)), Qt.BackgroundRole)
             item = self.model().item(self.count() - 1)
             item.setFlags(Qt.ItemIsEnabled)
-            for i in range(self.mdlPersos.rowCount()):
+            for i in range(self.mdlCharacters.rowCount()):
-                imp = toInt(self.mdlPersos.importance(i))
+                imp = toInt(self.mdlCharacters.importance(i))
 
                 if not 2 - imp == importance:
                     continue
 
-                self.addItem(self.mdlPersos.icon(i), self.mdlPersos.name(i), self.mdlPersos.ID(i))
+                self.addItem(self.mdlCharacters.icon(i), self.mdlCharacters.name(i), self.mdlCharacters.ID(i))
-                self.setItemData(self.count() - 1, self.mdlPersos.name(i), Qt.ToolTipRole)
+                self.setItemData(self.count() - 1, self.mdlCharacters.name(i), Qt.ToolTipRole)
 
         self._various = False
 

manuskript/ui/views/metadataView.py

@@ -16,8 +16,8 @@ class metadataView(QWidget, Ui_metadataView):
         self.txtNotes.setColumn(Outline.notes.value)
         self.revisions.setEnabled(False)
 
-    def setModels(self, mdlOutline, mdlPersos, mdlLabels, mdlStatus):
+    def setModels(self, mdlOutline, mdlCharacter, mdlLabels, mdlStatus):
-        self.properties.setModels(mdlOutline, mdlPersos, mdlLabels, mdlStatus)
+        self.properties.setModels(mdlOutline, mdlCharacter, mdlLabels, mdlStatus)
         self.txtSummarySentence.setModel(mdlOutline)
         self.txtSummaryFull.setModel(mdlOutline)
         self.txtNotes.setModel(mdlOutline)

manuskript/ui/views/outlineBasics.py

@@ -83,12 +83,12 @@ class outlineBasics(QAbstractItemView):
             self.menuPOV.addMenu(m)
 
         mpr = QSignalMapper(self.menuPOV)
-        for i in range(mw.mdlPersos.rowCount()):
+        for i in range(mw.mdlCharacter.rowCount()):
-            a = QAction(mw.mdlPersos.icon(i), mw.mdlPersos.name(i), self.menuPOV)
+            a = QAction(mw.mdlCharacter.icon(i), mw.mdlCharacter.name(i), self.menuPOV)
             a.triggered.connect(mpr.map)
-            mpr.setMapping(a, int(mw.mdlPersos.ID(i)))
+            mpr.setMapping(a, int(mw.mdlCharacter.ID(i)))
 
-            imp = toInt(mw.mdlPersos.importance(i))
+            imp = toInt(mw.mdlCharacter.importance(i))
 
             menus[2 - imp].addAction(a)
 

manuskript/ui/views/outlineDelegates.py

@@ -6,7 +6,7 @@ from PyQt5.QtWidgets import QStyledItemDelegate, QStyleOptionViewItem, QStyle, Q
 from PyQt5.QtWidgets import qApp
 
 from manuskript import settings
-from manuskript.enums import Perso, Outline
+from manuskript.enums import Character, Outline
 from manuskript.functions import outlineItemColors, mixColors, colorifyPixmap, toInt, toFloat, drawProgress
 
 
@@ -93,17 +93,17 @@ class outlineTitleDelegate(QStyledItemDelegate):
 
 
 class outlinePersoDelegate(QStyledItemDelegate):
-    def __init__(self, mdlPersos, parent=None):
+    def __init__(self, mdlCharacter, parent=None):
         QStyledItemDelegate.__init__(self, parent)
-        self.mdlPersos = mdlPersos
+        self.mdlCharacter = mdlCharacter
 
     def sizeHint(self, option, index):
         # s = QStyledItemDelegate.sizeHint(self, option, index)
 
         item = QModelIndex()
-        for i in range(self.mdlPersos.rowCount()):
+        for i in range(self.mdlCharacter.rowCount()):
-            if self.mdlPersos.ID(i) == index.data():
+            if self.mdlCharacter.ID(i) == index.data():
-                item = self.mdlPersos.index(i, Perso.name.value)
+                item = self.mdlCharacter.index(i, Character.name.value)
 
         opt = QStyleOptionViewItem(option)
         self.initStyleOption(opt, item)
@@ -136,13 +136,13 @@ class outlinePersoDelegate(QStyledItemDelegate):
             editor.setItemData(editor.count() - 1, QBrush(QColor(Qt.blue).lighter(190)), Qt.BackgroundRole)
             item = editor.model().item(editor.count() - 1)
             item.setFlags(Qt.ItemIsEnabled)
-            for i in range(self.mdlPersos.rowCount()):
+            for i in range(self.mdlCharacter.rowCount()):
-                imp = toInt(self.mdlPersos.importance(i))
+                imp = toInt(self.mdlCharacter.importance(i))
                 if not 2 - imp == importance: continue
 
                 # try:
-                editor.addItem(self.mdlPersos.icon(i), self.mdlPersos.name(i), self.mdlPersos.ID(i))
+                editor.addItem(self.mdlCharacter.icon(i), self.mdlCharacter.name(i), self.mdlCharacter.ID(i))
-                editor.setItemData(editor.count() - 1, self.mdlPersos.name(i), Qt.ToolTipRole)
+                editor.setItemData(editor.count() - 1, self.mdlCharacter.name(i), Qt.ToolTipRole)
                 # except:
                 # pass
 
@@ -159,9 +159,9 @@ class outlinePersoDelegate(QStyledItemDelegate):
         ##option.rect.setWidth(option.rect.width() + 18)
 
         item = QModelIndex()
-        for i in range(self.mdlPersos.rowCount()):
+        for i in range(self.mdlCharacter.rowCount()):
-            if self.mdlPersos.ID(i) == index.data():
+            if self.mdlCharacter.ID(i) == index.data():
-                item = self.mdlPersos.index(i, Perso.name.value)
+                item = self.mdlCharacter.index(i, Character.name.value)
 
         opt = QStyleOptionViewItem(option)
         self.initStyleOption(opt, item)
@@ -169,7 +169,7 @@ class outlinePersoDelegate(QStyledItemDelegate):
         qApp.style().drawControl(QStyle.CE_ItemViewItem, opt, painter)
 
         # if index.isValid() and index.internalPointer().data(Outline.POV.value) not in ["", None]:
-        if index.isValid() and self.mdlPersos.data(index) not in ["", None]:
+        if index.isValid() and self.mdlCharacter.data(index) not in ["", None]:
             opt = QStyleOptionComboBox()
             opt.rect = option.rect
             r = qApp.style().subControlRect(QStyle.CC_ComboBox, opt, QStyle.SC_ComboBoxArrow)

manuskript/ui/views/outlineView.py

@@ -11,20 +11,20 @@ from manuskript.ui.views.outlineDelegates import outlineTitleDelegate, outlinePe
 
 
 class outlineView(QTreeView, dndView, outlineBasics):
-    def __init__(self, parent=None, modelPersos=None, modelLabels=None, modelStatus=None):
+    def __init__(self, parent=None, modelCharacters=None, modelLabels=None, modelStatus=None):
         QTreeView.__init__(self, parent)
         dndView.__init__(self)
         outlineBasics.__init__(self, parent)
 
-        self.modelPersos = modelPersos
+        self.modelCharacters = modelCharacters
         self.modelLabels = modelLabels
         self.modelStatus = modelStatus
 
         self.header().setStretchLastSection(False)
 
-    def setModelPersos(self, model):
+    def setModelCharacters(self, model):
         # This is used by outlinePersoDelegate to select character
-        self.modelPersos = model
+        self.modelCharacters = model
 
     def setModelLabels(self, model):
         # This is used by outlineLabelDelegate to display labels
@@ -41,7 +41,7 @@ class outlineView(QTreeView, dndView, outlineBasics):
         self.outlineTitleDelegate = outlineTitleDelegate(self)
         # self.outlineTitleDelegate.setView(self)
         self.setItemDelegateForColumn(Outline.title.value, self.outlineTitleDelegate)
-        self.outlinePersoDelegate = outlinePersoDelegate(self.modelPersos)
+        self.outlinePersoDelegate = outlinePersoDelegate(self.modelCharacters)
         self.setItemDelegateForColumn(Outline.POV.value, self.outlinePersoDelegate)
         self.outlineCompileDelegate = outlineCompileDelegate()
         self.setItemDelegateForColumn(Outline.compile.value, self.outlineCompileDelegate)

manuskript/ui/views/propertiesView.py

@@ -12,8 +12,8 @@ class propertiesView(QWidget, Ui_propertiesView):
         self.setupUi(self)
         self.txtGoal.setColumn(Outline.setGoal.value)
 
-    def setModels(self, mdlOutline, mdlPersos, mdlLabels, mdlStatus):
+    def setModels(self, mdlOutline, mdlCharacter, mdlLabels, mdlStatus):
-        self.cmbPOV.setModels(mdlPersos, mdlOutline)
+        self.cmbPOV.setModels(mdlCharacter, mdlOutline)
         self.cmbLabel.setModels(mdlLabels, mdlOutline)
         self.cmbStatus.setModels(mdlStatus, mdlOutline)
         self.cmbType.setModel(mdlOutline)

manuskript/ui/views/storylineView.py

@@ -46,7 +46,7 @@ class storylineView(QWidget, Ui_storylineView):
 
         self.btnSettings.setMenu(m)
 
-    def setModels(self, mdlOutline, mdlPersos, mdlPlots):
+    def setModels(self, mdlOutline, mdlCharacter, mdlPlots):
         self._mdlPlots = mdlPlots
         # self._mdlPlots.dataChanged.connect(self.refresh)
         # self._mdlPlots.rowsInserted.connect(self.refresh)
@@ -54,8 +54,8 @@ class storylineView(QWidget, Ui_storylineView):
         self._mdlOutline = mdlOutline
         self._mdlOutline.dataChanged.connect(self.reloadTimer.start)
 
-        self._mdlPersos = mdlPersos
+        self._mdlCharacter = mdlCharacter
-        self._mdlPersos.dataChanged.connect(self.reloadTimer.start)
+        self._mdlCharacter.dataChanged.connect(self.reloadTimer.start)
 
     def plotReferences(self):
         "Returns a list of plot references"
@@ -73,10 +73,10 @@ class storylineView(QWidget, Ui_storylineView):
 
     def persosReferences(self):
         "Returns a list of character references"
-        if not self._mdlPersos:
+        if not self._mdlCharacter:
             pass
 
-        IDs = self._mdlPersos.getPersosByImportance()
+        IDs = self._mdlCharacter.getPersosByImportance()
         r = []
         for importance in IDs:
             for ID in importance:
@@ -86,7 +86,7 @@ class storylineView(QWidget, Ui_storylineView):
         return r
 
     def refresh(self):
-        if not self._mdlPlots or not self._mdlOutline or not self._mdlPersos:
+        if not self._mdlPlots or not self._mdlOutline or not self._mdlCharacter:
             pass
 
         LINE_HEIGHT = 18
@@ -222,7 +222,7 @@ class storylineView(QWidget, Ui_storylineView):
 
         for ref in trackedItems:
             if references.type(ref) == references.PersoLetter:
-                color = QColor(self._mdlPersos.getPersoColorByID(references.ID(ref)))
+                color = QColor(self._mdlCharacter.getPersoColorByID(references.ID(ref)))
             else:
                 color = randomColor()
 

manuskript/ui/welcome.py

@@ -12,9 +12,9 @@ from PyQt5.QtWidgets import QWidget, QAction, QFileDialog, QSpinBox, QLineEdit,
 from manuskript import settings
 from manuskript.enums import Outline
 from manuskript.functions import mainWindow, iconFromColor, appPath
+from manuskript.models.characterModel import characterModel
 from manuskript.models.outlineModel import outlineItem
 from manuskript.models.outlineModel import outlineModel
-from manuskript.models.persosModel import persosModel
 from manuskript.models.plotModel import plotModel
 from manuskript.models.worldModel import worldModel
 from manuskript.ui.welcome_ui import Ui_welcome
@@ -345,7 +345,7 @@ class welcome(QWidget, Ui_welcome):
 
         # Persos
         # self.mw.mdlPersos = QStandardItemModel(0, 0, self.mw)
-        self.mw.mdlPersos = persosModel(self.mw)
+        self.mw.mdlCharacter = characterModel(self.mw)
         # self.mdlPersosProxy = None # persosProxyModel() # None
         # self.mw.mdlPersosProxy = persosProxyModel(self.mw)