LCdraw/truthtable.py at master · njohnchi/LCdraw · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout
from kivy.graphics import Color, Rectangle
from kivy.uix.gridlayout import GridLayout

import boolean as boolean


class Cell(BoxLayout):
    def __init__(self, text, **kwargs):
        super(Cell, self).__init__(**kwargs)
        self.text = text
        self.label = Label(text=self.text, size=self.size, pos=self.pos, color=(0, 0, 0, 1))
        self.label.font_size = 30
        self.add_widget(self.label)
        with self.canvas.before:
            Color(1, 1, 1, 1)
            self.rect = Rectangle(size=self.size, pos=self.pos)
        self.bind(size=self._update_rect, pos=self._update_rect)

    def _update_rect(self, instance, value):
        self.rect.pos = instance.pos
        self.rect.size = instance.size
        self.label.pos = instance.pos
        self.label.size = instance.size


class TruthTable(GridLayout):
    def __init__(self, expression, output, **kwargs):
        super(TruthTable, self).__init__(**kwargs)
        self.output = output
        self.expression = self.expression(expression)
        self.table = self.table(self.expression)
        self.draw_table(self.table)
        with self.canvas.before:
            Color(1, 1, 1, 1)
            self.rect = Rectangle(size=self.size, pos=self.pos)
        self.bind(size=self._update_rect, pos=self._update_rect)
        self.bind(size=self.update_cell, pos=self.update_cell)
        self.bind(minimum_height=self.setter('height'))
        self.bind(minimum_width=self.setter('width'))
        self.size_hint_x=None
        self.size_hint_y=None

    def _update_rect(self, instance, value):
        self.rect.pos = instance.pos
        self.rect.size = instance.size

    def expression(self, expression):
        if isinstance(expression, str):
            expression = boolean.parse(expression, False)
        if not isinstance(expression, boolean.Expression):
            raise TypeError(
                "Argument must be str or Expression but it is {}"
                .format(expression.__class__))
        return expression

    def table(self, table):
        if isinstance(table, str):
            table = boolean.parse(table, False)
        if isinstance(table, boolean.Expression):
            table = boolean.truth_table(table)
        else:
            raise TypeError(
                "Argument must be Expression but it is {}"
                .format(table.__class__))
        # Table should not be directly modified
        return tuple(table)

    def no_cols(self, table):
        no = 0
        for sym in sorted(table[0].keys()):
            if isinstance(sym, boolean.Symbol):
                no += 1
        no += 1
        return no

    def draw_table(self, table):
        self.cols = self.no_cols(table)
        if len(table[0]) <= 1:
            self.cols -= 1
        for sym in sorted(table[0].keys()):
            if isinstance(sym, boolean.Symbol):
                self.cell = Cell(text=str(sym))
                self.add_widget(self.cell)
        if len(table[0]) > 1:
            self.cell = Cell(text=self.output)
            self.add_widget(self.cell)
        for dic in table:
            n = 0
            for key in sorted(dic.keys()):
                if n == self.no_cols(table)-1:
                    self.cell = Cell(text=str(dic[key]))
                    self.add_widget(self.cell)
                n += 1
                if isinstance(key, boolean.Symbol):
                    self.cell = Cell(text=str(dic[key]))
                    self.add_widget(self.cell)

    def update_cell(self, instance, value):
        for child in self.children:
            child.size = instance.size
            child.pos = instance.pos


if __name__ == '__main__':
    class TruthTableApp(App):

        def build(self):
            root = TruthTable("a+b", "Y")
            return root

    TruthTableApp().run()