home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / share / onboard / Key.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-04-29  |  8.5 KB  |  262 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import pango
  5. from math import sqrt
  6. BASE_PANE_TAB_HEIGHT = 40
  7.  
  8. class Key:
  9.     
  10.     def __init__(self, pane):
  11.         self.pane = pane
  12.         self.actions = [
  13.             False,
  14.             False,
  15.             False,
  16.             False,
  17.             False,
  18.             False]
  19.         self.on = False
  20.         self.stuckOn = False
  21.         self.beingScanned = False
  22.  
  23.     
  24.     def set_properties(self, actions, labels, sticky, fontOffsetX, fontOffsetY):
  25.         self.fontOffsetX = fontOffsetX
  26.         self.fontOffsetY = fontOffsetY
  27.         self.actions = actions
  28.         self.sticky = sticky
  29.         self.labels = labels
  30.  
  31.     
  32.     def paintFont(self, fontContext, xScale, yScale, x, y):
  33.         if xScale < yScale:
  34.             fontScale = xScale
  35.         else:
  36.             fontScale = yScale
  37.         fontContext.move_to((x + self.fontOffsetX) * xScale + 4, (y + self.fontOffsetY) * yScale - 0.029999999999999999 * self.pane.fontSize * sqrt(fontScale))
  38.         if self.pane.sok.mods[1]:
  39.             if self.pane.sok.mods[128] and self.labels[4]:
  40.                 self.layout = self.pane.da.create_pango_layout(self.labels[4])
  41.             elif self.labels[2]:
  42.                 self.layout = self.pane.da.create_pango_layout(self.labels[2])
  43.             elif self.labels[1]:
  44.                 self.layout = self.pane.da.create_pango_layout(self.labels[1])
  45.             else:
  46.                 self.layout = self.pane.da.create_pango_layout(self.labels[0])
  47.         elif self.pane.sok.mods[128] and self.labels[4]:
  48.             self.layout = self.pane.da.create_pango_layout(self.labels[3])
  49.         elif self.pane.sok.mods[2]:
  50.             if self.labels[1]:
  51.                 self.layout = self.pane.da.create_pango_layout(self.labels[1])
  52.             else:
  53.                 self.layout = self.pane.da.create_pango_layout(self.labels[0])
  54.         else:
  55.             self.layout = self.pane.da.create_pango_layout(self.labels[0])
  56.         self.layout.set_font_description(pango.FontDescription('Sans Serif %d' % fontScale * self.pane.fontSize))
  57.         fontContext.update_layout(self.layout)
  58.         fontContext.show_layout(self.layout)
  59.  
  60.  
  61.  
  62. class TabKey(Key):
  63.     '''class for those tabs up the right hand side'''
  64.     
  65.     def __init__(self, keyboard, width, pane):
  66.         Key.__init__(self, pane)
  67.         self.width = width
  68.         self.keyboard = keyboard
  69.         self.modifier = None
  70.         self.sticky = True
  71.  
  72.     
  73.     def point_within_key(self, mouseX, mouseY):
  74.         if mouseX > self.keyboard.kbwidth and mouseY > self.height * self.index + BASE_PANE_TAB_HEIGHT and mouseY < self.height * (self.index + 1) + BASE_PANE_TAB_HEIGHT:
  75.             return True
  76.         
  77.         return False
  78.  
  79.     
  80.     def paint(self, context):
  81.         self.height = self.keyboard.height / len(self.keyboard.panes) - BASE_PANE_TAB_HEIGHT / len(self.keyboard.panes)
  82.         self.index = self.keyboard.panes.index(self.pane)
  83.         context.rectangle(self.keyboard.kbwidth, self.height * self.index + BASE_PANE_TAB_HEIGHT, self.width, self.height)
  84.         if self.pane == self.keyboard.activePane and self.stuckOn:
  85.             context.set_source_rgba(1, 0, 0, 1)
  86.         else:
  87.             context.set_source_rgba(float(self.pane.rgba[0]), float(self.pane.rgba[1]), float(self.pane.rgba[2]), float(self.pane.rgba[3]))
  88.         context.fill()
  89.  
  90.  
  91.  
  92. class BaseTabKey(Key):
  93.     '''class for the tab that brings you to the base pane'''
  94.     
  95.     def __init__(self, keyboard, width):
  96.         Key.__init__(self, None)
  97.         self.width = width
  98.         self.keyboard = keyboard
  99.         self.modifier = None
  100.         self.sticky = False
  101.  
  102.     
  103.     def point_within_key(self, mouseX, mouseY):
  104.         if mouseX > self.keyboard.kbwidth and mouseY < BASE_PANE_TAB_HEIGHT:
  105.             return True
  106.         
  107.         return False
  108.  
  109.     
  110.     def paint(self, context):
  111.         pass
  112.  
  113.  
  114.  
  115. class LineKey(Key):
  116.     '''class for keyboard buttons made of lines'''
  117.     
  118.     def __init__(self, pane, coordList, rgba):
  119.         Key.__init__(self, pane)
  120.         self.coordList = coordList
  121.         self.rgba = rgba
  122.  
  123.     
  124.     def set_properties(self, actions, labels, sticky, fontOffsetX, fontOffsetY):
  125.         Key.set_properties(self, actions, labels, sticky, fontOffsetX, fontOffsetY)
  126.  
  127.     
  128.     def point_crosses_edge(self, x, y, xp1, yp1, sMouseX, sMouseY):
  129.         if (y <= sMouseY or sMouseY < yp1 or yp1 <= sMouseY or sMouseY < y) and sMouseX < (xp1 - x) * (sMouseY - y) / (yp1 - y) + x:
  130.             return True
  131.         else:
  132.             return False
  133.  
  134.     
  135.     def point_within_key(self, mouseX, mouseY):
  136.         '''Checks whether point is within shape.  Currently does not bother trying to work out curved paths accurately.'''
  137.         x = self.coordList[0]
  138.         y = self.coordList[1]
  139.         c = 2
  140.         coordLen = len(self.coordList)
  141.         within = False
  142.         sMouseX = mouseX / self.pane.xScale
  143.         sMouseY = mouseY / self.pane.yScale
  144.         while not c == coordLen:
  145.             xp1 = self.coordList[c + 1]
  146.             yp1 = self.coordList[c + 2]
  147.             
  148.             try:
  149.                 if self.coordList[c] == 'L':
  150.                     within = self.point_crosses_edge(x, y, xp1, yp1, sMouseX, sMouseY) ^ within
  151.                     c += 3
  152.                     x = xp1
  153.                     y = yp1
  154.                 else:
  155.                     xp2 = self.coordList[c + 3]
  156.                     yp2 = self.coordList[c + 4]
  157.                     xp3 = self.coordList[c + 5]
  158.                     yp3 = self.coordList[c + 6]
  159.                     within = self.point_crosses_edge(x, y, xp3, yp3, sMouseX, sMouseY) ^ within
  160.                     x = xp3
  161.                     y = yp3
  162.                     c += 7
  163.             continue
  164.             except ZeroDivisionError:
  165.                 strerror = None
  166.                 print strerror
  167.                 print 'x: %f, y: %f, yp1: %f' % (x, y, yp1)
  168.                 continue
  169.             
  170.  
  171.             None<EXCEPTION MATCH>ZeroDivisionError
  172.         return within
  173.  
  174.     
  175.     def paint(self, context, xScale, yScale):
  176.         c = 2
  177.         context.move_to(self.coordList[0] * xScale, self.coordList[1] * yScale)
  178.         while not c == len(self.coordList):
  179.             xp1 = self.coordList[c + 1] * xScale
  180.             yp1 = self.coordList[c + 2] * yScale
  181.             
  182.             try:
  183.                 if self.coordList[c] == 'L':
  184.                     c += 3
  185.                     context.line_to(xp1, yp1)
  186.                 else:
  187.                     xp2 = self.coordList[c + 3] * xScale
  188.                     yp2 = self.coordList[c + 4] * yScale
  189.                     xp3 = self.coordList[c + 5] * xScale
  190.                     yp3 = self.coordList[c + 6] * yScale
  191.                     context.curve_to(xp1, yp1, xp2, yp2, xp3, yp3)
  192.                     c += 7
  193.             except TypeError:
  194.                 strerror = None
  195.                 print x
  196.                 print y
  197.                 print xp1
  198.                 print yp1
  199.                 print strerror
  200.  
  201.             if self.stuckOn:
  202.                 context.set_source_rgba(1, 0, 0, 1)
  203.             elif self.on:
  204.                 context.set_source_rgba(0.5, 0.5, 0.5, 1)
  205.             elif self.beingScanned:
  206.                 context.set_source_rgba(0.45000000000000001, 0.45000000000000001, 0.69999999999999996, 1)
  207.             else:
  208.                 context.set_source_rgba(self.rgba[0], self.rgba[1], self.rgba[2], self.rgba[3])
  209.             context.fill_preserve()
  210.             context.set_source_rgb(0, 0, 0)
  211.  
  212.     
  213.     def paintFont(self, fontContext, xScale, yScale):
  214.         Key.paintFont(self, fontContext, xScale, yScale, self.coordList[0], self.coordList[1])
  215.  
  216.  
  217.  
  218. class RectKey(Key):
  219.     '''Class for rectangular keyboard buttons'''
  220.     
  221.     def __init__(self, pane, x, y, width, height, rgba):
  222.         Key.__init__(self, pane)
  223.         self.x = x
  224.         self.y = y
  225.         self.width = width
  226.         self.height = height
  227.         self.rgba = rgba
  228.  
  229.     
  230.     def set_properties(self, actions, labels, sticky, fontOffsetX, fontOffsetY):
  231.         Key.set_properties(self, actions, labels, sticky, fontOffsetX, fontOffsetY)
  232.  
  233.     
  234.     def point_within_key(self, mouseX, mouseY):
  235.         if mouseX / self.pane.xScale > self.x and mouseX / self.pane.xScale < self.x + self.width:
  236.             if mouseY / self.pane.yScale > self.y and mouseY / self.pane.yScale < self.y + self.height:
  237.                 return True
  238.             
  239.         else:
  240.             return False
  241.  
  242.     
  243.     def paint(self, context, xScale, yScale):
  244.         context.rectangle(self.x * xScale, self.y * yScale, self.width * xScale, self.height * yScale)
  245.         if self.stuckOn:
  246.             context.set_source_rgba(1, 0, 0, 1)
  247.         elif self.on:
  248.             context.set_source_rgba(0.5, 0.5, 0.5, 1)
  249.         elif self.beingScanned:
  250.             context.set_source_rgba(0.45000000000000001, 0.45000000000000001, 0.69999999999999996, 1)
  251.         else:
  252.             context.set_source_rgba(self.rgba[0], self.rgba[1], self.rgba[2], self.rgba[3])
  253.         context.fill_preserve()
  254.         context.set_source_rgb(0, 0, 0)
  255.         context.stroke()
  256.  
  257.     
  258.     def paintFont(self, fontContext, xScale, yScale):
  259.         Key.paintFont(self, fontContext, xScale, yScale, self.x, self.y)
  260.  
  261.  
  262.