%(counter)d. 
+ 
%(counter)d.
   %(opis)s
   %(wskazowki)s
  
@@ -99,80 +79,277 @@ class EduModule(Xmill):
 
     handle_opis = ifoption(activity=False)(tag('div', 'description'))
     handle_wskazowki = ifoption(activity=False)(tag('div', ('hints', 'teacher')))
-    
+
     @ifoption(activity=False)
     @tagged('div', 'materials')
     def handle_pomoce(self, _):
         return "Pomoce: ", ""
-    
+
     def handle_czas(self, *_):
         return
 
     def handle_forma(self, *_):
         return
-        
+
+    def handle_cwiczenie(self, element):
+        excercise_handlers = {
+            'wybor': Wybor,
+            'uporzadkuj': Uporzadkuj,
+            'luki': Luki,
+            'zastap': Zastap,
+            'przyporzadkuj': Przyporzadkuj,
+            'prawdafalsz': PrawdaFalsz
+            }
+
+        typ = element.attrib['typ']
+        handler = excercise_handlers[typ](self.options)
+        return handler.generate(element)
+
+    # Lists
+    def handle_lista(self, element, attrs={}):
+        ltype = element.attrib.get('typ', 'punkt')
+        if ltype == 'slowniczek':
+            self.options = {'slowniczek': True}
+            return '
', '
'
+### robie teraz punkty wyboru
+        listtag = {'num': 'ol',
+               'punkt': 'ul',
+               'alfa': 'ul',
+               'czytelnia': 'ul'}[ltype]
+
+        classes = attrs.get('class', '')
+        if classes: del attrs['class']
+
+        attrs_s = ' '.join(['%s="%s"' % kv for kv in attrs.items()])
+        if attrs_s: attrs_s = ' ' + attrs_s
+
+        return '<%s class="lista %s %s"%s>' % (listtag, ltype, classes, attrs_s), '%s>' % listtag
+
+    def handle_punkt(self, element):
+        if self.options['slowniczek']:
+            return '
', ' '
+        else:
+            return '
', ' '
+
+    def handle_rdf__RDF(self, _):
+        # ustal w opcjach  rzeczy :D
+        return
+
+
+class Excercise(EduModule):
+    def __init__(self, *args, **kw):
+        self.question_counter = 0
+        super(Excercise, self).__init__(*args, **kw)
+
+    def handle_rozw_kom(self, element):
+        return None
+
     def handle_cwiczenie(self, element):
         self.options = {'excercise': element.attrib['typ']}
         self.question_counter = 0
         self.piece_counter = 0
 
-        return u"""
+        pre = u"""
 
 """
- 
+        # Add a single 
 tag if it's not there
+        if not element.xpath(".//pytanie"):
+            qpre, qpost = self.handle_pytanie(element)
+            pre = pre + qpre
+            post = qpost + post
+        return pre, post
+
     def handle_pytanie(self, element):
+        """This will handle  element, when there is no 
+        """
+        add_class = ""
         self.question_counter += 1
         self.piece_counter = 0
         solution = element.attrib.get('rozw', None)
         if solution: solution_s = ' data-solution="%s"' % solution
         else: solution_s = ''
 
-        return '' %\
-            (self.question_counter, solution_s), \
-    "
"    
+        handles = element.attrib.get('uchwyty', None)
+        if handles:
+            add_class += ' handles handles-%s' % handles
+            self.options = {'handles': handles}
 
-    # Lists
-    def handle_lista(self, element):
-        ltype = element.attrib.get('typ', 'punkt')
-        if ltype == 'slowniczek':
-            self.options = {'slowniczek': True}
-            return '', '
'
-### robie teraz punkty wyboru
-        listtag = {'num': 'ol', 
-               'punkt': 'ul', 
-               'alfa': 'ul', 
-               'czytelnia': 'ul'}[ltype]
+        minimum = element.attrib.get('min', None)
+        if minimum: minimum_s = ' data-minimum="%d"' % int(minimum)
+        else: minimum_s = ''
 
-        return '<%s class="lista %s">' % (listtag, ltype), '%s>' % listtag
+        return '' %\
+            (add_class, self.question_counter, solution_s + minimum_s), \
+            "
"
+
+
+class Wybor(Excercise):
+    def handle_cwiczenie(self, element):
+        pre, post = super(Wybor, self).handle_cwiczenie(element)
+        is_single_choice = True
+        for p in element.xpath(".//pytanie"):
+            solutions = re.split(r"[, ]+", p.attrib['rozw'])
+            if len(solutions) != 1:
+                is_single_choice = False
+                break
+        self.options = {'single': is_single_choice}
+        return pre, post
 
     def handle_punkt(self, element):
-        if self.options['excercise'] and element.attrib['nazwa']:
+        if self.options['excercise'] and element.attrib.get('nazwa', None):
             qc = self.question_counter
             self.piece_counter += 1
             no = self.piece_counter
+            eid = "q%(qc)d_%(no)d" % locals()
+            aname = element.attrib.get('nazwa', None)
+            if self.options['single']:
+                return u"""
+
+ 
+
+                """ % locals(), u"  "
+            else:
+                return u"""
+
+ 
+
+""" % locals(), u"  "
 
-            return u"""
- 
-""" % locals(), u" "
+        else:
+            return super(Wybor, self).handle_punkt(element)
 
-        elif self.options['slowniczek']:
-            return '', ' '
+
+class Uporzadkuj(Excercise):
+    def handle_pytanie(self, element):
+        """
+Overrides the returned content default handle_pytanie
+        """
+        # we ignore the result, returning our own
+        super(Uporzadkuj, self).handle_pytanie(element)
+        order_items = element.xpath(".//punkt/@rozw")
+
+        return u"""""" % \
+            (','.join(order_items), self.question_counter), \
+            u"""
"""
+
+    def handle_punkt(self, element):
+        return """ """ \
+            % element.attrib,\
+            ""
+
+
+class Luki(Excercise):
+    def find_pieces(self, question):
+        return question.xpath("//luka")
+
+    def solution_html(self, piece):
+        return piece.text + ''.join(
+            [etree.tostring(n, encoding=unicode)
+             for n in piece])
+
+    def handle_pytanie(self, element):
+        qpre, qpost = super(Luki, self).handle_pytanie(element)
+
+        luki = list(enumerate(self.find_pieces(element)))
+        luki_html = ""
+        i = 0
+        random.shuffle(luki)
+        for (i, luka) in luki:
+            i += 1
+            luka_html = self.solution_html(luka)
+            luki_html += u'%s ' % (i, luka_html)
+        self.words_html = '%s
' % luki_html
+
+        return qpre, qpost
+
+    def handle_opis(self, element):
+        pre, post = super(Luki, self).handle_opis(element)
+        return pre, self.words_html + post
+
+    def handle_luka(self, element):
+        self.piece_counter += 1
+        return ' ' % self.piece_counter
+
+
+class Zastap(Luki):
+    def find_pieces(self, question):
+        return question.xpath("//zastap")
+
+    def solution_html(self, piece):
+        return piece.attrib['rozw']
+
+    def handle_zastap(self, element):
+        self.piece_counter += 1
+        return '' \
+            % self.piece_counter, ' '
+
+
+class Przyporzadkuj(Excercise):
+    def handle_pytanie(self, element):
+        pre, post = super(Przyporzadkuj, self).handle_pytanie(element)
+        minimum = element.attrib.get("min", None)
+        if minimum:
+            self.options = {"min": int(minimum)}
+        return pre, post
+
+    def handle_lista(self, lista):
+        if 'nazwa' in lista.attrib:
+            attrs = {
+                'data-name': lista.attrib['nazwa'],
+                'class': 'predicate'
+            }
+            self.options = {'predicate': True}
+        elif 'cel' in lista.attrib:
+            attrs = {
+                'data-target': lista.attrib['cel'],
+                'class': 'subject'
+            }
+            self.options = {'subject': True, 'handles': 'uchwyty' in lista.attrib}
         else:
-            return '', ' '
+            attrs = {}
+        pre, post = super(Przyporzadkuj, self).handle_lista(lista, attrs)
+        return pre, post + ' '
 
-    def handle_rdf__RDF(self, _):
-        # ustal w opcjach  rzeczy :D
-        return 
+    def handle_punkt(self, element):
+        if self.options['subject']:
+            self.piece_counter += 1
+            if self.options['handles']:
+                return '%s ' % (element.attrib['rozw'], self.piece_counter, self.piece_counter), ' '
+            else:
+                return '' % (element.attrib['rozw'], self.piece_counter), ' '
+
+        elif self.options['predicate']:
+            if self.options['min']:
+                placeholders = u' ' * self.options['min']
+            else:
+                placeholders = u' '
+            return '' % element.attrib, ' '
+
+        else:
+            return super(Przyporzadkuj, self).handle_punkt(element)
+
+
+class PrawdaFalsz(Excercise):
+    def handle_punkt(self, element):
+        if 'rozw' in element.attrib:
+            return u'''
+            
+            Prawda 
+            FaÅsz 
+         ''' % {'prawda': 'true', 'falsz': 'false'}[element.attrib['rozw']], ' '
+        else:
+            return super(PrawdaFalsz, self).handle_punkt(element)
 
 
 def transform(wldoc, stylesheet='edumed', options=None, flags=None):
@@ -182,7 +359,6 @@ def transform(wldoc, stylesheet='edumed', options=None, flags=None):
     otherwise returns True if file has been written,False if it hasn't.
     File won't be written if it has no content.
     """
-    
     edumod = EduModule(options)
 #    from pdb import set_trace; set_trace()
     html = edumod.generate(wldoc.edoc.getroot())