path: root/src/mapwidget.cc

/*
   mapwidget.cc
   This file is part of the Project::OSiRiON world editor 
   and is distributed under the terms and conditions of 
   the GNU General Public License version 2
*/

#include "entitywidget.h"
#include "manipulator.h"
#include "mapwidget.h"

#include <QPainter>
#include <QMouseEvent>
#include <QWheelEvent>
#include <QDebug>
#include <QtGui>

namespace editor
{

MapWidget::MapWidget(QWidget *parent) : QWidget(parent)
{
	//setMinimumSize(256,256);
	mapwidget_manipulator = new Manipulator(this);
	
	// zoom sucks but it works
	mapwidget_zoom = 16;
	
	// center of the map (used for dragging)
	center_x = 0;
	center_y = 0;
	
	dragstart_x = 0;
	dragstart_y = 0;
	
	is_dragging = false;
	
	mapwidget_selected = 0;
	
	setFocusPolicy(Qt::ClickFocus);
}

void MapWidget::wheelEvent(QWheelEvent *event)
{
	if (event->orientation() == Qt::Vertical) {
		int oldzoom = mapwidget_zoom;
		
		mapwidget_zoom -= event->delta() / 120;
		if (mapwidget_zoom < 1)
			mapwidget_zoom = 1;
		else if (mapwidget_zoom > 64) {
			mapwidget_zoom = 64;
		}
		
		center_x = center_x * oldzoom / mapwidget_zoom;
		center_y = center_y * oldzoom / mapwidget_zoom;
		
		resizeChildren();
		update();
		event->accept();
	}
}

void MapWidget::mousePressEvent(QMouseEvent *event)
{
	if (event->button() == Qt::RightButton) {
		dragstart_x = event->pos().x();
		dragstart_y = event->pos().y();
		event->accept();
		is_dragging = true;
	} else {
		is_dragging = false;
	}
}

void MapWidget::mouseReleaseEvent(QMouseEvent *event)
{
	if (event->button() == Qt::RightButton) {
		is_dragging = false;
	}
}

void MapWidget::mouseMoveEvent(QMouseEvent *event)
{
	if (is_dragging) {
		int delta_x = event->pos().x() - dragstart_x;
		int delta_y = event->pos().y() - dragstart_y;
		
		center_x += delta_x;
		center_y += delta_y;
		
		//qDebug() << "dragging " << delta_x << " " << delta_y;
		
		dragstart_x = event->pos().x();
		dragstart_y = event->pos().y();
		
		event->accept();
		
		resizeChildren();
		
		update();
	}
}

void MapWidget::resizeChildren()
{
	if ((width() < 16) || (height() < 16))
		return;
	
	const float scale = (float) width() / (float) (mapwidget_zoom * 256);
	
	for (int i = 0; i < mapwidget_enties.size(); ++i) {
		EntityWidget * entity = mapwidget_enties.at(i);
		int radius = (int) (entity->properties()->radius() * scale);
		if (radius < 6)
			radius = 6;
		
		int x = width() / 2 - (int) (entity->properties()->location()[1] * scale) - radius;
		int y = height() / 2 - (int)(entity->properties()->location()[0] * scale) - radius;
		
		entity->setGeometry(center_x + x, center_y + y, radius * 2 , radius * 2);
		//qDebug() << "Moving entity to " << x << " " << y;
		if (entity->selected()) {
			mapwidget_manipulator->setSize(entity);
			mapwidget_manipulator->setProperties(entity->properties());
			mapwidget_manipulator->update();
		}
	}

}

void MapWidget::deselect()
{
	for (int i = 0; i < mapwidget_enties.size(); ++i) {		
		EntityWidget *entitywidget = mapwidget_enties.at(i);
		entitywidget->set_selected(false);
	}
	
	mapwidget_selected = 0;
	emit propertiesChanged(0);	
	mapwidget_manipulator->setMode(Manipulator::None);
}

void MapWidget::dragEntity(EntityWidget *entity, int x, int y)
{
	const float scale = (float) (mapwidget_zoom * 256) / (float) width();
	int radius = (int) (entity->properties()->radius() / scale);
	if (radius < 6)
		radius = 6;
	
	entity->properties()->set_location(
		entity->properties()->location()[0] - (int) ((float) (y - radius) * scale),
		entity->properties()->location()[1] - (int) ((float) (x - radius) * scale),
		entity->properties()->location()[2]
	);
	
	emit propertiesChanged(entity->properties());
	resizeChildren();	
	mapwidget_manipulator->setMode(Manipulator::Move);
}

void MapWidget::select(EntityWidget *entity)
{
	mapwidget_selected = 0;
	mapwidget_manipulator->setMode(Manipulator::None);
	
	for (int i = 0; i < mapwidget_enties.size(); ++i) {
		
		EntityWidget *entitywidget = mapwidget_enties.at(i);
		
		if (entity == entitywidget) {
			
			entity->set_selected(true);
			//qDebug() << "selected entity " << entity->name();
			emit propertiesChanged(entity->properties());
			mapwidget_manipulator->setMode(Manipulator::Select);
			mapwidget_manipulator->setProperties(entity->properties());
			mapwidget_manipulator->setSize(entity);
			mapwidget_selected = entity;
		} else {
			
			entitywidget->set_selected(false);
		}
	}
	update();
}

void MapWidget::keyPressEvent(QKeyEvent *event)
{
	if (event->key() == Qt::Key_Escape) {
		deselect();
		event->accept();
	} else {
		event->ignore();
	}
	
}

void MapWidget::resizeEvent(QResizeEvent *event)
{
	resizeChildren();
}

void MapWidget::paintEvent(QPaintEvent *event)
{
	if ((width() < 16) || (height() < 16))
		return;

	const QColor gridlinecolor(0, 0, 128);
	const QColor axislinecolor(128, 0, 0);
	
	
	QPen pen(gridlinecolor, 1, Qt::SolidLine);
	QPainter painter(this);
	
	painter.setPen(pen);

	// mapwidget_zoom is used to scale from game units to screen coorinates	
	// 1 grid square is 256 game units
	// gridsize is the size of one grid square in screen coordinates
	int gridsize = width() / mapwidget_zoom;
	
	int x = center_x + width() / 2;	
	pen.setColor(axislinecolor);
	painter.setPen(pen);
	painter.drawLine(x, 0, x, height());
	x -= gridsize;
	pen.setColor(gridlinecolor);
	painter.setPen(pen);
	
	while (x > 0) {
		painter.drawLine(x, 0, x, height());
		x -= gridsize;
	}
	x = center_x + width() / 2 + gridsize;
	while (x <= width()) {
		painter.drawLine(x, 0, x, height());
		x += gridsize;
	}
	
	
	int y = center_y + height() / 2;
	pen.setColor(axislinecolor);
	painter.setPen(pen);
	
	painter.drawLine(0, y, width(), y);
	y -= gridsize;
	pen.setColor(gridlinecolor);
	painter.setPen(pen);
	
	while (y > 0) {
		painter.drawLine(0, y, width(), y);
		y -= gridsize;
	}
	y = center_y + height() / 2 + gridsize;
	while (y <= height()) {
		painter.drawLine(0, y, width(), y);
		y += gridsize;
	}
}


void MapWidget::save(QTextStream &textstream)
{
	for (int i = 0; i < mapwidget_enties.size(); ++i) {
		
		EntityWidget *entitywidget = mapwidget_enties.at(i);
		entitywidget->properties()->save(textstream);
	}
}

EntityWidget *MapWidget::addEntity()
{
	EntityWidget *entitywidget = new EntityWidget(this);
	mapwidget_enties.append(entitywidget);
	
	// connect the EntityWidget::clicked() signal to the MapWidget::selected() slot
	connect(entitywidget, SIGNAL(clicked(EntityWidget *)), this, SLOT(select(EntityWidget *)));
	connect(entitywidget, SIGNAL(dragMove(EntityWidget *, int, int)), this, SLOT(dragEntity(EntityWidget *, int, int)));
	
	entitywidget->show();
	
	resizeChildren();
	update();
	
	return entitywidget;
}

void MapWidget::duplicateSelected()
{
	for (int i = 0; i < mapwidget_enties.size(); ++i) {
		
		EntityWidget *entitywidget = mapwidget_enties.at(i);
		if (entitywidget->selected()) {
			// duplicate the child widget
			
		} else {
		}
	}
}

void MapWidget::deleteSelected()
{
	Entities::iterator i = mapwidget_enties.begin();
	
	while (i != mapwidget_enties.end()) {		
		EntityWidget *entitywidget = (*i);
		
		if (entitywidget->selected()) {
			// delete the child widget
			delete entitywidget;
			// set the pointer in the list to NULL
			(*i) = 0;
			// remove the actual list entry
			i = mapwidget_enties.erase(i);
		} else {
			++i;
		}
	}
	deselect();
}

}