from common import *
from editorui import *


class KPLayerList(QtGui.QWidget):
	

	def __init__(self):
		QtGui.QWidget.__init__(self)

		self.layout = QtGui.QVBoxLayout()
		self.layout.setSpacing(0)

		self.model = KP.map.layerModel

		self.listView = QtGui.QListView()
		self.listView.setModel(self.model)
		self.layout.addWidget(self.listView)

		self.toolbar = QtGui.QToolBar()
		self.layout.addWidget(self.toolbar)

		self.setupToolbar(self.toolbar)

		self.setLayout(self.layout)
	

	def setupToolbar(self, tb):
		tb.addAction(QtGui.QIcon(), 'Add', self.addLayer)
		tb.addAction(QtGui.QIcon(), 'Remove', self.removeLayer)
		tb.addAction(QtGui.QIcon(), 'Move Up', self.moveUp)
		tb.addAction(QtGui.QIcon(), 'Move Down', self.moveDown)
	

	def selectedLayerIndex(self):
		return self.listView.selectionModel().currentIndex().row()
	def selectedLayer(self):
		return KP.map.layers[self.listView.selectionModel().currentIndex().row()]
	

	def addLayer(self):
		KP.map.appendLayer(KP.map.createNewLayer())

	def removeLayer(self):
		KP.map.removeLayer(self.selectedLayer())

	def moveUp(self):
		index = self.selectedLayerIndex()
		KP.map.moveLayer(index, index - 1)

	def moveDown(self):
		index = self.selectedLayerIndex()
		KP.map.moveLayer(index, index + 2)




class KPObjectSelector(QtGui.QListView):

    def __init__(self):
        """Initialises the widget. Remember to call setModel() on it with a KPGroupModel
        whenever the layer changes."""
        
        QtGui.QListView.__init__(self)
        self.setFlow(QtGui.QListView.LeftToRight)
        self.setLayoutMode(QtGui.QListView.SinglePass)
        self.setMovement(QtGui.QListView.Static)
        self.setResizeMode(QtGui.QListView.Adjust)
        self.setWrapping(True)
                
        # self.setItemDelegate(KPObjectSelector.ObjectItemDelegate())
        
        self.clicked.connect(self.HandleObjReplace)
    
    
    def toggleTopLevel(self, id):
        """Changes the top level group in the list view."""
    
    	# Not quite sure how to implement this yet. Basically, the model is hierarchal,
    	# and it'll return items from whatever the top level KPGroupItem is. But removing
    	# and adding stuff isn't possible, since I need to retain my recursive object.
    	#
    	# So here's the structure. Above this QListView, there will be a QComboBox.
    	#
    	# The QComboBox will list all groups in my hierarchy.
    	# Selecting a group will cause the QListView to only show items for those rows,
    	# even though all rows are retained.
    	#
   		# It's kind of like a custom QSortFilterProxyModel. Maybe I should subclass that.
    

        self.setCurrentIndex(self.model().index(sel, 0, QtCore.QModelIndex()))
    
    @QtCore.pyqtSlot(QtCore.QModelIndex, QtCore.QModelIndex)
    def currentChanged(self, current, previous):
        """Throws a signal when the selected object changed"""
        self.ObjChanged.emit(current.row())
    
    def HandleObjReplace(self, index):
        """Throws a signal when the selected object is used as a replacement"""
        if QtGui.QApplication.keyboardModifiers() == QtCore.Qt.AltModifier:
            self.ObjReplace.emit(index.row())
    
    ObjChanged = QtCore.pyqtSignal(int)
    ObjReplace = QtCore.pyqtSignal(int)
    
    
    class KPGroupItemDelegate(QtGui.QAbstractItemDelegate):
        """Handles tileset groups, objects and their rendering"""
        
        def __init__(self):
            """Initialises the delegate"""
            QtGui.QAbstractItemDelegate.__init__(self)
        
        def paint(self, painter, option, index):
            """Paints an object"""
            if option.state & QtGui.QStyle.State_Selected:
                painter.fillRect(option.rect, option.palette.highlight())
            
            p = index.model().data(index, QtCore.Qt.DecorationRole)
            painter.drawPixmap(option.rect.x()+2, option.rect.y()+2, p)
            #painter.drawText(option.rect, str(index.row()))
        
        def sizeHint(self, option, index):
            """Returns the size for the object"""
            p = index.model().data(index, QtCore.Qt.UserRole)
            return p
    
    
        






class KPMainWindow(QtGui.QMainWindow):
	def __init__(self):
		QtGui.QMainWindow.__init__(self)

		self.editor = KPEditorWidget()
		self.setCentralWidget(self.editor)

		self.setupMenuBar()

		self.setupDocks()
	

	def setupMenuBar(self):
		mb = self.menuBar()

		m = mb.addMenu('&File')
		# ...
	

	def setupDocks(self):
		self.layerList = KPLayerList()
		self.layerListDock = QtGui.QDockWidget('Layers')
		self.layerListDock.setWidget(self.layerList)

		self.objectSelector = KPObjectSelector()
		# self.objectSelector.setModel(SomeTileset.getModel())
		self.objectSelectorDock = QtGui.QDockWidget('Layers')
		self.objectSelectorDock.setWidget(self.layerList)


		self.addDockWidget(Qt.RightDockWidgetArea, self.layerListDock)