diff --git a/Common.py b/Common.py
index 04ce776..1e9d91f 100644
--- a/Common.py
+++ b/Common.py
@@ -20,9 +20,10 @@
keytypes = Enum.Enum("SIMPLE SPECIAL").vals(illegal=255)
alignments = Enum.Enum("LEFT CENTRE RIGHT").vals(illegal=255)
keysegments = Enum.Enum("ALL ONE TWO THREE FOUR NONE").vals(illegal=255)
-keyvaluetype = Enum.Enum("UNICHAR CODEPOINT KEYSYM CONSTANT DEADKEY ANY VOIDSYMBOL NOSYMBOL NOACTION VERBATIM").vals(illegal=255)
+keyvaluetype = Enum.Enum("UNICHAR CODEPOINT KEYSYM CONSTANT DEADKEY ANY VOIDSYMBOL NOSYMBOL NOACTION VERBATIM").vals(
+ illegal=255)
-keysegmentslist = [keysegments.ONE, keysegments.TWO,
+keysegmentslist = [keysegments.ONE, keysegments.TWO,
keysegments.THREE, keysegments.FOUR]
keysegmentslistreverse = list(keysegmentslist)
keysegmentslistreverse.reverse()
@@ -52,10 +53,10 @@
HOMEDIR = ''
# The application's official full name.
-applicationname="Keyboard Layout Editor"
+applicationname = "Keyboard Layout Editor"
# Holds the current filename.
-currentlayoutfile=''
+currentlayoutfile = ''
# The directory to the xkeyboard-config base directory.
basedir = '/usr/share/X11/xkb/'
@@ -78,27 +79,31 @@
"""
+
# Sorts a dictionary by value, produces a sorted list of values.
-def sortDict(adict, cmp_function = None):
+def sortDict(adict, cmp_function=None):
keys = adict.keys()
keys.sort(cmp_function)
return map(adict.get, keys)
+
def addtostatusbar(message):
statusbar.push(statusbar.console_context, message)
+
def parseIncludeString(include):
"""
Parses strings of the form 'us(intl)', 'us', and produces
{ 'filename': 'us', 'variant': 'intl' }, { 'filename': 'us', 'variant': 'basic' }
"""
if include.partition('(')[1] == '(':
- return { 'filename': include.partition('(')[0], 'variant': include.partition('(')[2].partition(')')[0] }
+ return {'filename': include.partition('(')[0], 'variant': include.partition('(')[2].partition(')')[0]}
else:
- return { 'filename': include.partition('(')[0], 'variant': '' }
+ return {'filename': include.partition('(')[0], 'variant': ''}
+
-if __name__ == '__main__':
- print parseIncludeString('us')
- print parseIncludeString('us(level1)')
-
-
+if __name__ != '__main__':
+ pass
+else:
+ print(parseIncludeString('us'))
+ print(parseIncludeString('us(level1)'))
diff --git a/DeadKeysDict.py b/DeadKeysDict.py
index 782f1af..4b46197 100644
--- a/DeadKeysDict.py
+++ b/DeadKeysDict.py
@@ -15,42 +15,43 @@
# along with this program. If not, see
class DeadKeysClass:
- def __init__(self):
- self.dict = {
- 'dead_grave' : ('Grave', '`'),
- 'dead_acute' : ('Acute', '´'),
- 'dead_circumflex' : ('Circumflex', '^'),
- 'dead_tilde' : ('Tilde', '~'),
- 'dead_perispomeni' : ('Perispomeni', '῀'),
- 'dead_macron' : ('Macron', 'ˉ'),
- 'dead_breve' : ('Breve', '˘'),
- 'dead_abovedot' : ('Abovedot', '˙'),
- 'dead_diaeresis' : ('Diaeresis', '¨'),
- 'dead_abovering' : ('Abovering', '˚'),
- 'dead_doubleacute' : ('Double Acute', '˝'),
- 'dead_caron' : ('Caron', 'ˇ'),
- 'dead_cedilla' : ('Cedilla', '¸'),
- 'dead_ogonek' : ('Ogonek', '˛'),
- 'dead_iota' : ('Iota', 'ͺ'),
- 'dead_voiced_sound' : ('Voiced Sound', 'ﾞ'), # TODO (maybe)
- 'dead_semivoiced_sound' : ('Semivoiced Sound', 'ﾟ'), # TODO (maybe)
- 'dead_belowdot' : ('Below Dot', '?'), # TODO
- 'dead_hook' : ('Hook', '?'), # TODO
- 'dead_horn' : ('Horn', '?'), # TODO
- 'dead_stroke' : ('Stroke', '?'), # TODO
- 'dead_abovecomma' : ('Above Comma', '?'), # TODO
- 'dead_psili' : ('Psili', '?'), # TODO
- 'dead_abovereversedcomma' : ('Above Reversed Comma', 'ʽ'),
- 'dead_dasia' : ('Dasia', '῾'),
- 'dead_belowring' : ('Below Ring', '˳'),
- 'dead_belowmacron' : ('Below Macron', 'ˍ'),
- 'dead_belowcircumflex' : ('Below Circumflex', 'ˬ'),
- 'dead_belowtilde' : ('Below Tilde', '˷'),
- 'dead_belowbreve' : ('Below Breve', '?'), # TODO
- 'dead_belowdiaeresis' : ('Below Diaeresis', '?') } # TODO
+ def __init__(self):
+ self.dict = {
+ 'dead_grave': ('Grave', '`'),
+ 'dead_acute': ('Acute', '´'),
+ 'dead_circumflex': ('Circumflex', '^'),
+ 'dead_tilde': ('Tilde', '~'),
+ 'dead_perispomeni': ('Perispomeni', '῀'),
+ 'dead_macron': ('Macron', 'ˉ'),
+ 'dead_breve': ('Breve', '˘'),
+ 'dead_abovedot': ('Abovedot', '˙'),
+ 'dead_diaeresis': ('Diaeresis', '¨'),
+ 'dead_abovering': ('Abovering', '˚'),
+ 'dead_doubleacute': ('Double Acute', '˝'),
+ 'dead_caron': ('Caron', 'ˇ'),
+ 'dead_cedilla': ('Cedilla', '¸'),
+ 'dead_ogonek': ('Ogonek', '˛'),
+ 'dead_iota': ('Iota', 'ͺ'),
+ 'dead_voiced_sound': ('Voiced Sound', 'ﾞ'), # TODO (maybe)
+ 'dead_semivoiced_sound': ('Semivoiced Sound', 'ﾟ'), # TODO (maybe)
+ 'dead_belowdot': ('Below Dot', '?'), # TODO
+ 'dead_hook': ('Hook', '?'), # TODO
+ 'dead_horn': ('Horn', '?'), # TODO
+ 'dead_stroke': ('Stroke', '?'), # TODO
+ 'dead_abovecomma': ('Above Comma', '?'), # TODO
+ 'dead_psili': ('Psili', '?'), # TODO
+ 'dead_abovereversedcomma': ('Above Reversed Comma', 'ʽ'),
+ 'dead_dasia': ('Dasia', '῾'),
+ 'dead_belowring': ('Below Ring', '˳'),
+ 'dead_belowmacron': ('Below Macron', 'ˍ'),
+ 'dead_belowcircumflex': ('Below Circumflex', 'ˬ'),
+ 'dead_belowtilde': ('Below Tilde', '˷'),
+ 'dead_belowbreve': ('Below Breve', '?'), # TODO
+ 'dead_belowdiaeresis': ('Below Diaeresis', '?')} # TODO
+
DeadKeys = DeadKeysClass()
if __name__ == "__main__":
for k in DeadKeys.dict.keys():
- print k, DeadKeys.dict[k]
\ No newline at end of file
+ print(k, DeadKeys.dict[k])
diff --git a/DumbKey.py b/DumbKey.py
index a146248..c919b5f 100644
--- a/DumbKey.py
+++ b/DumbKey.py
@@ -23,11 +23,12 @@
import KeyValue
from KeyDict import KeyDict, included_files, activated_variants
+
class DumbKey(gtk.DrawingArea):
- def __init__(self, size = 1, keycode = None, vertical = False,
- keytype = Common.keytypes.SIMPLE,
- level1 = '', level2 = '',
- level3 = '', level4 = ''):
+ def __init__(self, size=1, keycode=None, vertical=False,
+ keytype=Common.keytypes.SIMPLE,
+ level1='', level2='',
+ level3='', level4=''):
gtk.DrawingArea.__init__(self)
self.connect("expose_event", self.expose)
@@ -36,26 +37,26 @@ def __init__(self, size = 1, keycode = None, vertical = False,
self.dvalues = {}
self.dvalues_inherited = {}
- self.setvalues(size, keycode, vertical, keytype,
+ self.setvalues(size, keycode, vertical, keytype,
level1, level2, level3, level4)
self.modifier = 1
self.highlight_x = -1
self.highlight_y = -1
self.highlight = False
- self.pending = { "ispending": False,
+ self.pending = {"ispending": False,
"keysegment": Common.keysegments.NONE,
- "value": '',
- "coordinates": (-1, -1) }
+ "value": '',
+ "coordinates": (-1, -1)}
self.popup_highlight = 0
-
+
self.infowin = gtk.Window()
self.infowin.set_decorated(False)
-
- def setvalues(self, size = 1, keycode = None, vertical = False,
- keytype = Common.keytypes.SIMPLE,
- level1 = '', level2 = '',
- level3 = '', level4 = ''):
+
+ def setvalues(self, size=1, keycode=None, vertical=False,
+ keytype=Common.keytypes.SIMPLE,
+ level1='', level2='',
+ level3='', level4=''):
self.keycode = keycode
self.size = size
self.vertical = vertical
@@ -64,26 +65,26 @@ def setvalues(self, size = 1, keycode = None, vertical = False,
self.verbatim = True
else:
self.verbatim = False
- self.keyvalues = {
- Common.keysegments.ONE: KeyValue.KeyValue(level1.decode('utf-8'), self.verbatim),
- Common.keysegments.TWO: KeyValue.KeyValue(level2.decode('utf-8'), self.verbatim),
- Common.keysegments.THREE: KeyValue.KeyValue(level3.decode('utf-8'), self.verbatim),
- Common.keysegments.FOUR: KeyValue.KeyValue(level4.decode('utf-8'), self.verbatim)
- }
+ self.keyvalues = {
+ Common.keysegments.ONE: KeyValue.KeyValue(level1.decode('utf-8'), self.verbatim),
+ Common.keysegments.TWO: KeyValue.KeyValue(level2.decode('utf-8'), self.verbatim),
+ Common.keysegments.THREE: KeyValue.KeyValue(level3.decode('utf-8'), self.verbatim),
+ Common.keysegments.FOUR: KeyValue.KeyValue(level4.decode('utf-8'), self.verbatim)
+ }
# Fills up the dvalues list with the values to display
self.extract_display_keyvalues()
def expose(self, widget, event):
self.context = widget.window.cairo_create()
-
+
# set a clip region for the expose event
- self.context.rectangle(event.area.x, event.area.y,
- event.area.width, event.area.height)
+ self.context.rectangle(event.area.x, event.area.y,
+ event.area.width, event.area.height)
self.context.clip()
self.a = self.parent.get_parent()
self.b = self.a.parent.get_parent()
- self.set_size_request(int(self.__key_width*self.size), -1)
+ self.set_size_request(int(self.__key_width * self.size), -1)
self.draw(self.context)
return False
@@ -95,14 +96,14 @@ def draw(self, context):
""" Draw the rectangle, filling in with color """
self.context.set_source_rgb(0.0, 0.0, 0.0)
self.roundedrec(context, 0, 0, rect.width, rect.height, 15, 3)
-
+
if self.keytype == Common.keytypes.SIMPLE:
- context.set_source_rgb(1.0 * self.modifier,
- 1.0 * self.modifier,
+ context.set_source_rgb(1.0 * self.modifier,
+ 1.0 * self.modifier,
0.9 * self.modifier)
elif self.keytype == Common.keytypes.SPECIAL:
context.set_source_rgb(.7 * self.modifier,
- .7 * self.modifier,
+ .7 * self.modifier,
.5 * self.modifier)
self.context.fill_preserve()
self.context.stroke()
@@ -110,13 +111,13 @@ def draw(self, context):
""" Highlight the segment """
if self.highlight or self.popup_highlight:
self.context.set_source_rgb(1.0, 1.0, 0.6)
- self.roundedrec_segment(context, self.pending["keysegment"],
+ self.roundedrec_segment(context, self.pending["keysegment"],
0, 0, rect.width, rect.height, 15, 3)
self.context.fill_preserve()
self.context.stroke()
""" Draw the cross """
- context.set_source_rgb(.1,.1,.1)
+ context.set_source_rgb(.1, .1, .1)
context.set_line_width(0.3)
if self.dvalues[Common.keysegments.THREE].getPValue() != '' \
or self.dvalues[Common.keysegments.FOUR].getPValue() != '':
@@ -128,42 +129,42 @@ def draw(self, context):
self.context.stroke()
""" Draw the four characters on the key """
- self.context.set_source_rgb(0,1,0)
+ self.context.set_source_rgb(0, 1, 0)
if self.dvalues[Common.keysegments.ONE].getPValue() == '':
pass
if self.dvalues[Common.keysegments.TWO].getPValue() == '' and \
- self.dvalues[Common.keysegments.THREE].getPValue() == '' and \
- self.dvalues[Common.keysegments.FOUR].getPValue() == '' \
- or self.dvalues[Common.keysegments.THREE].getPValue() == '' and \
- self.dvalues[Common.keysegments.FOUR].getPValue() == '':
- self.draw_character(context, self.dvalues[Common.keysegments.ONE].getPValue(),
- Common.alignments.LEFT,
+ self.dvalues[Common.keysegments.THREE].getPValue() == '' and \
+ self.dvalues[Common.keysegments.FOUR].getPValue() == '' \
+ or self.dvalues[Common.keysegments.THREE].getPValue() == '' and \
+ self.dvalues[Common.keysegments.FOUR].getPValue() == '':
+ self.draw_character(context, self.dvalues[Common.keysegments.ONE].getPValue(),
+ Common.alignments.LEFT,
0, rect.height / 2, rect.width, rect.height / 2)
else:
- self.draw_character(context, self.dvalues[Common.keysegments.ONE].getPValue(),
- Common.alignments.CENTRE,
+ self.draw_character(context, self.dvalues[Common.keysegments.ONE].getPValue(),
+ Common.alignments.CENTRE,
0, rect.height / 2, rect.width / 2, rect.height / 2)
if self.dvalues[Common.keysegments.THREE].getPValue() == '' and \
- self.dvalues[Common.keysegments.FOUR].getPValue() == '':
- self.draw_character(context, self.dvalues[Common.keysegments.TWO].getPValue(),
- Common.alignments.LEFT,
+ self.dvalues[Common.keysegments.FOUR].getPValue() == '':
+ self.draw_character(context, self.dvalues[Common.keysegments.TWO].getPValue(),
+ Common.alignments.LEFT,
0, 0, rect.width, rect.height / 2)
else:
- self.draw_character(context, self.dvalues[Common.keysegments.TWO].getPValue(),
- Common.alignments.CENTRE,
+ self.draw_character(context, self.dvalues[Common.keysegments.TWO].getPValue(),
+ Common.alignments.CENTRE,
0, 0, rect.width / 2, rect.height / 2)
- self.draw_character(context, self.dvalues[Common.keysegments.THREE].getPValue(),
- Common.alignments.CENTRE,
- rect.width / 2, rect.height / 2,
- rect.width / 2, rect.height / 2 )
- self.draw_character(context, self.dvalues[Common.keysegments.FOUR].getPValue(),
- Common.alignments.CENTRE,
+ self.draw_character(context, self.dvalues[Common.keysegments.THREE].getPValue(),
+ Common.alignments.CENTRE,
+ rect.width / 2, rect.height / 2,
+ rect.width / 2, rect.height / 2)
+ self.draw_character(context, self.dvalues[Common.keysegments.FOUR].getPValue(),
+ Common.alignments.CENTRE,
rect.width / 2, 0, rect.width / 2, rect.height / 2)
def draw_segment(self, segment):
pass
-
+
def draw_line(self, context, x1, y1, x2, y2):
self.context.move_to(x1, y1)
self.context.line_to(x2, y2)
@@ -171,40 +172,40 @@ def draw_line(self, context, x1, y1, x2, y2):
def draw_linewh(self, context, x, y, w, h):
self.context.move_to(x, y)
- self.context.line_to(x+w, y+h)
+ self.context.line_to(x + w, y + h)
self.context.stroke()
-
+
def draw_character(self, context, char, align, cx, cy, cwidth, cheight):
if char == '':
return
- self.context.select_font_face(Common.fontname, Common.fontstyle,
+ self.context.select_font_face(Common.fontname, Common.fontstyle,
Common.fontweight)
self.context.set_font_size(Common.fontsize * 1.0)
fascent, fdescent, fheight, fxadvance, fyadvance = self.context.font_extents()
xbearing, ybearing, width, height, xadvance, yadvance = \
- self.context.text_extents(char)
+ self.context.text_extents(char)
if align == Common.alignments.CENTRE:
- self.context.move_to(cx + cwidth/2 - width/2 - xbearing,
- cy + cheight/2 - height/2 - ybearing)
+ self.context.move_to(cx + cwidth / 2 - width / 2 - xbearing,
+ cy + cheight / 2 - height / 2 - ybearing)
elif align == Common.alignments.LEFT:
- self.context.move_to(cx + cwidth/16 - xbearing,
- cy + cheight - cheight/16 + ybearing)
+ self.context.move_to(cx + cwidth / 16 - xbearing,
+ cy + cheight - cheight / 16 + ybearing)
elif align == Common.alignments.RIGHT:
- self.context.move_to(cx + cwidth/2 - width/2 - xbearing,
- cy + cheight/2 - height/2 - ybearing)
+ self.context.move_to(cx + cwidth / 2 - width / 2 - xbearing,
+ cy + cheight / 2 - height / 2 - ybearing)
else:
- print "Error; unknown alignment"
+ print("Error; unknown alignment")
sys.exit(-1)
self.context.set_source_rgb(.30, .30, .30)
self.context.show_text(char)
-
+
def redraw(self):
- (x,y,width,height) = self.get_allocation()
- self.queue_draw_area(x, y, width, height)
-
- def roundedrec(self, context, x, y, w, h, r = 10, line_width=1):
+ (x, y, width, height) = self.get_allocation()
+ self.queue_draw_area(x, y, width, height)
+
+ def roundedrec(self, context, x, y, w, h, r=10, line_width=1):
"Draw a rounded rectangle (source: anonymous/pygtk website)"
# A****BQ
# H C
@@ -213,17 +214,17 @@ def roundedrec(self, context, x, y, w, h, r = 10, line_width=1):
# F****E
context.set_line_width(line_width)
- context.move_to(x+r,y) # Move to A
- context.line_to(x+w-r,y) # Straight line to B
- context.curve_to(x+w,y,x+w,y,x+w,y+r) # Curve to C, Control points are both at Q
- context.line_to(x+w,y+h-r) # Move to D
- context.curve_to(x+w,y+h,x+w,y+h,x+w-r,y+h) # Curve to E
- context.line_to(x+r,y+h) # Line to F
- context.curve_to(x,y+h,x,y+h,x,y+h-r) # Curve to G
- context.line_to(x,y+r) # Line to H
- context.curve_to(x,y,x,y,x+r,y) # Curve to A
-
- def roundedrec_segment(self,context, which_segment, x, y, w, h, r = 10,
+ context.move_to(x + r, y) # Move to A
+ context.line_to(x + w - r, y) # Straight line to B
+ context.curve_to(x + w, y, x + w, y, x + w, y + r) # Curve to C, Control points are both at Q
+ context.line_to(x + w, y + h - r) # Move to D
+ context.curve_to(x + w, y + h, x + w, y + h, x + w - r, y + h) # Curve to E
+ context.line_to(x + r, y + h) # Line to F
+ context.curve_to(x, y + h, x, y + h, x, y + h - r) # Curve to G
+ context.line_to(x, y + r) # Line to H
+ context.curve_to(x, y, x, y, x + r, y) # Curve to A
+
+ def roundedrec_segment(self, context, which_segment, x, y, w, h, r=10,
line_width=1):
"Draw a rounded rectangle (source: anonymous/pygtk website)"
# A****BQ
@@ -236,41 +237,41 @@ def roundedrec_segment(self,context, which_segment, x, y, w, h, r = 10,
if which_segment == Common.keysegments.ALL:
self.roundedrec(context, x, y, w, h, r, line_width)
elif which_segment == Common.keysegments.ONE:
- context.move_to(x, y + h / 2) # Move to GH-middle
- context.line_to(x, y + h - r) # Line to G
- context.curve_to(x, y + h, x, y + h, x + r, y+h)# Curve to F
- context.line_to(x + w / 2, y + h) # Line to FE-middle
- context.line_to(x + w / 2, y + h / 2) # Line to middle
- context.line_to(x, y + h / 2) # Line to GH-middle
+ context.move_to(x, y + h / 2) # Move to GH-middle
+ context.line_to(x, y + h - r) # Line to G
+ context.curve_to(x, y + h, x, y + h, x + r, y + h) # Curve to F
+ context.line_to(x + w / 2, y + h) # Line to FE-middle
+ context.line_to(x + w / 2, y + h / 2) # Line to middle
+ context.line_to(x, y + h / 2) # Line to GH-middle
elif which_segment == Common.keysegments.TWO:
- context.move_to(x, y + h / 2) # Move to GH-middle
- context.line_to(x, y + r) # Line to H
- context.curve_to(x, y, x, y, x + r, y) # Curve to A
- context.line_to(x + w / 2, y) # Line to AB-middle
- context.line_to(x + w / 2, y + h / 2) # Line to middle
- context.line_to(x, y + h / 2) # Line to GH-middle
+ context.move_to(x, y + h / 2) # Move to GH-middle
+ context.line_to(x, y + r) # Line to H
+ context.curve_to(x, y, x, y, x + r, y) # Curve to A
+ context.line_to(x + w / 2, y) # Line to AB-middle
+ context.line_to(x + w / 2, y + h / 2) # Line to middle
+ context.line_to(x, y + h / 2) # Line to GH-middle
elif which_segment == Common.keysegments.THREE:
- context.move_to(x + w / 2, y + h) # Move to FE-middle
- context.line_to(x + w - r, y + h) # Line to E
- context.curve_to(x + w, y + h, x + w, y + h,
- x + w, y + h - r) # Curve to D
- context.line_to(x + w, y + h / 2) # Line to CD-middle
- context.line_to(x + w / 2, y + h / 2) # Line to middle
- context.line_to(x + w / 2, y + h) # Line to FE-middle
+ context.move_to(x + w / 2, y + h) # Move to FE-middle
+ context.line_to(x + w - r, y + h) # Line to E
+ context.curve_to(x + w, y + h, x + w, y + h,
+ x + w, y + h - r) # Curve to D
+ context.line_to(x + w, y + h / 2) # Line to CD-middle
+ context.line_to(x + w / 2, y + h / 2) # Line to middle
+ context.line_to(x + w / 2, y + h) # Line to FE-middle
elif which_segment == Common.keysegments.FOUR:
- context.move_to(x + w, y + h / 2) # Move to CD-middle
- context.line_to(x + w, y + r) # Line to C
- context.curve_to(x + w, y, x + w, y,
- x + w - r, y) # Curve to B
- context.line_to(x + w / 2, y) # Line to AB-middle
- context.line_to(x + w / 2, y + h / 2) # Line to middle
- context.line_to(x + w, y + h / 2) # Line to CD-middle
-
- def do_highlight(self, do_highlight = Common.keysegments.NONE, x = -1, y = -1):
+ context.move_to(x + w, y + h / 2) # Move to CD-middle
+ context.line_to(x + w, y + r) # Line to C
+ context.curve_to(x + w, y, x + w, y,
+ x + w - r, y) # Curve to B
+ context.line_to(x + w / 2, y) # Line to AB-middle
+ context.line_to(x + w / 2, y + h / 2) # Line to middle
+ context.line_to(x + w, y + h / 2) # Line to CD-middle
+
+ def do_highlight(self, do_highlight=Common.keysegments.NONE, x=-1, y=-1):
self.highlight_x = x
self.highlight_y = y
-
- #print "do_highlight():", x, y
+
+ # print "do_highlight():", x, y
if do_highlight:
self.modifier = .8
else:
@@ -290,8 +291,8 @@ def extract_display_keyvalues(self):
if activated_variants[layout][variant].has_key(self.keycode):
if activated_variants[layout][variant][self.keycode].has_key(counter):
self.dvalues_inherited[counter] = True
- self.dvalues[counter] = copy.copy(activated_variants[layout][variant][self.keycode][counter])
+ self.dvalues[counter] = copy.copy(
+ activated_variants[layout][variant][self.keycode][counter])
if self.dvalues[counter].getType() == Common.keyvaluetype.NOSYMBOL:
self.dvalues_inherited[counter] = False
self.dvalues[counter] = copy.copy(self.keyvalues[counter])
-
\ No newline at end of file
diff --git a/GenericLayout.py b/GenericLayout.py
index 32c7cfb..a1b6a26 100644
--- a/GenericLayout.py
+++ b/GenericLayout.py
@@ -18,6 +18,7 @@
from lxml import etree
from KeyDict import KeyDict, included_files, activated_variants
+
#
#
#
@@ -37,12 +38,13 @@
#
#
#
-#
+#
class GenericLayout:
- def __init__(self):
- self.generic_layout = etree.Element("layout", layoutname = "CHANGEME")
+ def __init__(self):
+ self.tokenkey = None
+ self.generic_layout = etree.Element("layout", layoutname="CHANGEME")
self.symbols = etree.SubElement(self.generic_layout, "symbols")
@@ -67,13 +69,14 @@ def __init__(self):
for counter in range(Common.LEVELS):
etree.SubElement(self.symbolsgroup, "symbol")
"""
-
+
def create_layout(self, layoutcode, layoutvariant, layoutcountry, layoutname, layoutkeys):
"""
Creates an lxml construct with the layout.
Makes use of KeyDict.included_files, KeyDict.activated_variants
"""
- self.new_layout = etree.Element("layout", layoutname = layoutcode)
+ global max_index
+ self.new_layout = etree.Element("layout", layoutname=layoutcode)
self.symbols = etree.SubElement(self.new_layout, "symbols")
@@ -92,7 +95,7 @@ def create_layout(self, layoutcode, layoutvariant, layoutcountry, layoutname, la
for keycodename in layoutkeys.keys():
if keycodename in KeyDict.IgnoreKeys:
- #print "keycodename", keycodename, "is in ignorekeys"
+ # print "keycodename", keycodename, "is in ignorekeys"
continue
votes_empty = 0
for counter in Common.keysegmentslist:
@@ -101,13 +104,13 @@ def create_layout(self, layoutcode, layoutvariant, layoutcountry, layoutname, la
if votes_empty == len(Common.keysegmentslist):
# print "Keycode", keycodename, "is empty, skipping"
continue
- else:
+ else:
# print keycodename, "we only had", votes_empty, "votes,"
for counter in Common.keysegmentslist:
pass
- #print layoutkeys[keycodename].key.keyvalues[counter].getValue(),
- #print
- #print layoutkeys[keycodename].key.keyvalues[Common.keysegments.ONE].getValue()
+ # print layoutkeys[keycodename].key.keyvalues[counter].getValue(),
+ # print
+ # print layoutkeys[keycodename].key.keyvalues[Common.keysegments.ONE].getValue()
self.tokenkey = etree.SubElement(self.mapmaterial, "tokenkey")
self.tokenkey.attrib["override"] = "False"
@@ -121,12 +124,12 @@ def create_layout(self, layoutcode, layoutvariant, layoutcountry, layoutname, la
for counter in Common.keysegmentslistreverse:
max_index = counter
if layoutkeys[keycodename].key.keyvalues[counter].getType() == Common.keyvaluetype.NOSYMBOL:
- #print "O",
+ # print "O",
continue
else:
break
- #print
- #print "Doing look between", Common.keysegments.ONE, "and", max_index
+ # print
+ # print "Doing look between", Common.keysegments.ONE, "and", max_index
for counter in range(Common.keysegments.ONE, max_index + 1):
sym = etree.SubElement(self.symbolsgroup, "symbol")
sym.text = layoutkeys[keycodename].key.keyvalues[counter].getValue()
@@ -135,7 +138,7 @@ def create_layout(self, layoutcode, layoutvariant, layoutcountry, layoutname, la
# print "sym.text", sym.text
return self.new_layout
-
+
def create_tokenkey(self, keycodenametext):
if not self.exists_tokenkey(keycodenametext):
tokenkey = etree.SubElement(self.mapmaterial, "tokenkey")
@@ -155,11 +158,11 @@ def create_tokenkey(self, keycodenametext):
def return_tokenkey(self, keycode):
all_tokenkeys = self.generic_layout.findall(".//tokenkey")
- if all_tokenkeys == []:
+ if not all_tokenkeys:
return None
for tk in all_tokenkeys:
keycodenames = tk.findall(".//keycodename")
- if keycodenames == []:
+ if not keycodenames:
SystemError("Internal error, expecting a keycodename")
if len(keycodenames) > 1:
SystemError("Internal error, expecting only one keycodename")
@@ -168,11 +171,11 @@ def return_tokenkey(self, keycode):
def exists_tokenkey(self, keycode):
all_tokenkeys = self.generic_layout.findall(".//tokenkey")
- if all_tokenkeys == []:
+ if not all_tokenkeys:
return False
for tk in all_tokenkeys:
keycodenames = tk.findall(".//keycodename")
- if keycodenames == []:
+ if not keycodenames:
SystemError("Internal error, expecting a keycodename")
if len(keycodenames) > 1:
SystemError("Internal error, expecting only one keycodename")
@@ -180,10 +183,11 @@ def exists_tokenkey(self, keycode):
return True
else:
return False
-
+
def tostring(self):
- return etree.tostring(self.generic_layout, pretty_print = True)
-
+ return etree.tostring(self.generic_layout, pretty_print=True)
+
+
if __name__ == "__main__":
gl = GenericLayout()
- print gl.tostring()
+ print(gl.tostring())
diff --git a/Key.py b/Key.py
index 233a5a3..417e5fa 100644
--- a/Key.py
+++ b/Key.py
@@ -22,19 +22,20 @@
import KeyValue
from KeyDict import KeyDict
-class Key(gtk.EventBox):
+
+class Key(gtk.EventBox):
TARGET_TYPE_TEXT = 80
- __toKey__ = [ ( "text/plain", 0, TARGET_TYPE_TEXT ) ]
-
- def __init__(self, size = 1, keycode = None, vertical = False,
- keytype = Common.keytypes.SIMPLE,
- level1 = '', level2 = '', level3 = '', level4 = ''):
+ __toKey__ = [("text/plain", 0, TARGET_TYPE_TEXT)]
+
+ def __init__(self, size=1, keycode=None, vertical=False,
+ keytype=Common.keytypes.SIMPLE,
+ level1='', level2='', level3='', level4=''):
gtk.EventBox.__init__(self)
self.keycode = keycode
- #print "Key: Invoked __init__(), level1:", level1
+ # print "Key: Invoked __init__(), level1:", level1
- self.key = DumbKey.DumbKey(size, keycode, vertical, keytype,
+ self.key = DumbKey.DumbKey(size, keycode, vertical, keytype,
level1, level2, level3, level4)
self.add(self.key)
self.set_events(gtk.gdk.BUTTON_PRESS_MASK)
@@ -45,24 +46,24 @@ def __init__(self, size = 1, keycode = None, vertical = False,
self.context_menu = gtk.Menu()
self.context_menu_item = gtk.MenuItem("Remove")
self.context_menu.add(self.context_menu_item)
- self.context_menu_item.connect("activate", self.menu_item_activate_callback,
+ self.context_menu_item.connect("activate", self.menu_item_activate_callback,
"remove")
self.context_menu.connect("selection-done", self.menu_selection_done_callback)
self.context_menu.show_all()
-
+
# Adding DnD support
if self.keycode not in KeyDict.IgnoreKeys:
self.connect("drag_data_received", self.drag_data_get_callback)
self.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
- gtk.DEST_DEFAULT_HIGHLIGHT |
- gtk.DEST_DEFAULT_DROP,
- self.__toKey__, gtk.gdk.ACTION_COPY)
-
+ gtk.DEST_DEFAULT_HIGHLIGHT |
+ gtk.DEST_DEFAULT_DROP,
+ self.__toKey__, gtk.gdk.ACTION_COPY)
+
self.add_events(self.get_events() | gtk.gdk.EXPOSURE_MASK
- | gtk.gdk.BUTTON1_MOTION_MASK | gtk.gdk.BUTTON_PRESS_MASK
- | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.DRAG_MOTION
- | gtk.gdk.DROP_FINISHED | gtk.gdk.DRAG_STATUS | gtk.gdk.ENTER_NOTIFY
- | gtk.gdk.DRAG_ENTER)
+ | gtk.gdk.BUTTON1_MOTION_MASK | gtk.gdk.BUTTON_PRESS_MASK
+ | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.DRAG_MOTION
+ | gtk.gdk.DROP_FINISHED | gtk.gdk.DRAG_STATUS | gtk.gdk.ENTER_NOTIFY
+ | gtk.gdk.DRAG_ENTER)
# self.connect("motion-notify-event", self.mouse_move_signal)
self.connect("enter_notify_event", self.enter_notify_callback)
self.connect("leave_notify_event", self.leave_notify_callback)
@@ -71,37 +72,37 @@ def __init__(self, size = 1, keycode = None, vertical = False,
self.connect("drag_leave", self.drag_leave_callback)
self.tooltips = gtk.Tooltips()
self.tooltips.set_tip(self, "Keycode: " + self.keycode)
-
+
def drag_data_get_callback(self, widget, context, x, y, selection, targetType, time):
- #print "Callback drag_data_get: Received a callback for '%(str)s', segment: %(s)d at %(x)d, %(y)d" % \
+ # print "Callback drag_data_get: Received a callback for '%(str)s', segment: %(s)d at %(x)d, %(y)d" % \
# { "s": self.key.pending["keysegment"], "str": selection.data.decode('utf-8'), "x": x, "y": y }
if selection.data[0] == '\\' and \
- (selection.data[1] == 'u' or selection.data[1] == 'U'):
+ (selection.data[1] == 'u' or selection.data[1] == 'U'):
newval = selection.data.decode('unicode-escape')
else:
newval = selection.data
self.key.pending["ispending"] = True
self.key.pending["value"] = newval
- #print "drag_data_get"
- #print "self.key.pending[\"keysegment\"]:", self.key.pending["keysegment"]
+ # print "drag_data_get"
+ # print "self.key.pending[\"keysegment\"]:", self.key.pending["keysegment"]
self.key.keyvalues[self.key.pending["keysegment"]].add(newval)
self.key.extract_display_keyvalues()
self.key.redraw()
self.set_tooltip()
Common.addtostatusbar('Added ' + newval + ' to key ' + self.keycode + \
', at level ' + str(self.key.pending["keysegment"]))
-
+
def mouse_move_callback(self, widget, event):
pass
-
+
def enter_notify_callback(self, widget, event):
- #print "enter_notify"
+ # print "enter_notify"
self.key.do_highlight(True)
self.set_tooltip()
def leave_notify_callback(self, widget, event):
- #self.key.infowin.hide()
- #print "leave_notify"
+ # self.key.infowin.hide()
+ # print "leave_notify"
self.key.do_highlight(False, event.x, event.y)
def drag_drop_callback(self, widget, drag_context, x, y, timestamp):
@@ -109,13 +110,13 @@ def drag_drop_callback(self, widget, drag_context, x, y, timestamp):
pass
def drag_motion_callback(self, widget, drag_context, x, y, timestamp):
- #print "drag_motion"
+ # print "drag_motion"
self.key.highlight = True
self.key.do_highlight(True, x, y)
self.key.pending["keysegment"] = self.find_highlighted_segment(x, y)
-
+
def drag_leave_callback(self, widget, drag_context, timestamp):
- #print "drag_leave"
+ # print "drag_leave"
self.key.highlight = False
self.key.do_highlight(False)
@@ -127,7 +128,7 @@ def button_press_event_callback(self, widget, event):
self.key.pending["keysegment"] = self.find_highlighted_segment(event.x, event.y)
# Tell calling code that we have handled this event.
return True
-
+
# Tell calling code we have not handled this code; pass it on
return False
@@ -145,28 +146,28 @@ def menu_item_activate_callback(self, menuitem, action):
self.key.extract_display_keyvalues()
self.set_tooltip()
self.key.redraw()
-
+
def myname(self):
return "[%(k1)s, %(k2)s, %(k3)s, %(k4)s]" % \
- { "k1": self.key.keyvalues[Common.keysegments.ONE].getValue(),
- "k2": self.key.keyvalues[Common.keysegments.TWO].getValue(),
- "k3": self.key.keyvalues[Common.keysegments.THREE].getValue(),
- "k4": self.key.keyvalues[Common.keysegments.FOUR].getValue()
- }
-
+ {"k1": self.key.keyvalues[Common.keysegments.ONE].getValue(),
+ "k2": self.key.keyvalues[Common.keysegments.TWO].getValue(),
+ "k3": self.key.keyvalues[Common.keysegments.THREE].getValue(),
+ "k4": self.key.keyvalues[Common.keysegments.FOUR].getValue()
+ }
+
def find_highlighted_segment(self, x, y):
dummy, dummy, width, height = self.get_allocation()
- #print "find:", width, height, x, y
+ # print "find:", width, height, x, y
if x != -1 and y != -1:
- if x <= width/2:
- if y <= height/2:
+ if x <= width / 2:
+ if y <= height / 2:
return Common.keysegments.TWO
else:
return Common.keysegments.ONE
- elif y <= height/2:
- return Common.keysegments.FOUR
+ elif y <= height / 2:
+ return Common.keysegments.FOUR
else:
- return Common.keysegments.THREE
+ return Common.keysegments.THREE
else:
return Common.keysegments.NONE
@@ -175,10 +176,10 @@ def set_tooltip(self):
counter_empty = 0
for counter in Common.keysegmentslist:
if self.key.dvalues[counter].getType() == Common.keyvaluetype.NOSYMBOL:
- counter_empty +=1
+ counter_empty += 1
if counter_empty < len(Common.keysegmentslist):
for counter in Common.keysegmentslist:
- tooltip_string += '\n' + str(counter) + '. ' +\
- str(self.key.dvalues[counter].getValue()) + ' ' +\
- self.key.dvalues[counter].getPValue()
+ tooltip_string += '\n' + str(counter) + '. ' + \
+ str(self.key.dvalues[counter].getValue()) + ' ' + \
+ self.key.dvalues[counter].getPValue()
self.tooltips.set_tip(self, tooltip_string)
diff --git a/KeyDict.py b/KeyDict.py
index 8e73c8a..f470ea9 100644
--- a/KeyDict.py
+++ b/KeyDict.py
@@ -17,104 +17,106 @@
import Key
import Common
+
class KeyDictClass:
def __init__(self):
- self.Keys = {}
+ self.Keys = {}
- self.IgnoreKeys = [ "ESC", "FK01", "FK02", "FK03", "FK04", "FK05", "FK06",
- "FK07", "FK08", "FK09", "FK10", "FK11", "FK12",
- "BKSP", "TAB", "CAPS", "RTRN", "LFSH", "RTSH", "LCTL",
- "LWIN", "LALT", "SPCE", "RALT", "RWIN", "MENU", "RCTL" ]
+ self.IgnoreKeys = ["ESC", "FK01", "FK02", "FK03", "FK04", "FK05", "FK06",
+ "FK07", "FK08", "FK09", "FK10", "FK11", "FK12",
+ "BKSP", "TAB", "CAPS", "RTRN", "LFSH", "RTSH", "LCTL",
+ "LWIN", "LALT", "SPCE", "RALT", "RWIN", "MENU", "RCTL"]
def set(self):
self.Keys = {
- "ESC" : Key.Key(1, "ESC", False, Common.keytypes.SPECIAL,'Esc'),
- "FK01": Key.Key(1, "FK01", False, Common.keytypes.SIMPLE, 'F1'),
- "FK02": Key.Key(1, "FK02", False, Common.keytypes.SIMPLE, 'F2'),
- "FK03": Key.Key(1, "FK03", False, Common.keytypes.SIMPLE, 'F3'),
- "FK04": Key.Key(1, "FK04", False, Common.keytypes.SIMPLE, 'F4'),
- "FK05": Key.Key(1, "FK05", False, Common.keytypes.SIMPLE, 'F5'),
- "FK06": Key.Key(1, "FK06", False, Common.keytypes.SIMPLE, 'F6'),
- "FK07": Key.Key(1, "FK07", False, Common.keytypes.SIMPLE, 'F7'),
- "FK08": Key.Key(1, "FK08", False, Common.keytypes.SIMPLE, 'F8'),
- "FK09": Key.Key(1, "FK09", False, Common.keytypes.SIMPLE, 'F9'),
- "FK10": Key.Key(1, "FK10", False, Common.keytypes.SIMPLE, 'F10'),
- "FK11": Key.Key(1, "FK11", False, Common.keytypes.SIMPLE, 'F11'),
- "FK12": Key.Key(1, "FK12", False, Common.keytypes.SIMPLE, 'F12'),
+ "ESC": Key.Key(1, "ESC", False, Common.keytypes.SPECIAL, 'Esc'),
+ "FK01": Key.Key(1, "FK01", False, Common.keytypes.SIMPLE, 'F1'),
+ "FK02": Key.Key(1, "FK02", False, Common.keytypes.SIMPLE, 'F2'),
+ "FK03": Key.Key(1, "FK03", False, Common.keytypes.SIMPLE, 'F3'),
+ "FK04": Key.Key(1, "FK04", False, Common.keytypes.SIMPLE, 'F4'),
+ "FK05": Key.Key(1, "FK05", False, Common.keytypes.SIMPLE, 'F5'),
+ "FK06": Key.Key(1, "FK06", False, Common.keytypes.SIMPLE, 'F6'),
+ "FK07": Key.Key(1, "FK07", False, Common.keytypes.SIMPLE, 'F7'),
+ "FK08": Key.Key(1, "FK08", False, Common.keytypes.SIMPLE, 'F8'),
+ "FK09": Key.Key(1, "FK09", False, Common.keytypes.SIMPLE, 'F9'),
+ "FK10": Key.Key(1, "FK10", False, Common.keytypes.SIMPLE, 'F10'),
+ "FK11": Key.Key(1, "FK11", False, Common.keytypes.SIMPLE, 'F11'),
+ "FK12": Key.Key(1, "FK12", False, Common.keytypes.SIMPLE, 'F12'),
+
+ "TLDE": Key.Key(1, "TLDE", False, Common.keytypes.SIMPLE),
+ "AE01": Key.Key(1, "AE01", False, Common.keytypes.SIMPLE),
+ "AE02": Key.Key(1, "AE02", False, Common.keytypes.SIMPLE),
+ "AE03": Key.Key(1, "AE03", False, Common.keytypes.SIMPLE),
+ "AE04": Key.Key(1, "AE04", False, Common.keytypes.SIMPLE),
+ "AE05": Key.Key(1, "AE05", False, Common.keytypes.SIMPLE),
+ "AE06": Key.Key(1, "AE06", False, Common.keytypes.SIMPLE),
+ "AE07": Key.Key(1, "AE07", False, Common.keytypes.SIMPLE),
+ "AE08": Key.Key(1, "AE08", False, Common.keytypes.SIMPLE),
+ "AE09": Key.Key(1, "AE09", False, Common.keytypes.SIMPLE),
+ "AE10": Key.Key(1, "AE10", False, Common.keytypes.SIMPLE),
+ "AE11": Key.Key(1, "AE11", False, Common.keytypes.SIMPLE),
+ "AE12": Key.Key(1, "AE12", False, Common.keytypes.SIMPLE),
+ "BKSP": Key.Key(2, "BKSP", False, Common.keytypes.SPECIAL, 'Backspace'),
- "TLDE": Key.Key(1, "TLDE", False, Common.keytypes.SIMPLE),
- "AE01": Key.Key(1, "AE01", False, Common.keytypes.SIMPLE),
- "AE02": Key.Key(1, "AE02", False, Common.keytypes.SIMPLE),
- "AE03": Key.Key(1, "AE03", False, Common.keytypes.SIMPLE),
- "AE04": Key.Key(1, "AE04", False, Common.keytypes.SIMPLE),
- "AE05": Key.Key(1, "AE05", False, Common.keytypes.SIMPLE),
- "AE06": Key.Key(1, "AE06", False, Common.keytypes.SIMPLE),
- "AE07": Key.Key(1, "AE07", False, Common.keytypes.SIMPLE),
- "AE08": Key.Key(1, "AE08", False, Common.keytypes.SIMPLE),
- "AE09": Key.Key(1, "AE09", False, Common.keytypes.SIMPLE),
- "AE10": Key.Key(1, "AE10", False, Common.keytypes.SIMPLE),
- "AE11": Key.Key(1, "AE11", False, Common.keytypes.SIMPLE),
- "AE12": Key.Key(1, "AE12", False, Common.keytypes.SIMPLE),
- "BKSP": Key.Key(2, "BKSP", False, Common.keytypes.SPECIAL,'Backspace'),
+ "TAB": Key.Key(1.8, "TAB", False, Common.keytypes.SPECIAL, 'Tab', 'ISO_Left'),
+ "AD01": Key.Key(1, "AD01", False, Common.keytypes.SIMPLE),
+ "AD02": Key.Key(1, "AD02", False, Common.keytypes.SIMPLE),
+ "AD03": Key.Key(1, "AD03", False, Common.keytypes.SIMPLE),
+ "AD04": Key.Key(1, "AD04", False, Common.keytypes.SIMPLE),
+ "AD05": Key.Key(1, "AD05", False, Common.keytypes.SIMPLE),
+ "AD06": Key.Key(1, "AD06", False, Common.keytypes.SIMPLE),
+ "AD07": Key.Key(1, "AD07", False, Common.keytypes.SIMPLE),
+ "AD08": Key.Key(1, "AD08", False, Common.keytypes.SIMPLE),
+ "AD09": Key.Key(1, "AD09", False, Common.keytypes.SIMPLE),
+ "AD10": Key.Key(1, "AD10", False, Common.keytypes.SIMPLE),
+ "AD11": Key.Key(1, "AD11", False, Common.keytypes.SIMPLE),
+ "AD12": Key.Key(1, "AD12", False, Common.keytypes.SIMPLE),
+ "BKSL": Key.Key(1, "BKSL", False, Common.keytypes.SIMPLE),
- "TAB" : Key.Key(1.8, "TAB", False, Common.keytypes.SPECIAL, 'Tab', 'ISO_Left'),
- "AD01": Key.Key(1, "AD01", False, Common.keytypes.SIMPLE),
- "AD02": Key.Key(1, "AD02", False, Common.keytypes.SIMPLE),
- "AD03": Key.Key(1, "AD03", False, Common.keytypes.SIMPLE),
- "AD04": Key.Key(1, "AD04", False, Common.keytypes.SIMPLE),
- "AD05": Key.Key(1, "AD05", False, Common.keytypes.SIMPLE),
- "AD06": Key.Key(1, "AD06", False, Common.keytypes.SIMPLE),
- "AD07": Key.Key(1, "AD07", False, Common.keytypes.SIMPLE),
- "AD08": Key.Key(1, "AD08", False, Common.keytypes.SIMPLE),
- "AD09": Key.Key(1, "AD09", False, Common.keytypes.SIMPLE),
- "AD10": Key.Key(1, "AD10", False, Common.keytypes.SIMPLE),
- "AD11": Key.Key(1, "AD11", False, Common.keytypes.SIMPLE),
- "AD12": Key.Key(1, "AD12", False, Common.keytypes.SIMPLE),
- "BKSL": Key.Key(1, "BKSL", False, Common.keytypes.SIMPLE),
+ "CAPS": Key.Key(2, "CAPS", False, Common.keytypes.SPECIAL, 'Caps Lock'),
+ "AC01": Key.Key(1, "AC01", False, Common.keytypes.SIMPLE),
+ "AC02": Key.Key(1, "AC02", False, Common.keytypes.SIMPLE),
+ "AC03": Key.Key(1, "AC03", False, Common.keytypes.SIMPLE),
+ "AC04": Key.Key(1, "AC04", False, Common.keytypes.SIMPLE),
+ "AC05": Key.Key(1, "AC05", False, Common.keytypes.SIMPLE),
+ "AC06": Key.Key(1, "AC06", False, Common.keytypes.SIMPLE),
+ "AC07": Key.Key(1, "AC07", False, Common.keytypes.SIMPLE),
+ "AC08": Key.Key(1, "AC08", False, Common.keytypes.SIMPLE),
+ "AC09": Key.Key(1, "AC09", False, Common.keytypes.SIMPLE),
+ "AC10": Key.Key(1, "AC10", False, Common.keytypes.SIMPLE),
+ "AC11": Key.Key(1, "AC11", False, Common.keytypes.SIMPLE),
+ "RTRN": Key.Key(2, "RTRN", False, Common.keytypes.SPECIAL, 'Return'),
- "CAPS": Key.Key(2, "CAPS", False, Common.keytypes.SPECIAL, 'Caps Lock'),
- "AC01": Key.Key(1, "AC01", False, Common.keytypes.SIMPLE),
- "AC02": Key.Key(1, "AC02", False, Common.keytypes.SIMPLE),
- "AC03": Key.Key(1, "AC03", False, Common.keytypes.SIMPLE),
- "AC04": Key.Key(1, "AC04", False, Common.keytypes.SIMPLE),
- "AC05": Key.Key(1, "AC05", False, Common.keytypes.SIMPLE),
- "AC06": Key.Key(1, "AC06", False, Common.keytypes.SIMPLE),
- "AC07": Key.Key(1, "AC07", False, Common.keytypes.SIMPLE),
- "AC08": Key.Key(1, "AC08", False, Common.keytypes.SIMPLE),
- "AC09": Key.Key(1, "AC09", False, Common.keytypes.SIMPLE),
- "AC10": Key.Key(1, "AC10", False, Common.keytypes.SIMPLE),
- "AC11": Key.Key(1, "AC11", False,Common.keytypes.SIMPLE),
- "RTRN": Key.Key(2, "RTRN", False, Common.keytypes.SPECIAL, 'Return'),
+ "LFSH": Key.Key(1, "LFSH", False, Common.keytypes.SPECIAL, 'Shift L', 'ISO Prev'),
+ "LSGT": Key.Key(1, "LSGT", False, Common.keytypes.SIMPLE),
+ "AB01": Key.Key(1, "AB01", False, Common.keytypes.SIMPLE),
+ "AB02": Key.Key(1, "AB02", False, Common.keytypes.SIMPLE),
+ "AB03": Key.Key(1, "AB03", False, Common.keytypes.SIMPLE),
+ "AB04": Key.Key(1, "AB04", False, Common.keytypes.SIMPLE),
+ "AB05": Key.Key(1, "AB05", False, Common.keytypes.SIMPLE),
+ "AB06": Key.Key(1, "AB06", False, Common.keytypes.SIMPLE),
+ "AB07": Key.Key(1, "AB07", False, Common.keytypes.SIMPLE),
+ "AB08": Key.Key(1, "AB08", False, Common.keytypes.SIMPLE),
+ "AB09": Key.Key(1, "AB09", False, Common.keytypes.SIMPLE),
+ "AB10": Key.Key(1, "AB10", False, Common.keytypes.SIMPLE),
+ "RTSH": Key.Key(2.5, "RTSH", False, Common.keytypes.SPECIAL, 'Shift R', 'ISO Next'),
- "LFSH": Key.Key(1, "LFSH", False, Common.keytypes.SPECIAL,'Shift L', 'ISO Prev'),
- "LSGT": Key.Key(1, "LSGT", False, Common.keytypes.SIMPLE),
- "AB01": Key.Key(1, "AB01", False, Common.keytypes.SIMPLE),
- "AB02": Key.Key(1, "AB02", False, Common.keytypes.SIMPLE),
- "AB03": Key.Key(1, "AB03", False, Common.keytypes.SIMPLE),
- "AB04": Key.Key(1, "AB04", False, Common.keytypes.SIMPLE),
- "AB05": Key.Key(1, "AB05", False, Common.keytypes.SIMPLE),
- "AB06": Key.Key(1, "AB06", False, Common.keytypes.SIMPLE),
- "AB07": Key.Key(1, "AB07", False, Common.keytypes.SIMPLE),
- "AB08": Key.Key(1, "AB08", False, Common.keytypes.SIMPLE),
- "AB09": Key.Key(1, "AB09", False, Common.keytypes.SIMPLE),
- "AB10": Key.Key(1, "AB10", False, Common.keytypes.SIMPLE),
- "RTSH": Key.Key(2.5, "RTSH", False, Common.keytypes.SPECIAL, 'Shift R', 'ISO Next'),
+ "LCTL": Key.Key(1.8, "LCTL", False, Common.keytypes.SPECIAL, 'Control L'),
+ "LWIN": Key.Key(1.5, "LWIN", False, Common.keytypes.SPECIAL, 'Super L'),
+ "LALT": Key.Key(1.5, "LALT", False, Common.keytypes.SPECIAL, 'Alt L'),
+ "SPCE": Key.Key(9.0, "SPCE", False, Common.keytypes.SIMPLE, 'Spacebar'),
+ "RALT": Key.Key(1.3, "RALT", False, Common.keytypes.SPECIAL, 'AltGr'),
+ "RWIN": Key.Key(1.3, "RWIN", False, Common.keytypes.SPECIAL, 'Super R'),
+ "MENU": Key.Key(1.3, "MENU", False, Common.keytypes.SPECIAL, 'Compose'),
+ "RCTL": Key.Key(1.5, "RCTL", False, Common.keytypes.SPECIAL, 'Control R')
+ }
- "LCTL": Key.Key(1.8, "LCTL", False, Common.keytypes.SPECIAL, 'Control L'),
- "LWIN": Key.Key(1.5, "LWIN", False, Common.keytypes.SPECIAL, 'Super L'),
- "LALT": Key.Key(1.5, "LALT", False, Common.keytypes.SPECIAL, 'Alt L'),
- "SPCE": Key.Key(9.0, "SPCE", False, Common.keytypes.SIMPLE, 'Spacebar'),
- "RALT": Key.Key(1.3, "RALT", False, Common.keytypes.SPECIAL, 'AltGr'),
- "RWIN": Key.Key(1.3, "RWIN", False, Common.keytypes.SPECIAL, 'Super R'),
- "MENU": Key.Key(1.3, "MENU", False, Common.keytypes.SPECIAL, 'Compose'),
- "RCTL": Key.Key(1.5, "RCTL", False, Common.keytypes.SPECIAL, 'Control R')
- }
# The dict keeps the current variants that are selected.
# For example, { "latin": {"basic": parsed1, "east": parsed2},
# "kpdl": {"one": parsed3, "two":parsed4} }
activated_variants = {}
-
+
# This dict keeps track of included files
# For example, included_files["latin"] = { "file": "/tmp/latin",
# "variants": variants_list, "xml": xml_layout }
@@ -124,4 +126,4 @@ def set(self):
if __name__ == "__main__":
for k in KeyDict.Keys.keys():
- print k, KeyDict.Keys[k]
+ print(k, KeyDict.Keys[k])
diff --git a/KeyValue.py b/KeyValue.py
index f73a905..f25916e 100644
--- a/KeyValue.py
+++ b/KeyValue.py
@@ -20,32 +20,33 @@
from KeysymsUniByValue import KeysymsUniByValue
from KeysymsUni import KeysymsUni
+
class KeyValue:
- def __init__(self, value = None, verbatim = False):
+ def __init__(self, value=None, verbatim=False):
# Any of Common.keyvaluetype.
self.__type__ = ""
# String that goes to the XKB file
self.__value__ = ""
# String shown in the editor
self.__presentation_value__ = ""
-
+
if value != None:
self.add(value, verbatim)
-
+
def getType(self):
return self.__type__
-
+
def getValue(self):
return self.__value__
-
+
def getPValue(self):
""" Accessor to retrieve the PresenationValue """
return self.__presentation_value__
-
+
def tostring(self):
return "type: %(type)s, value: %(value)s, pvalue: %(pvalue)s" % \
- { "type": self.getType(), "value": self.getValue(),
- "pvalue": self.getPValue() }
+ {"type": self.getType(), "value": self.getValue(),
+ "pvalue": self.getPValue()}
def copy(self, existing):
self.__type__ = existing.getType()
@@ -53,9 +54,9 @@ def copy(self, existing):
self.__presentation_value__ = existing.getPValue()
def reset(self):
- self.add('')
-
- def add(self, value, verbatim = False):
+ self.add(decode, '')
+
+ def add(self, value, verbatim=False):
if verbatim:
if value != '':
self.__type__ = Common.keyvaluetype.VERBATIM
@@ -64,13 +65,13 @@ def add(self, value, verbatim = False):
return
try:
intval = ord(value.decode('utf8'))
- except TypeError, e:
+ except TypeError as e:
intval = 0
if value == '':
""" If value is empty, we put NoSymbol and inherit from above. """
self.__type__ = Common.keyvaluetype.NOSYMBOL
self.__value__ = ''
- self.__presentation_value__ = ''
+ self.__presentation_value__ = ''
elif intval > 0:
""" If value is a verbatim character, """
if KeysymsUniByValue.has_key(intval):
@@ -85,7 +86,7 @@ def add(self, value, verbatim = False):
""" if value is of the form Uxxxx, where xxxx a hex number, """
try:
val = int(value[1:], 16)
- except ValueError, e:
+ except ValueError as e:
val = 0
if val > 0:
self.__type__ = Common.keyvaluetype.CODEPOINT
@@ -103,10 +104,10 @@ def add(self, value, verbatim = False):
0x1000 000. This should not have happened because we\
changed this in the code, all over the place.\
Sorry, I cannot continue. Error with %(e)s, value %(v)d"
- % { "e": value, "v": val} )
+ % {"e": value, "v": val})
self.__type__ = Common.keyvaluetype.CONSTANT
self.__value__ = value.lower()
- self.__presentation_value__ = unichr(val - 0x1000000) # TODO: 0x200E (special)
+ self.__presentation_value__ = unichr(val - 0x1000000) # TODO: 0x200E (special)
elif value[:5] == "dead_":
self.__type__ = Common.keyvaluetype.DEADKEY
self.__value__ = value
@@ -134,13 +135,13 @@ def add(self, value, verbatim = False):
else:
self.__presentation_value__ = value
+
if __name__ == "__main__":
- print KeyValue("U0392").tostring()
- print KeyValue("U4FE8").tostring()
- print KeyValue("0x1000389").tostring()
- print KeyValue("dead_acute").tostring()
- print KeyValue("0x1000392").tostring()
- print KeyValue("A").tostring()
- print KeyValue("'").tostring()
- print KeyValue("α").tostring()
-
\ No newline at end of file
+ print(KeyValue("U0392").tostring())
+ print(KeyValue("U4FE8").tostring())
+ print(KeyValue("0x1000389").tostring())
+ print(KeyValue("dead_acute").tostring())
+ print(KeyValue("0x1000392").tostring())
+ print(KeyValue("A").tostring())
+ print(KeyValue("'").tostring())
+ print(KeyValue("α").tostring())
diff --git a/Keyboard.py b/Keyboard.py
index f6f7ab9..c69a4dd 100644
--- a/Keyboard.py
+++ b/Keyboard.py
@@ -26,18 +26,20 @@
from ParseXML import ParseXML
from KeyDict import KeyDict, included_files, activated_variants
+
class Keyboard(gtk.Frame):
__gtype_name__ = 'Keyboard'
-
+
SPACING = 6
def __init__(self, layout):
gtk.Frame.__init__(self)
+ self.gl_layout = None
self.connect("expose_event", self.expose)
# This is a GenericLayout object, created in KeyboardLayoutEditor.
self.xmllayout = layout
-
+
self.layoutcode = ''
self.layoutvariant = ''
self.layoutcountry = ''
@@ -48,38 +50,44 @@ def __init__(self, layout):
# Fill in the KeyDict structure with xml branches
for key in KeyDict.Keys.keys():
if self.xmllayout.exists_tokenkey(key):
- print "Key", key, "already exists in xmllayout."
- if KeyDict.Keys[key].xmlbranch == None:
- print "Key", key, "was not set, setting now"
+ print("Key", key, "already exists in xmllayout.")
+ if KeyDict.Keys[key].xmlbranch is None:
+ print("Key", key, "was not set, setting now")
elif KeyDict.Keys[key].xmlbranch != xmllayout.return_tokenkey(key):
- print "Key", key, "already set to something..."
+ print("Key", key, "already set to something...")
else:
KeyDict.Keys[key].xmlbranch = xmllayout.create_tokenkey(key)
- elif self.xmllayout.create_tokenkey(key) != None:
+ elif self.xmllayout.create_tokenkey(key) is not None:
pass
- #print "Added", key
+ # print "Added", key
else:
SystemError("Unable to add " + key)
-
- #print self.xmllayout.tostring()
-
+
+ # print self.xmllayout.tostring()
+
self.set_label("")
self.set_shadow_type(gtk.SHADOW_NONE)
- __row1 = ("ESC" , "FK01", "FK02", "FK03", "FK04", "FK05", "FK06", "FK07", "FK08", "FK09", "FK10", "FK11", "FK12")
+ __row1 = ("ESC", "FK01", "FK02", "FK03", "FK04", "FK05", "FK06", "FK07", "FK08", "FK09", "FK10", "FK11", "FK12")
__row1_esc = ("ESC",)
__row1_f14 = ("FK01", "FK02", "FK03", "FK04")
__row1_f58 = ("FK05", "FK06", "FK07", "FK08")
__row1_f92 = ("FK09", "FK10", "FK11", "FK12")
- __row2 = ("TLDE", "AE01", "AE02", "AE03", "AE04", "AE05", "AE06", "AE07", "AE08", "AE09", "AE10", "AE11", "AE12", "BKSP")
- __row3 = ("TAB" , "AD01", "AD02", "AD03", "AD04", "AD05", "AD06", "AD07", "AD08", "AD09", "AD10", "AD11", "AD12", "BKSL")
- __row4 = ("CAPS", "AC01", "AC02", "AC03", "AC04", "AC05", "AC06", "AC07", "AC08", "AC09", "AC10", "AC11", "RTRN")
- __row5 = ("LFSH", "LSGT", "AB01", "AB02", "AB03", "AB04", "AB05", "AB06", "AB07", "AB08", "AB09", "AB10", "RTSH")
+ __row2 = (
+ "TLDE", "AE01", "AE02", "AE03", "AE04", "AE05", "AE06", "AE07", "AE08", "AE09", "AE10", "AE11", "AE12",
+ "BKSP")
+ __row3 = (
+ "TAB", "AD01", "AD02", "AD03", "AD04", "AD05", "AD06", "AD07", "AD08", "AD09", "AD10", "AD11", "AD12",
+ "BKSL")
+ __row4 = (
+ "CAPS", "AC01", "AC02", "AC03", "AC04", "AC05", "AC06", "AC07", "AC08", "AC09", "AC10", "AC11", "RTRN")
+ __row5 = (
+ "LFSH", "LSGT", "AB01", "AB02", "AB03", "AB04", "AB05", "AB06", "AB07", "AB08", "AB09", "AB10", "RTSH")
__row6 = ("LCTL", "LWIN", "LALT", "SPCE", "RALT", "RWIN", "MENU", "RCTL")
- vbox = gtk.VBox(False, Keyboard.SPACING)
-
+ vbox = gtk.VBox(False, Keyboard.SPACING)
+
hbox1 = gtk.HBox(False, Keyboard.SPACING)
hbox2 = gtk.HBox(False, Keyboard.SPACING)
hbox3 = gtk.HBox(False, Keyboard.SPACING)
@@ -91,18 +99,18 @@ def __init__(self, layout):
hboxtop_f14 = gtk.HBox(False, Keyboard.SPACING)
hboxtop_f58 = gtk.HBox(False, Keyboard.SPACING)
hboxtop_f92 = gtk.HBox(False, Keyboard.SPACING)
- aligntop_esc = gtk.Alignment( 0, 0, .1, 1)
+ aligntop_esc = gtk.Alignment(0, 0, .1, 1)
aligntop_f14 = gtk.Alignment(.1, 0, .5, 1)
aligntop_f58 = gtk.Alignment(.8, 0, .5, 1)
- aligntop_f92 = gtk.Alignment( 1, 0, .4, 1)
+ aligntop_f92 = gtk.Alignment(1, 0, .4, 1)
aligntop_esc.add(hboxtop_esc)
aligntop_f14.add(hboxtop_f14)
aligntop_f58.add(hboxtop_f58)
aligntop_f92.add(hboxtop_f92)
- hbox1.pack_start(aligntop_esc, expand=True, fill=True)
- hbox1.pack_start(aligntop_f14, expand=True, fill=True)
- hbox1.pack_start(aligntop_f58, expand=True, fill=True)
- hbox1.pack_start(aligntop_f92, expand=True, fill=True)
+ hbox1.pack_start(aligntop_esc, expand=True, fill=True)
+ hbox1.pack_start(aligntop_f14, expand=True, fill=True)
+ hbox1.pack_start(aligntop_f58, expand=True, fill=True)
+ hbox1.pack_start(aligntop_f92, expand=True, fill=True)
vbox.pack_start(hbox1, expand=True, fill=True)
vbox.pack_start(hbox2, expand=True, fill=True)
@@ -121,20 +129,20 @@ def __init__(self, layout):
hboxtop_f92.pack_start(KeyDict.Keys[item], expand=True, fill=True)
for item in __row2:
- hbox2.pack_start(KeyDict.Keys[item], expand=True, fill=True)
+ hbox2.pack_start(KeyDict.Keys[item], expand=True, fill=True)
for item in __row3:
- hbox3.pack_start(KeyDict.Keys[item], expand=True, fill=True)
+ hbox3.pack_start(KeyDict.Keys[item], expand=True, fill=True)
for item in __row4:
- hbox4.pack_start(KeyDict.Keys[item], expand=True, fill=True)
+ hbox4.pack_start(KeyDict.Keys[item], expand=True, fill=True)
for item in __row5:
- hbox5.pack_start(KeyDict.Keys[item], expand=True, fill=True)
+ hbox5.pack_start(KeyDict.Keys[item], expand=True, fill=True)
for item in __row6:
- hbox6.pack_start(KeyDict.Keys[item], expand=True, fill=True)
-
+ hbox6.pack_start(KeyDict.Keys[item], expand=True, fill=True)
+
self.add(vbox)
def draw(self, context):
- pass
+ pass
def expose(self, widget, event):
self.context = widget.window.cairo_create()
@@ -142,15 +150,15 @@ def expose(self, widget, event):
# set a clip region for the expose event
self.context.set_source_rgb(0.81, 0.84, 0.81)
self.context.rectangle(event.area.x, event.area.y,
- event.area.width, event.area.height)
+ event.area.width, event.area.height)
self.context.fill_preserve()
self.context.clip()
self.draw(self.context)
return False
-
+
def receiveCallback(widget, context, x, y, selection, targetType, time):
- print "Keyboard: Received a callback for", selection, "at", x, y, "at", time
+ print("Keyboard: Received a callback for", selection, "at", x, y, "at", time)
def redraw(self):
for keycode in KeyDict.Keys.keys():
@@ -160,18 +168,17 @@ def redraw(self):
def save(self, layout_file):
try:
fout = open(layout_file, "w")
- except IOError, e:
+ except IOError as e:
return False
self.gl_layout = GenericLayout.GenericLayout()
- newxml = self.gl_layout.create_layout(self.layoutcode,
- self.layoutvariant,
+ newxml = self.gl_layout.create_layout(self.layoutcode,
+ self.layoutvariant,
self.layoutcountry,
- self.layoutname,
+ self.layoutname,
KeyDict.Keys)
fout.write(Common.layout_preamble)
ParseXML(newxml, fout)
fout.close()
-
- return True
+ return True
diff --git a/KeyboardLayoutEditor b/KeyboardLayoutEditor
index c82a974..15bdae0 100755
--- a/KeyboardLayoutEditor
+++ b/KeyboardLayoutEditor
@@ -27,34 +27,36 @@ try:
import sys
import copy
import string
- import gtk
+ import pygtk
import gobject
import pango
-except ImportError, e:
- raise SystemExit("Import error, Keyboard Layout Editor: " + str(e))
+except (ImportError, e):
+ raise SystemExit(f"Import error, Keyboard Layout Editor: {str(e)}")
if gtk.pygtk_version < (2, 12):
- print "PyGtk 2.12 or later required for this application"
- print "You have pyGTK", gtk.pygtk_version
+ print("PyGtk 2.12 or later required for this application")
+ print("You have pyGTK", gtk.pygtk_version)
raise SystemExit
try:
import cairo
-except ImportError, e:
+except (ImportError, e) as exc:
raise SystemExit("The Python bindings for Cairo are required \
- for this application: " + str(e))
+ for this application: " + str(e)) from exc
+
try:
from lxml import etree
-except ImportError, e:
- raise SystemExit("The Python bindings for libxml2 were not found: " + str(e))
+except (ImportError, e) as err:
+ raise SystemExit(f"The Python bindings for libxml2 were not found: {str(e)}") from err
+
try:
import antlr3
-except ImportError, err:
- print 'Import error:', err
- print 'This script requires to have the python antl3 package installed.'
- print 'Please see the README file for further instructions.\nExiting...'
+except(ImportError, err):
+ print('Import error:', err)
+ print('This script requires to have the python antl3 package installed.')
+ print('Please see the README file for further instructions.\nExiting...')
sys.exit(-10)
try:
@@ -68,9 +70,8 @@ try:
from KeyDict import KeyDict, included_files, activated_variants
from ParseXML import ExtractVariantsKeycodes
from DeadKeysDict import DeadKeys
-except ImportError, e:
- raise SystemExit("Import error, Keyboard Layout Editor: " + str(e))
-
+except (ImportError, e):
+ raise SystemExit(f"Import error, Keyboard Layout Editor: {str(e)}")
class Controller_KeyboardLayoutEditor:
""" The keyboard layout editor controller """
@@ -804,11 +805,11 @@ Please do not put punctuation marks."
if activated_variants.has_key(selected_layout):
del activated_variants[selected_layout]
- print "clicked_removeentry_callback:", included_files
+ print("clicked_removeentry_callback:", included_files)
del included_files[selected_layout]
del self.include_layout_selected["model"][self.include_layout_selected["paths"][0]]
- self.mykeyboard.redraw()
- Common.addtostatusbar('Removed layout ' + selected_layout)
+ self.myke('Import error:', erryboard.redraw())
+ Common.addtostatusbar(f'Removed layout {selected_layout}')
button.set_sensitive(False)
def col1_toggled_callback( self, cell, path, model ):
@@ -966,9 +967,7 @@ Please do not put punctuation marks."
def keypress_filter_callback(self, event, data = None):
if event.type == gtk.gdk.KEY_PRESS:
- #print event.keyval, event.string
- pass
- gtk.main_do_event(event)
+ gtk.main_do_event(event)
if __name__ == "__main__":
myeditor = Controller_KeyboardLayoutEditor()
diff --git a/KeycodesReader.py b/KeycodesReader.py
index 6a72d0e..dc9198d 100644
--- a/KeycodesReader.py
+++ b/KeycodesReader.py
@@ -30,12 +30,12 @@
# Helper function to iterate through all children of a given type
def getChildrenListByType(tree, type_value):
- list = []
+ a_list = []
for i in range(tree.getChildCount()):
child = tree.getChild(i)
if child.getType() == type_value:
- list.append(child)
- return list
+ a_list.append(child)
+ return a_list
def parseFile(fileandvariant = "/usr/share/X11/xkb/keycodes/xfree86|xfree86", *morefilesandvariants):
@@ -46,9 +46,9 @@ def parseFile(fileandvariant = "/usr/share/X11/xkb/keycodes/xfree86|xfree86", *m
try:
file = open(filename, 'r')
except OSError:
- print "Could not open file ", filename, " Aborting..."
+ print("Could not open file ", filename, " Aborting...")
sys.exit(-1)
- file.close
+ file.close()
char_stream = antlr3.ANTLRFileStream(filename)
lexer = KeycodesLexer(char_stream)
@@ -69,10 +69,10 @@ def parseFile(fileandvariant = "/usr/share/X11/xkb/keycodes/xfree86|xfree86", *m
listType = getChildrenListByType(itemKeycodeDoc, KEYCODELISTTYPE)
material = getChildrenListByType(itemKeycodeDoc, KEYCODEMATERIAL)
if len(listType) != 1:
- print "Requires single node for KEYCODELISTTYPE. Found", len(listType)
+ print("Requires single node for KEYCODELISTTYPE. Found", len(listType))
sys.exit(-1)
if len(material) != 1:
- print "Requires single node for KEYCODEMATERIAL. Found", len(material)
+ print("Requires single node for KEYCODEMATERIAL. Found", len(material))
sys.exit(-1)
for listNameGroup in getChildrenListByType(listType[0], KEYCODELISTNAME):
diff --git a/ParseXKB.py b/ParseXKB.py
index d27b063..05c4033 100644
--- a/ParseXKB.py
+++ b/ParseXKB.py
@@ -26,8 +26,8 @@
from XKBGrammarLexer import XKBGrammarLexer
from XKBGrammarParser import XKBGrammarParser
from XKBGrammarWalker import XKBGrammarWalker, LAYOUT, SYMBOLS, MAPMATERIAL, MAPTYPE, MAPOPTIONS, MAPOPTS, MAPNAME, TOKEN_INCLUDE, TOKEN_NAME, TOKEN_KEY_TYPE, TOKEN_KEY, TOKEN_TYPE, TOKEN_MODIFIER_MAP, TOKEN_VIRTUAL_MODIFIERS, KEYCODE, KEYCODEX, ELEM_KEYSYMS, ELEM_KEYSYMGROUP, ELEM_VIRTUALMODS, OVERLAY, VALUE, STATE, NAME, DQSTRING, OVERRIDE
-except ImportError, e:
- raise SystemExit("A generated source file by ANTLR was not found.\nSee the README on how to generate.\nImport error: " + str(e))
+except ImportError as e:
+ raise SystemExit("A generated source file by ANTLR was not found.\nSee the README on how to generate.\nImport error: " + str(e))
import KeycodesReader
import KeysymsUni
@@ -36,288 +36,289 @@
from ParseXML import ExtractVariantsKeycodes
class ParseXKB:
- def __init__(self):
- KeycodesReader.initialise()
-
- # Sorts a dictionary by value, produces a sorted list of values.
- def sortDict(self, adict, cmp_function = None):
- keys = adict.keys()
- keys.sort(cmp_function)
- return map(adict.get, keys)
-
- # Helper function to iterate through all children of a given type
- def getChildrenByType(self, tree, type_value):
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- yield child
-
- # Helper function to iterate through all children of a given type
- def getChildrenByTypes(self, tree, type_value1, type_value2):
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value1 or child.getType() == type_value2:
- yield child
-
- # Helper function to iterate through all children of a given type
- def getChildrenListByType(self, tree, type_value):
- list = []
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- list.append(child)
- return list
-
- # Helper function to iterate through all children of a given type
- def getChildrenListByTypes(self, tree, type_value1, type_value2):
- list = []
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value1 or child.getType() == type_value2:
- list.append(child)
- return list
-
- def hasChildByType(self, tree, type_value):
- has = False
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- has = True
- break
- return has
-
- def parse(self, xkbfilename):
- char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
- lexer = XKBGrammarLexer(char_stream)
- tokens = antlr3.CommonTokenStream(lexer)
- parser = XKBGrammarParser(tokens)
-
- result = parser.layout()
-
- # print "tree =", result.tree.toStringTree()
-
- nodes = antlr3.tree.CommonTreeNodeStream(result.tree)
- nodes.setTokenStream(tokens)
- walker = XKBGrammarWalker(nodes)
- # walker.layout()
-
- layout = etree.Element('layout')
-
- doc = etree.ElementTree(layout)
-
- layout.attrib['layoutname'] = os.path.basename(xkbfilename)
-
- #print "Processing", os.path.basename(xkbfilename), "...",
- for symbols in result.tree.getChildren():
- eSymbol = etree.SubElement(layout, 'symbols')
- for mapobject in symbols.getChildren():
- if mapobject.getType() == MAPTYPE:
- for maptypesect in mapobject.getChildren():
- if maptypesect.getType() == MAPOPTIONS:
- for mapoption in maptypesect.getChildren():
- if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
- eMapOption = etree.SubElement(eSymbol, 'mapoption')
- eMapOption.text = mapoption.getText()
- elif maptypesect.getType() == MAPNAME:
- if maptypesect.getChildCount() == 1:
- eMapName = etree.SubElement(eSymbol, 'mapname')
- eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
- else:
- print "\t\t\tInternal error in mapoption"
- else:
- print "\t\tInternal error in maptypesect"
- sys.exit(-2)
- elif mapobject.getType() == MAPMATERIAL:
- eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
- for name in self.getChildrenByType(mapobject, TOKEN_NAME):
- nameText = name.getChild(0).getText()[1:-1]
- eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
- for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
- eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
- eInclude.text = include.getChild(0).getText()[1:-1]
- for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
- keytypeText = keytype.getChild(0).getText()
- eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
- eKeyType.text = keytypeText[1:-1]
- for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
- eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
- for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
- if modstate.getType() == KEYCODE:
- eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
- elif modstate.getType() == KEYCODEX:
- eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
- else:
- print "Unexpected token encountered. Aborting...", modstate.getText()
- sys.exit(-1)
- allkeysymgroups = {}
- for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
- allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
- sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
- for keyset in sortedkeysymgroups:
- elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
- elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
- elem_overlay = self.getChildrenByType(keyset, OVERLAY)
- override = self.getChildrenListByType(keyset, OVERRIDE)
- eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
- eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
- keycodex = self.getChildrenListByType(keyset, KEYCODEX)
- if len(keycodex) == 1:
- eKeyCodeName.text = keycodex[0].getChild(0).getText()
- else:
- print "Could not retrieve keycode name"
- exit(-1)
- if len(override) == 1:
- eTokenKey.attrib['override'] = "True"
- else:
- eTokenKey.attrib['override'] = "False"
- if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
- elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
- eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
- keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
- for elem in elem_keysymgroup:
- eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
- for elem2 in elem.getChildren():
- for elem3 in elem2.getChildren():
- eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
- eSymbol.text = elem3.getText()
- if len(elem_keysyms) > 0:
- if len(elem_keysyms) == 1:
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- else:
- """ We are probably processing level3; we keep first item """
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- #print "Possibly processing level3"
- if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
- for vmods in elem_virtualmods:
- etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
- if len(self.getChildrenListByType(keyset, OVERLAY)):
- for elem in elem_overlay:
- for elem2 in self.getChildrenByType(elem, KEYCODEX):
- pass
- else:
- print "\tInternal error at map level,", mapobject.getText()
- # sys.exit(-2)
-
- return layout
-
-
- def parse_layout(self, xkbfilename, variant = None):
- char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
- lexer = XKBGrammarLexer(char_stream)
- tokens = antlr3.CommonTokenStream(lexer)
- parser = XKBGrammarParser(tokens)
-
- result = parser.layout()
- variants = []
-
- layout = etree.Element('layout')
- layout.attrib['layoutname'] = os.path.basename(xkbfilename)
-
- #print "Processing", os.path.basename(xkbfilename), "...",
- for symbols in result.tree.getChildren():
- eSymbol = etree.SubElement(layout, 'symbols')
- for mapobject in symbols.getChildren():
- if mapobject.getType() == MAPTYPE:
- for maptypesect in mapobject.getChildren():
- if maptypesect.getType() == MAPOPTIONS:
- for mapoption in maptypesect.getChildren():
- if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
- eMapOption = etree.SubElement(eSymbol, 'mapoption')
- eMapOption.text = mapoption.getText()
- elif maptypesect.getType() == MAPNAME:
- if maptypesect.getChildCount() == 1:
- eMapName = etree.SubElement(eSymbol, 'mapname')
- eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
- variants.append(maptypesect.getChildren()[0].getText()[1:-1])
- else:
- return { "success": False }
- #print "\t\t\tInternal error in mapoption"
- else:
- return { "success": False }
- #print "\t\tInternal error in maptypesect"
- #sys.exit(-2)
- elif mapobject.getType() == MAPMATERIAL:
- eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
- for name in self.getChildrenByType(mapobject, TOKEN_NAME):
- nameText = name.getChild(0).getText()[1:-1]
- eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
- for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
- eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
- eInclude.text = include.getChild(0).getText()[1:-1]
- for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
- keytypeText = keytype.getChild(0).getText()
- eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
- eKeyType.text = keytypeText[1:-1]
- for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
- eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
- for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
- if modstate.getType() == KEYCODE:
- eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
- elif modstate.getType() == KEYCODEX:
- eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
- else:
- return { "success": False }
- # print "Unexpected token encountered. Aborting...", modstate.getText()
- # sys.exit(-1)
- allkeysymgroups = {}
- for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
- try:
- allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
- except AttributeError:
- print "Error setting keyset:", keyset
- sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
- for keyset in sortedkeysymgroups:
- elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
- elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
- elem_overlay = self.getChildrenByType(keyset, OVERLAY)
- override = self.getChildrenListByType(keyset, OVERRIDE)
- eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
- eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
- keycodex = self.getChildrenListByType(keyset, KEYCODEX)
- if len(keycodex) == 1:
- eKeyCodeName.text = keycodex[0].getChild(0).getText()
- else:
- return { "success": False }
- #print "Could not retrieve keycode name"
- #exit(-1)
- if len(override) == 1:
- eTokenKey.attrib['override'] = "True"
- else:
- eTokenKey.attrib['override'] = "False"
- if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
- elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
- eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
- keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
- for elem in elem_keysymgroup:
- eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
- for elem2 in elem.getChildren():
- for elem3 in elem2.getChildren():
- eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
- eSymbol.text = elem3.getText()
- if len(elem_keysyms) > 0:
- if len(elem_keysyms) == 1:
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- else:
- """ We are probably processing level3; we keep first item """
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- #print "Possibly processing level3"
- if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
- for vmods in elem_virtualmods:
- etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
- if len(self.getChildrenListByType(keyset, OVERLAY)):
- for elem in elem_overlay:
- for elem2 in self.getChildrenByType(elem, KEYCODEX):
- pass
- else:
- return { "success": False }
- #print "\tInternal error at map level,", mapobject.getText()
- # sys.exit(-2)
-
- return { "success": True, "variants": variants, "layout": layout }
+ def __init__(self):
+ KeycodesReader.initialise()
+
+ # Sorts a dictionary by value, produces a sorted list of values.
+ def sortDict(self, adict, cmp_function = None):
+ keys = adict.keys()
+ keys.sort(cmp_function)
+ return map(adict.get, keys)
+
+ # Helper function to iterate through all children of a given type
+ def getChildrenByType(self, tree, type_value):
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ yield child
+
+ # Helper function to iterate through all children of a given type
+ def getChildrenByTypes(self, tree, type_value1, type_value2):
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value1 or child.getType() == type_value2:
+ yield child
+
+ # Helper function to iterate through all children of a given type
+ def getChildrenListByType(self, tree, type_value):
+ list = []
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ list.append(child)
+ return list
+
+ # Helper function to iterate through all children of a given type
+ def getChildrenListByTypes(self, tree, type_value1, type_value2):
+ list = []
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value1 or child.getType() == type_value2:
+ list.append(child)
+ return list
+
+ def hasChildByType(self, tree, type_value):
+ has = False
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ has = True
+ break
+ return has
+
+ def parse(self, xkbfilename):
+ global eKeySymGroup
+ char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
+ lexer = XKBGrammarLexer(char_stream)
+ tokens = antlr3.CommonTokenStream(lexer)
+ parser = XKBGrammarParser(tokens)
+
+ result = parser.layout()
+
+ # print "tree =", result.tree.toStringTree()
+
+ nodes = antlr3.tree.CommonTreeNodeStream(result.tree)
+ nodes.setTokenStream(tokens)
+ walker = XKBGrammarWalker(nodes)
+ # walker.layout()
+
+ layout = etree.Element('layout')
+
+ doc = etree.ElementTree(layout)
+
+ layout.attrib['layoutname'] = os.path.basename(xkbfilename)
+
+ #print "Processing", os.path.basename(xkbfilename), "...",
+ for symbols in result.tree.getChildren():
+ eSymbol = etree.SubElement(layout, 'symbols')
+ for mapobject in symbols.getChildren():
+ if mapobject.getType() == MAPTYPE:
+ for maptypesect in mapobject.getChildren():
+ if maptypesect.getType() == MAPOPTIONS:
+ for mapoption in maptypesect.getChildren():
+ if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
+ eMapOption = etree.SubElement(eSymbol, 'mapoption')
+ eMapOption.text = mapoption.getText()
+ elif maptypesect.getType() == MAPNAME:
+ if maptypesect.getChildCount() == 1:
+ eMapName = etree.SubElement(eSymbol, 'mapname')
+ eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
+ else:
+ print( "\t\t\tInternal error in mapoption")
+ else:
+ print("\t\tInternal error in maptypesect")
+ sys.exit(-2)
+ elif mapobject.getType() == MAPMATERIAL:
+ eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
+ for name in self.getChildrenByType(mapobject, TOKEN_NAME):
+ nameText = name.getChild(0).getText()[1:-1]
+ eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
+ for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
+ eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
+ eInclude.text = include.getChild(0).getText()[1:-1]
+ for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
+ keytypeText = keytype.getChild(0).getText()
+ eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
+ eKeyType.text = keytypeText[1:-1]
+ for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
+ eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
+ for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
+ if modstate.getType() == KEYCODE:
+ eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
+ elif modstate.getType() == KEYCODEX:
+ eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
+ else:
+ print("Unexpected token encountered. Aborting...", modstate.getText())
+ sys.exit(-1)
+ allkeysymgroups = {}
+ for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
+ allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
+ sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
+ for keyset in sortedkeysymgroups:
+ elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
+ elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
+ elem_overlay = self.getChildrenByType(keyset, OVERLAY)
+ override = self.getChildrenListByType(keyset, OVERRIDE)
+ eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
+ eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
+ keycodex = self.getChildrenListByType(keyset, KEYCODEX)
+ if len(keycodex) == 1:
+ eKeyCodeName.text = keycodex[0].getChild(0).getText()
+ else:
+ print("Could not retrieve keycode name")
+ exit(-1)
+ if len(override) == 1:
+ eTokenKey.attrib['override'] = "True"
+ else:
+ eTokenKey.attrib['override'] = "False"
+ if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
+ elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
+ eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
+ keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
+ for elem in elem_keysymgroup:
+ eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
+ for elem2 in elem.getChildren():
+ for elem3 in elem2.getChildren():
+ eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
+ eSymbol.text = elem3.getText()
+ if len(elem_keysyms) > 0:
+ if len(elem_keysyms) == 1:
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ else:
+ """ We are probably processing level3; we keep first item """
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ #print "Possibly processing level3"
+ if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
+ for vmods in elem_virtualmods:
+ etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
+ if len(self.getChildrenListByType(keyset, OVERLAY)):
+ for elem in elem_overlay:
+ for elem2 in self.getChildrenByType(elem, KEYCODEX):
+ pass
+ else:
+ print("\tInternal error at map level,", mapobject.getText())
+ # sys.exit(-2)
+
+ return layout
+
+
+ def parse_layout(self, xkbfilename, variant = None):
+ char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
+ lexer = XKBGrammarLexer(char_stream)
+ tokens = antlr3.CommonTokenStream(lexer)
+ parser = XKBGrammarParser(tokens)
+
+ result = parser.layout()
+ variants = []
+
+ layout = etree.Element('layout')
+ layout.attrib['layoutname'] = os.path.basename(xkbfilename)
+
+ #print "Processing", os.path.basename(xkbfilename), "...",
+ for symbols in result.tree.getChildren():
+ eSymbol = etree.SubElement(layout, 'symbols')
+ for mapobject in symbols.getChildren():
+ if mapobject.getType() == MAPTYPE:
+ for maptypesect in mapobject.getChildren():
+ if maptypesect.getType() == MAPOPTIONS:
+ for mapoption in maptypesect.getChildren():
+ if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
+ eMapOption = etree.SubElement(eSymbol, 'mapoption')
+ eMapOption.text = mapoption.getText()
+ elif maptypesect.getType() == MAPNAME:
+ if maptypesect.getChildCount() == 1:
+ eMapName = etree.SubElement(eSymbol, 'mapname')
+ eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
+ variants.append(maptypesect.getChildren()[0].getText()[1:-1])
+ else:
+ return { "success": False }
+ #print "\t\t\tInternal error in mapoption"
+ else:
+ return { "success": False }
+ #print "\t\tInternal error in maptypesect"
+ #sys.exit(-2)
+ elif mapobject.getType() == MAPMATERIAL:
+ eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
+ for name in self.getChildrenByType(mapobject, TOKEN_NAME):
+ nameText = name.getChild(0).getText()[1:-1]
+ eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
+ for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
+ eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
+ eInclude.text = include.getChild(0).getText()[1:-1]
+ for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
+ keytypeText = keytype.getChild(0).getText()
+ eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
+ eKeyType.text = keytypeText[1:-1]
+ for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
+ eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
+ for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
+ if modstate.getType() == KEYCODE:
+ eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
+ elif modstate.getType() == KEYCODEX:
+ eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
+ else:
+ return { "success": False }
+ # print "Unexpected token encountered. Aborting...", modstate.getText()
+ # sys.exit(-1)
+ allkeysymgroups = {}
+ for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
+ try:
+ allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
+ except AttributeError:
+ print("Error setting keyset:", keyset)
+ sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
+ for keyset in sortedkeysymgroups:
+ elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
+ elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
+ elem_overlay = self.getChildrenByType(keyset, OVERLAY)
+ override = self.getChildrenListByType(keyset, OVERRIDE)
+ eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
+ eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
+ keycodex = self.getChildrenListByType(keyset, KEYCODEX)
+ if len(keycodex) == 1:
+ eKeyCodeName.text = keycodex[0].getChild(0).getText()
+ else:
+ return { "success": False }
+ #print "Could not retrieve keycode name"
+ #exit(-1)
+ if len(override) == 1:
+ eTokenKey.attrib['override'] = "True"
+ else:
+ eTokenKey.attrib['override'] = "False"
+ if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
+ elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
+ eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
+ keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
+ for elem in elem_keysymgroup:
+ eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
+ for elem2 in elem.getChildren():
+ for elem3 in elem2.getChildren():
+ eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
+ eSymbol.text = elem3.getText()
+ if len(elem_keysyms) > 0:
+ if len(elem_keysyms) == 1:
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ else:
+ """ We are probably processing level3; we keep first item """
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ #print "Possibly processing level3"
+ if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
+ for vmods in elem_virtualmods:
+ etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
+ if len(self.getChildrenListByType(keyset, OVERLAY)):
+ for elem in elem_overlay:
+ for elem2 in self.getChildrenByType(elem, KEYCODEX):
+ pass
+ else:
+ return { "success": False }
+ #print "\tInternal error at map level,", mapobject.getText()
+ # sys.exit(-2)
+
+ return { "success": True, "variants": variants, "layout": layout }
@@ -338,181 +339,181 @@ def parse_layout(self, xkbfilename, variant = None):
# 1. Collect include statements
# 2. Parse include files
#
- def parse_layout_controller(self, store_keydict, xkbfilename, variantname = None):
- self.parse_layout_recursive(store_keydict, xkbfilename, variantname, start = True)
- return store_keydict
-
- def parse_layout_recursive(self, store_keydict, xkbfilename, variantname = None, start = True):
- #print "Processing", os.path.basename(xkbfilename), "..."
- parsed_layout = self.parse_layout_slave(xkbfilename, variantname)
-
- #print "############# ", xkbfilename, variantname, "Looping for", parsed_layout['variants']
- for includefile in parsed_layout['variants']:
- #print " Doing includefile:", includefile
- include_components = Common.parseIncludeString(includefile)
- if include_components['variant'] == '':
- #print " variant was empty",
- include_parse_result = self.parse_layout(xkbfilename)
- include_components['variant'] = include_parse_result["variants"][0]
- #print " we fix to", include_components
-
- #print " Calling ourselves", Common.symbolsdir + include_components['filename'], include_components['variant']
- new_parsed_layout = self.parse_layout_recursive(store_keydict,
- Common.symbolsdir + include_components['filename'],
- include_components['variant'],
- True)
- #print " new_parsed_result for variantname", include_components['variant'], " is ", new_parsed_layout
- if new_parsed_layout.has_key('keydict'):
- #print " LINES:", len(new_parsed_layout['keydict'].keys())
- for k in new_parsed_layout['keydict'].keys():
- for i in parsed_layout['keydict'][k].keys():
- #print parsed_layout['keydict'][k][i].getPValue(),
- if store_keydict.has_key(k) == False:
- store_keydict[k] = {}
- store_keydict[k][i] = copy.copy(new_parsed_layout['keydict'][k][i])
- #print
-
- #extraction_result = ExtractVariantsKeycodes(parsed_layout['layout'], variantname)
- if start == True:
- #print "parsed_result for variantname", variantname, " is ", parsed_layout
- if parsed_layout.has_key('keydict'):
- #print " LINES:", len(parsed_layout['keydict'].keys())
- for k in parsed_layout['keydict'].keys():
- #print k,
- for i in parsed_layout['keydict'][k].keys():
- #print parsed_layout['keydict'][k][i].getPValue(),
- if store_keydict.has_key(k) == False:
- store_keydict[k] = {}
- store_keydict[k][i] = copy.copy(parsed_layout['keydict'][k][i])
- #print
-
- return { 'success': True, 'layout': parsed_layout['layout'], 'variants': parsed_layout['variants'] }
-
- def parse_layout_slave(self, xkbfilename, variantname = None):
- #print "+++++We are recursive, called with", xkbfilename, variantname
- char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
- lexer = XKBGrammarLexer(char_stream)
- tokens = antlr3.CommonTokenStream(lexer)
- parser = XKBGrammarParser(tokens)
-
- parser_layout = parser.layout()
- variants = []
-
- xml_layout = etree.Element('layout')
- xml_layout.attrib['layoutname'] = os.path.basename(xkbfilename)
-
- includes = []
-
- for symbols in parser_layout.tree.getChildren():
- eSymbol = etree.SubElement(xml_layout, 'symbols')
- for mapobject in symbols.getChildren():
- if mapobject.getType() == MAPTYPE:
- for maptypesect in mapobject.getChildren():
- if maptypesect.getType() == MAPOPTIONS:
- for mapoption in maptypesect.getChildren():
- if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
- eMapOption = etree.SubElement(eSymbol, 'mapoption')
- eMapOption.text = mapoption.getText()
- elif maptypesect.getType() == MAPNAME:
- if maptypesect.getChildCount() == 1:
- eMapName = etree.SubElement(eSymbol, 'mapname')
- eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
- variants.append(maptypesect.getChildren()[0].getText()[1:-1])
- else:
- return { "success": False }
- else:
- return { "success": False }
- elif mapobject.getType() == MAPMATERIAL:
- eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
- for name in self.getChildrenByType(mapobject, TOKEN_NAME):
- nameText = name.getChild(0).getText()[1:-1]
- eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
- for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
- eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
- eInclude.text = include.getChild(0).getText()[1:-1]
- includes.append(eInclude.text)
- for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
- keytypeText = keytype.getChild(0).getText()
- eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
- eKeyType.text = keytypeText[1:-1]
- for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
- eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
- for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
- if modstate.getType() == KEYCODE:
- eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
- elif modstate.getType() == KEYCODEX:
- eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
- else:
- return { "success": False }
- # print "Unexpected token encountered. Aborting...", modstate.getText()
- # sys.exit(-1)
- allkeysymgroups = {}
- for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
- allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
- sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
- for keyset in sortedkeysymgroups:
- elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
- elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
- elem_overlay = self.getChildrenByType(keyset, OVERLAY)
- override = self.getChildrenListByType(keyset, OVERRIDE)
- eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
- eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
- keycodex = self.getChildrenListByType(keyset, KEYCODEX)
- if len(keycodex) == 1:
- eKeyCodeName.text = keycodex[0].getChild(0).getText()
- else:
- return { "success": False }
- #print "Could not retrieve keycode name"
- #exit(-1)
- if len(override) == 1:
- eTokenKey.attrib['override'] = "True"
- else:
- eTokenKey.attrib['override'] = "False"
- if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
- elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
- eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
- keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
- for elem in elem_keysymgroup:
- eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
- for elem2 in elem.getChildren():
- for elem3 in elem2.getChildren():
- eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
- eSymbol.text = elem3.getText()
- if len(elem_keysyms) > 0:
- if len(elem_keysyms) == 1:
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- else:
- """ We are probably processing level3; we keep first item """
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- #print "Possibly processing level3"
- if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
- for vmods in elem_virtualmods:
- etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
- if len(self.getChildrenListByType(keyset, OVERLAY)):
- for elem in elem_overlay:
- for elem2 in self.getChildrenByType(elem, KEYCODEX):
- pass
- else:
- return { "success": False }
-
- extraction_result = ExtractVariantsKeycodes(xml_layout, variantname)
- return { 'success': True,
- 'all_variants': variants,
- 'variants': extraction_result['variants'],
- 'layout': xml_layout,
- 'keydict': extraction_result['keydict']
- }
+ def parse_layout_controller(self, store_keydict, xkbfilename, variantname = None):
+ self.parse_layout_recursive(store_keydict, xkbfilename, variantname, start = True)
+ return store_keydict
+
+ def parse_layout_recursive(self, store_keydict, xkbfilename, variantname = None, start = True):
+ #print "Processing", os.path.basename(xkbfilename), "..."
+ parsed_layout = self.parse_layout_slave(xkbfilename, variantname)
+
+ #print "############# ", xkbfilename, variantname, "Looping for", parsed_layout['variants']
+ for includefile in parsed_layout['variants']:
+ #print " Doing includefile:", includefile
+ include_components = Common.parseIncludeString(includefile)
+ if include_components['variant'] == '':
+ #print " variant was empty",
+ include_parse_result = self.parse_layout(xkbfilename)
+ include_components['variant'] = include_parse_result["variants"][0]
+ #print " we fix to", include_components
+
+ #print " Calling ourselves", Common.symbolsdir + include_components['filename'], include_components['variant']
+ new_parsed_layout = self.parse_layout_recursive(store_keydict,
+ Common.symbolsdir + include_components['filename'],
+ include_components['variant'],
+ True)
+ #print " new_parsed_result for variantname", include_components['variant'], " is ", new_parsed_layout
+ if new_parsed_layout.has_key('keydict'):
+ #print " LINES:", len(new_parsed_layout['keydict'].keys())
+ for k in new_parsed_layout['keydict'].keys():
+ for i in parsed_layout['keydict'][k].keys():
+ #print parsed_layout['keydict'][k][i].getPValue(),
+ if store_keydict.has_key(k) == False:
+ store_keydict[k] = {}
+ store_keydict[k][i] = copy.copy(new_parsed_layout['keydict'][k][i])
+ #print
+
+ #extraction_result = ExtractVariantsKeycodes(parsed_layout['layout'], variantname)
+ if start == True:
+ #print "parsed_result for variantname", variantname, " is ", parsed_layout
+ if parsed_layout.has_key('keydict'):
+ #print " LINES:", len(parsed_layout['keydict'].keys())
+ for k in parsed_layout['keydict'].keys():
+ #print k,
+ for i in parsed_layout['keydict'][k].keys():
+ #print parsed_layout['keydict'][k][i].getPValue(),
+ if store_keydict.has_key(k) == False:
+ store_keydict[k] = {}
+ store_keydict[k][i] = copy.copy(parsed_layout['keydict'][k][i])
+ #print
+
+ return { 'success': True, 'layout': parsed_layout['layout'], 'variants': parsed_layout['variants'] }
+
+ def parse_layout_slave(self, xkbfilename, variantname = None):
+ #print "+++++We are recursive, called with", xkbfilename, variantname
+ char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
+ lexer = XKBGrammarLexer(char_stream)
+ tokens = antlr3.CommonTokenStream(lexer)
+ parser = XKBGrammarParser(tokens)
+
+ parser_layout = parser.layout()
+ variants = []
+
+ xml_layout = etree.Element('layout')
+ xml_layout.attrib['layoutname'] = os.path.basename(xkbfilename)
+
+ includes = []
+
+ for symbols in parser_layout.tree.getChildren():
+ eSymbol = etree.SubElement(xml_layout, 'symbols')
+ for mapobject in symbols.getChildren():
+ if mapobject.getType() == MAPTYPE:
+ for maptypesect in mapobject.getChildren():
+ if maptypesect.getType() == MAPOPTIONS:
+ for mapoption in maptypesect.getChildren():
+ if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
+ eMapOption = etree.SubElement(eSymbol, 'mapoption')
+ eMapOption.text = mapoption.getText()
+ elif maptypesect.getType() == MAPNAME:
+ if maptypesect.getChildCount() == 1:
+ eMapName = etree.SubElement(eSymbol, 'mapname')
+ eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
+ variants.append(maptypesect.getChildren()[0].getText()[1:-1])
+ else:
+ return { "success": False }
+ else:
+ return { "success": False }
+ elif mapobject.getType() == MAPMATERIAL:
+ eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
+ for name in self.getChildrenByType(mapobject, TOKEN_NAME):
+ nameText = name.getChild(0).getText()[1:-1]
+ eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
+ for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE):
+ eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
+ eInclude.text = include.getChild(0).getText()[1:-1]
+ includes.append(eInclude.text)
+ for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE):
+ keytypeText = keytype.getChild(0).getText()
+ eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
+ eKeyType.text = keytypeText[1:-1]
+ for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
+ eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
+ for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
+ if modstate.getType() == KEYCODE:
+ eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
+ elif modstate.getType() == KEYCODEX:
+ eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
+ else:
+ return { "success": False }
+ # print "Unexpected token encountered. Aborting...", modstate.getText()
+ # sys.exit(-1)
+ allkeysymgroups = {}
+ for keyset in self.getChildrenByType(mapobject, TOKEN_KEY):
+ allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
+ sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
+ for keyset in sortedkeysymgroups:
+ elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP)
+ elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS)
+ elem_overlay = self.getChildrenByType(keyset, OVERLAY)
+ override = self.getChildrenListByType(keyset, OVERRIDE)
+ eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
+ eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
+ keycodex = self.getChildrenListByType(keyset, KEYCODEX)
+ if len(keycodex) == 1:
+ eKeyCodeName.text = keycodex[0].getChild(0).getText()
+ else:
+ return { "success": False }
+ #print "Could not retrieve keycode name"
+ #exit(-1)
+ if len(override) == 1:
+ eTokenKey.attrib['override'] = "True"
+ else:
+ eTokenKey.attrib['override'] = "False"
+ if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
+ elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS)
+ eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
+ keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
+ for elem in elem_keysymgroup:
+ eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
+ for elem2 in elem.getChildren():
+ for elem3 in elem2.getChildren():
+ eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
+ eSymbol.text = elem3.getText()
+ if len(elem_keysyms) > 0:
+ if len(elem_keysyms) == 1:
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ else:
+ """ We are probably processing level3; we keep first item """
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ #print "Possibly processing level3"
+ if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
+ for vmods in elem_virtualmods:
+ etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
+ if len(self.getChildrenListByType(keyset, OVERLAY)):
+ for elem in elem_overlay:
+ for elem2 in self.getChildrenByType(elem, KEYCODEX):
+ pass
+ else:
+ return { "success": False }
+
+ extraction_result = ExtractVariantsKeycodes(xml_layout, variantname)
+ return { 'success': True,
+ 'all_variants': variants,
+ 'variants': extraction_result['variants'],
+ 'layout': xml_layout,
+ 'keydict': extraction_result['keydict']
+ }
if __name__ == '__main__':
- px = ParseXKB()
-
- store_keydict = {}
- px.parse_layout_controller(store_keydict, '/usr/share/X11/xkb/symbols/gr', 'polytonic')
- print "About to print"
- for k in store_keydict.keys():
- print k,
- for i in store_keydict[k].keys():
- print store_keydict[k][i].getValue(),
- print
+ px = ParseXKB()
+
+ store_keydict = {}
+ px.parse_layout_controller(store_keydict, '/usr/share/X11/xkb/symbols/gr', 'polytonic')
+ print("About to print")
+ for k in store_keydict.keys():
+ print(k,)
+ for i in store_keydict[k].keys():
+ print(store_keydict[k][i].getValue(),)
+ print()
diff --git a/ParseXML.py b/ParseXML.py
index c5235a8..65e805b 100644
--- a/ParseXML.py
+++ b/ParseXML.py
@@ -21,9 +21,11 @@
import Common
import KeyValue
+
def __recurse_tree__(node, fout):
+ global keycodelinekeycode
if node.tag == "layout":
- #print "Parsing", node.attrib["layoutname"]
+ # print "Parsing", node.attrib["layoutname"]
for n in node:
__recurse_tree__(n, fout)
elif node.tag == "symbols":
@@ -32,31 +34,31 @@ def __recurse_tree__(node, fout):
fout.write(k.text)
fout.write(" ")
elif k.tag == "mapname":
- fout.write("\"%(s)s\"\n{\n" % { "s": k.text })
+ fout.write("\"%(s)s\"\n{\n" % {"s": k.text})
elif k.tag == "mapmaterial":
keycodedict_lines = {}
for t in k:
if t.tag == "tokenname":
- fout.write("\tname[Group1] = \"%(s)s\";\n" % { "s": t.attrib["name"] })
+ fout.write("\tname[Group1] = \"%(s)s\";\n" % {"s": t.attrib["name"]})
elif t.tag == "tokeninclude":
- fout.write("\tinclude \"%(s)s\"\n" % { "s": t.text })
+ fout.write("\tinclude \"%(s)s\"\n" % {"s": t.text})
elif t.tag == "tokentype":
- fout.write("\tkey.type = \"%(s)s\";\n" % { "s": t.text })
+ fout.write("\tkey.type = \"%(s)s\";\n" % {"s": t.text})
elif t.tag == "tokenmodifiermap":
- fout.write("\tmodifier_map %(s)s { " % { "s": t.attrib['state'] })
+ fout.write("\tmodifier_map %(s)s { " % {"s": t.attrib['state']})
count_mm = len(t)
for mm in t:
if mm.tag == "keycodex":
- fout.write("<%(s)s>" % { "s": mm.attrib["value"] })
+ fout.write("<%(s)s>" % {"s": mm.attrib["value"]})
elif mm.tag == "keycode":
- fout.write("%(s)s" % { "s": mm.attrib["value"] })
+ fout.write("%(s)s" % {"s": mm.attrib["value"]})
if count_mm > 1:
fout.write(", ")
count_mm -= 1
fout.write(' };\n')
elif t.tag == "tokenkey":
# We attempt to sort the keycode lines by keycode value.
- keycodelinelist = []
+ keycodelinelist = []
keycodelinecomment = []
keycodelinelist.append("\t")
keycodelinecomment.append(" // ")
@@ -64,7 +66,7 @@ def __recurse_tree__(node, fout):
keycodelinelist.append("override ")
for tk in t:
if tk.tag == "keycodename":
- keycodelinelist.append("key <%(s)s> { " % { "s": tk.text })
+ keycodelinelist.append("key <%(s)s> { " % {"s": tk.text})
keycodelinekeycode = tk.text
elif tk.tag == "keysymgroup":
gotitem = False
@@ -72,12 +74,12 @@ def __recurse_tree__(node, fout):
if ks.tag == "typegroup":
if gotitem:
keycodelinelist.append(", ")
- keycodelinelist.append("type = \"%(s)s\" " % { "s": ks.attrib["value"] })
+ keycodelinelist.append("type = \"%(s)s\" " % {"s": ks.attrib["value"]})
gotitem = True
elif ks.tag == "tokenvirtualmodifiers":
if gotitem:
keycodelinelist.append(", ")
- keycodelinelist.append("virtualMods = %(s)s " % { "s": ks.attrib["value"] })
+ keycodelinelist.append("virtualMods = %(s)s " % {"s": ks.attrib["value"]})
elif ks.tag == "symbolsgroup":
if gotitem:
keycodelinelist.append(', ')
@@ -87,40 +89,42 @@ def __recurse_tree__(node, fout):
for sg in ks:
if sg.tag == 'symbol':
if count_sg > 1:
- keycodelinelist.append("%(s)14s, " % { "s": sg.text })
+ keycodelinelist.append("%(s)14s, " % {"s": sg.text})
else:
- keycodelinelist.append("%(s)14s " % { "s": sg.text })
+ keycodelinelist.append("%(s)14s " % {"s": sg.text})
count_sg -= 1
kval = KeyValue.KeyValue(sg.text)
keycodelinecomment.append(kval.getPValue())
keycodelinecomment.append(' ')
else:
- print 'ERROR'
+ print('ERROR')
sys.exit(-1)
for spaces_count in range(Common.LEVELMAX - len(ks)):
- keycodelinelist.append('%(s)15s ' % { 's': ' ' })
+ keycodelinelist.append('%(s)15s ' % {'s': ' '})
keycodelinelist.append(']')
keycodelinelist.append(' };')
keycodelinecomment.append('\n')
keycodedict_lines[keycodelinekeycode] = "".join(keycodelinelist) \
- + "".join(keycodelinecomment)
+ + "".join(keycodelinecomment)
keycodeslist = keycodedict_lines.keys()
keycodeslist.sort()
for kc in keycodeslist:
fout.write(keycodedict_lines[kc])
fout.write("};\n\n")
+
def __extract_keycodes__(node, variants, keydict, variant):
+ global keycodename
we_are_shooting = False
variant_verbose_name = ''
if node.tag == "layout":
- #print "Parsing", node.attrib["layoutname"]
+ # print "Parsing", node.attrib["layoutname"]
for n in node:
result = __extract_keycodes__(n, variants, keydict, variant)
if result != None:
if result['done'] == True:
return result
-
+
if node.tag == "symbols":
for k in node:
if k.tag == "mapoption":
@@ -141,8 +145,8 @@ def __extract_keycodes__(node, variants, keydict, variant):
# t.text
pass
elif t.tag == "tokenmodifiermap":
- pass
- elif t.tag == "tokenkey":
+ pass
+ elif t.tag == "tokenkey":
if t.attrib["override"] == "True":
pass
for tk in t:
@@ -167,21 +171,24 @@ def __extract_keycodes__(node, variants, keydict, variant):
key_index += 1
keydict[keycodename] = keyvalues
if we_are_shooting:
- return { 'done' : True, 'variants': variants, 'keydict': keydict, 'variant_name': variant_verbose_name }
+ return {'done': True, 'variants': variants, 'keydict': keydict, 'variant_name': variant_verbose_name}
+
def ParseXML(xmllayoutroot, fout):
return __recurse_tree__(xmllayoutroot, fout)
+
def ExtractVariantsKeycodes(xmllayoutroot, variant):
VariantsNew = []
KeyDictNew = {}
return __extract_keycodes__(xmllayoutroot, VariantsNew, KeyDictNew, variant)
-
+
+
if __name__ == "__main__":
sourcefile = "/home/user/WORK/KEYBOARDLAYOUTEDITOR/keyboardlayouteditor/XKBGrammar/demo.xml"
sourcefile = "/home/user/WORK/KEYBOARDLAYOUTEDITOR/keyboardlayouteditor/XKBGrammar/us.xml"
doc = etree.parse(sourcefile)
- #print doc
- #print etree.tounicode(doc, pretty_print=True)
- #ParseXML(doc.getroot(), sys.stdout)
- print ExtractVariantsKeycodes(doc.getroot(), "euro")
\ No newline at end of file
+ # print doc
+ # print etree.tounicode(doc, pretty_print=True)
+ # ParseXML(doc.getroot(), sys.stdout)
+ print(ExtractVariantsKeycodes(doc.getroot(), "euro"))
diff --git a/parse_xkb_to_xml.py b/parse_xkb_to_xml.py
index d37a932..2c773e6 100644
--- a/parse_xkb_to_xml.py
+++ b/parse_xkb_to_xml.py
@@ -6,14 +6,16 @@
import sys
import os.path
import pdb
-import urllib # for urlretrieve
+import urllib # for urlretrieve
import string
import antlr3
import re
from lxml import etree
-from XKBGrammarLexer import XKBGrammarLexer
+from XKBGrammarLexer import XKBGrammarLexer
from XKBGrammarParser import XKBGrammarParser
-from XKBGrammarWalker import XKBGrammarWalker, LAYOUT, SYMBOLS, MAPMATERIAL, MAPTYPE, MAPOPTIONS, MAPOPTS, MAPNAME, TOKEN_INCLUDE, TOKEN_NAME, TOKEN_KEY_TYPE, TOKEN_KEY, TOKEN_TYPE, TOKEN_MODIFIER_MAP, TOKEN_VIRTUAL_MODIFIERS, KEYCODE, KEYCODEX, ELEM_KEYSYMS, ELEM_KEYSYMGROUP, ELEM_VIRTUALMODS, OVERLAY, VALUE, STATE, NAME, DQSTRING, OVERRIDE
+from XKBGrammarWalker import XKBGrammarWalker, LAYOUT, SYMBOLS, MAPMATERIAL, MAPTYPE, MAPOPTIONS, MAPOPTS, MAPNAME, \
+ TOKEN_INCLUDE, TOKEN_NAME, TOKEN_KEY_TYPE, TOKEN_KEY, TOKEN_TYPE, TOKEN_MODIFIER_MAP, TOKEN_VIRTUAL_MODIFIERS, \
+ KEYCODE, KEYCODEX, ELEM_KEYSYMS, ELEM_KEYSYMGROUP, ELEM_VIRTUALMODS, OVERLAY, VALUE, STATE, NAME, DQSTRING, OVERRIDE
import KeycodesReader
URL_KEYSYMSTXT = "http://www.cl.cam.ac.uk/~mgk25/ucs/keysyms.txt"
@@ -21,125 +23,137 @@
keysymdb = {}
opt_verbose = True
+
# Sorts a dictionary by value, produces a sorted list of values.
-def sortDict(adict, cmp_function = None):
+def sortDict(adict, cmp_function=None):
keys = adict.keys()
keys.sort(cmp_function)
return map(adict.get, keys)
+
# Helper function to iterate through all children of a given type
def getChildrenByType(tree, type_value):
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- yield child
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ yield child
+
# Helper function to iterate through all children of a given type
def getChildrenByTypes(tree, type_value1, type_value2):
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value1 or child.getType() == type_value2:
- yield child
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value1 or child.getType() == type_value2:
+ yield child
+
# Helper function to iterate through all children of a given type
def getChildrenListByType(tree, type_value):
- list = []
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- list.append(child)
- return list
+ list = []
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ list.append(child)
+ return list
+
# Helper function to iterate through all children of a given type
def getChildrenListByTypes(tree, type_value1, type_value2):
- list = []
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value1 or child.getType() == type_value2:
- list.append(child)
- return list
+ list = []
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value1 or child.getType() == type_value2:
+ list.append(child)
+ return list
+
def hasChildByType(tree, type_value):
- has = False
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- has = True
- break
- return has
+ has = False
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ has = True
+ break
+ return has
+
def download_file(url):
- """ Downloads a file provided a URL. Returns the filename. """
- """ Borks on failure """
- localfilename = url.split('/')[-1]
- if not os.path.isfile(localfilename) or os.path.getsize(localfilename) <= 0:
- print "Downloading ", url, "..."
- try:
- urllib.urlretrieve(url, localfilename, download_hook)
- except IOError, (errno, strerror):
- print "I/O errorxx(%s): %s" % (errno, strerror)
- sys.exit(-1)
- except:
- print "Unexpected error: ", sys.exc_info()[0]
- sys.exit(-1)
- print " done."
- else:
- if opt_verbose:
- print "Using cached file for ", url
+ """ Downloads a file provided a URL. Returns the filename. """
+ """ Borks on failure """
+ localfilename = url.split('/')[-1]
+ if not os.path.isfile(localfilename) or os.path.getsize(localfilename) <= 0:
+ print("Downloading ", url, "...")
+ try:
+ urllib.urlretrieve(url, localfilename, download_hook)
+ except IOError as (errno, strerror):
+ print("I/O errorxx(%s): %s" % (errno, strerror))
+ sys.exit(-1)
+ except:
+ print("Unexpected error: ", sys.exc_info()[0])
+ sys.exit(-1)
+ print(" done.")
+
+ elif optVerbose:
+ print("Using cached file for ", url)
return localfilename
+
def download_hook(blocks_transferred, block_size, file_size):
- """ A download hook to provide some feedback when downloading """
- if blocks_transferred == 0:
- if file_size > 0:
- if opt_verbose:
- print "Downloading", file_size, "bytes: ",
- else:
- if opt_verbose:
- print "Downloading: ",
- sys.stdout.write('#')
- sys.stdout.flush()
+ """ A download hook to provide some feedback when downloading """
+ if blocks_transferred == 0:
+ if file_size <= 0:
+ if opt_verbose:
+ print("Downloading: ")
+ else:
+ if not opt_verbose:
+ return
+ print("Downloading", file_size, "bytes: ")
+ sys.stdout.write('#')
+ sys.stdout.flush()
def process_keysymstxt():
- """ Grabs and opens the keysyms.txt file that Markus Kuhn maintains """
- """ This file keeps a record between keysyms <-> unicode chars """
- filename_keysymstxt = download_file(URL_KEYSYMSTXT)
- try:
- keysymstxt = open(filename_keysymstxt, 'r')
- except IOError, (errno, strerror):
- print "I/O errorxx(%s): %s" % (errno, strerror)
- sys.exit(-1)
- except:
- print "Unexpected error: ", sys.exc_info()[0]
- sys.exit(-1)
-
- """ Parse the keysyms.txt file and place content in keysymdb """
- linenum_keysymstxt = 0
- keysymdb = {}
- for line in keysymstxt.readlines():
- linenum_keysymstxt += 1
- line = line.strip()
- if line == "" or re.match('^#', line):
- continue
- components = re.split('\s+', line)
- if len(components) < 5:
- print "Invalid line %(linenum)d in %(filename)s: %(line)s'"\
- % {'linenum': linenum_keysymstxt, 'filename': filename_keysymstxt, 'line': line}
- print "Was expecting 5 items in the line"
- sys.exit(-1)
- if components[1][0] == 'U' and re.match('[0-9a-fA-F]+$', components[1][1:]):
- unival = string.atoi(components[1][1:], 16)
- if unival == 0:
- continue
- keysymdb[components[4]] = unival
- keysymstxt.close()
-
- """ Patch up the keysymdb with some of our own stuff """
-
- """ This is preferential treatment for Greek """
- """ => we get more savings if used for Greek """
- # keysymdb['dead_tilde'] = 0x342
+ """ Grabs and opens the keysyms.txt file that Markus Kuhn maintains """
+ global unival
+ """ This file keeps a record between keysyms <-> unicode chars """
+ filename_keysymstxt = download_file(URL_KEYSYMSTXT)
+ try:
+ keysymstxt = open(filename_keysymstxt, 'r')
+ except IOError as (errno, strerror):
+ print("I/O errorxx(%s): %s" % (errno, strerror))
+ sys.exit(-1)
+ except:
+ print("Unexpected error: ", sys.exc_info()[0])
+ sys.exit(-1)
+
+ """ Parse the keysyms.txt file and place content in keysymdb """
+ linenum_keysymstxt = 0
+ keysymdb = {}
+ for line in keysymstxt.readlines():
+ linenum_keysymstxt += 1
+ line = line.strip()
+ if line == "" or re.match('^#', line):
+ continue
+ components = re.split('\s+', line)
+ if len(components) < 5:
+ print("Invalid line %(linenum)d in %(filename)s: %(line)s'"
+ % {'linenum': linenum_keysymstxt, 'filename': filename_keysymstxt, 'line': line})
+ print("Was expecting 5 items in the line")
+ sys.exit(-1)
+ if components[1][0] == 'U' and re.match('[0-9a-fA-F]+$', components[1][1:]):
+ unival = string.atoi(components[1][1:], 16)
+ if unival == 0:
+ continue
+ keysymdb[components[4]] = unival
+ keysymstxt.close()
+
+ """ Patch up the keysymdb with some of our own stuff """
+
+ """ This is preferential treatment for Greek """
+ """ => we get more savings if used for Greek """
+
+
+# keysymdb['dead_tilde'] = 0x342
process_keysymstxt()
@@ -151,13 +165,13 @@ def process_keysymstxt():
# print "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", sys.argv[1]
-try:
- xkbfile = open(xkbfilename, 'r')
+try:
+ xkbfile = open(xkbfilename, 'r')
except OSError:
- print "Could not open file ", xkbfilename, ". Aborting..."
- sys.exit(-1)
+ print("Could not open file ", xkbfilename, ". Aborting...")
+ sys.exit(-1)
-xkbfile.close
+xkbfile.close()
char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
lexer = XKBGrammarLexer(char_stream)
@@ -179,98 +193,98 @@ def process_keysymstxt():
layout.attrib['layoutname'] = os.path.basename(xkbfilename)
-#print "Processing", os.path.basename(xkbfilename), "...",
+# print "Processing", os.path.basename(xkbfilename), "...",
for symbols in result.tree.getChildren():
- eSymbol = etree.SubElement(layout, 'symbols')
- for mapobject in symbols.getChildren():
- if mapobject.getType() == MAPTYPE:
- for maptypesect in mapobject.getChildren():
- if maptypesect.getType() == MAPOPTIONS:
- for mapoption in maptypesect.getChildren():
- if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
- eMapOption = etree.SubElement(eSymbol, 'mapoption')
- eMapOption.text = mapoption.getText()
- elif maptypesect.getType() == MAPNAME:
- if maptypesect.getChildCount() == 1:
- eMapName = etree.SubElement(eSymbol, 'mapname')
- eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
- else:
- print "\t\t\tInternal error in mapoption"
- else:
- print "\t\tInternal error in maptypesect"
- sys.exit(-2)
- elif mapobject.getType() == MAPMATERIAL:
- eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
- for name in getChildrenByType(mapobject, TOKEN_NAME):
- nameText = name.getChild(0).getText()[1:-1]
- eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText )
- for include in getChildrenByType(mapobject, TOKEN_INCLUDE):
- eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
- eInclude.text = include.getChild(0).getText()[1:-1]
- for keytype in getChildrenByType(mapobject, TOKEN_KEY_TYPE):
- keytypeText = keytype.getChild(0).getText()
- eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
- eKeyType.text = keytypeText[1:-1]
- for modmap in getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
- eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
- for modstate in getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
- if modstate.getType() == KEYCODE:
- eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
- elif modstate.getType() == KEYCODEX:
- eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
- else:
- print "Unexpected token encountered. Aborting...", modstate.getText()
- sys.exit(-1)
- allkeysymgroups = {}
- for keyset in getChildrenByType(mapobject, TOKEN_KEY):
- allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
- sortedkeysymgroups = sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
- for keyset in sortedkeysymgroups:
- elem_keysymgroup = getChildrenByType(keyset, ELEM_KEYSYMGROUP)
- elem_virtualmods = getChildrenByType(keyset, ELEM_VIRTUALMODS)
- elem_overlay = getChildrenByType(keyset, OVERLAY)
- override = getChildrenListByType(keyset, OVERRIDE)
- eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
- eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
- keycodex = getChildrenListByType(keyset, KEYCODEX)
- if len(keycodex) == 1:
- eKeyCodeName.text = keycodex[0].getChild(0).getText()
- else:
- print "Could not retrieve keycode name"
- exit(-1)
- if len(override) == 1:
- eTokenKey.attrib['override'] = "True"
- else:
- eTokenKey.attrib['override'] = "False"
- if len(getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
- elem_keysyms = getChildrenListByType(keyset, ELEM_KEYSYMS)
- eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
- keysymgroup_counter = len(getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
- for elem in elem_keysymgroup:
- eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
- for elem2 in elem.getChildren():
- for elem3 in elem2.getChildren():
- eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
- eSymbol.text = elem3.getText()
- if len(elem_keysyms) > 0:
- if len(elem_keysyms) == 1:
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- else:
- """ We are probably processing level3; we keep first item """
- ksname = elem_keysyms[0].getChild(0).getText()
- eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
- #print "Possibly processing level3"
- if len(getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
- for vmods in elem_virtualmods:
- etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
- if len(getChildrenListByType(keyset, OVERLAY)):
- for elem in elem_overlay:
- for elem2 in getChildrenByType(elem, KEYCODEX):
- pass
- else:
- print "\tInternal error at map level,", mapobject.getText()
- # sys.exit(-2)
+ eSymbol = etree.SubElement(layout, 'symbols')
+ for mapobject in symbols.getChildren():
+ if mapobject.getType() == MAPTYPE:
+ for maptypesect in mapobject.getChildren():
+ if maptypesect.getType() == MAPOPTIONS:
+ for mapoption in maptypesect.getChildren():
+ if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden':
+ eMapOption = etree.SubElement(eSymbol, 'mapoption')
+ eMapOption.text = mapoption.getText()
+ elif maptypesect.getType() == MAPNAME:
+ if maptypesect.getChildCount() == 1:
+ eMapName = etree.SubElement(eSymbol, 'mapname')
+ eMapName.text = maptypesect.getChildren()[0].getText()[1:-1]
+ else:
+ print('\t\t\tInternal error in mapoption')
+ else:
+ print("\t\tInternal error in maptypesect")
+ sys.exit(-2)
+ elif mapobject.getType() == MAPMATERIAL:
+ eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial')
+ for name in getChildrenByType(mapobject, TOKEN_NAME):
+ nameText = name.getChild(0).getText()[1:-1]
+ eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText)
+ for include in getChildrenByType(mapobject, TOKEN_INCLUDE):
+ eInclude = etree.SubElement(eMapMaterial, 'tokeninclude')
+ eInclude.text = include.getChild(0).getText()[1:-1]
+ for keytype in getChildrenByType(mapobject, TOKEN_KEY_TYPE):
+ keytypeText = keytype.getChild(0).getText()
+ eKeyType = etree.SubElement(eMapMaterial, 'tokentype')
+ eKeyType.text = keytypeText[1:-1]
+ for modmap in getChildrenByType(mapobject, TOKEN_MODIFIER_MAP):
+ eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText())
+ for modstate in getChildrenByTypes(modmap, KEYCODE, KEYCODEX):
+ if modstate.getType() == KEYCODE:
+ eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText())
+ elif modstate.getType() == KEYCODEX:
+ eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText())
+ else:
+ print("Unexpected token encountered. Aborting...", modstate.getText())
+ sys.exit(-1)
+ allkeysymgroups = {}
+ for keyset in getChildrenByType(mapobject, TOKEN_KEY):
+ allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset
+ sortedkeysymgroups = sortDict(allkeysymgroups, KeycodesReader.compare_keycode)
+ for keyset in sortedkeysymgroups:
+ elem_keysymgroup = getChildrenByType(keyset, ELEM_KEYSYMGROUP)
+ elem_virtualmods = getChildrenByType(keyset, ELEM_VIRTUALMODS)
+ elem_overlay = getChildrenByType(keyset, OVERLAY)
+ override = getChildrenListByType(keyset, OVERRIDE)
+ eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey')
+ eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename')
+ keycodex = getChildrenListByType(keyset, KEYCODEX)
+ if len(keycodex) != 1:
+ print("Could not retrieve keycode name")
+ exit(-1)
+ else:
+ eKeyCodeName.text = keycodex[0].getChild(0).getText()
+ if len(override) == 1:
+ eTokenKey.attrib['override'] = "True"
+ else:
+ eTokenKey.attrib['override'] = "False"
+ if len(getChildrenListByType(keyset, ELEM_KEYSYMGROUP)):
+ elem_keysyms = getChildrenListByType(keyset, ELEM_KEYSYMS)
+ eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup')
+ keysymgroup_counter = len(getChildrenListByType(keyset, ELEM_KEYSYMGROUP))
+ for elem in elem_keysymgroup:
+ eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup')
+ for elem2 in elem.getChildren():
+ for elem3 in elem2.getChildren():
+ eSymbol = etree.SubElement(eSymbolsGroup, 'symbol')
+ eSymbol.text = elem3.getText()
+ if len(elem_keysyms) > 0:
+ if len(elem_keysyms) == 1:
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ else:
+ """ We are probably processing level3; we keep first item """
+ ksname = elem_keysyms[0].getChild(0).getText()
+ eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1])
+ # print "Possibly processing level3"
+ if len(getChildrenListByType(keyset, ELEM_VIRTUALMODS)):
+ for vmods in elem_virtualmods:
+ etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText())
+ if len(getChildrenListByType(keyset, OVERLAY)):
+ for elem in elem_overlay:
+ for elem2 in getChildrenByType(elem, KEYCODEX):
+ pass
+ else:
+ print("\tInternal error at map level,", mapobject.getText())
+ # sys.exit(-2)
fout = open(os.path.basename(xkbfilename) + ".xml", "w")
fout.write("\n")
@@ -279,6 +293,6 @@ def process_keysymstxt():
fout.write(etree.tostring(layout, pretty_print=True))
fout.close()
-print " done."
+print(" done.")
-#pdb.set_trace()
+# pdb.set_trace()
diff --git a/parse_xml_to_xkb.py b/parse_xml_to_xkb.py
index 654736d..9088d58 100644
--- a/parse_xml_to_xkb.py
+++ b/parse_xml_to_xkb.py
@@ -11,96 +11,97 @@
xmlfilename = "xkbsample.xml"
if len(sys.argv) > 1:
- xmlfilename = sys.argv[1]
+ xmlfilename = sys.argv[1]
try:
- xmlfile = open(xmlfilename, 'r')
- xmlfile.close
+ xmlfile = open(xmlfilename, 'r')
+ xmlfile.close()
except OSError:
- print "Could not open file ", xmlfilename, ". Aborting..."
- sys.exit(-1)
-
+ print("Could not open file ", xmlfilename, ". Aborting...")
+ sys.exit(-1)
doc = etree.parse(xmlfilename)
# for elem in doc.getiterator():
# print elem.tag, "has", len(elem), "children", elem.attrib, elem.text
-TABS="\t\t\t\t\t\t\t\t\t\t\t\t"
+TABS = "\t\t\t\t\t\t\t\t\t\t\t\t"
xkbfilename = os.path.basename(xmlfilename)[:-4]
fout = open(xkbfilename, "w")
+
def recurse_tree(node, depth):
- if node.tag == "layout":
- print "Parsing", node.attrib["layoutname"]
- for n in node:
- recurse_tree(n, depth+1)
- elif node.tag == "symbols":
- for k in node:
- if k.tag == "mapoption":
- fout.write(k.text)
- fout.write(" ")
- elif k.tag == "mapname":
- fout.write("\"%(s)s\"\n{\n" % { "s": k.text })
- elif k.tag == "mapmaterial":
- for t in k:
- if t.tag == "tokenname":
- fout.write("\tname = \"%(s)s\";\n" % { "s": t.attrib["name"] })
- elif t.tag == "tokeninclude":
- fout.write("\tinclude \"%(s)s\"\n" % { "s": t.text })
- elif t.tag == "tokentype":
- fout.write("\tkey.type = \"%(s)s\";\n" % { "s": t.text })
- elif t.tag == "tokenmodifiermap":
- fout.write("\tmodifier_map %(s)s { " % { "s": t.attrib['state'] })
- count_mm = len(t)
- for mm in t:
- if mm.tag == "keycodex":
- fout.write("<%(s)s>" % { "s": mm.attrib["value"] })
- elif mm.tag == "keycode":
- fout.write("%(s)s" % { "s": mm.attrib["value"] })
- if count_mm > 1:
- fout.write(", ")
- count_mm -= 1
- fout.write(" };\n")
-
- elif t.tag == "tokenkey":
- fout.write("\t")
- if t.attrib["override"] == "True":
- fout.write("override ")
- for tk in t:
- if tk.tag == "keycodename":
- fout.write("key <%(s)s> { " % { "s": tk.text })
- elif tk.tag == "keysymgroup":
- gotitem = False
- for ks in tk:
- if ks.tag == "typegroup":
- if gotitem:
- fout.write(", ")
- fout.write("type = \"%(s)s\" " % { "s": ks.attrib["value"] })
- gotitem = True
- elif ks.tag == "tokenvirtualmodifiers":
- if gotitem:
- fout.write(", ")
- fout.write("virtualMods = %(s)s " % { "s": ks.attrib["value"] })
- elif ks.tag == "symbolsgroup":
- if gotitem:
- fout.write(", ")
- gotitem = True
- fout.write("[ ")
- count_sg = len(ks)
- for sg in ks:
- if sg.tag == "symbol":
- if count_sg > 1:
- fout.write("%(s)s, " % { "s": sg.text })
- else:
- fout.write("%(s)s " % { "s": sg.text })
- count_sg -= 1
- else:
- print "ERROR"
- sys.exit(-1)
- fout.write("]")
- fout.write(" };\n")
- fout.write("};\n\n")
+ if node.tag == "layout":
+ print("Parsing", node.attrib["layoutname"])
+ for n in node:
+ recurse_tree(n, depth + 1)
+ elif node.tag == "symbols":
+ for k in node:
+ if k.tag == "mapoption":
+ fout.write(k.text)
+ fout.write(" ")
+ elif k.tag == "mapname":
+ fout.write("\"%(s)s\"\n{\n" % {"s": k.text})
+ elif k.tag == "mapmaterial":
+ for t in k:
+ if t.tag == "tokenname":
+ fout.write("\tname = \"%(s)s\";\n" % {"s": t.attrib["name"]})
+ elif t.tag == "tokeninclude":
+ fout.write("\tinclude \"%(s)s\"\n" % {"s": t.text})
+ elif t.tag == "tokentype":
+ fout.write("\tkey.type = \"%(s)s\";\n" % {"s": t.text})
+ elif t.tag == "tokenmodifiermap":
+ fout.write("\tmodifier_map %(s)s { " % {"s": t.attrib['state']})
+ count_mm = len(t)
+ for mm in t:
+ if mm.tag == "keycodex":
+ fout.write("<%(s)s>" % {"s": mm.attrib["value"]})
+ elif mm.tag == "keycode":
+ fout.write("%(s)s" % {"s": mm.attrib["value"]})
+ if count_mm > 1:
+ fout.write(", ")
+ count_mm -= 1
+ fout.write(" };\n")
+
+ elif t.tag == "tokenkey":
+ fout.write("\t")
+ if t.attrib["override"] == "True":
+ fout.write("override ")
+ for tk in t:
+ if tk.tag == "keycodename":
+ fout.write("key <%(s)s> { " % {"s": tk.text})
+ elif tk.tag == "keysymgroup":
+ gotitem = False
+ for ks in tk:
+ if ks.tag == "typegroup":
+ if gotitem:
+ fout.write(", ")
+ fout.write("type = \"%(s)s\" " % {"s": ks.attrib["value"]})
+ gotitem = True
+ elif ks.tag == "tokenvirtualmodifiers":
+ if gotitem:
+ fout.write(", ")
+ fout.write("virtualMods = %(s)s " % {"s": ks.attrib["value"]})
+ elif ks.tag == "symbolsgroup":
+ if gotitem:
+ fout.write(", ")
+ gotitem = True
+ fout.write("[ ")
+ count_sg = len(ks)
+ for sg in ks:
+ if sg.tag == "symbol":
+ if count_sg > 1:
+ fout.write("%(s)s, " % {"s": sg.text})
+ else:
+ fout.write("%(s)s " % {"s": sg.text})
+ count_sg -= 1
+ else:
+ print("ERROR")
+ sys.exit(-1)
+ fout.write("]")
+ fout.write(" };\n")
+ fout.write("};\n\n")
+
recurse_tree(doc.getroot(), 0)
diff --git a/print_tree.py b/print_tree.py
index 066cbb3..bbded68 100644
--- a/print_tree.py
+++ b/print_tree.py
@@ -6,37 +6,41 @@
import sys
import pdb
import antlr3
-from XKBGrammarLexer import XKBGrammarLexer, LAYOUT, SYMBOLS, MAPTYPE, MAPNAME, MAPOPTIONS, MAPMATERIAL, TOKEN_INCLUDE, TOKEN_NAME, TOKEN_KEY_TYPE, TOKEN_KEY, VALUE, KEYCODE, KEYCODEX
+from XKBGrammarLexer import XKBGrammarLexer, LAYOUT, SYMBOLS, MAPTYPE, MAPNAME, MAPOPTIONS, MAPMATERIAL, TOKEN_INCLUDE, \
+ TOKEN_NAME, TOKEN_KEY_TYPE, TOKEN_KEY, VALUE, KEYCODE, KEYCODEX
from XKBGrammarParser import XKBGrammarParser
from XKBGrammarWalker import XKBGrammarWalker
+
# Helper function to iterate through all children of a given type
def getChildrenByType(tree, type_value):
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- yield child
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ yield child
+
# Helper function to iterate through all children of a given type
def getChildrenListByType(tree, type_value):
- list = []
- for i in range(tree.getChildCount()):
- child = tree.getChild(i)
- if child.getType() == type_value:
- list.append(child)
- return list
+ a_list = []
+ for i in range(tree.getChildCount()):
+ child = tree.getChild(i)
+ if child.getType() == type_value:
+ a_list.append(child)
+ return a_list
+
xkbfilename = "gr"
if len(sys.argv) > 1:
xkbfilename = sys.argv[1]
-try:
- xkbfile = open(xkbfilename, 'r')
+try:
+ xkbfile = open(xkbfilename, 'r')
except OSError:
- print "Could not open file ", xkbfilename, ". Aborting..."
- sys.exit(-1)
+ print("Could not open file ", xkbfilename, ". Aborting...")
+ sys.exit(-1)
-xkbfile.close
+xkbfile.close()
# char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8')
char_stream = antlr3.ANTLRFileStream(xkbfilename)
@@ -46,8 +50,8 @@ def getChildrenListByType(tree, type_value):
result = parser.layout()
-print "XXXXXXXXXXXXXXXXXXXXXXX", xkbfilename
-print "tree =", result.tree.toStringTree()
+print("XXXXXXXXXXXXXXXXXXXXXXX", xkbfilename)
+print("tree =", result.tree.toStringTree())
nodes = antlr3.tree.CommonTreeNodeStream(result.tree)
nodes.setTokenStream(tokens)
@@ -57,14 +61,15 @@ def getChildrenListByType(tree, type_value):
MAX = 10
TABS = "\t\t\t\t\t\t\t\t\t\t"
+
def print_tree(node, depth):
- if depth >= MAX:
- return
- for n in node.getChildren():
- print TABS[:depth], "===", n.getText(), "==="
- print_tree(n, depth + 1)
-
-
-print result.tree.getChild(0).getText()
-print
+ if depth >= MAX:
+ return
+ for n in node.getChildren():
+ print(TABS[:depth], "===", n.getText(), "===")
+ print_tree(n, depth + 1)
+
+
+print(result.tree.getChild(0).getText())
+print()
print_tree(result.tree, 0)
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..b86b027
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+pygtk=>2.24.0
+gobject=>0.1.0
+lxml=>4.8.0
+Enum=>0.4.7
\ No newline at end of file