lc-building/interlockingwindow.py at main · penguintutor/lc-building · 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
# Window which shows interlocking and ability to add (through edit window) or delete

import os
from PySide6.QtCore import QCoreApplication, QThreadPool, Signal, QFileInfo, QObject, Qt
from PySide6.QtWidgets import QMainWindow, QFileDialog, QMessageBox, QWidget
from PySide6.QtSvgWidgets import QGraphicsSvgItem
from PySide6.QtUiTools import QUiLoader
from scale import Scale
from builder import Builder
from viewscene import ViewScene
from lcconfig import LCConfig
from gconfig import GConfig
from vgraphicsscene import ViewGraphicsScene
from wall import Wall
from editinterlockingwindow import EditInterlockingWindowUI
import copy

loader = QUiLoader()
basedir = os.path.dirname(__file__)

app_title = "Wall interlocking"

class InterlockingWindowUI(QMainWindow):


    def __init__(self, parent, config, gconfig, builder):
        super().__init__()

        self.parent = parent
        self.gui = parent

        self.ui = loader.load(os.path.join(basedir, "interlockingwindow.ui"), None)
        self.ui.setWindowTitle(app_title)

        self.edit_window = None

        self.config = config
        self.gconfig = gconfig
        self.builder = builder

        # create list from UI elements to allow reference by index
        self.il_elements = {"edge1":[], "edge2":[], "type":[], "delete":[]}
        for i in range (0, 10):
            exec ("self.il_elements[\"edge1\"].append("+f"self.ui.interlock_{i:02}_a_Label"+")")
            exec ("self.il_elements[\"edge2\"].append("+f"self.ui.interlock_{i:02}_b_Label"+")")
            exec ("self.il_elements[\"type\"].append("+f"self.ui.interlock_{i:02}_type_Label"+")")
            exec ("self.il_elements[\"delete\"].append("+f"self.ui.delButton_{i:02}"+")")

        self.ui.buttonBox.accepted.connect(self.accept)

        self.ui.newInterlockButton.pressed.connect(self.new_interlock)

        self.ui.delButton_00.pressed.connect(lambda: self.del_entry(0))
        self.ui.delButton_01.pressed.connect(lambda: self.del_entry(1))
        self.ui.delButton_02.pressed.connect(lambda: self.del_entry(2))
        self.ui.delButton_03.pressed.connect(lambda: self.del_entry(3))
        self.ui.delButton_04.pressed.connect(lambda: self.del_entry(4))
        self.ui.delButton_05.pressed.connect(lambda: self.del_entry(5))
        self.ui.delButton_06.pressed.connect(lambda: self.del_entry(6))
        self.ui.delButton_07.pressed.connect(lambda: self.del_entry(7))
        self.ui.delButton_08.pressed.connect(lambda: self.del_entry(8))
        self.ui.delButton_09.pressed.connect(lambda: self.del_entry(9))

        self.update()
        self.ui.show()

    def del_entry (self, entry_id):
        # Delete secondary, then primary
        groups = self.builder.interlocking_groups
        wall2 = self.builder.walls[groups[entry_id].secondary_wall]
        il2 = groups[entry_id].secondary_il
        wall1 = self.builder.walls[groups[entry_id].primary_wall]
        il1 = groups[entry_id].primary_il


        # Old parameters are used for undo (ie. what would we restore)
        old_params = {
            'primary_wall_id': groups[entry_id].primary_wall,
            'primary_edge': il1.edge,
            'primary_reverse': il1.reverse,
            'secondary_wall_id': groups[entry_id].secondary_wall,
            'secondary_edge': il2.edge,
            'secondary_reverse': il2.reverse,
            'il_type': il1.il_type,
            'step': il1.step,
            'parameters': copy.copy(il1.parameters)
            }
        # New parameters are redo - how we create if we ever needed to recreate it
        new_params = {"primary_il": il1, "secondary_il": il2, "il_group": groups[entry_id]}

        self.gui.history.add(f"Delete IL", "Delete IL", old_params, new_params)


        wall2.il.remove(il2)
        wall1.il.remove(il1)
        # Remove from group last (otherwise can't get details)
        self.builder.del_il_group(entry_id)

        # Update the walls
        wall2.update_cuts()
        wall1.update_cuts()

        # Update the current window
        self.update()
        # refresh all windows (as may include walls on different views etc.)
        self.parent.update_all_views()


    def new_interlock(self):
        if self.edit_window == None:
            self.edit_window = EditInterlockingWindowUI(self, self.config, self.gconfig, self.builder)
        else:
            self.edit_window.new()

    def clear (self):
        for i in range (0, 10):
            # set each of the values empty
            self.il_elements['edge1'][i].setText("")
            self.il_elements['edge2'][i].setText("")
            self.il_elements['type'][i].setText("")
            self.il_elements['delete'][i].hide()

    # Update list of interlocking groups
    # Do we need to update parent - if so set parent to true
    def update (self, parent=False):
        groups = self.builder.interlocking_groups
        #print (f"Num il groups {len(groups)}")

        # Hide all existing
        self.clear()

        num_groups = 0
        for group in groups:
            wall1_wall = self.builder.walls[group.primary_wall].name
            #wall1_edge = self.builder.walls[group.primary_wall].il[group.primary_il].edge
            # + 1 more user friendly starting at 1 (consistant with edit)
            wall1_edge = group.primary_il.edge +1
            wall1_string = f"Primary: {wall1_wall}, edge {wall1_edge}"
            # Get type from primary
            il_type = f"{group.primary_il.il_type}, {group.primary_il.step}"

            self.il_elements['edge1'][num_groups].setText(wall1_string)
            wall2_wall = self.builder.walls[group.secondary_wall].name
            wall2_edge = group.secondary_il.edge +1
            wall2_string = f"Secondary: {wall2_wall}, edge {wall2_edge}"
            self.il_elements['edge2'][num_groups].setText(wall2_string)

            self.il_elements['type'][num_groups].setText(il_type)
            self.il_elements['delete'][num_groups].show()

            num_groups += 1
        if (parent):
            self.parent.update_all_views()


    def display (self):
        self.ui.show()


    # hide entire windows
    def hide(self):
        self.ui.hide()


    # Accept button is pressed
    # If we don't have an existing texture then this is new
    # Otherwise we need to update the existing texture
    def accept(self):
        self.ui.hide()