diff options
Diffstat (limited to '')
| -rwxr-xr-x | Puzzle+/puzzle+.py | 1858 |
1 files changed, 1858 insertions, 0 deletions
diff --git a/Puzzle+/puzzle+.py b/Puzzle+/puzzle+.py new file mode 100755 index 0000000..886a80a --- /dev/null +++ b/Puzzle+/puzzle+.py @@ -0,0 +1,1858 @@ +#!/usr/bin/env python + +import archive +import os.path +import struct +import sys +import cPickle + +from ctypes import create_string_buffer +from PyQt4 import QtCore, QtGui + + +try: + import nsmblib + HaveNSMBLib = True +except ImportError: + HaveNSMBLib = False + + +######################################################## +# To Do: +# +# - Object Editor +# - Moving objects around +# +# - Make UI simpler for Pop +# - C speed saving +# +######################################################## + + +Tileset = None + +############################################################################################# +########################## Tileset Class and Tile/Object Subclasses ######################### + +class TilesetClass(): + '''Contains Tileset data. Inits itself to a blank tileset. + Methods: addTile, removeTile, addObject, removeObject, clear''' + + class Tile(): + def __init__(self, image, noalpha): + '''Tile Constructor''' + + self.image = image + self.noalpha = noalpha + + + class Object(): + + def __init__(self, height, width, uslope, lslope, tilelist): + '''Tile Constructor''' + + self.height = height + self.width = width + + self.upperslope = uslope + self.lowerslope = lslope + + self.tiles = tilelist + + + def __init__(self): + '''Constructor''' + + self.tiles = [] + self.objects = [] + + self.slot = 0 + + + def addTile(self, image, noalpha): + '''Adds an tile class to the tile list with the passed image or parameters''' + + self.tiles.append(self.Tile(image, noalpha)) + + + def addObject(self, height = 1, width = 1, uslope = [0, 0], lslope = [0, 0], tilelist = [[(0, 0xFFFF, 0)]]): + '''Adds a new object''' + + global Tileset + + + # Initialize trusim power! This is required to work, due to python's single default parameter initialization + if tilelist == [[(0, 0xFFFF, 0)]]: + tilelist = [[(0, 0xFFFF, 0)]] + + self.objects.append(self.Object(height, width, uslope, lslope, tilelist)) + + + def removeObject(self, index): + '''Removes an Object by Index number. Don't use this much, because we want objects to preserve their ID.''' + + self.objects.pop(index) + + + def clear(self): + '''Clears the tileset for a new file''' + + self.tiles = [] + self.objects = [] + + + def clearObjects(self): + '''Clears the object data''' + + self.objects = [] + + +############################################################################################# +##################### Object List Widget and Model Setup with Painter ####################### + + +class objectList(QtGui.QListView): + + def __init__(self, parent=None): + super(objectList, self).__init__(parent) + + + self.setFlow(QtGui.QListView.TopToBottom) + # self.setViewMode(QtGui.QListView.ListMode) + self.setIconSize(QtCore.QSize(96,96)) + self.setGridSize(QtCore.QSize(100,100)) + self.setMovement(QtGui.QListView.Static) + self.setBackgroundRole(QtGui.QPalette.BrightText) + self.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) + self.setWrapping(False) + + + +def SetupObjectModel(self, objects, tiles): + global Tileset + self.clear() + + count = 0 + for object in objects: + tex = QtGui.QPixmap(object.width * 24, object.height * 24) + tex.fill(QtCore.Qt.transparent) + painter = QtGui.QPainter(tex) + + Xoffset = 0 + Yoffset = 0 + + for i in range(len(object.tiles)): + for tile in object.tiles[i]: + if (Tileset.slot == 0): + painter.drawPixmap(Xoffset, Yoffset, tiles[tile[1]].image) + Xoffset += 24 + Xoffset = 0 + Yoffset += 24 + + painter.end() + + self.appendRow(QtGui.QStandardItem(QtGui.QIcon(tex), 'Object {0}'.format(count))) + + count += 1 + + +@QtCore.pyqtSlot(QtGui.QTreeWidgetItem, int) +def connectToTileWidget(tree, column): + + row = tree.text(0) + if row[:7] == "Object ": + + newrow = int(row[7:]) + index = window.objmodel.index(newrow, 0) + + window.objectList.setCurrentIndex(index) + + window.tileWidget.setObject(index) + + + +############################################################################################# +######################## List Widget with custom painter/MouseEvent ######################### + + +class displayWidget(QtGui.QListView): + + def __init__(self, parent=None): + super(displayWidget, self).__init__(parent) + + self.setMinimumWidth(818) + self.setMaximumWidth(818) + self.setMinimumHeight(404) + self.setMaximumHeight(404) + self.setDragEnabled(True) + self.setViewMode(QtGui.QListView.IconMode) + self.setIconSize(QtCore.QSize(24,24)) + self.setGridSize(QtCore.QSize(25,25)) + self.setMovement(QtGui.QListView.Static) + self.setAcceptDrops(False) + self.setDropIndicatorShown(True) + self.setResizeMode(QtGui.QListView.Adjust) + self.setUniformItemSizes(True) + self.setBackgroundRole(QtGui.QPalette.BrightText) + self.setMouseTracking(True) + self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) + + self.setItemDelegate(self.TileItemDelegate()) + + + + class TileItemDelegate(QtGui.QAbstractItemDelegate): + """Handles tiles and their rendering""" + + def __init__(self): + """Initialises the delegate""" + QtGui.QAbstractItemDelegate.__init__(self) + + def paint(self, painter, option, index): + """Paints an object""" + + global Tileset + p = index.model().data(index, QtCore.Qt.DecorationRole) + painter.drawPixmap(option.rect.x(), option.rect.y(), p.pixmap(24,24)) + + x = option.rect.x() + y = option.rect.y() + + + # Collision Overlays + curTile = Tileset.tiles[index.row()] + + + # Highlight stuff. + colour = QtGui.QColor(option.palette.highlight()) + colour.setAlpha(80) + + if option.state & QtGui.QStyle.State_Selected: + painter.fillRect(option.rect, colour) + + + def sizeHint(self, option, index): + """Returns the size for the object""" + return QtCore.QSize(24,24) + + + +############################################################################################# +############################ Tile widget for drag n'drop Objects ############################ + + +class tileOverlord(QtGui.QWidget): + + def __init__(self): + super(tileOverlord, self).__init__() + + # Setup Widgets + self.tiles = tileWidget() + + self.addObject = QtGui.QPushButton('Add') + self.removeObject = QtGui.QPushButton('Remove') + + self.addRow = QtGui.QPushButton('+') + self.removeRow = QtGui.QPushButton('-') + + self.addColumn = QtGui.QPushButton('+') + self.removeColumn = QtGui.QPushButton('-') + + self.tilingMethod = QtGui.QComboBox() + + self.tilingMethod.addItems(['Repeat', + 'Stretch Center', + 'Stretch X', + 'Stretch Y', + 'Repeat Bottom', + 'Repeat Top', + 'Repeat Left', + 'Repeat Right', + 'Upward slope', + 'Downward slope', + 'Downward reverse slope', + 'Upward reverse slope']) + + + # Connections + self.addObject.released.connect(self.addObj) + self.removeObject.released.connect(self.removeObj) + self.addRow.released.connect(self.tiles.addRow) + self.removeRow.released.connect(self.tiles.removeRow) + self.addColumn.released.connect(self.tiles.addColumn) + self.removeColumn.released.connect(self.tiles.removeColumn) + + self.tilingMethod.activated.connect(self.setTiling) + + + # Layout + layout = QtGui.QGridLayout() + + layout.addWidget(self.tilingMethod, 0, 0, 1, 3) + + layout.addWidget(self.addObject, 0, 6, 1, 1) + layout.addWidget(self.removeObject, 0, 7, 1, 1) + + layout.setRowMinimumHeight(1, 40) + + layout.setRowStretch(1, 1) + layout.setRowStretch(2, 5) + layout.setRowStretch(5, 5) + layout.addWidget(self.tiles, 2, 1, 4, 6) + + layout.addWidget(self.addColumn, 3, 7, 1, 1) + layout.addWidget(self.removeColumn, 4, 7, 1, 1) + layout.addWidget(self.addRow, 6, 3, 1, 1) + layout.addWidget(self.removeRow, 6, 4, 1, 1) + + self.setLayout(layout) + + + def addObj(self): + global Tileset + + Tileset.addObject() + + pix = QtGui.QPixmap(24, 24) + pix.fill(QtCore.Qt.transparent) + painter = QtGui.QPainter(pix) + painter.drawPixmap(0, 0, pix) + painter.end() + + count = len(Tileset.objects) + window.objmodel.appendRow(QtGui.QStandardItem(QtGui.QIcon(pix), 'Object {0}'.format(count-1))) + a = QtGui.QTreeWidgetItem(window.treeki) + a.setText(0, 'Object {0}'.format(count-1)) + a.setFlags(QtCore.Qt.ItemFlags(0x25)) + a.setIcon(1, QtGui.QIcon(pix)) + + index = window.objectList.currentIndex() + window.objectList.setCurrentIndex(index) + self.setObject(index) + + window.objectList.update() + self.update() + + + def removeObj(self): + global Tileset + + index = window.objectList.currentIndex() + + Tileset.removeObject(index.row()) + window.objmodel.removeRow(index.row()) + self.tiles.clear() + + matchList = window.treeki.findItems("Object {0}".format(index.row()), QtCore.Qt.MatchExactly | QtCore.Qt.MatchRecursive | QtCore.Qt.MatchWrap) + for x in matchList: + index = window.treeki.indexFromItem(x, 0) + realx = index.row() + if x.parent(): + y = x.parent().takeChild(realx) + del y + else: + y =window.treeki.takeTopLevelItem(realx) + del y + + + window.objectList.update() + self.update() + + + def setObject(self, index): + global Tileset + object = Tileset.objects[index.row()] + + width = len(object.tiles[0])-1 + height = len(object.tiles)-1 + Xuniform = True + Yuniform = True + Xstretch = False + Ystretch = False + + for tile in object.tiles[0]: + if tile[0] != object.tiles[0][0][1]: + Xuniform = False + + for tile in object.tiles: + if tile[0][0] != object.tiles[0][0][1]: + Yuniform = False + + if object.tiles[0][0][1] == object.tiles[0][width][0] and Xuniform == False: + Xstretch = True + + if object.tiles[0][0][1] == object.tiles[height][0][0] and Xuniform == False: + Ystretch = True + + + + if object.upperslope[0] != 0: + if object.upperslope[0] == 0x90: + self.tilingMethod.setCurrentIndex(8) + elif object.upperslope[0] == 0x91: + self.tilingMethod.setCurrentIndex(9) + elif object.upperslope[0] == 0x92: + self.tilingMethod.setCurrentIndex(10) + elif object.upperslope[0] == 0x93: + self.tilingMethod.setCurrentIndex(11) + + else: + if Xuniform and Yuniform: + self.tilingMethod.setCurrentIndex(0) + elif Xstretch and Ystretch: + self.tilingMethod.setCurrentIndex(1) + elif Xstretch: + self.tilingMethod.setCurrentIndex(2) + elif Ystretch: + self.tilingMethod.setCurrentIndex(3) + elif Xuniform and Yuniform == False and object.tiles[0][0][0] == 0: + self.tilingMethod.setCurrentIndex(4) + elif Xuniform and Yuniform == False and object.tiles[height][0][0] == 0: + self.tilingMethod.setCurrentIndex(5) + elif Xuniform == False and Yuniform and object.tiles[0][0][0] == 0: + self.tilingMethod.setCurrentIndex(6) + elif Xuniform == False and Yuniform and object.tiles[0][width][0] == 0: + self.tilingMethod.setCurrentIndex(7) + + + self.tiles.setObject(object) + + # print 'Object {0}, Width: {1} / Height: {2}, Slope {3}/{4}'.format(index.row(), object.width, object.height, object.upperslope, object.lowerslope) + # for row in object.tiles: + # print 'Row: {0}'.format(row) + # print '' + + @QtCore.pyqtSlot(int) + def setTiling(self, listindex): + global Tileset + + index = window.objectList.currentIndex() + object = Tileset.objects[index.row()] + + + if listindex == 0: # Repeat + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + if listindex == 1: # Stretch Center + + if object.width < 3 and object.height < 3: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 3 tiles\nwide and 3 tiles tall to apply stretch center.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if crow == 0 and ctile == 0: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif crow == 0 and ctile == object.width-1: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif crow == object.height-1 and ctile == object.width-1: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif crow == object.height-1 and ctile == 0: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif crow == 0 or crow == object.height-1: + object.tiles[crow][ctile] = (1, tile[1], tile[2]) + elif ctile == 0 or ctile == object.width-1: + object.tiles[crow][ctile] = (2, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (3, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 2: # Stretch X + + if object.width < 3: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 3 tiles\nwide to apply stretch X.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if ctile == 0: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif ctile == object.width-1: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (1, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 3: # Stretch Y + + if object.height < 3: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 3 tiles\ntall to apply stretch Y.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if crow == 0: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + elif crow == object.height-1: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (2, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 4: # Repeat Bottom + + if object.height < 2: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 2 tiles\ntall to apply repeat bottom.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if crow == object.height-1: + object.tiles[crow][ctile] = (2, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 5: # Repeat Top + + if object.height < 2: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 2 tiles\ntall to apply repeat top.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if crow == 0: + object.tiles[crow][ctile] = (2, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 6: # Repeat Left + + if object.width < 2: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 2 tiles\nwide to apply repeat left.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if ctile == 0: + object.tiles[crow][ctile] = (1, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + if listindex == 7: # Repeat Right + + if object.width < 2: + reply = QtGui.QMessageBox.information(self, "Warning", "An object must be at least 2 tiles\nwide to apply repeat right.") + self.setObject(index) + return + + ctile = 0 + crow = 0 + + for row in object.tiles: + for tile in row: + if ctile == object.width-1: + object.tiles[crow][ctile] = (1, tile[1], tile[2]) + else: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0, 0] + object.lowerslope = [0, 0] + + + if listindex == 8: # Upward Slope + ctile = 0 + crow = 0 + for row in object.tiles: + for tile in row: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0x90, 1] + object.lowerslope = [0x84, object.height - 1] + self.tiles.slope = 1 + + self.tiles.update() + + if listindex == 9: # Downward Slope + ctile = 0 + crow = 0 + for row in object.tiles: + for tile in row: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0x91, 1] + object.lowerslope = [0x84, object.height - 1] + self.tiles.slope = 1 + + self.tiles.update() + + if listindex == 10: # Upward Reverse Slope + ctile = 0 + crow = 0 + for row in object.tiles: + for tile in row: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0x92, object.height - 1] + object.lowerslope = [0x84, 1] + self.tiles.slope = 0-(object.height-1) + + self.tiles.update() + + if listindex == 11: # Downward Reverse Slope + ctile = 0 + crow = 0 + for row in object.tiles: + for tile in row: + object.tiles[crow][ctile] = (0, tile[1], tile[2]) + ctile += 1 + crow += 1 + ctile = 0 + + object.upperslope = [0x93, object.height - 1] + object.lowerslope = [0x84, 1] + self.tiles.slope = 0-(object.height-1) + + self.tiles.update() + + +class tileWidget(QtGui.QWidget): + + def __init__(self): + super(tileWidget, self).__init__() + + self.tiles = [] + + self.size = [1, 1] + self.setMinimumSize(120, 120) + + self.slope = 0 + + self.highlightedRect = QtCore.QRect() + + self.setAcceptDrops(True) + self.object = 0 + + + def clear(self): + self.tiles = [] + self.size = [1, 1] # [width, height] + + self.slope = 0 + self.highlightedRect = QtCore.QRect() + + self.update() + + return + + + def addColumn(self): + global Tileset + + if self.size[0] >= 24: + return + + if len(Tileset.objects) == 0: + window.tileWidget.addObj() + + self.size[0] += 1 + self.setMinimumSize(self.size[0]*24, self.size[1]*24) + + pix = QtGui.QPixmap(24,24) + pix.fill(QtGui.QColor(205, 205, 255)) + + for y in xrange(self.size[1]): + self.tiles.insert(((y+1) * self.size[0]) -1, [self.size[0]-1, y, pix]) + + + curObj = Tileset.objects[self.object] + curObj.width += 1 + + for row in curObj.tiles: + row.append((0, 0xFFFF, 0)) + + self.update() + self.updateList() + + + def removeColumn(self): + global Tileset + + if self.size[0] == 1: + return + + if len(Tileset.objects) == 0: + window.tileWidget.addObj() + + for y in xrange(self.size[1]): + self.tiles.pop(((y+1) * self.size[0])-(y+1)) + + self.size[0] = self.size[0] - 1 + self.setMinimumSize(self.size[0]*24, self.size[1]*24) + + + curObj = Tileset.objects[self.object] + curObj.width -= 1 + + for row in curObj.tiles: + row.pop() + + self.update() + self.updateList() + + + def addRow(self): + global Tileset + + if len(Tileset.objects) == 0: + window.tileWidget.addObj() + + if self.size[1] >= 24: + return + + self.size[1] += 1 + self.setMinimumSize(self.size[0]*24, self.size[1]*24) + + pix = QtGui.QPixmap(24,24) + pix.fill(QtGui.QColor(205, 205, 255)) + + for x in xrange(self.size[0]): + self.tiles.append([x, self.size[1]-1, pix]) + + curObj = Tileset.objects[self.object] + curObj.height += 1 + + curObj.tiles.append([]) + for i in xrange(0, curObj.width): + curObj.tiles[len(curObj.tiles)-1].append((0, 0xFFFF, 0)) + + self.update() + self.updateList() + + + def removeRow(self): + global Tileset + + if self.size[1] == 1: + return + + if len(Tileset.objects) == 0: + window.tileWidget.addObj() + + for x in xrange(self.size[0]): + self.tiles.pop() + + self.size[1] -= 1 + self.setMinimumSize(self.size[0]*24, self.size[1]*24) + + curObj = Tileset.objects[self.object] + curObj.height -= 1 + + curObj.tiles.pop() + + self.update() + self.updateList() + + + def setObject(self, object): + self.clear() + + global Tileset + + self.size = [object.width, object.height] + + if not object.upperslope[1] == 0: + if object.upperslope[0] & 2: + self.slope = 0 - object.lowerslope[1] + else: + self.slope = object.upperslope[1] + + x = 0 + y = 0 + for row in object.tiles: + for tile in row: + + if (Tileset.slot == 0) or ((tile[2] & 3) != 0): + if (tile[1] == 0xFFFF): + pix = QtGui.QPixmap(24,24) + pix.fill(QtGui.QColor(205, 205, 255)) + self.tiles.append([x, y, pix]) + else: + self.tiles.append([x, y, Tileset.tiles[tile[1]].image]) + else: + pix = QtGui.QPixmap(24,24) + pix.fill(QtGui.QColor(205, 205, 255)) + self.tiles.append([x, y, pix]) + x += 1 + y += 1 + x = 0 + + + self.object = window.objectList.currentIndex().row() + self.update() + self.updateList() + + + def contextMenuEvent(self, event): + + TileMenu = QtGui.QMenu(self) + self.contX = event.x() + self.contY = event.y() + + TileMenu.addAction('Set tile...', self.setTile) + + TileMenu.exec_(event.globalPos()) + + + def mousePressEvent(self, event): + global Tileset + + if event.button() == 2: + return + + if window.tileDisplay.selectedIndexes() == []: + return + + currentSelected = window.tileDisplay.selectedIndexes() + + ix = 0 + iy = 0 + for modelItem in currentSelected: + # Update yourself! + centerPoint = self.contentsRect().center() + + tile = modelItem.row() + upperLeftX = centerPoint.x() - self.size[0]*12 + upperLeftY = centerPoint.y() - self.size[1]*12 + + lowerRightX = centerPoint.x() + self.size[0]*12 + lowerRightY = centerPoint.y() + self.size[1]*12 + + + x = (event.x() - upperLeftX)/24 + ix + y = (event.y() - upperLeftY)/24 + iy + + if event.x() < upperLeftX or event.y() < upperLeftY or event.x() > lowerRightX or event.y() > lowerRightY: + return + + self.tiles[(y * self.size[0]) + x][2] = Tileset.tiles[tile].image + + Tileset.objects[self.object].tiles[y][x] = (Tileset.objects[self.object].tiles[y][x][0], tile, Tileset.slot) + + ix += 1 + if self.size[0]-1 < ix: + ix = 0 + iy += 1 + if iy > self.size[1]-1: + break + + + self.update() + + self.updateList() + + + def updateList(self): + # Update the list >.> + object = window.objmodel.itemFromIndex(window.objectList.currentIndex()) + matchList = window.treeki.findItems("Object {0}".format(window.objectList.currentIndex().row()), QtCore.Qt.MatchExactly | QtCore.Qt.MatchRecursive | QtCore.Qt.MatchWrap) + + + tex = QtGui.QPixmap(self.size[0] * 24, self.size[1] * 24) + tex.fill(QtCore.Qt.transparent) + painter = QtGui.QPainter(tex) + + Xoffset = 0 + Yoffset = 0 + + for tile in self.tiles: + painter.drawPixmap(tile[0]*24, tile[1]*24, tile[2]) + + painter.end() + + try: + object.setIcon(QtGui.QIcon(tex)) + matchList[0].setIcon(1, QtGui.QIcon(tex)) + except: + pass + + window.objectList.update() + + + + def setTile(self): + global Tileset + + dlg = self.setTileDialog() + if dlg.exec_() == QtGui.QDialog.Accepted: + # Do stuff + centerPoint = self.contentsRect().center() + + upperLeftX = centerPoint.x() - self.size[0]*12 + upperLeftY = centerPoint.y() - self.size[1]*12 + + tile = dlg.tile.value() + tileset = dlg.tileset.currentIndex() + + x = (self.contX - upperLeftX)/24 + y = (self.contY - upperLeftY)/24 + + if tileset != Tileset.slot: + tex = QtGui.QPixmap(self.size[0] * 24, self.size[1] * 24) + tex.fill(QtCore.Qt.transparent) + + self.tiles[(y * self.size[0]) + x][2] = tex + + Tileset.objects[self.object].tiles[y][x] = (Tileset.objects[self.object].tiles[y][x][0], tile, tileset) + + self.update() + self.updateList() + + + class setTileDialog(QtGui.QDialog): + + def __init__(self): + QtGui.QDialog.__init__(self) + + self.setWindowTitle('Set tiles') + + self.tile = QtGui.QSpinBox() + self.tile.setRange(0, 512) + + self.buttons = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel) + self.buttons.accepted.connect(self.accept) + self.buttons.rejected.connect(self.reject) + + self.layout = QtGui.QGridLayout() + self.layout.addWidget(QtGui.QLabel('Tile:'), 0,3,1,1, QtCore.Qt.AlignLeft) + self.layout.addWidget(self.tile, 1, 3, 1, 3) + self.layout.addWidget(self.buttons, 2, 3) + self.setLayout(self.layout) + + + + def paintEvent(self, event): + painter = QtGui.QPainter() + painter.begin(self) + + centerPoint = self.contentsRect().center() + upperLeftX = centerPoint.x() - self.size[0]*12 + lowerRightX = centerPoint.x() + self.size[0]*12 + + upperLeftY = centerPoint.y() - self.size[1]*12 + lowerRightY = centerPoint.y() + self.size[1]*12 + + + painter.fillRect(upperLeftX, upperLeftY, self.size[0] * 24, self.size[1]*24, QtGui.QColor(205, 205, 255)) + + for x, y, pix in self.tiles: + painter.drawPixmap(upperLeftX + (x * 24), upperLeftY + (y * 24), pix) + + if not self.slope == 0: + pen = QtGui.QPen() + # pen.setStyle(QtCore.Qt.QDashLine) + pen.setWidth(1) + pen.setColor(QtCore.Qt.blue) + painter.setPen(QtGui.QPen(pen)) + painter.drawLine(upperLeftX, upperLeftY + (abs(self.slope) * 24), lowerRightX, upperLeftY + (abs(self.slope) * 24)) + + if self.slope > 0: + main = 'Main' + sub = 'Sub' + elif self.slope < 0: + main = 'Sub' + sub = 'Main' + + font = painter.font() + font.setPixelSize(8) + font.setFamily('Monaco') + painter.setFont(font) + + painter.drawText(upperLeftX+1, upperLeftY+10, main) + painter.drawText(upperLeftX+1, upperLeftY + (abs(self.slope) * 24) + 9, sub) + + painter.end() + + + +############################################################################################# +############################ Subclassed one dimension Item Model ############################ + + +class PiecesModel(QtCore.QAbstractListModel): + def __init__(self, parent=None): + super(PiecesModel, self).__init__(parent) + + self.pixmaps = [] + self.setSupportedDragActions(QtCore.Qt.CopyAction | QtCore.Qt.MoveAction | QtCore.Qt.LinkAction) + + def data(self, index, role=QtCore.Qt.DisplayRole): + if not index.isValid(): + return None + + if role == QtCore.Qt.DecorationRole: + return QtGui.QIcon(self.pixmaps[index.row()]) + + if role == QtCore.Qt.UserRole: + return self.pixmaps[index.row()] + + return None + + def addPieces(self, pixmap): + row = len(self.pixmaps) + + self.beginInsertRows(QtCore.QModelIndex(), row, row) + self.pixmaps.insert(row, pixmap) + self.endInsertRows() + + def flags(self,index): + if index.isValid(): + return (QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | + QtCore.Qt.ItemIsDragEnabled) + + def clear(self): + row = len(self.pixmaps) + + del self.pixmaps[:] + + + def mimeTypes(self): + return ['image/x-tile-piece'] + + + def mimeData(self, indexes): + mimeData = QtCore.QMimeData() + encodedData = QtCore.QByteArray() + + stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.WriteOnly) + + for index in indexes: + if index.isValid(): + pixmap = QtGui.QPixmap(self.data(index, QtCore.Qt.UserRole)) + stream << pixmap + + mimeData.setData('image/x-tile-piece', encodedData) + return mimeData + + + def rowCount(self, parent): + if parent.isValid(): + return 0 + else: + return len(self.pixmaps) + + def supportedDragActions(self): + return QtCore.Qt.CopyAction | QtCore.Qt.MoveAction + + + +############################################################################################# +################## Python-based RGB5a3 Decoding code from my BRFNT program ################## + + +def RGB4A3Decode(tex): + dest = QtGui.QImage(1024,512,QtGui.QImage.Format_ARGB32) + dest.fill(QtCore.Qt.transparent) + + i = 0 + for ytile in xrange(0, 512, 4): + for xtile in xrange(0, 1024, 4): + for ypixel in xrange(ytile, ytile + 4): + for xpixel in xrange(xtile, xtile + 4): + + if(xpixel >= 1024 or ypixel >= 512): + continue + + newpixel = (tex[i] << 8) | tex[i+1] + + + if(newpixel >= 0x8000): # Check if it's RGB555 + red = ((newpixel >> 10) & 0x1F) * 255 / 0x1F + green = ((newpixel >> 5) & 0x1F) * 255 / 0x1F + blue = (newpixel & 0x1F) * 255 / 0x1F + alpha = 0xFF + + else: # If not, it's RGB4A3 + alpha = ((newpixel & 0x7000) >> 12) * 255 / 0x7 + blue = ((newpixel & 0xF00) >> 8) * 255 / 0xF + green = ((newpixel & 0xF0) >> 4) * 255 / 0xF + red = (newpixel & 0xF) * 255 / 0xF + + argb = (blue) | (green << 8) | (red << 16) | (alpha << 24) + dest.setPixel(xpixel, ypixel, argb) + i += 2 + return dest + + +def RGB4A3Encode(tex): + destBuffer = create_string_buffer(1024*512*2) + + shortstruct = struct.Struct('>H') + offset = 0 + + for ytile in xrange(0, 512, 4): + for xtile in xrange(0, 1024, 4): + for ypixel in xrange(ytile, ytile + 4): + for xpixel in xrange(xtile, xtile + 4): + + if(xpixel >= 1024 or ypixel >= 512): + continue + + pixel = tex.pixel(xpixel, ypixel) + + a = pixel >> 24 + r = (pixel >> 16) & 0xFF + g = (pixel >> 8) & 0xFF + b = pixel & 0xFF + + if a < 245: #RGB4A3 + alpha = a/32 + red = r/16 + green = g/16 + blue = b/16 + + rgbDAT = (blue) | (green << 4) | (red << 8) | (alpha << 12) + + else: # RGB555 + red = r/8 + green = g/8 + blue = b/8 + + rgbDAT = (blue) | (green << 5) | (red << 10) | (0x8000) # 0rrrrrgggggbbbbb + + shortstruct.pack_into(destBuffer, offset, rgbDAT) + offset += 2 + + return destBuffer.raw + + +############################################################################################# +############ Main Window Class. Takes care of menu functions and widget creation ############ + + +class MainWindow(QtGui.QMainWindow): + def __init__(self, parent=None): + super(MainWindow, self).__init__(parent) + + self.tileImage = QtGui.QPixmap() + self.alpha = True + + global Tileset + Tileset = TilesetClass() + + self.name = '' + + self.setupMenus() + self.setupWidgets() + + self.setuptile() + + self.newTileset() + + self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, + QtGui.QSizePolicy.Fixed)) + self.setWindowTitle("New Tileset") + + + def setuptile(self): + self.tileWidget.tiles.clear() + self.model.clear() + + if self.alpha == True: + for tile in Tileset.tiles: + self.model.addPieces(tile.image) + else: + for tile in Tileset.tiles: + self.model.addPieces(tile.noalpha) + + + def newTileset(self): + '''Creates a new, blank tileset''' + + global Tileset + Tileset.clear() + Tileset = TilesetClass() + + self.treeki.clear() + # self.objectList.clear() + self.objmodel.clear() + + EmptyPix = QtGui.QPixmap(24, 24) + EmptyPix.fill(QtCore.Qt.black) + + for i in range(512): + Tileset.addTile(EmptyPix, EmptyPix) + + self.setuptile() + self.setWindowTitle('New Tileset') + + + def openTileset(self): + '''Opens a Koopatlas tileset arc and parses the heck out of it.''' + + path = str(QtGui.QFileDialog.getOpenFileName(self, "Open Koopatlas Tileset", '', + "Image Files (*.arc)")) + + if path: + self.setWindowTitle(os.path.basename(path)) + Tileset.clear() + + name = path[str(path).rfind('/')+1:-4] + + file = open(path,'rb') + data = file.read() + file.close() + + arc = archive.U8() + arc._load(data) + + Image = None + behaviourdata = None + objstrings = None + metadata = None + + for key, value in arc.files: + if value == None: + pass + if key.startswith('BG_tex/') and key.endswith('_tex.bin'): + Image = arc[key] + if key.startswith('BG_grp/') and key.endswith('_grp.bin'): + Image = arc[key] + if key.startswith('BG_unt/'): + if key.endswith('_hd.bin'): + metadata = arc[key] + elif key.endswith('.bin'): + objstrings = arc[key] + + + if (Image == None) or (group == None) or (objstrings == None) or (metadata == None): + QtGui.QMessageBox.warning(None, 'Error', 'Error - the necessary files were not found.\n\nNot a valid Koopatlas tileset, sadly.') + return + + # Stolen from Reggie! Loads the Image Data. + if HaveNSMBLib: + argbdata = nsmblib.decodeTileset(Image) + rgbdata = nsmblib.decodeTilesetNoAlpha(Image) + dest = QtGui.QImage(argbdata, 1024, 512, 4096, QtGui.QImage.Format_ARGB32_Premultiplied) + noalphadest = QtGui.QImage(rgbdata, 1024, 512, 4096, QtGui.QImage.Format_ARGB32_Premultiplied) + else: + dest = RGB4A3Decode(Image) + + self.tileImage = QtGui.QPixmap.fromImage(dest) + noalpha = QtGui.QPixmap.fromImage(noalphadest) + + + # Makes us some nice Tile Classes! + Xoffset = 4 + Yoffset = 4 + for i in range(512): + Tileset.addTile(self.tileImage.copy(Xoffset,Yoffset,24,24), noalpha.copy(Xoffset,Yoffset,24,24)) + Xoffset += 32 + if Xoffset >= 1024: + Xoffset = 4 + Yoffset += 32 + + + # Load Objects + + meta = [] + for i in xrange(len(metadata)/4): + meta.append(struct.unpack_from('>H2B', metadata, i * 4)) + + tilelist = [[]] + upperslope = [0, 0] + lowerslope = [0, 0] + byte = 0 + + for entry in meta: + offset = entry[0] + byte = struct.unpack_from('>B', objstrings, offset)[0] + row = 0 + + while byte != 0xFF: + + if byte == 0xFE: + tilelist.append([]) + + if (upperslope[0] != 0) and (lowerslope[0] == 0): + upperslope[1] = upperslope[1] + 1 + + if lowerslope[0] != 0: + lowerslope[1] = lowerslope[1] + 1 + + offset += 1 + byte = struct.unpack_from('>B', objstrings, offset)[0] + + elif (byte & 0x80): + + if upperslope[0] == 0: + upperslope[0] = byte + else: + lowerslope[0] = byte + + offset += 1 + byte = struct.unpack_from('>B', objstrings, offset)[0] + + else: + tilelist[len(tilelist)-1].append(struct.unpack_from('>BH', objstrings, offset).extend([0])) + + offset += 3 + byte = struct.unpack_from('>B', objstrings, offset)[0] + + tilelist.pop() + + if (upperslope[0] & 0x80) and (upperslope[0] & 0x2): + for i in range(lowerslope[1]): + pop = tilelist.pop() + tilelist.insert(0, pop) + + Tileset.addObject(entry[2], entry[1], upperslope, lowerslope, tilelist) + + tilelist = [[]] + upperslope = [0, 0] + lowerslope = [0, 0] + + Tileset.slot = Tileset.objects[0].tiles[0][0][2] & 3 + self.tileWidget.tilesetType.setText('Pa{0}'.format(Tileset.slot)) + + self.setuptile() + SetupObjectModel(self.objmodel, Tileset.objects, Tileset.tiles) + + self.name = path + + + def openImage(self): + '''Opens an Image from png, and creates a new tileset from it.''' + + path = QtGui.QFileDialog.getOpenFileName(self, "Open Image", '', + "Image Files (*.png)") + + if path: + newImage = QtGui.QPixmap() + self.tileImage = newImage + + if not newImage.load(path): + QtGui.QMessageBox.warning(self, "Open Image", + "The image file could not be loaded.", + QtGui.QMessageBox.Cancel) + return + + if ((newImage.width() == 768) & (newImage.height() == 384)): + x = 0 + y = 0 + for i in range(512): + Tileset.tiles[i].image = self.tileImage.copy(x*24,y*24,24,24) + x += 1 + if (x * 24) >= 768: + y += 1 + x = 0 + + else: + QtGui.QMessageBox.warning(self, "Open Image", + "The image was not the proper dimensions." + "Please resize the image to 768x384 pixels.", + QtGui.QMessageBox.Cancel) + return + + + self.setuptile() + + + def saveImage(self): + + fn = QtGui.QFileDialog.getSaveFileName(self, 'Choose a new filename', '', '.png (*.png)') + if fn == '': return + + tex = QtGui.QPixmap(768, 384) + tex.fill(QtCore.Qt.transparent) + painter = QtGui.QPainter(tex) + + Xoffset = 0 + Yoffset = 0 + + for tile in Tileset.tiles: + painter.drawPixmap(Xoffset, Yoffset, tile.image) + Xoffset += 24 + if Xoffset >= 768: + Xoffset = 0 + Yoffset += 24 + + painter.end() + + tex.save(fn) + + + def saveTileset(self): + if self.name == '': + self.saveTilesetAs() + return + + + outdata = self.saving(os.path.basename(self.name)[:-4]) + + fn = self.name + f = open(fn, 'wb') + f.write(outdata) + f.close() + + + def saveTilesetAs(self): + + fn = QtGui.QFileDialog.getSaveFileName(self, 'Choose a new filename', '', '.arc (*.arc)') + if fn == '': return + + self.name = fn + self.setWindowTitle(os.path.basename(unicode(fn))) + + outdata = self.saving(os.path.basename(unicode(fn))[:-4]) + f = open(fn, 'wb') + f.write(outdata) + f.close() + + + def saving(self, name): + + # Prepare tiles, objects, object metadata, and textures and stuff into buffers. + + textureBuffer = self.PackTexture() + objectBuffers = self.PackObjects() + objectBuffer = objectBuffers[0] + objectMetaBuffer = objectBuffers[1] + groupBuffer = self.PackGroups() + + + # Make an arc and pack up the files! + arc = archive.U8() + arc['BG_tex'] = None + arc['BG_tex/{0}_tex.bin'.format(name)] = textureBuffer + + arc['BG_unt'] = None + arc['BG_unt/{0}.bin'.format(name)] = objectBuffer + arc['BG_unt/{0}_hd.bin'.format(name)] = objectMetaBuffer + + arc['BG_grp'] = None + arc['BG_grp/{0}_grp.bin'.format(name)] = groupBuffer + + return arc._dump() + + + def PackTexture(self): + + tex = QtGui.QImage(1024, 512, QtGui.QImage.Format_ARGB32) + tex.fill(QtCore.Qt.transparent) + painter = QtGui.QPainter(tex) + + Xoffset = 0 + Yoffset = 0 + + for tile in Tileset.tiles: + minitex = QtGui.QImage(32, 32, QtGui.QImage.Format_ARGB32) + minitex.fill(QtCore.Qt.transparent) + minipainter = QtGui.QPainter(minitex) + + minipainter.drawPixmap(4, 4, tile.image) + minipainter.end() + + # Read colours and DESTROY THEM (or copy them to the edges, w/e) + for i in xrange(4,28): + + # Top Clamp + colour = minitex.pixel(i, 4) + for p in xrange(0,4): + minitex.setPixel(i, p, colour) + + # Left Clamp + colour = minitex.pixel(4, i) + for p in xrange(0,4): + minitex.setPixel(p, i, colour) + + # Right Clamp + colour = minitex.pixel(i, 27) + for p in xrange(27,31): + minitex.setPixel(i, p, colour) + + # Bottom Clamp + colour = minitex.pixel(27, i) + for p in xrange(27,31): + minitex.setPixel(p, i, colour) + + # UpperLeft Corner Clamp + colour = minitex.pixel(4, 4) + for x in xrange(0,4): + for y in xrange(0,4): + minitex.setPixel(x, y, colour) + + # UpperRight Corner Clamp + colour = minitex.pixel(27, 4) + for x in xrange(27,31): + for y in xrange(0,4): + minitex.setPixel(x, y, colour) + + # LowerLeft Corner Clamp + colour = minitex.pixel(4, 27) + for x in xrange(0,4): + for y in xrange(27,31): + minitex.setPixel(x, y, colour) + + # LowerRight Corner Clamp + colour = minitex.pixel(27, 27) + for x in xrange(27,31): + for y in xrange(27,31): + minitex.setPixel(x, y, colour) + + + painter.drawImage(Xoffset, Yoffset, minitex) + + Xoffset += 32 + + if Xoffset >= 1024: + Xoffset = 0 + Yoffset += 32 + + painter.end() + + dest = RGB4A3Encode(tex) + + return dest + + + + def PackObjects(self): + objectStrings = [] + + o = 0 + for object in Tileset.objects: + + + # Slopes + if object.upperslope[0] != 0: + + # Reverse Slopes + if object.upperslope[0] & 0x2: + a = struct.pack('>B', object.upperslope[0]) + + if object.height == 1: + iterationsA = 0 + iterationsB = 1 + else: + iterationsA = object.upperslope[1] + iterationsB = object.lowerslope[1] + object.upperslope[1] + + for row in xrange(iterationsA, iterationsB): + for tile in object.tiles[row]: + a = a + struct.pack('>BH', tile[0], tile[1]) + a = a + '\xfe' + + if object.height > 1: + a = a + struct.pack('>B', object.lowerslope[0]) + + for row in xrange(0, object.upperslope[1]): + for tile in object.tiles[row]: + a = a + struct.pack('>BH', tile[0], tile[1]) + a = a + '\xfe' + + a = a + '\xff' + + objectStrings.append(a) + + + # Regular Slopes + else: + a = struct.pack('>B', object.upperslope[0]) + + for row in xrange(0, object.upperslope[1]): + for tile in object.tiles[row]: + a = a + struct.pack('>BH', tile[0], tile[1]) + a = a + '\xfe' + + if object.height > 1: + a = a + struct.pack('>B', object.lowerslope[0]) + + for row in xrange(object.upperslope[1], object.height): + for tile in object.tiles[row]: + a = a + struct.pack('>BH', tile[0], tile[1]) + a = a + '\xfe' + + a = a + '\xff' + + objectStrings.append(a) + + + # Not slopes! + else: + a = '' + + for tilerow in object.tiles: + for tile in tilerow: + a = a + struct.pack('>BH', tile[0], tile[1]) + + a = a + '\xfe' + + a = a + '\xff' + + objectStrings.append(a) + + o += 1 + + Objbuffer = '' + Metabuffer = '' + i = 0 + for a in objectStrings: + Metabuffer = Metabuffer + struct.pack('>H2B', len(Objbuffer), Tileset.objects[i].width, Tileset.objects[i].height) + Objbuffer = Objbuffer + a + + i += 1 + + return (Objbuffer, Metabuffer) + + + + def PackGroups(self): + + groupList = [] + for kiddy in xrange(self.treeki.topLevelItemCount()): + self.walkTree(groupList, self.treeki.topLevelItem(kiddy)); + + return cPickle.dumps(groupList) + + + def walkTree(self, stringsList, treeItem): + + for kiddy in xrange(treeItem.childCount()): + newList = [] + self.walkTree(newList, treeItem.child(kiddy)) + + if treeItem.childCount() > 0: + stringsList.append(str(treeItem.text(0)), newList) + else: + stringsList.append(str(treeItem.text(0))) + + + def setupMenus(self): + fileMenu = self.menuBar().addMenu("&File") + + pixmap = QtGui.QPixmap(60,60) + pixmap.fill(QtCore.Qt.black) + icon = QtGui.QIcon(pixmap) + + self.action = fileMenu.addAction(icon, "New", self.newTileset, QtGui.QKeySequence.New) + fileMenu.addAction("Open...", self.openTileset, QtGui.QKeySequence.Open) + fileMenu.addAction("Import Image...", self.openImage, QtGui.QKeySequence('Ctrl+I')) + fileMenu.addAction("Export Image...", self.saveImage, QtGui.QKeySequence('Ctrl+E')) + fileMenu.addAction("Save", self.saveTileset, QtGui.QKeySequence.Save) + fileMenu.addAction("Save as...", self.saveTilesetAs, QtGui.QKeySequence.SaveAs) + fileMenu.addAction("Quit", self.close, QtGui.QKeySequence('Ctrl-Q')) + + taskMenu = self.menuBar().addMenu("&Tasks") + + taskMenu.addAction("Toggle Alpha", self.toggleAlpha, QtGui.QKeySequence('Ctrl+Shift+A')) + taskMenu.addAction("Clear Object Data", Tileset.clearObjects, QtGui.QKeySequence('Ctrl+Alt+Backspace')) + + + + def toggleAlpha(self): + # Replace Alpha Image with non-Alpha images in model + if self.alpha == True: + self.alpha = False + else: + self.alpha = True + + self.setuptile() + + + def TriggerNewGroup(self): + + a = QtGui.QTreeWidgetItem(self.treeki) + a.setText(0, 'Double Click to Rename') + a.setFlags(QtCore.Qt.ItemFlags(0x2F)) + a.setChildIndicatorPolicy(QtGui.QTreeWidgetItem.ShowIndicator) + a.setExpanded(True) + + + def TriggerDelGroup(self): + + treecko = self.treeki.currentItem() + if str(treecko.text(0)).find("Object"): + eggs = treecko.takeChildren() + + self.treeki.addTopLevelItems(eggs) + + index = window.treeki.indexFromItem(treecko, 0) + realx = index.row() + + if treecko.parent(): + y = treecko.parent().takeChild(realx) + else: + y = self.treeki.takeTopLevelItem(realx) + + del y + + + + def setupWidgets(self): + frame = QtGui.QFrame() + frameLayout = QtGui.QHBoxLayout(frame) + + # Displays the tiles + self.tileDisplay = displayWidget() + + # Sets up the model for the tile pieces + self.model = PiecesModel(self) + self.tileDisplay.setModel(self.model) + + # Object List + self.objectList = objectList() + self.objmodel = QtGui.QStandardItemModel() + SetupObjectModel(self.objmodel, Tileset.objects, Tileset.tiles) + self.objectList.setModel(self.objmodel) + + self.tileWidget = tileOverlord() + + # Vertical Container A + self.container = QtGui.QWidget() + layout = QtGui.QVBoxLayout() + layout.addWidget(self.tileDisplay) + layout.addWidget(self.tileWidget) + self.container.setLayout(layout) + + + # Create the Group Tree + self.treeki = QtGui.QTreeWidget() + self.treeki.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) + self.treeki.setDragEnabled(True) + self.treeki.setDragDropMode(QtGui.QAbstractItemView.InternalMove) + self.treeki.setAcceptDrops(True) + self.treeki.setDropIndicatorShown(True) + self.treeki.setEditTriggers(QtGui.QAbstractItemView.DoubleClicked) + self.treeki.setColumnCount(2) + self.treeki.setColumnWidth(0, 200) + + self.treeki.setColumnWidth(1, 40) + + + # Vertical Container B + self.treeBario = QtGui.QWidget() + tlayout = QtGui.QVBoxLayout() + tlayout.addWidget(self.treeki) + + self.groupbar = QtGui.QToolBar() + + self.newGroup = QtGui.QAction('New Group', self.groupbar) + self.newGroup.triggered.connect(self.TriggerNewGroup) + self.newGroup.setShortcut(QtGui.QKeySequence('Ctrl+Shift+N')) + + self.delGroup = QtGui.QAction('Delete Group', self.groupbar) + self.delGroup.triggered.connect(self.TriggerDelGroup) + self.delGroup.setShortcut(QtGui.QKeySequence('Ctrl+Shift+Del')) + + self.groupbar.addAction(self.newGroup) + self.groupbar.addAction(self.delGroup) + + self.groupbar.setFloatable(False) + + tlayout.addWidget(self.groupbar) + self.treeBario.setLayout(tlayout) + + + # Creates the Tab Widget for behaviours and objects + self.tabWidget = QtGui.QTabWidget() + + # Sets the Tabs + self.tabWidget.addTab(self.objectList, 'Object List') + self.tabWidget.addTab(self.treeBario, 'Object Groups') + + + + # Connections do things! + self.objectList.clicked.connect(self.tileWidget.setObject) + self.treeki.itemClicked.connect(connectToTileWidget) + + + frameLayout.addWidget(self.container) + frameLayout.addWidget(self.tabWidget) + + + self.setCentralWidget(frame) + + + + +############################################################################################# +####################################### Main Function ####################################### + + +if __name__ == '__main__': + + import sys + + app = QtGui.QApplication(sys.argv) + window = MainWindow() + window.show() + sys.exit(app.exec_()) + app.deleteLater()
\ No newline at end of file |