Add files via upload

wacom-gui.py
* changed toggle to use MapToOutput next
options.py
* reworked screen detection; now supports more than 2 displays
* uses MapToOutput HEAD-<displayID> vs generating a matrix; seems to support non-standard monitor layouts better
  * this breaks support for CentOS 6 as it requires a newer release of the wacom drivers to support

Author: tb2097

wacom-gui/options.py

@@ -1,12 +1,15 @@
 #!/usr/bin/python
 
-from PyQt4 import QtCore,QtGui
-import sys, os, re
+from PyQt4 import QtCore, QtGui
+import sys
+import os
+import re
+import subprocess
 
 class otherOptions(QtGui.QWidget):
     def __init__(self, tabletName, parent=None):
         QtGui.QWidget.__init__(self, parent)
-        self.tabletName=tabletName
+        self.tabletName = tabletName.replace('Pad', 'Pen')
 
         self.initUI()
 
@@ -19,29 +22,41 @@ def initUI(self):
         #layout code
         self.mainLayout = QtGui.QHBoxLayout()
         self.mainLayout.setAlignment(QtCore.Qt.AlignLeft)
-        self.mainLayout.addWidget(self.screenOptions())
+        screens = self.screenOptions()
+        if screens:
+            self.mainLayout.addWidget(screens)
         self.mainLayout.addWidget(self.flipOptions())
         self.setLayout(self.mainLayout)
 
         #update current active screen area
         self.getCurrentScreen()
 
     def screenOptions(self):
+        if QtGui.QDesktopWidget().numScreens() == 1:
+            return None
         groupBox = QtGui.QGroupBox("Screen Area")
         groupBox.setAlignment(QtCore.Qt.AlignHCenter)
         groupBox.setFixedHeight(120)
+        displays = self.get_monitors()
         self.screenGroup = QtGui.QButtonGroup(groupBox)
-        self.screenLeft = QtGui.QRadioButton("Left Monitor")
-        self.screenRight = QtGui.QRadioButton("Right Monitor")
-        self.screenFull  = QtGui.QRadioButton("Both Monitors")
-        
-        self.screenGroup.addButton(self.screenLeft)
-        self.screenGroup.addButton(self.screenRight)
+        self.displays = []
+        for x in range(0, QtGui.QDesktopWidget().numScreens()):
+            self.displays.append(QtGui.QRadioButton("Monitor %d" % x))
+        #self.screenLeft = QtGui.QRadioButton("Left Monitor")
+        #self.screenRight = QtGui.QRadioButton("Right Monitor")
+        self.screenFull  = QtGui.QRadioButton("All Monitors")
+
+        for screen in self.displays:
+            self.screenGroup.addButton(screen)
+        #self.screenGroup.addButton(self.screenLeft)
+        #self.screenGroup.addButton(self.screenRight)
         self.screenGroup.addButton(self.screenFull)
 
         screenLayout = QtGui.QVBoxLayout()
-        screenLayout.addWidget(self.screenLeft)
-        screenLayout.addWidget(self.screenRight)
+        for screen in self.displays:
+            screenLayout.addWidget(screen)
+        #screenLayout.addWidget(self.screenLeft)
+        #screenLayout.addWidget(self.screenRight)
         screenLayout.addWidget(self.screenFull)
         screenLayout.addStretch(1)
 
@@ -50,7 +65,25 @@ def screenOptions(self):
         groupBox.setLayout(screenLayout)
 
         return groupBox
-    
+
+
+    def get_monitors(self):
+        p = subprocess.Popen("xrandr | grep \" connected\"", shell=True, stdout=subprocess.PIPE)
+        output = p.communicate()[0].split('\n')
+        regex = r"^([\w-]+)(\D+)(\d+)x(\d+)\+(\d+)\+(\d+)"
+        screens = {}
+        for display in output:
+            if display != '':
+                match = re.search(regex, display)
+                if match.group(5) not in screens.keys():
+                    screens[match.group(5)] = {}
+                screens[match.group(5)][match.group(6)] = match.group(1)
+        displays = []
+        for x in sorted(screens.keys()):
+            for y in sorted(screens[x].keys()):
+                displays.append(screens[x][y])
+        return displays
+
     def flipOptions(self):
         groupBox = QtGui.QGroupBox("Tablet Orientation")
         groupBox.setAlignment(QtCore.Qt.AlignHCenter)
@@ -67,15 +100,15 @@ def flipOptions(self):
         flipLayout.addWidget(self.tabletLeft)
         flipLayout.addStretch(1)
 
-        getCommand = os.popen("xsetwacom --get \""+self.tabletName+" stylus\" Rotate").readlines()
-        #check correct button for orientation
+        getCommand = os.popen("xsetwacom --get \"%s stylus\" Rotate" % self.tabletName).readlines()
+        # check correct button for orientation
         if getCommand[0] == "none\n":
-            self.orient = "xsetwacom --set \""+self.tabletName+" stylus\" Rotate none"
-            self.orient += "\nxsetwacom --set \"" + self.tabletName + " eraser\" Rotate none"
+            self.orient = "xsetwacom --set \"%s stylus\" Rotate none" % self.tabletName
+            self.orient += "\nxsetwacom --set \"%s eraser\" Rotate none" % self.tabletName
             self.tabletRight.setChecked(1)
         elif getCommand[0] == "half\n":
-            self.orient = "xsetwacom --set \""+self.tabletName+" stylus\" Rotate half"
-            self.orient += "\nxsetwacom --set \"" + self.tabletName + " eraser\" Rotate half"
+            self.orient = "xsetwacom --set \"%s stylus\" Rotate half" % self.tabletName
+            self.orient += "\nxsetwacom --set \"%s eraser\" Rotate half" % self.tabletName
             self.tabletLeft.setChecked(1)
 
         self.tabletFlipGroup.buttonClicked.connect(self.tabletFlipChange)
@@ -86,140 +119,124 @@ def flipOptions(self):
 
     def tabletFlipChange(self, buttonId):
         if buttonId.text() == "Right-Handed":
-            self.orient = "xsetwacom --set \""+self.tabletName+" stylus\" Rotate none"
-            self.orient +="\nxsetwacom --set \"" + self.tabletName + " eraser\" Rotate none"
+            self.orient = "xsetwacom --set \"%s stylus\" Rotate none" % self.tabletName
+            self.orient += "\nxsetwacom --set \"%s eraser\" Rotate none" % self.tabletName
         elif buttonId.text() == "Left-Handed":
-            self.orient = "xsetwacom --set \""+self.tabletName+" stylus\" Rotate half"
-            self.orient +="\nxsetwacom --set \"" + self.tabletName + " eraser\" Rotate half"
+            self.orient = "xsetwacom --set \"%s stylus\" Rotate half" % self.tabletName
+            self.orient += "\nxsetwacom --set \"%s eraser\" Rotate half" % self.tabletName
         flipTablet = os.popen(self.orient)
 
-    def screenChange(self,buttonId):
-        screen = ""
-        coords = ""
-        if buttonId.text() == "Both Monitors":
+
+    def screenChange(self, buttonId):
+        if buttonId.text() == "All Monitors":
             self.tabletActiveArea = "1 0 0 0 1 0 0 0 1"
             for device in self.devices:
-                if device != self.tabletName+" pad":
-                    setCommand = os.popen("xinput set-prop \"" + self.tabletName+ " " + device + "\" --type=float \"Coordinate Transformation Matrix\" " + self.tabletActiveArea)
-                    #for i in range(len(self.otherOptionSettings)):
-                    #    if self.otherOptionSettings[i].find("xinput set-prop") != -1 and self.otherOptionSettings[i].find(device) != -1:
-                    #        self.otherOptionSettings[i] =  "xinput set-prop \"" + device + "\" --type=float \"Coordinate Transformation Matrix\" 1 0 0 0 1 0 0 0 1"
-        elif buttonId.text() == "Left Monitor":
-            screen = QtGui.QDesktopWidget().screenGeometry(0)
-        elif buttonId.text() == "Right Monitor":
-            screen = QtGui.QDesktopWidget().screenGeometry(1)
-        if screen != "":
-            totalResolution = os.popen("xdpyinfo | grep dimensions | awk '{print $2}' | awk -Fx '{print $1, $2}'").read()
-            totalResolution = totalResolution.split()
-
-            display = [[0 for x in xrange(3)] for x in xrange(3)]
-            display[2][2]=1.0 
-
-            display[0][0] = float(screen.width()) / float(totalResolution[0])
-            display[1][1] = float(screen.height()) / float(totalResolution[1])
-            if float(screen.topLeft().x())!=0:
-                display[0][2] = float(screen.x()) / float(totalResolution[0])
-            if float(screen.topLeft().y())!=0:
-                display[1][2] = float(screen.y()) / float(totalResolution[1])
-            
-            self.tabletActiveArea = ''
-            for x in xrange(3):
-                for y in xrange(3):
-                    self.tabletActiveArea = self.tabletActiveArea + " " + str(display[x][y])
-            
+                if device != "pad":
+                    cmd = "xinput set-prop \"%s %s\" --type=float \"Coordinate Transformation Matrix\" %s" % \
+                          (self.tabletName, device, self.tabletActiveArea)
+                    setCommand = os.popen(cmd)
+        else:
+            self.tabletActiveArea = "HEAD-%s" % buttonId.text().split(' ')[1]
             for device in self.devices:
-                if device != self.tabletName+" pad":
-                    setCommand = os.popen("xinput set-prop \"" + self.tabletName+ " " + device + "\" --type=float \"Coordinate Transformation Matrix\" " + self.tabletActiveArea)
-                    #for i in range(len(self.otherOptionSettings)): 
-                    #    if self.otherOptionSettings[i].find("xinput set-prop") != -1 and self.otherOptionSettings[i].find(device) != -1:
-                    #        self.otherOptionSettings[i] =  "xinput set-prop \"" + device + "\" " + coordset
+                if device != "pad":
+                    cmd = "xsetwacom set \"%s %s\" MapToOutput %s" % (self.tabletName, device, self.tabletActiveArea)
+                    setCommand = os.popen(cmd)
+
 
     def getTabletArea(self):
-        #get current tablet area
-        tabletInfo = os.popen("xinput list-props \""+ self.tabletName+ " stylus\" | grep Coordinate").readlines()
+        # get current tablet area
+        tabletInfo = os.popen("xinput list-props \"%s stylus\" | grep Coordinate" % self.tabletName).readlines()
         tabletInfo[0] = tabletInfo[0][41:].rstrip('\n')
-        tabletInfo[0] = re.sub(",","",tabletInfo[0])
+        tabletInfo[0] = re.sub(",", "", tabletInfo[0])
         tabletScreenCoords = {}
         blarg = tabletInfo[0].split()
         count = 0
-        for i in range(0,3):
-            for j in range(0,3):
-                tabletScreenCoords[(i,j)] = blarg[count]
+        for i in range(0, 3):
+            for j in range(0, 3):
+                tabletScreenCoords[(i, j)] = blarg[count]
                 self.tabletActiveArea = self.tabletActiveArea + " " + blarg[count]
-                count+=1
+                count += 1
 
-        #check if "full screen"
+        # check if "full screen"
         fullScreen = True
-        for i in range(0,3):
-            for j in range(0,3):
-                if i == j and float(tabletScreenCoords[(i,j)]) != 1.0:
+        for i in range(0, 3):
+            for j in range(0, 3):
+                if i == j and float(tabletScreenCoords[(i, j)]) != 1.0:
                     fullScreen = False
                     break
-                elif i != j and float(tabletScreenCoords[(i,j)]) != 0.0:
+                elif i != j and float(tabletScreenCoords[(i, j)]) != 0.0:
                     fullScreen = False
                     break
         if fullScreen:
             self.screenFull.setChecked(1)
-        #have to build array then compare... boo
+        # have to build array then compare... boo
         else:
-            screen1 = QtGui.QDesktopWidget().screenGeometry(0)
-            screen2 = QtGui.QDesktopWidget().screenGeometry(1)
-            totalResolution = os.popen("xdpyinfo | grep dimensions | awk '{print $2}' | awk -Fx '{print $1, $2}'").read()
-            totalResolution = totalResolution.split()
-
-
-            display = [[0 for x in xrange(3)] for x in xrange(3)]
-            display[2][2]=1.0 
-
-            display[0][0] = float(screen1.width()) / float(totalResolution[0])
-            #percent of screen height
-            display[1][1] = float(screen1.height()) / float(totalResolution[1])
-            #offset in x
-            if float(screen1.topLeft().x())!=0:
-                display[0][2] = float(screen1.topLeft().x()) / float(totalResolution[0])
-            #offset in y
-            if float(screen1.topLeft().y())!=0:
-                display[1][2] = float(screen1.topLeft().y()) / float(totalResolution[1])
-
-            isLeft = True
-            for i in range(0,3):
-                for j in range(0,3):
-                    if float(tabletScreenCoords[(i,j)]) != float(display[i][j]):
-                        isLeft = False
-                        break
-
-            if isLeft:
-                self.screenLeft.setChecked(1)
-            #crap... check if right
-            else:
-                display[0][0] = float(screen2.width()) / float(totalResolution[0])
-                #percent of screen height
-                display[1][1] = float(screen2.height()) / float(totalResolution[1])
-                #offset in x
-                if float(screen2.topLeft().x())!=0:
-                    display[0][2] = float(screen2.topLeft().x()) / float(totalResolution[0])
-                #offset in y
-                if float(screen2.topLeft().y())!=0:
-                    display[1][2] = float(screen2.topLeft().y()) / float(totalResolution[1])
-
-                isRight = True
-                for i in range(0,3):
-                    for j in range(0,3):
-                        if float(tabletScreenCoords[(i,j)]) != float(display[i][j]):
-                            isRight = False
+            for id in range(0, QtGui.QDesktopWidget().numScreens()):
+                screen = QtGui.QDesktopWidget().screenGeometry(id)
+            #screen1 = QtGui.QDesktopWidget().screenGeometry(0)
+            #screen2 = QtGui.QDesktopWidget().screenGeometry(1)
+                totalResolution = os.popen("xdpyinfo | grep dimensions | awk '{print $2}' | awk -Fx '{print $1, $2}'").read()
+                totalResolution = totalResolution.split()
+
+
+                display = [[0 for x in xrange(3)] for x in xrange(3)]
+                display[2][2] = 1.0
+
+                display[0][0] = float(screen.width()) / float(totalResolution[0])
+                # percent of screen height
+                display[1][1] = float(screen.height()) / float(totalResolution[1])
+                # offset in x
+                if float(screen.topLeft().x()) != 0:
+                    display[0][2] = float(screen.topLeft().x()) / float(totalResolution[0])
+                # offset in y
+                if float(screen.topLeft().y()) != 0:
+                    display[1][2] = float(screen.topLeft().y()) / float(totalResolution[1])
+                valid = True
+
+            #isLeft = True
+                for i in range(0, 3):
+                    for j in range(0, 3):
+                        if float(tabletScreenCoords[(i, j)]) != float(display[i][j]):
+                            valid = False
                             break
-                if isRight:
-                    self.screenRight.setChecked(1)
+                if valid:
+                    self.displays[id].setChecked(1)
+                    break
+
+
+            #if isLeft:
+            #    self.screenLeft.setChecked(1)
+            # crap... check if right
+            #else:
+            #    display[0][0] = float(screen2.width()) / float(totalResolution[0])
+            #    # percent of screen height
+            #    display[1][1] = float(screen2.height()) / float(totalResolution[1])
+            #    # offset in x
+            #    if float(screen2.topLeft().x()) != 0:
+            #        display[0][2] = float(screen2.topLeft().x()) / float(totalResolution[0])
+            #    # offset in y
+            #    if float(screen2.topLeft().y()) != 0:
+            #        display[1][2] = float(screen2.topLeft().y()) / float(totalResolution[1])#
+
+            #    isRight = True
+            #    for i in range(0,3):
+            #        for j in range(0,3):
+            #            if float(tabletScreenCoords[(i, j)]) != float(display[i][j]):
+            #                isRight = False
+            #                break
+            #    if isRight:
+            #        self.screenRight.setChecked(1)
+
 
     def getCurrentScreen(self):
-        #check if we actually have more that 1 screen
+        # check if we actually have more that 1 screen
         if QtGui.QDesktopWidget().numScreens() < 2 or QtGui.QDesktopWidget().numScreens() > 2:
             self.screenLeft.enabled = False 
             self.screenRight.enabled = False 
             self.screenFull.enabled = False 
             if QtGui.QDesktopWidget().numScreens() > 2:
                 print "More that 2 monitors; this isn't available yet.  Disabling tablet area option"
-        #set correct check box for active area... if it is valid
+        # set correct check box for active area... if it is valid
         else:
             self.getTabletArea()
 
@@ -231,23 +248,30 @@ def setDevices(self, devices):
     def getScreenArea(self):
         setCommands = []
         for device in self.devices:
-            if device != "pad" and device !='touch':
-                setCommands.append("xinput set-prop \""+self.tabletName+" " + device +
-                                   "\" --type=float \"Coordinate Transformation Matrix\" " + self.tabletActiveArea)
+            if device != "pad" and device != 'touch':
+                if 'HEAD' in self.tabletActiveArea:
+                    setCommands.append("xsetwacom set \"%s %s\" MapToOutput %s" %
+                                       (self.tabletName, device, self.tabletActiveArea))
+                else:
+                    setCommands.append("xinput set-prop \"%s %s\" --type=float \"Coordinate Transformation Matrix\" %s"
+                                       % (self.tabletName, device, self.tabletActiveArea))
         return setCommands
 
+
     def getFlip(self):
         return self.orient
 
 
     def resetDefaults(self):
-        self.orient = "xsetwacom --set \"" + self.tabletName + " stylus\" Rotate none"
-        self.orient += "\nxsetwacom --set \"" + self.tabletName + " eraser\" Rotate none"
+        self.orient = "xsetwacom --set \"%s stylus\" Rotate none" % self.tabletName
+        self.orient += "\nxsetwacom --set \"%s eraser\" Rotate none" % self.tabletName
         self.tabletRight.setChecked(1)
         os.popen(self.orient)
         for device in self.devices:
-            if device != self.tabletName + " pad":
-                setCommand = os.popen("xinput set-prop \"" + self.tabletName + " " + device + "\" --type=float \"Coordinate Transformation Matrix\" 1 0 0 0 1 0 0 0 1")
+            if device != "pad":
+                cmd = "xinput set-prop \"%s %s\" --type=float \"Coordinate Transformation Matrix\" 1 0 0 0 1 0 0 0 1" % \
+                      (self.tabletName, device)
+                setCommand = os.popen(cmd)
         self.screenFull.setChecked(True)
 
 if __name__ == '__main__':