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())
		# 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.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)