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.listView.selectionModel().currentRowChanged.connect(self.handleRowChanged)
		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()]

	selectedLayerChanged = QtCore.pyqtSignal(KPLayer, KPLayer)

	@QtCore.pyqtSlot(QtCore.QModelIndex, QtCore.QModelIndex)
	def handleRowChanged(self, current, previous):
		self.selectedLayerChanged.emit(
				KP.map.layers[current.row()],
				((previous.row() >= 0) and KP.map.layers[previous.row()]) or None
				)


	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())
		# Borrowed the signals and junk from Reggie, figure we'll need em'

		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.objReplaced.emit(index.row())

	objChanged = QtCore.pyqtSignal(int)
	objReplaced = 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.scene = KPMapScene()
		self.editor.setScene(self.scene)

		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.updateObjectSelector()
		self.objectSelectorDock = QtGui.QDockWidget('Objects')
		self.objectSelectorDock.setWidget(self.objectSelector)


		self.addDockWidget(Qt.RightDockWidgetArea, self.layerListDock)
		self.addDockWidget(Qt.RightDockWidgetArea, self.objectSelectorDock)
	
	@QtCore.pyqtSlot()
	def updateObjectSelector(self):
		pass