Merge pull request #49 from moyogo/fontinfo

fontInfo: Add OS/2 tab, add class TabWidget, use load and write functions

1 files changed, 548 insertions, 673 deletions

diff --git a/Lib/defconQt/fontInfo.py b/Lib/defconQt/fontInfo.py
index 45f954f..93fc3df 100644
--- a/Lib/defconQt/fontInfo.py
+++ b/Lib/defconQt/fontInfo.py
@@ -1,9 +1,10 @@
 from PyQt5.QtCore import QDate, QDateTime, QTime, Qt
-from PyQt5.QtGui import QDoubleValidator, QIntValidator
+from PyQt5.QtGui import (
+    QDoubleValidator, QIntValidator, QStandardItem, QStandardItemModel)
 from PyQt5.QtWidgets import (
     QCheckBox, QComboBox, QDateTimeEdit, QDialog, QDialogButtonBox,
-    QGridLayout, QGroupBox, QLabel, QLineEdit, QPlainTextEdit, QTabWidget,
-    QVBoxLayout, QWidget)
+    QGridLayout, QGroupBox, QLabel, QLineEdit, QListView, QPlainTextEdit,
+    QTabWidget, QVBoxLayout, QWidget)
 
 
 class InfoTabWidget(QTabWidget):
@@ -15,13 +16,14 @@ class InfoTabWidget(QTabWidget):
 class TabDialog(QDialog):
 
     def __init__(self, font, parent=None):
-        super(TabDialog, self).__init__(parent)
+        super().__init__(parent)
         self.font = font
 
         self.tabWidget = InfoTabWidget(self)
         self.tabWidget.addNamedTab(GeneralTab(self.font))
         self.tabWidget.addNamedTab(MetricsTab(self.font))
         self.tabWidget.addNamedTab(OpenTypeTab(self.font))
+        self.tabWidget.addNamedTab(OS2Tab(self.font))
         self.tabWidget.addNamedTab(PostScriptTab(self.font))
 
         buttonBox = QDialogButtonBox(
@@ -41,80 +43,170 @@ class TabDialog(QDialog):
     def accept(self):
         for i in range(self.tabWidget.count()):
             self.tabWidget.widget(i).writeValues(self.font)
-        super(TabDialog, self).accept()
+        super().accept()
 
 
-class GeneralTab(QWidget):
-    name = "General"
+class TabWidget(QWidget):
+
+    def __init__(self, font, parent=None, name=None):
+        self.name = name
+        self.font = font
+        super().__init__(parent)
+
+    def loadString(self, font, src, dst):
+        value = getattr(font.info, src)
+        if value is not None:
+            setattr(self, dst + "Edit", QLineEdit(value, self))
+        else:
+            setattr(self, dst + "Edit", QLineEdit(None, self))
+
+    def writeString(self, font, src, dst):
+        value = getattr(self, src + "Edit").text()
+        if value != "":
+            setattr(font.info, dst, value)
+        else:
+            setattr(font.info, dst, None)
+
+    def loadInteger(self, font, src, dst):
+        value = getattr(font.info, src)
+        if value is not None:
+            value = str(value)
+        else:
+            value = ""
+        setattr(self, dst + "Edit", QLineEdit(value, self))
+        getattr(self, dst + "Edit").setValidator(QIntValidator(self))
+
+    def writeInteger(self, font, src, dst):
+        value = getattr(self, src + "Edit").text()
+        if value != "":
+            setattr(font.info, dst, int(value))
+        else:
+            setattr(font.info, dst, None)
+
+    def loadPositiveInteger(self, font, src, dst):
+        value = getattr(font.info, src)
+        if value is not None:
+            value = str(value)
+        else:
+            value = ""
+        setattr(self, dst + "Edit", QLineEdit(value, self))
+        getattr(self, dst + "Edit").setValidator(QIntValidator(self))
+        validator = QIntValidator(self)
+        validator.setBottom(0)
+        getattr(self, dst + "Edit").setValidator(validator)
+
+    writePositiveInteger = writeInteger
+
+    def loadIntegerFloat(self, font, src, dst):
+        value = getattr(font.info, src)
+        if value is not None:
+            value = str(value)
+        else:
+            value = ""
+        setattr(self, dst + "Edit", QLineEdit(value, self))
+        getattr(self, dst + "Edit").setValidator(QDoubleValidator(self))
+
+    def writeIntegerFloat(self, font, src, dst):
+        value = getattr(self, src + "Edit").text()
+        if "." in value:
+            setattr(font.info, dst, float(value))
+        elif value:
+            setattr(font.info, dst, int(value))
+        else:
+            setattr(font.info, dst, None)
+
+    def loadPositiveIntegerFloat(self, font, src, dst):
+        value = getattr(font.info, src)
+        if value is not None:
+            value = str(value)
+        else:
+            value = ""
+        setattr(self, dst + "Edit", QLineEdit(value, self))
+        validator = QDoubleValidator(self)
+        validator.setBottom(0)
+        getattr(self, dst + "Edit").setValidator(validator)
+
+    writePositiveIntegerFloat = writeIntegerFloat
+
+    def loadIntegerFloatList(self, font, src, dst):
+        values = " ".join(str(val) for val in getattr(font.info, src))
+        setattr(self, dst + "Edit", QLineEdit(values, self))
+
+    def writeIntegerFloatList(self, font, src, dst):
+        values = getattr(self, src + "Edit").text()
+        dstValues = []
+        for val in values:
+            if "." in val:
+                dstValues.append(float(val))
+            elif val not in ("", " "):
+                dstValues.append(int(val))
+        setattr(font.info, dst, dstValues)
+
+    def loadBoolean(self, font, src, dst):
+        value = getattr(font.info, src)
+        setattr(self, dst + "Box", QCheckBox(self))
+        if value is None:
+            getattr(self, dst + "Box").setCheckState(Qt.PartiallyChecked)
+        else:
+            getattr(self, dst + "Box").setCheckState(value)
+
+    def writeBoolean(self, font, src, dst):
+        value = getattr(self, src + "Box").checkState()
+        if value == Qt.PartiallyChecked:
+            setattr(font.info, dst, None)
+        else:
+            setattr(font.info, dst, bool(value))
+
+
+class GeneralTab(TabWidget):
 
     def __init__(self, font, parent=None):
-        super(GeneralTab, self).__init__(parent)
+        super().__init__(parent, name="General")
         mainLayout = QGridLayout(self)
 
         familyNameLabel = QLabel("Family name:", self)
-        self.familyNameEdit = QLineEdit(font.info.familyName, self)
         styleNameLabel = QLabel("Style name:", self)
-        self.styleNameEdit = QLineEdit(font.info.styleName, self)
+        designerLabel = QLabel("Designer:", self)
+        designerURLLabel = QLabel("Designer URL:", self)
+        manufacturerLabel = QLabel("Manufacturer:", self)
+        manufacturerURLLabel = QLabel("Manufacturer URL:", self)
+        copyrightLabel = QLabel("Copyright:", self)
+        licenseLabel = QLabel("License:", self)
+        licenseURLLabel = QLabel("License URL:", self)
+        trademarkLabel = QLabel("Trademark:", self)
+        # TODO: give visual feedback of input data validity using QLineEdit
+        # lose focus event
+        # http://snorf.net/blog/2014/08/09/using-qvalidator-in-pyqt4-to-validate-user-input/ # noqa
+        versionLabel = QLabel("Version:", self)
+        versionDotLabel = QLabel(".", self)
+        self.loadString(font, "familyName", "familyName")
+        self.loadString(font, "styleName", "styleName")
+        self.loadString(font, "openTypeNameDesigner", "designer")
+        self.loadString(font, "openTypeNameDesignerURL", "designerURL")
+        self.loadString(font, "openTypeNameManufacturer", "manufacturer")
+        self.loadString(font, "openTypeNameManufacturerURL", "manufacturerURL")
+        self.loadString(font, "copyright", "copyright")
+        self.loadString(font, "openTypeNameLicense", "license")
+        self.loadString(font, "openTypeNameLicenseURL", "licenseURL")
+        self.loadString(font, "trademark", "trademark")
+        self.loadInteger(font, "versionMajor", "versionMajor")
+        self.versionMajorEdit.setAlignment(Qt.AlignRight)
+        self.loadPositiveInteger(font, "versionMinor", "versionMinor")
 
         mainLayout.addWidget(familyNameLabel, 0, 0)
         mainLayout.addWidget(self.familyNameEdit, 0, 1, 1, 3)
         mainLayout.addWidget(styleNameLabel, 0, 4)
         mainLayout.addWidget(self.styleNameEdit, 0, 5)
-
-        designerLabel = QLabel("Designer:", self)
-        self.designerEdit = QLineEdit(font.info.openTypeNameDesigner, self)
-
         mainLayout.addWidget(designerLabel, 1, 0)
         mainLayout.addWidget(self.designerEdit, 1, 1, 1, 5)
-
-        designerURLLabel = QLabel("Designer URL:", self)
-        self.designerURLEdit = QLineEdit(
-            font.info.openTypeNameDesignerURL, self)
-
         mainLayout.addWidget(designerURLLabel, 2, 0)
         mainLayout.addWidget(self.designerURLEdit, 2, 1, 1, 5)
-
-        manufacturerLabel = QLabel("Manufacturer:", self)
-        self.manufacturerEdit = QLineEdit(
-            font.info.openTypeNameManufacturer, self)
-
         mainLayout.addWidget(manufacturerLabel, 3, 0)
         mainLayout.addWidget(self.manufacturerEdit, 3, 1, 1, 5)
-
-        manufacturerURLLabel = QLabel("Manufacturer URL:", self)
-        self.manufacturerURLEdit = QLineEdit(
-            font.info.openTypeNameManufacturerURL, self)
-
         mainLayout.addWidget(manufacturerURLLabel, 4, 0)
         mainLayout.addWidget(self.manufacturerURLEdit, 4, 1, 1, 5)
-
-        copyrightLabel = QLabel("Copyright:", self)
-        self.copyrightEdit = QLineEdit(font.info.copyright, self)
-
         mainLayout.addWidget(copyrightLabel, 5, 0)
         mainLayout.addWidget(self.copyrightEdit, 5, 1, 1, 5)
-
-        # TODO: give visual feedback of input data validity using QLineEdit
-        # lose focus event
-        # http://snorf.net/blog/2014/08/09/using-qvalidator-in-pyqt4-to-validate-user-input/ # noqa
-        versionLabel = QLabel("Version:", self)
-        if font.info.versionMajor is not None:
-            versionMajor = str(font.info.versionMajor)
-        else:
-            versionMajor = ''
-        self.versionMajorEdit = QLineEdit(versionMajor, self)
-        self.versionMajorEdit.setAlignment(Qt.AlignRight)
-        self.versionMajorEdit.setValidator(QIntValidator(self))
-        versionDotLabel = QLabel(".", self)
-        if font.info.versionMinor is not None:
-            versionMinor = str(font.info.versionMinor)
-        else:
-            versionMinor = ''
-        self.versionMinorEdit = QLineEdit(versionMinor, self)
-        validator = QIntValidator(self)
-        validator.setBottom(0)
-        self.versionMinorEdit.setValidator(validator)
-
         mainLayout.addWidget(versionLabel, 6, 0)
         mainLayout.addWidget(self.versionMajorEdit, 6, 1)
         mainLayout.addWidget(versionDotLabel, 6, 2)
@@ -142,97 +234,39 @@ class GeneralTab(QWidget):
 
         mainLayout.addWidget(dateCreatedLabel, 6, 4)
         mainLayout.addWidget(self.dateCreatedEdit, 6, 5)
-
-        licenseLabel = QLabel("License:", self)
-        self.licenseEdit = QLineEdit(font.info.openTypeNameLicense, self)
-
         mainLayout.addWidget(licenseLabel, 7, 0)
         mainLayout.addWidget(self.licenseEdit, 7, 1, 1, 5)
-
-        licenseURLLabel = QLabel("License URL:", self)
-        self.licenseURLEdit = QLineEdit(font.info.openTypeNameLicenseURL, self)
-
         mainLayout.addWidget(licenseURLLabel, 8, 0)
         mainLayout.addWidget(self.licenseURLEdit, 8, 1, 1, 5)
-
-        trademarkLabel = QLabel("Trademark:", self)
-        self.trademarkEdit = QLineEdit(font.info.trademark, self)
-
         mainLayout.addWidget(trademarkLabel, 9, 0)
         mainLayout.addWidget(self.trademarkEdit, 9, 1, 1, 5)
 
         self.setLayout(mainLayout)
 
     def writeValues(self, font):
-        familyName = self.familyNameEdit.text()
-        if familyName != '':
-            font.info.familyName = familyName
-        else:
-            font.info.trademark = None
-        styleName = self.styleNameEdit.text()
-        if styleName != '':
-            font.info.styleName = styleName
-        else:
-            font.info.trademark = None
-        designer = self.designerEdit.text()
-        if designer != '':
-            font.info.openTypeNameDesigner = designer
-        else:
-            font.info.trademark = None
-        designerURL = self.designerURLEdit.text()
-        if designerURL != '':
-            font.info.openTypeNameDesignerURL = designerURL
-        else:
-            font.info.trademark = None
-        manufacturer = self.manufacturerEdit.text()
-        if manufacturer != '':
-            font.info.openTypeNameManufacturer = manufacturer
-        else:
-            font.info.trademark = None
-        manufacturerURL = self.manufacturerURLEdit.text()
-        if manufacturerURL != '':
-            font.info.openTypeNameManufacturerURL = manufacturerURL
-        else:
-            font.info.trademark = None
-        copyright = self.copyrightEdit.text()
-        if copyright != '':
-            font.info.copyright = copyright
-        else:
-            font.info.trademark = None
-        versionMajor = self.versionMajorEdit.text()
-        if versionMajor:
-            font.info.versionMajor = int(versionMajor)
-        else:
-            font.info.versionMajor = None
-        versionMinor = self.versionMinorEdit.text()
-        if versionMinor:
-            font.info.versionMinor = int(versionMinor)
-        else:
-            font.info.versionMinor = None
-        font.info.openTypeHeadCreated = self.dateCreatedEdit.dateTime(
-        ).toString("yyyy/MM/dd hh:mm:ss")
-        license = self.licenseEdit.text()
-        if license != '':
-            font.info.openTypeNameLicense = license
-        else:
-            font.info.trademark = None
-        licenseURL = self.licenseURLEdit.text()
-        if licenseURL != '':
-            font.info.openTypeNameLicenseURL = licenseURL
-        else:
-            font.info.trademark = None
-        trademark = self.trademarkEdit.text()
-        if trademark != '':
-            font.info.trademark = trademark
-        else:
-            font.info.trademark = None
+        self.writeString(font, "familyName", "familyName")
+        self.writeString(font, "styleName", "styleName")
+        self.writeString(font, "trademark", "trademark")
+        self.writeString(font, "copyright", "copyright")
+        self.writeString(font, "designer", "openTypeNameDesigner")
+        self.writeString(font, "designerURL", "openTypeNameDesignerURL")
+        self.writeString(font, "manufacturer", "openTypeNameManufacturer")
+        self.writeString(
+            font, "manufacturerURL", "openTypeNameManufacturerURL")
+        self.writeString(font, "license", "openTypeNameLicense")
+        self.writeString(font, "licenseURL", "openTypeNameLicenseURL")
+
+        self.writeInteger(font, "versionMajor", "versionMajor")
+        self.writePositiveInteger(font, "versionMinor", "versionMinor")
 
+        font.info.openTypeHeadCreated = \
+            self.dateCreatedEdit.dateTime().toString("yyyy/MM/dd hh:mm:ss")
 
-class MetricsTab(QWidget):
-    name = "Metrics"
+
+class MetricsTab(TabWidget):
 
     def __init__(self, font, parent=None):
-        super(MetricsTab, self).__init__(parent)
+        super().__init__(parent, name="Metrics")
         mainLayout = QGridLayout()
 
         styleMapFamilyLabel = QLabel("Style map family name:", self)
@@ -260,24 +294,19 @@ class MetricsTab(QWidget):
         mainLayout.addWidget(self.styleMapStyleDrop, 0, 5)
 
         unitsPerEmLabel = QLabel("Units per em:", self)
-        unitsPerEm = str(
-            font.info.unitsPerEm) if font.info.unitsPerEm is not None else ''
-        self.unitsPerEmEdit = QLineEdit(unitsPerEm, self)
-        validator = QIntValidator(self)
-        validator.setBottom(0)
-        self.unitsPerEmEdit.setValidator(validator)
-
         ascenderLabel = QLabel("Ascender:", self)
-        ascender = str(
-            font.info.ascender) if font.info.ascender is not None else ''
-        self.ascenderEdit = QLineEdit(ascender, self)
-        self.ascenderEdit.setValidator(QIntValidator(self))
-
         capHeightLabel = QLabel("Cap height:", self)
-        capHeight = str(
-            font.info.capHeight) if font.info.capHeight is not None else ''
-        self.capHeightEdit = QLineEdit(capHeight, self)
-        self.capHeightEdit.setValidator(QIntValidator(self))
+        italicAngleLabel = QLabel("Italic angle:", self)
+        descenderLabel = QLabel("Descender:", self)
+        xHeightLabel = QLabel("x-height:", self)
+        # In the UFO specs these are integer or float, and unitsPerEm is
+        # non-negative integer or float
+        self.loadPositiveIntegerFloat(font, "unitsPerEm", "unitsPerEm")
+        self.loadIntegerFloat(font, "ascender", "ascender")
+        self.loadIntegerFloat(font, "capHeight", "capHeight")
+        self.loadIntegerFloat(font, "italicAngle", "italicAngle")
+        self.loadIntegerFloat(font, "descender", "descender")
+        self.loadIntegerFloat(font, "xHeight", "xHeight")
 
         mainLayout.addWidget(unitsPerEmLabel, 1, 0)
         mainLayout.addWidget(self.unitsPerEmEdit, 1, 1)
@@ -285,25 +314,6 @@ class MetricsTab(QWidget):
         mainLayout.addWidget(self.ascenderEdit, 1, 3)
         mainLayout.addWidget(capHeightLabel, 1, 4)
         mainLayout.addWidget(self.capHeightEdit, 1, 5)
-
-        italicAngleLabel = QLabel("Italic angle:", self)
-        italicAngle = str(
-            font.info.italicAngle) if font.info.italicAngle is not None else ''
-        self.italicAngleEdit = QLineEdit(italicAngle, self)
-        self.italicAngleEdit.setValidator(QDoubleValidator(self))
-
-        descenderLabel = QLabel("Descender:", self)
-        descender = str(
-            font.info.descender) if font.info.descender is not None else ''
-        self.descenderEdit = QLineEdit(descender, self)
-        self.descenderEdit.setValidator(QIntValidator(self))
-
-        xHeightLabel = QLabel("x-height:", self)
-        xHeight = str(
-            font.info.xHeight) if font.info.xHeight is not None else ''
-        self.xHeightEdit = QLineEdit(xHeight, self)
-        self.xHeightEdit.setValidator(QIntValidator(self))
-
         mainLayout.addWidget(italicAngleLabel, 2, 0)
         mainLayout.addWidget(self.italicAngleEdit, 2, 1)
         mainLayout.addWidget(descenderLabel, 2, 2)
@@ -336,48 +346,14 @@ class MetricsTab(QWidget):
             font.info.styleMapStyleName = "bold italic"
         else:
             font.info.styleMapStyleName = None
-        unitsPerEm = self.unitsPerEmEdit.text()
-        if "." in unitsPerEm:
-            font.info.unitsPerEm = float(unitsPerEm)
-        elif unitsPerEm:
-            font.info.unitsPerEm = int(unitsPerEm)
-        else:
-            font.info.unitsPerEm = None
-        italicAngle = self.italicAngleEdit.text()
-        if "." in italicAngle:
-            font.info.italicAngle = float(italicAngle)
-        elif italicAngle:
-            font.info.italicAngle = int(italicAngle)
-        else:
-            font.info.italicAngle = None
-        ascender = self.ascenderEdit.text()
-        if "." in ascender:
-            font.info.ascender = float(ascender)
-        elif ascender:
-            font.info.ascender = int(ascender)
-        else:
-            font.info.ascender = None
-        descender = self.descenderEdit.text()
-        if "." in descender:
-            font.info.descender = float(descender)
-        elif descender:
-            font.info.descender = int(descender)
-        else:
-            font.info.descender = None
-        capHeight = self.capHeightEdit.text()
-        if "." in capHeight:
-            font.info.capHeight = float(capHeight)
-        elif capHeight:
-            font.info.capHeight = int(capHeight)
-        else:
-            font.info.capHeight = None
-        xHeight = self.xHeightEdit.text()
-        if "." in xHeight:
-            font.info.xHeight = float(xHeight)
-        elif xHeight:
-            font.info.xHeight = int(xHeight)
-        else:
-            font.info.xHeight = None
+
+        self.writePositiveIntegerFloat(font, "unitsPerEm", "unitsPerEm")
+        self.writeIntegerFloat(font, "italicAngle", "italicAngle")
+        self.writeIntegerFloat(font, "ascender", "ascender")
+        self.writeIntegerFloat(font, "descender", "descender")
+        self.writeIntegerFloat(font, "capHeight", "capHeight")
+        self.writeIntegerFloat(font, "xHeight", "xHeight")
+
         note = self.noteEdit.toPlainText()
         if note != '':
             font.info.note = note
@@ -385,48 +361,38 @@ class MetricsTab(QWidget):
             font.info.note = None
 
 
-class OpenTypeTab(QWidget):
-    name = "OpenType"
+class OpenTypeTab(TabWidget):
 
     def __init__(self, font, parent=None):
-        super(OpenTypeTab, self).__init__(parent)
+        super().__init__(parent, name="OpenType")
 
         nameGroup = QGroupBox("name table", self)
         # nameGroup.setFlat(True)
         nameLayout = QGridLayout(self)
 
         preferredFamilyNameLabel = QLabel("Pref. Family Name:", self)
-        self.preferredFamilyNameEdit = QLineEdit(
-            font.info.openTypeNamePreferredFamilyName, self)
-
         preferredSubfamilyNameLabel = QLabel("Pref. Subfamily Name:", self)
-        self.preferredSubfamilyNameEdit = QLineEdit(
-            font.info.openTypeNamePreferredSubfamilyName, self)
-
         compatibleFullNameLabel = QLabel("Compatible Full Name:", self)
-        self.compatibleFullNameEdit = QLineEdit(
-            font.info.openTypeNameCompatibleFullName, self)
-
         WWSFamilyNameLabel = QLabel("WWS Family Name:", self)
-        self.WWSFamilyNameEdit = QLineEdit(
-            font.info.openTypeNameWWSFamilyName, self)
-
         WWSSubfamilyNameLabel = QLabel("WWS Subfamily Name:", self)
-        self.WWSSubfamilyNameEdit = QLineEdit(
-            font.info.openTypeNameWWSSubfamilyName, self)
-
         versionLabel = QLabel("Version:", self)
-        self.versionEdit = QLineEdit(font.info.openTypeNameVersion, self)
-
         uniqueIDLabel = QLabel("Unique ID:", self)
-        self.uniqueIDEdit = QLineEdit(font.info.openTypeNameUniqueID, self)
-
         descriptionLabel = QLabel("Description:", self)
-        self.descriptionEdit = QLineEdit(
-            font.info.openTypeNameDescription, self)
-
         sampleTextLabel = QLabel("Sample text:", self)
-        self.sampleTextEdit = QLineEdit(font.info.openTypeNameSampleText, self)
+        self.loadString(
+            font, "openTypeNamePreferredFamilyName", "preferredFamilyName")
+        self.loadString(
+            font, "openTypeNamePreferredSubfamilyName",
+            "preferredSubfamilyName")
+        self.loadString(
+            font, "openTypeNameCompatibleFullName", "compatibleFullName")
+        self.loadString(font, "openTypeNameWWSFamilyName", "WWSFamilyName")
+        self.loadString(
+            font, "openTypeNameWWSSubfamilyName", "WWSSubfamilyName")
+        self.loadString(font, "openTypeNameVersion", "version")
+        self.loadString(font, "openTypeNameUniqueID", "uniqueID")
+        self.loadString(font, "openTypeNameDescription", "description")
+        self.loadString(font, "openTypeNameSampleText", "sampleText")
 
         l = 0
         nameLayout.addWidget(preferredFamilyNameLabel, l, 0)
@@ -458,52 +424,17 @@ class OpenTypeTab(QWidget):
         hheaLayout = QGridLayout(self)
 
         ascenderLabel = QLabel("Ascender:", self)
-        if font.info.openTypeHheaAscender is not None:
-            ascender = str(font.info.openTypeHheaAscender)
-        else:
-            ascender = ''
-        self.ascenderEdit = QLineEdit(ascender, self)
-        self.ascenderEdit.setValidator(QIntValidator(self))
-
         descenderLabel = QLabel("Descender:", self)
-        if font.info.openTypeHheaDescender is not None:
-            descender = str(font.info.openTypeHheaDescender)
-        else:
-            descender = ''
-        self.descenderEdit = QLineEdit(descender, self)
-        self.descenderEdit.setValidator(QIntValidator(self))
-
         lineGapLabel = QLabel("LineGap:", self)
-        if font.info.openTypeHheaLineGap is not None:
-            lineGap = str(font.info.openTypeHheaLineGap)
-        else:
-            lineGap = ''
-        self.lineGapEdit = QLineEdit(lineGap, self)
-        self.lineGapEdit.setValidator(QIntValidator(self))
-
         caretSlopeRiseLabel = QLabel("caretSlopeRise:", self)
-        if font.info.openTypeHheaCaretSlopeRise is not None:
-            caretSlopeRise = str(font.info.openTypeHheaCaretSlopeRise)
-        else:
-            caretSlopeRise = ''
-        self.caretSlopeRiseEdit = QLineEdit(caretSlopeRise, self)
-        self.caretSlopeRiseEdit.setValidator(QIntValidator(self))
-
         caretSlopeRunLabel = QLabel("caretSlopeRun:", self)
-        if font.info.openTypeHheaCaretSlopeRun is not None:
-            caretSlopeRun = str(font.info.openTypeHheaCaretSlopeRun)
-        else:
-            caretSlopeRun = ''
-        self.caretSlopeRunEdit = QLineEdit(caretSlopeRun, self)
-        self.caretSlopeRunEdit.setValidator(QIntValidator(self))
-
         caretOffsetLabel = QLabel("caretOffset:", self)
-        if font.info.openTypeHheaCaretOffset is not None:
-            caretOffset = str(font.info.openTypeHheaCaretOffset)
-        else:
-            caretOffset = ''
-        self.caretOffsetEdit = QLineEdit(caretOffset, self)
-        self.caretOffsetEdit.setValidator(QIntValidator(self))
+        self.loadInteger(font, "openTypeHheaAscender", "ascender")
+        self.loadInteger(font, "openTypeHheaDescender", "descender")
+        self.loadInteger(font, "openTypeHheaLineGap", "lineGap")
+        self.loadInteger(font, "openTypeHheaCaretSlopeRise", "caretSlopeRise")
+        self.loadInteger(font, "openTypeHheaCaretSlopeRun", "caretSlopeRun")
+        self.loadInteger(font, "openTypeHheaCaretOffset", "caretOffset")
 
         l = 0
         hheaLayout.addWidget(ascenderLabel, l, 0)
@@ -527,52 +458,22 @@ class OpenTypeTab(QWidget):
         vheaLayout = QGridLayout(self)
 
         vertTypoAscenderLabel = QLabel("vertTypoAscender:", self)
-        if font.info.openTypeVheaVertTypoAscender is not None:
-            vertTypoAscender = str(font.info.openTypeVheaVertTypoAscender)
-        else:
-            vertTypoAscender = ''
-        self.vertTypoAscenderEdit = QLineEdit(vertTypoAscender, self)
-        self.vertTypoAscenderEdit.setValidator(QIntValidator(self))
-
         vertTypoDescenderLabel = QLabel("vertTypoDescender:", self)
-        if font.info.openTypeVheaVertTypoDescender is not None:
-            vertTypoDescender = str(font.info.openTypeVheaVertTypoDescender)
-        else:
-            vertTypoDescender = ''
-        self.vertTypoDescenderEdit = QLineEdit(vertTypoDescender, self)
-        self.vertTypoDescenderEdit.setValidator(QIntValidator(self))
-
         vertTypoLineGapLabel = QLabel("vertTypoLineGap:", self)
-        if font.info.openTypeVheaVertTypoLineGap is not None:
-            vertTypoLineGap = str(font.info.openTypeVheaVertTypoLineGap)
-        else:
-            vertTypoLineGap = ''
-        self.vertTypoLineGapEdit = QLineEdit(vertTypoLineGap, self)
-        self.vertTypoLineGapEdit.setValidator(QIntValidator(self))
-
         vheaCaretSlopeRiseLabel = QLabel("caretSlopeRise:", self)
-        if font.info.openTypeVheaCaretSlopeRise is not None:
-            vheaCaretSlopeRise = str(font.info.openTypeVheaCaretSlopeRise)
-        else:
-            vheaCaretSlopeRise = ''
-        self.vheaCaretSlopeRiseEdit = QLineEdit(vheaCaretSlopeRise, self)
-        self.vheaCaretSlopeRiseEdit.setValidator(QIntValidator(self))
-
         vheaCaretSlopeRunLabel = QLabel("caretSlopeRun:", self)
-        if font.info.openTypeVheaCaretSlopeRun is not None:
-            vheaCaretSlopeRun = str(font.info.openTypeVheaCaretSlopeRun)
-        else:
-            vheaCaretSlopeRun = ''
-        self.vheaCaretSlopeRunEdit = QLineEdit(vheaCaretSlopeRun, self)
-        self.vheaCaretSlopeRunEdit.setValidator(QIntValidator(self))
-
         vheaCaretOffsetLabel = QLabel("caretOffset:", self)
-        if font.info.openTypeVheaCaretOffset is not None:
-            vheaCaretOffset = str(font.info.openTypeVheaCaretOffset)
-        else:
-            vheaCaretOffset = ''
-        self.vheaCaretOffsetEdit = QLineEdit(vheaCaretOffset, self)
-        self.vheaCaretOffsetEdit.setValidator(QIntValidator(self))
+        self.loadInteger(
+            font, "openTypeVheaVertTypoAscender", "vertTypoAscender")
+        self.loadInteger(
+            font, "openTypeVheaVertTypoDescender", "vertTypoDescender")
+        self.loadInteger(
+            font, "openTypeVheaVertTypoLineGap", "vertTypoLineGap")
+        self.loadInteger(
+            font, "openTypeVheaCaretSlopeRise", "vheaCaretSlopeRise")
+        self.loadInteger(
+            font, "openTypeVheaCaretSlopeRun", "vheaCaretSlopeRun")
+        self.loadInteger(font, "openTypeVheaCaretOffset", "vheaCaretOffset")
 
         l = 0
         vheaLayout.addWidget(vertTypoAscenderLabel, l, 0)
@@ -598,140 +499,298 @@ class OpenTypeTab(QWidget):
         self.setLayout(mainLayout)
 
     def writeValues(self, font):
-        preferredFamilyName = self.preferredFamilyNameEdit.text()
-        if preferredFamilyName != '':
-            font.info.openTypeNamePreferredFamilyName = preferredFamilyName
-        else:
-            font.info.openTypeNamePreferredFamilyName = None
-        preferredSubfamilyName = self.preferredSubfamilyNameEdit.text()
-        if preferredSubfamilyName != '':
-            font.info.openTypeNamePreferredSubfamilyName = \
-                preferredSubfamilyName
-        else:
-            font.info.openTypeNamePreferredSubfamilyName = None
-        WWSFamilyName = self.WWSFamilyNameEdit.text()
-        if WWSFamilyName != '':
-            font.info.openTypeNameWWSFamilyName = WWSFamilyName
-        else:
-            font.info.openTypeNameWWSFamilyName = None
-        WWSSubfamilyName = self.WWSSubfamilyNameEdit.text()
-        if WWSSubfamilyName != '':
-            font.info.openTypeNameWWSSubfamilyName = WWSSubfamilyName
-        else:
-            font.info.openTypeNameWWSSubfamilyName = None
-        compatibleFullName = self.compatibleFullNameEdit.text()
-        if compatibleFullName != '':
-            font.info.openTypeNameCompatibleFullName = compatibleFullName
-        else:
-            font.info.openTypeNameCompatibleFullName = None
-        version = self.versionEdit.text()
-        if version != '':
-            font.info.openTypeNameVersion = version
-        else:
-            font.info.openTypeNameVersion = None
-        uniqueID = self.uniqueIDEdit.text()
-        if uniqueID != '':
-            font.info.openTypeNameUniqueID = uniqueID
-        else:
-            font.info.openTypeNameUniqueID = None
-        description = self.descriptionEdit.text()
-        if description != '':
-            font.info.openTypeNameDescription = description
-        else:
-            font.info.openTypeNameDescription = None
-        sampleText = self.sampleTextEdit.text()
-        if sampleText != '':
-            font.info.openTypeNameSampleText = sampleText
-        else:
-            font.info.openTypeNameSampleText = None
-        ascender = self.ascenderEdit.text()
-        if ascender != '':
-            font.info.openTypeHheaAscender = int(ascender)
-        else:
-            font.info.openTypeHheaAscender = None
-        descender = self.descenderEdit.text()
-        if descender != '':
-            font.info.openTypeHheaDescender = int(descender)
-        else:
-            font.info.openTypeHheaDescender = None
-        lineGap = self.lineGapEdit.text()
-        if lineGap != '':
-            font.info.openTypeHheaLineGap = int(lineGap)
-        else:
-            font.info.openTypeHheaLineGap = None
-        caretSlopeRise = self.caretSlopeRiseEdit.text()
-        if caretSlopeRise != '':
-            font.info.openTypeHheaCaretSlopeRise = int(caretSlopeRise)
-        else:
-            font.info.openTypeHheaCaretSlopeRise = None
-        caretSlopeRun = self.caretSlopeRunEdit.text()
-        if caretSlopeRun != '':
-            font.info.openTypeHheaCaretSlopeRun = int(caretSlopeRun)
-        else:
-            font.info.openTypeHheaCaretSlopeRun = None
-        caretOffset = self.caretOffsetEdit.text()
-        if caretOffset != '':
-            font.info.openTypeHheaCaretOffset = int(caretOffset)
-        else:
-            font.info.openTypeHheaCaretOffset = None
-        vertTypoAscender = self.vertTypoAscenderEdit.text()
-        if vertTypoAscender != '':
-            font.info.openTypeVheaAscender = int(vertTypoAscender)
-        else:
-            font.info.openTypeVheaAscender = None
-        vertTypoDescender = self.vertTypoDescenderEdit.text()
-        if vertTypoDescender != '':
-            font.info.openTypeVheaDescender = int(vertTypoDescender)
-        else:
-            font.info.openTypeVheaDescender = None
-        vertTypoLineGap = self.vertTypoLineGapEdit.text()
-        if vertTypoLineGap != '':
-            font.info.openTypeVheaLineGap = int(vertTypoLineGap)
-        else:
-            font.info.openTypeVheaLineGap = None
-        vheaCaretSlopeRise = self.vheaCaretSlopeRiseEdit.text()
-        if vheaCaretSlopeRise != '':
-            font.info.openTypeVheaCaretSlopeRise = int(vheaCaretSlopeRise)
-        else:
-            font.info.openTypeVheaCaretSlopeRise = None
-        vheaCaretSlopeRun = self.vheaCaretSlopeRunEdit.text()
-        if vheaCaretSlopeRun != '':
-            font.info.openTypeVheaCaretSlopeRun = int(vheaCaretSlopeRun)
-        else:
-            font.info.openTypeVheaCaretSlopeRun = None
-        vheaCaretOffset = self.vheaCaretOffsetEdit.text()
-        if vheaCaretOffset != '':
-            font.info.openTypeVheaCaretOffset = int(vheaCaretOffset)
-        else:
-            font.info.openTypeVheaCaretOffset = None
+        self.writeString(
+            font, "preferredFamilyName", "openTypeNamePreferredFamilyName")
+        self.writeString(
+            font, "preferredSubfamilyName",
+            "openTypeNamePreferredSubfamilyName")
+        self.writeString(font, "WWSFamilyName", "openTypeNameWWSFamilyName")
+        self.writeString(
+            font, "WWSSubfamilyName", "openTypeNameWWSSubfamilyName")
+        self.writeString(
+            font, "compatibleFullName", "openTypeNameCompatibleFullName")
+        self.writeString(font, "version", "openTypeNameVersion")
+        self.writeString(font, "uniqueID", "openTypeNameUniqueID")
+        self.writeString(font, "description", "openTypeNameDescription")
+        self.writeString(font, "sampleText", "openTypeNameSampleText")
+        self.writeInteger(font, "ascender", "openTypeHheaAscender")
+        self.writeInteger(font, "descender", "openTypeHheaDescender")
+        self.writeInteger(font, "lineGap", "openTypeHheaLineGap")
+        self.writeInteger(font, "caretSlopeRise", "openTypeHheaCaretSlopeRise")
+        self.writeInteger(font, "caretSlopeRun", "openTypeHheaCaretSlopeRun")
+        self.writeInteger(font, "caretOffset", "openTypeHheaCaretOffset")
+        self.writeInteger(
+            font, "vertTypoAscender", "openTypeVheaVertTypoAscender")
+        self.writeInteger(
+            font, "vertTypoDescender", "openTypeVheaVertTypoDescender")
+        self.writeInteger(
+            font, "vertTypoLineGap", "openTypeVheaVertTypoLineGap")
+        self.writeInteger(
+            font, "vheaCaretSlopeRise", "openTypeVheaCaretSlopeRise")
+        self.writeInteger(
+            font, "vheaCaretSlopeRun", "openTypeVheaCaretSlopeRun")
+        self.writeInteger(font, "vheaCaretOffset", "openTypeVheaCaretOffset")
+
+
+class OS2Tab(TabWidget):
+
+    def __init__(self, font, parent=None):
+        super().__init__(parent, name="OS/2")
+
+        # OS2Group = QGroupBox("OS/2 table", self)
+        # OS2Group.setFlat(True)
+        OS2Layout = QGridLayout(self)
+
+        usWidthClassLabel = QLabel("usWidthClass:", self)
+        self.usWidthClassDrop = QComboBox(self)
+        items = [
+            "None", "Ultra-condensed", "Extra-condensed", "Condensed",
+            "Semi-Condensed", "Medium (normal)", "Semi-expanded", "Expanded",
+            "Extra-expanded", "Ultra-expanded"]
+        self.usWidthClassDrop.insertItems(0, items)
+        if font.info.openTypeOS2WidthClass is not None:
+            self.usWidthClassDrop.setCurrentIndex(
+                font.info.openTypeOS2WidthClass)
+
+        fsSelectionLabel = QLabel("fsSelection:", self)
+        fsSelection = font.info.openTypeOS2Selection
+        self.fsSelectionList = QListView(self)
+        items = [
+            "1 UNDERSCORE", "2 NEGATIVE", "3 OUTLINED", "4 STRIKEOUT",
+            "7 USE_TYPO_METRICS", "8 WWS", "9 OBLIQUE"]
+        # http://stackoverflow.com/a/26613163
+        model = QStandardItemModel(7, 1)
+        for index, elem in enumerate(items):
+            item = QStandardItem()
+            item.setText(elem)
+            item.setCheckable(True)
+            bit = index + 1
+            if fsSelection is not None and bit in fsSelection:
+                # maybe default setting? if so, unneeded
+                item.setCheckState(Qt.Checked)
+            else:
+                item.setCheckState(Qt.Unchecked)
+            model.setItem(index, item)
+        self.fsSelectionList.setModel(model)
+
+        achVendorIDLabel = QLabel("achVendorID:", self)
+        self.achVendorIDEdit = QLineEdit(font.info.openTypeOS2VendorID, self)
+        self.achVendorIDEdit.setMaxLength(4)
+
+        fsTypeLabel = QLabel("fsType:", self)
+        fsType = font.info.openTypeOS2Type
+        self.fsTypeDrop = QComboBox(self)
+        items = [
+            "No embedding restrictions", "Restricted embedding",
+            "Preview and print embedding allowed",
+            "Editable embedding allowed"]
+        self.allowSubsettingBox = QCheckBox("Allow subsetting", self)
+        self.allowBitmapEmbeddingBox = QCheckBox(
+            "Allow only bitmap embedding", self)
+        self.fsTypeDrop.currentIndexChanged[int].connect(
+            self._updateFsTypeVisibility)
+        self.fsTypeDrop.insertItems(0, items)
+        if fsType is not None:
+            for i in range(1, 4):
+                if i in fsType:
+                    self.fsTypeDrop.setCurrentIndex(i)
+                    break
+            self.allowSubsettingBox.setChecked(8 not in fsType)
+            self.allowBitmapEmbeddingBox.setChecked(9 in fsType)
+
+        # XXX: ulUnicodeRange
+
+        # XXX: ulCodePageRange
+
+        sTypoAscenderLabel = QLabel("sTypoAscender:", self)
+        sTypoDescenderLabel = QLabel("sTypoDescender:", self)
+        sTypoLineGapLabel = QLabel("sTypoLineGap:", self)
+        usWeightClassLabel = QLabel("usWeightClass:", self)
+        usWinAscentLabel = QLabel("usWinAscent:", self)
+        usWinDescentLabel = QLabel("usWinDescent:", self)
+        ySubscriptXSizeLabel = QLabel("ySubscriptXSize:", self)
+        ySubscriptYSizeLabel = QLabel("ySubscriptYSize:", self)
+        ySubscriptXOffsetLabel = QLabel("ySubscriptXOffset:", self)
+        ySubscriptYOffsetLabel = QLabel("ySubscriptYOffset:", self)
+        ySuperscriptXSizeLabel = QLabel("ySuperscriptXSize:", self)
+        ySuperscriptYSizeLabel = QLabel("ySuperscriptYSize:", self)
+        ySuperscriptXOffsetLabel = QLabel("ySuperscriptXOffset:", self)
+        ySuperscriptYOffsetLabel = QLabel("ySuperscriptYOffset:", self)
+        yStrikeoutSizeLabel = QLabel("yStrikeoutSize:", self)
+        yStrikeoutPositionLabel = QLabel("yStrikeoutPosition:", self)
+        self.loadPositiveInteger(
+            font, "openTypeOS2WeightClass", "usWeightClass")
+        self.loadInteger(font, "openTypeOS2TypoAscender", "sTypoAscender")
+        self.loadInteger(font, "openTypeOS2TypoDescender", "sTypoDescender")
+        self.loadInteger(font, "openTypeOS2TypoLineGap", "sTypoLineGap")
+        self.loadPositiveInteger(font, "openTypeOS2WinAscent", "usWinAscent")
+        self.loadPositiveInteger(font, "openTypeOS2WinDescent", "usWinDescent")
+        self.loadInteger(font, "openTypeOS2SubscriptXSize", "ySubscriptXSize")
+        self.loadInteger(font, "openTypeOS2SubscriptYSize", "ySubscriptYSize")
+        self.loadInteger(
+            font, "openTypeOS2SubscriptXOffset", "ySubscriptXOffset")
+        self.loadInteger(
+            font, "openTypeOS2SubscriptYOffset", "ySubscriptYOffset")
+        self.loadInteger(
+            font, "openTypeOS2SuperscriptXSize", "ySuperscriptXSize")
+        self.loadInteger(
+            font, "openTypeOS2SuperscriptYSize", "ySuperscriptYSize")
+        self.loadInteger(
+            font, "openTypeOS2SuperscriptXOffset", "ySuperscriptXOffset")
+        self.loadInteger(
+            font, "openTypeOS2SuperscriptYOffset", "ySuperscriptYOffset")
+        self.loadInteger(font, "openTypeOS2StrikeoutSize", "yStrikeoutSize")
+        self.loadInteger(
+            font, "openTypeOS2StrikeoutPosition", "yStrikeoutPosition")
+
+        # XXX: panose
+
+        l = 0
+        OS2Layout.addWidget(usWidthClassLabel, l, 0)
+        OS2Layout.addWidget(self.usWidthClassDrop, l, 1, 1, 2)
+        OS2Layout.addWidget(achVendorIDLabel, l, 3)
+        OS2Layout.addWidget(self.achVendorIDEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(usWeightClassLabel, l, 0)
+        OS2Layout.addWidget(self.usWeightClassEdit, l, 1, 1, 2)
+        l += 1
+        OS2Layout.addWidget(fsSelectionLabel, l, 0, 3, 1)
+        OS2Layout.addWidget(self.fsSelectionList, l, 1, 3, 2)
+        OS2Layout.addWidget(fsTypeLabel, l, 3, 3, 1)
+        OS2Layout.addWidget(self.fsTypeDrop, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(self.allowSubsettingBox, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(self.allowBitmapEmbeddingBox, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(sTypoAscenderLabel, l, 0)
+        OS2Layout.addWidget(self.sTypoAscenderEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(usWinAscentLabel, l, 3)
+        OS2Layout.addWidget(self.usWinAscentEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(sTypoDescenderLabel, l, 0)
+        OS2Layout.addWidget(self.sTypoDescenderEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(usWinDescentLabel, l, 3)
+        OS2Layout.addWidget(self.usWinDescentEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(sTypoLineGapLabel, l, 0)
+        OS2Layout.addWidget(self.sTypoLineGapEdit, l, 1, 1, 2)
+        l += 1
+        OS2Layout.addWidget(ySubscriptXSizeLabel, l, 0)
+        OS2Layout.addWidget(self.ySubscriptXSizeEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(ySubscriptXOffsetLabel, l, 3)
+        OS2Layout.addWidget(self.ySubscriptXOffsetEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(ySubscriptYSizeLabel, l, 0)
+        OS2Layout.addWidget(self.ySubscriptYSizeEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(ySubscriptYOffsetLabel, l, 3)
+        OS2Layout.addWidget(self.ySubscriptYOffsetEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(ySuperscriptXSizeLabel, l, 0)
+        OS2Layout.addWidget(self.ySuperscriptXSizeEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(ySuperscriptXOffsetLabel, l, 3)
+        OS2Layout.addWidget(self.ySuperscriptXOffsetEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(ySuperscriptYSizeLabel, l, 0)
+        OS2Layout.addWidget(self.ySuperscriptYSizeEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(ySuperscriptYOffsetLabel, l, 3)
+        OS2Layout.addWidget(self.ySuperscriptYOffsetEdit, l, 4, 1, 2)
+        l += 1
+        OS2Layout.addWidget(yStrikeoutSizeLabel, l, 0)
+        OS2Layout.addWidget(self.yStrikeoutSizeEdit, l, 1, 1, 2)
+        OS2Layout.addWidget(yStrikeoutPositionLabel, l, 3)
+        OS2Layout.addWidget(self.yStrikeoutPositionEdit, l, 4, 1, 2)
+        # OS2Group.setLayout(OS2Layout)
+        self.setLayout(OS2Layout)
+
+    def _updateFsTypeVisibility(self, index):
+        if index == 0:
+            # TODO: maybe uncheck as well?
+            self.allowSubsettingBox.setEnabled(False)
+            self.allowBitmapEmbeddingBox.setEnabled(False)
+        else:
+            self.allowSubsettingBox.setEnabled(True)
+            self.allowBitmapEmbeddingBox.setEnabled(True)
 
+    def writeValues(self, font):
 
-class PostScriptTab(QWidget):
-    name = "Postscript"
+        self.writePositiveInteger(
+            font, "usWeightClass", "openTypeOS2WeightClass")
+        self.writeInteger(font, "sTypoAscender", "openTypeOS2TypoAscender")
+        self.writeInteger(font, "sTypoDescender", "openTypeOS2TypoDescender")
+        self.writeInteger(font, "sTypoLineGap", "openTypeOS2TypoLineGap")
+        self.writePositiveInteger(font, "usWinAscent", "openTypeOS2WinAscent")
+        self.writePositiveInteger(
+            font, "usWinDescent", "openTypeOS2WinDescent")
+        self.writeInteger(font, "ySubscriptXSize", "openTypeOS2SubscriptXSize")
+        self.writeInteger(font, "ySubscriptYSize", "openTypeOS2SubscriptYSize")
+        self.writeInteger(
+            font, "ySubscriptXOffset", "openTypeOS2SubscriptXOffset")
+        self.writeInteger(
+            font, "ySubscriptYOffset", "openTypeOS2SubscriptYOffset")
+        self.writeInteger(
+            font, "ySuperscriptXSize", "openTypeOS2SuperscriptXSize")
+        self.writeInteger(
+            font, "ySuperscriptYSize", "openTypeOS2SuperscriptYSize")
+        self.writeInteger(
+            font, "ySuperscriptXOffset", "openTypeOS2SuperscriptXOffset")
+        self.writeInteger(
+            font, "ySuperscriptYOffset", "openTypeOS2SuperscriptYOffset")
+        self.writeInteger(font, "yStrikeoutSize", "openTypeOS2StrikeoutSize")
+        self.writeInteger(
+            font, "yStrikeoutPosition", "openTypeOS2StrikeoutPosition")
+
+        fsSelectionModel = self.fsSelectionList.model()
+        fsSelection = []
+        for i in range(7):
+            item = fsSelectionModel.item(i)
+            if item.checkState() == Qt.Checked:
+                fsSelection.append(i)
+        if len(fsSelection):
+            font.info.openTypeOS2Selection = fsSelection
+        else:
+            # XXX: None or empty array? should distinct those cases
+            font.info.openTypeOS2Selection = None
+
+        fsTypeIndex = self.fsTypeDrop.currentIndex()
+        fsType = []
+        if fsTypeIndex > 0:
+            fsType.append(fsTypeIndex)
+            if not self.allowSubsettingBox.isChecked():
+                fsType.append(8)
+            if self.allowBitmapEmbeddingBox.isChecked():
+                fsType.append(9)
+        # TODO: provide a way to represent None w this?
+        font.info.openTypeOS2Type = fsType
+
+        # TODO: see if data needs to be padded to 4 chars.
+        # I think that this is to be deferred to ufo2fdk(?)
+        font.info.openTypeOS2VendorID = self.achVendorIDEdit.text()
+
+        # XXX: ulUnicodeRange
+
+        # XXX: ulCodePageRange
+
+        # XXX: panose
+
+
+class PostScriptTab(TabWidget):
 
     def __init__(self, font, parent=None):
-        super(PostScriptTab, self).__init__(parent)
+        super().__init__(parent, name="PostScript")
 
         namingGroup = QGroupBox("Naming", self)
         # namingGroup.setFlat(True)
         namingLayout = QGridLayout(self)
 
         fontNameLabel = QLabel("FontName:", self)
-        self.fontNameEdit = QLineEdit(font.info.postscriptFontName, self)
-
         fullNameLabel = QLabel("FullName:", self)
-        self.fullNameEdit = QLineEdit(font.info.postscriptFullName, self)
-
         weightNameLabel = QLabel("WeightName:", self)
-        self.weightNameEdit = QLineEdit(font.info.postscriptWeightName, self)
-
         uniqueIDLabel = QLabel("Unique ID:", self)
-        if font.info.postscriptUniqueID is not None:
-            uniqueID = str(font.info.postscriptUniqueID)
-        else:
-            uniqueID = ''
-        self.uniqueIDEdit = QLineEdit(uniqueID, self)
-        self.uniqueIDEdit.setValidator(QIntValidator(self))
+        self.loadString(font, "postscriptFontName", "fontName")
+        self.loadString(font, "postscriptFullName", "fullName")
+        self.loadString(font, "postscriptWeightName", "weightName")
+        self.loadInteger(font, "postscriptUniqueID", "uniqueID")
 
         l = 0
         namingLayout.addWidget(fontNameLabel, l, 0)
@@ -749,25 +808,15 @@ class PostScriptTab(QWidget):
         # hintingGroup.setFlat(True)
         hintingLayout = QGridLayout(self)
 
+        self.loadIntegerFloatList(font, "postscriptBlueValues", "blueValues")
+        self.loadIntegerFloatList(font, "postscriptOtherBlues", "otherBlues")
+        self.loadIntegerFloatList(font, "postscriptFamilyBlues", "familyBlues")
+        self.loadIntegerFloatList(
+            font, "postscriptFamilyOtherBlues", "familyOtherBlues")
         blueValuesLabel = QLabel("Blue values:", self)
-        blueValues = " ".join(str(val)
-                              for val in font.info.postscriptBlueValues)
-        self.blueValuesEdit = QLineEdit(blueValues, self)
-
         otherBluesLabel = QLabel("Other blues:", self)
-        otherBlues = " ".join(str(val)
-                              for val in font.info.postscriptOtherBlues)
-        self.otherBluesEdit = QLineEdit(otherBlues, self)
-
         familyBluesLabel = QLabel("Family blues:", self)
-        familyBlues = " ".join(str(val)
-                               for val in font.info.postscriptFamilyBlues)
-        self.familyBluesEdit = QLineEdit(familyBlues, self)
-
         familyOtherBluesLabel = QLabel("Family other blues:", self)
-        familyOtherBlues = " ".join(
-            str(val) for val in font.info.postscriptFamilyOtherBlues)
-        self.familyOtherBluesEdit = QLineEdit(familyOtherBlues, self)
 
         l = 0
         hintingLayout.addWidget(blueValuesLabel, l, 0)
@@ -782,45 +831,18 @@ class PostScriptTab(QWidget):
         l += 1
 
         blueFuzzLabel = QLabel("Blue fuzz:", self)
-        if font.info.postscriptBlueFuzz is not None:
-            blueFuzz = str(font.info.postscriptBlueFuzz)
-        else:
-            blueFuzz = ''
-        self.blueFuzzEdit = QLineEdit(blueFuzz, self)
-        self.blueFuzzEdit.setValidator(QDoubleValidator(self))
-
         stemSnapHLabel = QLabel("StemSnapH:", self)
-        stemSnapH = " ".join(str(val) for val in font.info.postscriptStemSnapH)
-        self.stemSnapHEdit = QLineEdit(stemSnapH, self)
-
         blueScaleLabel = QLabel("Blue scale:", self)
-        if font.info.postscriptBlueScale is not None:
-            blueScale = str(font.info.postscriptBlueScale)
-        else:
-            blueScale = ''
-        self.blueScaleEdit = QLineEdit(blueScale, self)
-        self.blueScaleEdit.setValidator(QDoubleValidator(self))
-
         stemSnapVLabel = QLabel("StemSnapV:", self)
-        stemSnapV = " ".join(str(val) for val in font.info.postscriptStemSnapV)
-        self.stemSnapVEdit = QLineEdit(stemSnapV, self)
-
         blueShiftLabel = QLabel("Blue shift:", self)
-        if font.info.postscriptBlueShift is not None:
-            blueShift = str(font.info.postscriptBlueShift)
-        else:
-            blueShift = ''
-        self.blueShiftEdit = QLineEdit(blueShift, self)
-        self.blueShiftEdit.setValidator(QDoubleValidator(self))
+        self.loadIntegerFloatList(font, "postscriptStemSnapH", "stemSnapH")
+        self.loadIntegerFloatList(font, "postscriptStemSnapV", "stemSnapV")
+        self.loadIntegerFloat(font, "postscriptBlueFuzz", "blueFuzz")
+        self.loadIntegerFloat(font, "postscriptBlueScale", "blueScale")
+        self.loadIntegerFloat(font, "postscriptBlueShift", "blueShift")
 
         forceBoldLabel = QLabel("Force bold:", self)
-        forceBold = font.info.postscriptForceBold
-        self.forceBoldBox = QCheckBox(self)
-        self.forceBoldBox.setTristate()
-        if forceBold is None:
-            self.forceBoldBox.setCheckState(Qt.PartiallyChecked)
-        else:
-            self.forceBoldBox.setChecked(forceBold)
+        self.loadBoolean(font, "postscriptForceBold", "forceBold")
 
         hintingLayout.addWidget(blueFuzzLabel, l, 0)
         hintingLayout.addWidget(self.blueFuzzEdit, l, 1, 1, 2)
@@ -843,53 +865,20 @@ class PostScriptTab(QWidget):
         metricsLayout = QGridLayout(self)
 
         defaultWidthXLabel = QLabel("DefaultWidthX:", self)
-        if font.info.postscriptDefaultWidthX is not None:
-            defaultWidthX = str(font.info.postscriptDefaultWidthX)
-        else:
-            defaultWidthX = ''
-        self.defaultWidthXEdit = QLineEdit(defaultWidthX, self)
-        self.defaultWidthXEdit.setValidator(QDoubleValidator(self))
-
         underlineThicknessLabel = QLabel("UnderlineThickness:", self)
-        if font.info.postscriptUnderlineThickness is not None:
-            underlineThickness = str(font.info.postscriptUnderlineThickness)
-        else:
-            underlineThickness = ''
-        self.underlineThicknessEdit = QLineEdit(underlineThickness, self)
-        self.underlineThicknessEdit.setValidator(QDoubleValidator(self))
-
         nominalWidthXLabel = QLabel("NominalWidthX:", self)
-        if font.info.postscriptNominalWidthX is not None:
-            nominalWidthX = str(font.info.postscriptNominalWidthX)
-        else:
-            nominalWidthX = ''
-        self.nominalWidthXEdit = QLineEdit(nominalWidthX, self)
-        self.nominalWidthXEdit.setValidator(QDoubleValidator(self))
-
         underlinePositionLabel = QLabel("UnderlinePosition:", self)
-        if font.info.postscriptUnderlinePosition is not None:
-            underlinePosition = str(font.info.postscriptUnderlinePosition)
-        else:
-            underlinePosition = ''
-        self.underlinePositionEdit = QLineEdit(underlinePosition, self)
-        self.underlinePositionEdit.setValidator(QDoubleValidator(self))
-
         slantAngleLabel = QLabel("SlantAngle:", self)
-        if font.info.postscriptSlantAngle is not None:
-            slantAngle = str(font.info.postscriptSlantAngle)
-        else:
-            slantAngle = ''
-        self.slantAngleEdit = QLineEdit(slantAngle, self)
-        self.slantAngleEdit.setValidator(QDoubleValidator(self))
+        self.loadIntegerFloat(font, "postscriptDefaultWidthX", "defaultWidthX")
+        self.loadIntegerFloat(font, "postscriptNominalWidthX", "nominalWidthX")
+        self.loadIntegerFloat(
+            font, "postscriptUnderlineThickness", "underlineThickness")
+        self.loadIntegerFloat(
+            font, "postscriptUnderlinePosition", "underlinePosition")
+        self.loadIntegerFloat(font, "postscriptSlantAngle", "slantAngle")
 
         isFixedPitchLabel = QLabel("isFixedPitched:", self)
-        isFixedPitch = font.info.postscriptIsFixedPitch
-        self.isFixedPitchBox = QCheckBox(self)
-        self.isFixedPitchBox.setTristate()
-        if isFixedPitch is None:
-            self.isFixedPitchBox.setCheckState(Qt.PartiallyChecked)
-        else:
-            self.isFixedPitchBox.setChecked(isFixedPitch)
+        self.loadBoolean(font, "postscriptIsFixedPitch", "isFixedPitch")
 
         l = 0
         metricsLayout.addWidget(defaultWidthXLabel, l, 0)
@@ -913,8 +902,7 @@ class PostScriptTab(QWidget):
         charactersLayout = QGridLayout(self)
 
         defaultCharacterLabel = QLabel("Default character:", self)
-        self.defaultCharacterEdit = QLineEdit(
-            font.info.postscriptDefaultCharacter, self)
+        self.loadString(font, "postscriptDefaultCharacter", "defaultCharacter")
 
         windowsCharacterSetLabel = QLabel("Windows character set:", self)
         self.windowsCharacterSetDrop = QComboBox(self)
@@ -943,150 +931,37 @@ class PostScriptTab(QWidget):
         self.setLayout(mainLayout)
 
     def writeValues(self, font):
-        fontName = self.fontNameEdit.text()
-        if fontName != '':
-            font.info.postscriptFontName = fontName
-        else:
-            font.info.postscriptFontName = None
-        fullName = self.fullNameEdit.text()
-        if fullName != '':
-            font.info.postscriptFullName = fullName
-        else:
-            font.info.postscriptFullName = None
-        weightName = self.weightNameEdit.text()
-        if weightName != '':
-            font.info.postscriptWeightName = weightName
-        else:
-            font.info.postscriptWeightName = None
-        uniqueID = self.uniqueIDEdit.text()
-        if uniqueID != '':
-            font.info.postscriptUniqueID = int(uniqueID)
-        else:
-            font.info.postscriptUniqueID = None
-        blueValues = self.blueValuesEdit.text().split(" ")
-        if blueValues is None:
-            font.info.postscriptBlueValues = None
-        else:
-            blues = []
-            for blue in blueValues:
-                if blue != '':
-                    blues.append(int(blue))
-            font.info.postscriptBlueValues = blues
-        otherBlues = self.otherBluesEdit.text().split(" ")
-        if otherBlues is None:
-            font.info.postscriptOtherBlues = None
-        else:
-            blues = []
-            for blue in otherBlues:
-                if blue != '':
-                    blues.append(int(blue))
-            font.info.postscriptOtherBlues = blues
-        familyBlues = self.familyBluesEdit.text().split(" ")
-        if familyBlues is None:
-            font.info.postscriptFamilyBlues = None
-        else:
-            blues = []
-            for blue in familyBlues:
-                if blue != '':
-                    blues.append(int(blue))
-            font.info.postscriptFamilyBlues = blues
-        familyOtherBlues = self.familyOtherBluesEdit.text().split(" ")
-        if familyOtherBlues is None:
-            font.info.postscriptFamilyOtherBlues = None
-        else:
-            blues = []
-            for blue in familyOtherBlues:
-                if blue != '':
-                    blues.append(int(blue))
-            font.info.postscriptFamilyOtherBlues = blues
-        blueFuzz = self.blueFuzzEdit.text()
-        if "." in blueFuzz:
-            font.info.postscriptBlueFuzz = float(blueFuzz)
-        elif blueFuzz != '':
-            font.info.postscriptBlueFuzz = int(blueFuzz)
-        else:
-            font.info.postscriptBlueFuzz = None
-        blueScale = self.blueScaleEdit.text()
-        if blueScale != '':
-            font.info.postscriptBlueScale = float(blueScale)
-        else:
-            font.info.postscriptBlueScale = None
-        blueShift = self.blueShiftEdit.text()
-        if "." in blueShift:
-            font.info.postscriptBlueShift = float(blueShift)
-        elif blueShift != '':
-            font.info.postscriptBlueShift = int(blueShift)
-        else:
-            font.info.postscriptBlueShift = None
-        stemSnapH = self.stemSnapHEdit.text().split(" ")
-        if stemSnapH is None:
-            font.info.postscriptStemSnapH = None
-        else:
-            stems = []
-            for stem in stemSnapH:
-                if stem != '':
-                    stems.append(int(stem))
-            font.info.postscriptStemSnapH = stems
-        stemSnapV = self.stemSnapVEdit.text().split(" ")
-        if stemSnapV is None:
-            font.info.postscriptStemSnapV = None
-        else:
-            stems = []
-            for stem in stemSnapV:
-                if stem != '':
-                    stems.append(int(stem))
-            font.info.postscriptStemSnapV = stems
-        forceBold = self.forceBoldBox.checkState()
-        if forceBold == Qt.PartiallyChecked:
-            font.info.postscriptForceBold = None
-        else:
-            font.info.postscriptForceBold = bool(forceBold)
-        defaultWidthX = self.defaultWidthXEdit.text()
-        if "." in defaultWidthX:
-            font.info.postscriptDefaultWidthX = float(defaultWidthX)
-        elif defaultWidthX != '':
-            font.info.postscriptDefaultWidthX = int(defaultWidthX)
-        else:
-            font.info.postscriptDefaultWidthX = None
-        nominalWidthX = self.nominalWidthXEdit.text()
-        if "." in nominalWidthX:
-            font.info.postscriptNominalWidthX = float(nominalWidthX)
-        elif nominalWidthX != '':
-            font.info.postscriptNominalWidthX = int(nominalWidthX)
-        else:
-            font.info.postscriptNominalWidthX = None
-        underlineThickness = self.underlineThicknessEdit.text()
-        if "." in underlineThickness:
-            font.info.postscriptUnderlineThickness = float(underlineThickness)
-        elif underlineThickness != '':
-            font.info.postscriptUnderlineThickness = \
-                int(underlineThickness)
-        else:
-            font.info.postscriptUnderlineThickness = None
-        underlinePosition = self.underlinePositionEdit.text()
-        if "." in underlinePosition:
-            font.info.postscriptUnderlinePosition = float(underlinePosition)
-        elif underlinePosition != '':
-            font.info.postscriptUnderlinePosition = int(underlinePosition)
-        else:
-            font.info.postscriptUnderlinePosition = None
-        slantAngle = self.slantAngleEdit.text()
-        if "." in slantAngle:
-            font.info.postscriptSlantAngle = float(slantAngle)
-        elif slantAngle != '':
-            font.info.postscriptSlantAngle = int(slantAngle)
-        else:
-                font.info.postscriptSlantAngle = None
-        isFixedPitch = self.isFixedPitchBox.checkState()
-        if isFixedPitch == Qt.PartiallyChecked:
-            font.info.postscriptIsFixedPitch = None
-        else:
-            font.info.postscriptIsFixedPitch = bool(isFixedPitch)
-        defaultCharacter = self.defaultCharacterEdit.text()
-        if defaultCharacter != '':
-            font.info.postscriptDefaultCharacter = defaultCharacter
-        else:
-            font.info.postscriptDefaultCharacter = None
+        self.writeString(font, "fontName", "postscriptFontName")
+        self.writeString(font, "fullName", "postscriptFullName")
+        self.writeString(font, "weightName", "postscriptWeightName")
+        self.writeInteger(font, "uniqueID", "postscriptUniqueID")
+        self.writeIntegerFloatList(font, "blueValues", "postscriptBlueValues")
+        self.writeIntegerFloatList(font, "otherBlues", "postscriptOtherBlues")
+        self.writeIntegerFloatList(
+            font, "familyBlues", "postscriptFamilyBlues")
+        self.writeIntegerFloatList(
+            font, "familyOtherBlues", "postscriptFamilyOtherBlues")
+        self.writeIntegerFloatList(font, "stemSnapH", "postscriptStemSnapH")
+        self.writeIntegerFloatList(font, "stemSnapV", "postscriptStemSnapV")
+        self.writeIntegerFloat(font, "blueFuzz", "postscriptBlueFuzz")
+        self.writeIntegerFloat(font, "blueScale", "postscriptBlueScale")
+        self.writeIntegerFloat(font, "blueShift", "postscriptBlueShift")
+        self.writeIntegerFloat(
+            font, "defaultWidthX", "postscriptDefaultWidthX")
+        self.writeIntegerFloat(
+            font, "nominalWidthX", "postscriptNominalWidthX")
+        self.writeIntegerFloat(
+            font, "underlineThickness", "postscriptUnderlineThickness")
+        self.writeIntegerFloat(
+            font, "underlinePosition", "postscriptUnderlinePosition")
+        self.writeIntegerFloat(font, "slantAngle", "postscriptSlantAngle")
+
+        self.writeBoolean(font, "forceBold", "postscriptForceBold")
+        self.writeBoolean(font, "isFixedPitch", "postscriptIsFixedPitch")
+
+        self.writeString(
+            font, "defaultCharacter", "postscriptDefaultCharacter")
+
         windowsCharacterSet = self.windowsCharacterSetDrop.currentIndex()
         if windowsCharacterSet == 0:
             font.info.postscriptWindowsCharacterSet = None