OE_document.cpp

/*
 * Copyright (c) 2015 Tricoire Sebastien 3dsman@free.fr
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software
 * in a product, an acknowledgment in the product documentation would be
 * appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 * misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 */

#include "OE_document.h"
#include "stitchs/OE_linestitch.h"

#include <string>
#include <iostream>
#include <fstream>
#include <map>
#include <limits>

OE_document::OE_document()
{
	OE_linestitch::initMotifs();
}

OE_document::~OE_document()
{

}

OE_document::ScopeLock::ScopeLock(OE_document& doc) : std::lock_guard<std::recursive_mutex>(doc.accessLock)
{
}

bool OE_document::saveToFile(std::string path)
{
	ScopeLock lock(*this);
	OE_ofstream out(path);
	if (!out.is_open())
		return false;
	std::map<OE_curve*,int> curveIds;
	std::map<OE_thread*,int> threadIds;
	int idx=0;
	out << "Super fichier de sauvegarde de la mort qui tueeeeeeeeeeee\r\n";
	out << "J'avais " << curves.size() << " curves, mais je sais pas lesquelles. Lol mdr\r\n";
	for (auto curve : curves)
	{
		out << "Curve " << idx << " ";
		out << *curve << "\r\n";
		curveIds.insert(std::pair<OE_curve*,int>(curve, idx++));
	}
	idx = 0;
	for (auto thread : threads)
	{
		out << "Thread " << idx << " ";
		out << *thread << "\r\n";
		threadIds.insert(std::pair<OE_thread*,int>(thread, idx++));
	}
	idx = 0;
	for (auto stitch : stitchs)
	{
		out << "Stitch " << idx << " ";
		out << *stitch << "\r\n";
		idx++; //StitchIds.insert(std::pair<OE_stitchs*,int>(stitch, idx++));
	}
	out.close();
	return true;
}

bool OE_document::loadFromFile(std::string path)
{
	ScopeLock lock(*this);
	OE_ifstream in(path);
	if (!in.is_open())
		return false;
	std::map<int, OE_curve*> curvePointers;
	std::map<int, OE_thread*> threadPointers;
	std::streamsize nolimit = std::numeric_limits<std::streamsize>::max();
	int idx;
	in.ignore(nolimit, '\n');
	in.ignore(nolimit, '\n');
	std::string type;
	while (in.good() && !in.eof())
	{
		in >> type;
		if (!type.compare("Curve"))
		{
			in >> idx;
            OE_pointcurve* curve = new OE_pointcurve();
			in >> *curve;
			if (curve->pts.size()) // TODO remove, ugly as fuck
			{
				curves.push_back(curve);
                curvePointers.insert(std::pair<int, OE_pointcurve*>(idx, curve));
			}
			else
			{
				delete curve;
				break;
			}
		}
		else if (!type.compare("Thread"))
		{
			in >> idx;
			OE_thread* thread = new OE_thread();
			in >> *thread;
			if (thread->getWidth()!=1) // TODO remove, ugly as fuck
			{
				threads.push_back(thread);
				threadPointers.insert(std::pair<int, OE_thread*>(idx, thread));
				std::cout << "Loaded thread " << idx << "width=" << thread->getWidth();
				std::cout << " color=(" << std::hex << (unsigned)thread->getColor()[0] << ", ";
				std::cout << (unsigned)thread->getColor()[1] << ", " << (unsigned)thread->getColor()[2] << ", ";
				std::cout << (unsigned)thread->getColor()[3] << ")" << std::dec << "\r\n";
			}
			else
			{
				delete thread;
				break;
			}
		}
		else if (!type.compare("Stitch"))
		{
			OE_stitchs* newStitch = OE_stitchs::load(in);
			if (newStitch)
				stitchs.push_back(newStitch);
		}
	}
	in.close();
	return true;
}

void OE_document::lock()
{
	accessLock.lock();
}

void OE_document::unlock()
{
	accessLock.unlock();
}

int OE_document::trylock()
{
	accessLock.try_lock();
}

void OE_document::getBound(float* xMin, float* yMin, float* xMax, float* yMax)
{
	float tmpXMin, tmpYMin, tmpXMax, tmpYMax;
	if (curves.size())
	{
		
        std::list<OE_pointcurve*>::iterator curve = curves.begin();
		(*curve)->getBound(xMin, yMin, xMax, yMax);
		curve++;
		
		while (curve != curves.end())
		{
		//for (unsigned i=0; i<curves.size(); i++)
		//{
			 (*curve)->getBound(&tmpXMin, &tmpYMin, &tmpXMax, &tmpYMax);
			 *xMin = minf(*xMin,tmpXMin);
			 *yMin = minf(*yMin,tmpYMin);
			 *xMax = maxf(*xMax,tmpXMax);
			 *yMax = maxf(*yMax,tmpYMax);
			 curve++;
		}
		
		std::list<OE_stitchs*>::iterator stitch = stitchs.begin();
		
		while (stitch != stitchs.end())
		{
		//for (unsigned i=0; i<stitchs.size(); i++)
		//{
			 (*stitch)->getBound(&tmpXMin, &tmpYMin, &tmpXMax, &tmpYMax);
			 *xMin = minf(*xMin,tmpXMin);
			 *yMin = minf(*yMin,tmpYMin);
			 *xMax = maxf(*xMax,tmpXMax);
			 *yMax = maxf(*yMax,tmpYMax);
			 stitch++;
		 }
	}
}

vector_2d OE_document::getHoopSize()
{
	return hoopSize;
}

unsigned int OE_document::getPulseByMm()
{
	return pulseByMm;
}

vector_2d OE_document::getZeroPoint()
{
	return zeroPoint;
}

void OE_document::setHoopSize(vector_2d hoopSize)
{
	this->hoopSize = hoopSize;
}

void OE_document::setPulseByMm(unsigned int pbm)
{
	pulseByMm = pbm;
}

void OE_document::setZeroPoint(vector_2d zeroPoint)
{
	this->zeroPoint = zeroPoint;
}


bool OE_document::addCurve(OE_pointcurve * curve)
{
	curves.push_back(curve);
	return true;
}

bool OE_document::addStitch(OE_stitchs * stitch)
{
	stitchs.push_back(stitch);
	return true;
}

bool OE_document::addThread(OE_thread * thread)
{
	threads.push_back(thread);
	return true;
}


bool OE_document::removeCurve(OE_pointcurve * curve)
{
    selectedCurves.remove(curve);
    curves.remove(curve);
}

bool OE_document::removeStitch(OE_stitchs * stitch)
{
    selectedStitchs.remove(stitch);
    stitchs.remove(stitch);
}

bool OE_document::removeThread(OE_thread * thread)
{
    threads.remove(thread);
}


bool OE_document::refresh()
{


	
	return true;
}
/*
bool OE_document::draw(float dpi)
{
			for (unsigned i=0; i<curves.size(); i++)
			 {
				 curves.at(i).draw(dpi);
			 }
			 for (unsigned i=0; i<stitchs.size(); i++)
			 {
				 stitchs.at(i)->draw();
			 }
			 return true;
}*/