// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/viewcommandids.h"

#include "toonzqt/imageutils.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/gutil.h"

// TnzLib includes

#include "toonz/preferences.h"

#include "toonz/namebuilder.h"

#include "toonz/toonzscene.h"

#include "toonz/tproject.h"

#include "toonz/Naa2TlvConverter.h"

#ifdef _WIN32

#include "avicodecrestrictions.h"

#endif

// TnzCore includes

#include "tsystem.h"

#include "tfilepath_io.h"

#include "timage_io.h"

#include "tlevel.h"

#include "tlevel_io.h"

#include "tpalette.h"

#include "tropcm.h"

#include "trasterimage.h"

#include "tvectorrenderdata.h"

#include "tofflinegl.h"

#include "tconvert.h"

#include "trop.h"

#include "timageinfo.h"

#include "tfiletype.h"

#include "tfilepath.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "tvectorimage.h"

#include "tstroke.h"

// TnzQt includes

#include <qapplication></qapplication>

// boost includes

#include <boost iterator="" transform_iterator.hpp=""></boost>

//**********************************************************************************

//    Local namespace  stuff

//**********************************************************************************

namespace

{

void addOverlappedRegions(TRegion *reg, std::vector<tfilledregioninf> ®Inf)</tfilledregioninf>

{

	regInf.push_back(TFilledRegionInf(reg->getId(), reg->getStyle()));

	UINT regNum = reg->getSubregionCount();

	for (UINT i = 0; i < regNum; i++)

		addOverlappedRegions(reg->getSubregion(i), regInf);

}

//--------------------------------------------------------------------

void addRegionsInArea(TRegion *reg, std::vector<tfilledregioninf> ®s, const TRectD &area)</tfilledregioninf>

{

	if (area.contains(reg->getBBox()))

		regs.push_back(TFilledRegionInf(reg->getId(), reg->getStyle()));

	if (reg->getBBox().overlaps(area)) {

		UINT regNum = reg->getSubregionCount();

		for (UINT i = 0; i < regNum; i++)

			addRegionsInArea(reg->getSubregion(i), regs, area);

	}

}

//--------------------------------------------------------------------

void getFrameIds(TFrameId from, TFrameId to, const TLevelP &level,

				 std::vector<tframeid> &frames)</tframeid>

{

	struct locals {

		static inline TFrameId getFrame(const TLevel::Table::value_type &pair)

		{

			return pair.first;

		}

	}; // locals

	if (from.isEmptyFrame())

		from = TFrameId(-(std::numeric_limits<int>::max)());</int>

	if (to.isEmptyFrame())

		to = TFrameId((std::numeric_limits<int>::max)());</int>

	if (from > to)

		tswap(from, to);

	const TLevel::Table &table = *level->getTable();

	TLevel::Table::const_iterator lBegin = table.lower_bound(from),

								  lEnd = table.upper_bound(to);

	assert(frames.empty());

	frames.insert(frames.end(), boost::make_transform_iterator(lBegin, locals::getFrame),

				  boost::make_transform_iterator(lEnd, locals::getFrame));

}

} // namespace

//**********************************************************************************

//    ImageUtils namespace  stuff

//**********************************************************************************

namespace ImageUtils

{

// todo: spostare da qualche altra parte. rendere accessibile a tutti. utilizzare

// anche nella libreria dovunque si usi direttamente "_files"

TFilePath getResourceFolder(const TFilePath &scenePath)

{

	return scenePath.getParentDir() + (scenePath.getName() + "_files");

}

//-----------------------------------------------------------------------------

void copyScene(const TFilePath &dst, const TFilePath &src)

{

	TSystem::copyFile(dst, src);

	if (TProjectManager::instance()->isTabModeEnabled())

		TSystem::copyDir(getResourceFolder(dst), getResourceFolder(src));

	TFilePath srcIcon = ToonzScene::getIconPath(src);

	if (TFileStatus(srcIcon).doesExist()) {

		TFilePath dstIcon = ToonzScene::getIconPath(dst);

		TSystem::copyFile(dstIcon, srcIcon);

	}

}

//-----------------------------------------------------------------------------

TFilePath duplicate(const TFilePath &levelPath)

{

	if (levelPath == TFilePath())

		return TFilePath();

	if (!TSystem::doesExistFileOrLevel(levelPath)) {

		DVGui::warning(QObject::tr("It is not possible to find the %1 level.").arg(QString::fromStdWString(levelPath.getWideString())));

		return TFilePath();

	}

	NameBuilder *nameBuilder = NameBuilder::getBuilder(::to_wstring(levelPath.getName()));

	std::wstring levelNameOut;

	do

		levelNameOut = nameBuilder->getNext();

	while (TSystem::doesExistFileOrLevel(levelPath.withName(levelNameOut)));

	TFilePath levelPathOut = levelPath.withName(levelNameOut);

	try {

		if (levelPath.getType() == "tnz")

			copyScene(levelPathOut, levelPath);

		else {

			TSystem::copyFileOrLevel_throw(levelPathOut, levelPath);

			if (levelPath.getType() == "tlv") {

				TFilePath pltPath = levelPath.withType("tpl");

				if (TSystem::doesExistFileOrLevel(pltPath))

					TSystem::copyFileOrLevel_throw(levelPathOut.withType("tpl"), pltPath);

			}

		}

	} catch (...) {

		QString msg = QObject::tr("There was an error copying %1").arg(toQString(levelPath));

		DVGui::error(msg);

		return TFilePath();

	}

	//  QString msg = QString("Copied ") +

	//                QString::fromStdWString(levelPath.withoutParentDir().getWideString()) +

	//                QString(" to " +

	//                QString::fromStdWString(levelPathOut.withoutParentDir().getWideString()));

	//  DVGui::info(msg);

	return levelPathOut;

}

//-----------------------------------------------------------------------------

void premultiply(const TFilePath &levelPath)

{

	if (levelPath == TFilePath())

		return;

	if (!TSystem::doesExistFileOrLevel(levelPath)) {

		DVGui::warning(QObject::tr("It is not possible to find the level %1").arg(QString::fromStdWString(levelPath.getWideString())));

		return;

	}

	TFileType::Type type = TFileType::getInfo(levelPath);

	if (type == TFileType::CMAPPED_LEVEL) {

		DVGui::warning(QObject::tr("Cannot premultiply the selected file."));

		return;

	}

	if (type == TFileType::VECTOR_LEVEL || type == TFileType::VECTOR_IMAGE) {

		DVGui::warning(QObject::tr("Cannot premultiply a vector-based level."));

		return;

	}

	if (type != TFileType::RASTER_LEVEL && type != TFileType::RASTER_IMAGE) {

		DVGui::info(QObject::tr("Cannot premultiply the selected file."));

		return;

	}

	try {

		TLevelReaderP lr = TLevelReaderP(levelPath);

		if (!lr)

			return;

		TLevelP level = lr->loadInfo();

		if (!level || level->getFrameCount() == 0)

			return;

		bool isMovie = type == TFileType::RASTER_LEVEL;

		/*  

    if (!isMovie && lr->getImageInfo()->m_samplePerPixel!=4)

    {

    QMessageBox::information(0, QString("ERROR"), QString("Only rgbm images can be premultiplied!"));

    return;

    }

    */

		TLevelWriterP lw;

		if (!isMovie) {

			lw = TLevelWriterP(levelPath);

			if (!lw)

				return;

		}

		qApp->setOverrideCursor(QCursor(Qt::WaitCursor));

		qApp->processEvents();

		int count = 0;

		TLevel::Iterator it = level->begin();

		for (; it != level->end(); ++it) {

			TImageReaderP ir = lr->getFrameReader(it->first);

			TRasterImageP rimg = (TRasterImageP)ir->load();

			if (!rimg)

				continue;

			TRop::premultiply(rimg->getRaster());

			ir = 0;

			if (isMovie)

				level->setFrame(it->first, rimg);

			else {

				TImageWriterP iw = lw->getFrameWriter(it->first);

				iw->save(levelPath.withFrame(it->first), rimg);

				iw = 0;

			}

		}

		lr = TLevelReaderP();

		if (isMovie) {

			TSystem::deleteFile(levelPath);

			lw = TLevelWriterP(levelPath);

			if (!lw) {

				QApplication::restoreOverrideCursor();

				return;

			}

			lw->save(level);

		}

	} catch (...) {

		DVGui::warning(QObject::tr("Cannot premultiply the selected file."));

		QApplication::restoreOverrideCursor();

		return;

	}

	QApplication::restoreOverrideCursor();

	QString msg = QObject::tr("Level %1 premultiplied.").arg(QString::fromStdString(levelPath.getLevelName()));

	DVGui::info(msg);

}

//-----------------------------------------------------------------------------

void getFillingInformationOverlappingArea(

	const TVectorImageP &vi,

	std::vector<tfilledregioninf> ®Inf,</tfilledregioninf>

	const TRectD &area1,

	const TRectD &area2)

{

	if (!vi->isComputedRegionAlmostOnce())

		return;

	assert(area1 != TRectD() || area2 != TRectD());

	vi->findRegions();

	UINT regNum = vi->getRegionCount();

	TRegion *reg;

	for (UINT i = 0; i < regNum; i++) {

		reg = vi->getRegion(i);

		if (reg->getBBox().overlaps(area1) || reg->getBBox().overlaps(area2))

			addOverlappedRegions(reg, regInf);

	}

}

//-----------------------------------------------------------------------------

void getFillingInformationInArea(

	const TVectorImageP &vi,

	std::vector<tfilledregioninf> ®s,</tfilledregioninf>

	const TRectD &area)

{

	if (!vi->isComputedRegionAlmostOnce())

		return;

	vi->findRegions();

	UINT regNum = vi->getRegionCount();

	for (UINT i = 0; i < regNum; i++)

		addRegionsInArea(vi->getRegion(i), regs, area);

}

//--------------------------------------------------------------------

void assignFillingInformation(

	TVectorImage &vi,

	const std::vector<tfilledregioninf> ®s)</tfilledregioninf>

{

	vi.findRegions();

	UINT r, rCount = UINT(regs.size());

	for (r = 0; r != rCount; ++r) {

		const TFilledRegionInf &rInfo = regs[r];

		if (TRegion *region = vi.getRegion(rInfo.m_regionId))

			region->setStyle(rInfo.m_styleId);

	}

}

//--------------------------------------------------------------------

void getStrokeStyleInformationInArea(

	const TVectorImageP &vi,

	std::vector<std::pair<int, int="">> &strokesInfo,</std::pair<int,>

	const TRectD &area)

{

	if (!vi->isComputedRegionAlmostOnce())

		return;

	vi->findRegions();

	UINT regNum = vi->getStrokeCount();

	for (UINT i = 0; i < vi->getStrokeCount(); i++) {

		if (!vi->inCurrentGroup(i))

			continue;

		if (area.contains(vi->getStroke(i)->getBBox()))

			strokesInfo.push_back(std::pair<int, int="">(i, vi->getStroke(i)->getStyle()));</int,>

	}

}

//--------------------------------------------------------------------

void convertFromCM(const TLevelReaderP &lr, const TPaletteP &plt, const TLevelWriterP &lw, const std::vector<tframeid> &frames,</tframeid>

				   const TAffine &aff, const TRop::ResampleFilterType &resType, FrameTaskNotifier *frameNotifier, const TPixel &bgColor, bool removeDotBeforeFrameNumber = false)

{

	for (int i = 0; i < (int)frames.size(); i++) {

		if (frameNotifier->abortTask())

			break;

		try {

			TImageReaderP ir = lr->getFrameReader(frames[i]);

			TImageP img = ir->load();

			TToonzImageP toonzImage(img);

			double xdpi, ydpi;

			toonzImage->getDpi(xdpi, ydpi);

			assert(toonzImage);

			if (toonzImage) {

				TRasterCM32P rasCMImage = toonzImage->getRaster();

				TRaster32P ras(convert(aff * convert(rasCMImage->getBounds())).getSize());

				if (!aff.isIdentity())

					TRop::resample(ras, rasCMImage, plt, aff, resType);

				else

					TRop::convert(ras, rasCMImage, plt);

				if (bgColor != TPixel::Transparent)

					TRop::addBackground(ras, bgColor);

				TRasterImageP rasImage(ras);

				rasImage->setDpi(xdpi, ydpi);

				/*---

					ConvertPopup での指定に合わせて、[レベル名].[フレーム番号].[拡張子]

					のうち、[レベル名]と[フレーム番号]の間のドットを消す。

					例：A.0001.tga → A0001.tga になる。

				---*/

				if (removeDotBeforeFrameNumber) {

					TFilePath outPath = lw->getFilePath().withFrame(frames[i]);

					/*--- フレーム番号と拡張子の文字数の合計。大抵8 ---*/

					int index = 4 + 1 + outPath.getType().length();

					std::wstring renamedStr = outPath.getWideString();

					if (renamedStr[renamedStr.length() - index - 1] == L'.')

						renamedStr = renamedStr.substr(0, renamedStr.length() - index - 1) + renamedStr.substr(renamedStr.length() - index, index);

					const TFilePath fp(renamedStr);

					TImageWriterP writer(fp);

					writer->setProperties(lw->getProperties());

					writer->save(rasImage);

				} else {

					TImageWriterP iw = lw->getFrameWriter(frames[i]);

					iw->save(rasImage);

				}

			}

		} catch (...) {

			//QString msg=QObject::tr("Frame %1 : conversion failed!").arg(QString::number(i+1));

			//      DVGui::info(msg);

		}

		/*-- これはプログレスバーを進めるものなので、動画番号ではなく、完了したフレームの枚数を投げる --*/

		frameNotifier->notifyFrameCompleted(100 * (i + 1) / frames.size());

	}

}

//--------------------------------------------------------------------

void convertFromVI(const TLevelReaderP &lr, const TPaletteP &plt, const TLevelWriterP &lw, const std::vector<tframeid> &frames,</tframeid>

				   const TRop::ResampleFilterType &resType, int width, FrameTaskNotifier *frameNotifier)

{

	QString msg;

	int i;

	std::vector<tvectorimagep> images;</tvectorimagep>

	TRectD maxBbox;

	for (i = 0; i < (int)frames.size(); i++) { //trovo la bbox che possa contenere tutte le immagini

		try {

			TImageReaderP ir = lr->getFrameReader(frames[i]);

			TVectorImageP img = ir->load();

			images.push_back(img);

			maxBbox += img->getBBox();

		} catch (...) {

			msg = QObject::tr("Frame %1 : conversion failed!").arg(QString::fromStdString(frames[i].expand()));

			DVGui::info(msg);

		}

	}

	maxBbox = maxBbox.enlarge(2);

	TAffine aff;

	if (width) //calcolo l'affine

		aff = TScale((double)width / maxBbox.getLx());

	maxBbox = aff * maxBbox;

	for (i = 0; i < (int)images.size(); i++) {

		if (frameNotifier->abortTask())

			break;

		try {

			TVectorImageP vectorImage = images[i];

			assert(vectorImage);

			if (vectorImage) {

				//faccio il render dell'immagine

				vectorImage->transform(aff, true);

				const TVectorRenderData rd(TTranslation(-maxBbox.getP00()), TRect(), plt.getPointer(), 0, true, true);

				TOfflineGL *glContext = new TOfflineGL(convert(maxBbox).getSize());

				glContext->clear(TPixel32::Transparent);

				glContext->draw(vectorImage, rd);

				TRaster32P rasImage = (glContext->getRaster());

				TImageWriterP iw = lw->getFrameWriter(TFrameId(i + 1));

				iw->save(TRasterImageP(rasImage));

			}

		} catch (...) {

			msg = QObject::tr("Frame %1 : conversion failed!").arg(QString::fromStdString(frames[i].expand()));

			DVGui::info(msg);

		}

		frameNotifier->notifyFrameCompleted(100 * (i + 1) / frames.size());

	}

}

//-----------------------------------------------------------------------

void convertFromFullRaster(const TLevelReaderP &lr, const TLevelWriterP &lw, const std::vector<tframeid> &_frames,</tframeid>

						   const TAffine &aff, const TRop::ResampleFilterType &resType, FrameTaskNotifier *frameNotifier,

						   const TPixel &bgColor, bool removeDotBeforeFrameNumber = false)

{

	std::vector<tframeid> frames = _frames;</tframeid>

	if (frames.empty() && lr->loadInfo()->getFrameCount() == 1) //e' una immagine singola, non un livello

		frames.push_back(TFrameId());

	for (int i = 0; i < (int)frames.size(); i++) {

		if (frameNotifier->abortTask())

			break;

		try {

			TRasterImageP img;

			if (frames[i] == TFrameId()) //immagine singola, non livello

			{

				assert(frames.size() == 1);

				TImageP _img;

				if (!TImageReader::load(lr->getFilePath(), _img))

					continue;

				img = _img;

			} else {

				TImageReaderP ir = lr->getFrameReader(frames[i]);

				img = ir->load();

			}

			TRaster32P raster(convert(aff * img->getBBox()).getSize());

			if (!aff.isIdentity())

				TRop::resample(raster, img->getRaster(), aff, resType);

			else {

				if ((TRaster32P)img->getRaster())

					raster = img->getRaster();

				else

					TRop::convert(raster, img->getRaster());

			}

			if (bgColor != TPixel::Transparent)

				TRop::addBackground(raster, bgColor);

			TRasterImageP newImg(raster);

			double xDpi, yDpi;

			img->getDpi(xDpi, yDpi);

			if (xDpi == 0 && yDpi == 0)

				xDpi = yDpi = Preferences::instance()->getDefLevelDpi();

			newImg->setDpi(xDpi, yDpi);

			if (frames[i] == TFrameId())

				TImageWriter::save(lw->getFilePath(), newImg);

			else {

				/*---

			ConvertPopup での指定に合わせて、[レベル名].[フレーム番号].[拡張子]

			のうち、[レベル名]と[フレーム番号]の間のドットを消す。

			例：A.0001.tga → A0001.tga になる。

			---*/

				if (removeDotBeforeFrameNumber) {

					TFilePath outPath = lw->getFilePath().withFrame(frames[i]);

					/*--- フレーム番号と拡張子の文字数の合計。大抵8 ---*/

					int index = 4 + 1 + outPath.getType().length();

					std::wstring renamedStr = outPath.getWideString();

					if (renamedStr[renamedStr.length() - index - 1] == L'.')

						renamedStr = renamedStr.substr(0, renamedStr.length() - index - 1) + renamedStr.substr(renamedStr.length() - index, index);

					const TFilePath fp(renamedStr);

					TImageWriterP writer(fp);

					writer->setProperties(lw->getProperties());

					writer->save(newImg);

				} else {

					TImageWriterP iw = lw->getFrameWriter(frames[i]);

					iw->save(newImg);

				}

			}

		} catch (...) {

			//QString msg=QObject::tr("Frame %1 : conversion failed!").arg(QString::number(i+1));

			//DVGui::info(msg);

		}

		/*-- これはプログレスバーを進めるものなので、動画番号ではなく、完了したフレームの枚数を投げる --*/

		frameNotifier->notifyFrameCompleted(100 * (i + 1) / frames.size());

	}

}

//-----------------------------------------------------------------------

void convertFromVector(const TLevelReaderP &lr, const TLevelWriterP &lw, const std::vector<tframeid> &_frames,</tframeid>

					   FrameTaskNotifier *frameNotifier)

{

	std::vector<tframeid> frames = _frames;</tframeid>

	TLevelP lv = lr->loadInfo();

	if (frames.empty() && lv->getFrameCount() == 1) //e' una immagine singola, non un livello

		frames.push_back(TFrameId());

	for (int i = 0; i < (int)frames.size(); i++) {

		if (frameNotifier->abortTask())

			break;

		try {

			TVectorImageP img;

			if (frames[i] == TFrameId()) //immagine singola, non livello

			{

				assert(frames.size() == 1);

				TImageP _img;

				if (!TImageReader::load(lr->getFilePath(), _img))

					continue;

				img = _img;

			} else {

				TImageReaderP ir = lr->getFrameReader(frames[i]);

				img = ir->load();

			}

			img->setPalette(lv->getPalette());

			if (frames[i] == TFrameId())

				TImageWriter::save(lw->getFilePath(), img);

			else {

				TImageWriterP iw = lw->getFrameWriter(frames[i]);

				iw->save(img);

			}

		} catch (...) {

			//QString msg=QObject::tr("Frame %1 : conversion failed!").arg(QString::number(i+1));

			//DVGui::info(msg);

		}

		frameNotifier->notifyFrameCompleted(100 * (i + 1) / frames.size());

	}

}

//-----------------------------------------------------------------------

void convert(const TFilePath &source, const TFilePath &dest,

			 const TFrameId &from, const TFrameId &to,

			 double framerate,

			 TPropertyGroup *prop,

			 FrameTaskNotifier *frameNotifier,

			 const TPixel &bgColor,

			 bool removeDotBeforeFrameNumber)

{

	std::string dstExt = dest.getType(),

				srcExt = source.getType();

	// Load source level structure

	TLevelReaderP lr(source);

	TLevelP level = lr->loadInfo();

#ifdef _WIN32

	if (dstExt == "avi") {

		TDimension res(0, 0);

		const TImageInfo *info = lr->getImageInfo(level->begin()->first);

		res.lx = info->m_lx;

		res.ly = info->m_ly;

		std::string codecName = prop->getProperty(0)->getValueAsString();

		if (!AviCodecRestrictions::canWriteMovie(::to_wstring(codecName), res)) {

			return;

		}

	}

#endif

	// Get the frames available in level inside the [from, to] range

	std::vector<tframeid> frames;</tframeid>

	getFrameIds(from, to, level, frames);

	// Write the destination level

	TLevelWriterP lw(dest, prop);

	lw->setFrameRate(framerate);

	if (srcExt == "tlv")

		convertFromCM(lr, level->getPalette(), lw, frames, TAffine(), TRop::Triangle, frameNotifier, bgColor, removeDotBeforeFrameNumber);

	else if (srcExt == "pli")

		//assert(!"Conversion from pli files is currently diabled");

		convertFromVector(lr, lw, frames, frameNotifier);

	else

		convertFromFullRaster(lr, lw, frames, TAffine(), TRop::Triangle, frameNotifier, bgColor, removeDotBeforeFrameNumber);

}

//=============================================================================

void convertNaa2Tlv(

	const TFilePath &source, const TFilePath &dest,

	const TFrameId &from, const TFrameId &to,

	FrameTaskNotifier *frameNotifier,

	TPalette *palette)

{

	std::string dstExt = dest.getType(),

				srcExt = source.getType();

	// Load source level structure

	TLevelReaderP lr(source);

	TLevelP level = lr->loadInfo();

	// Get the frames available in level inside the [from, to] range

	std::vector<tframeid> frames;</tframeid>

	getFrameIds(from, to, level, frames);

	if (frames.empty())

		return;

	// Write the destination level

	TLevelWriterP lw; // Initialized just before a sure write

	Naa2TlvConverter converter;

	converter.setPalette(palette);

	int f, fCount = int(frames.size());

	for (f = 0; f != fCount; ++f) {

		if (frameNotifier->abortTask())

			break;

		try {

			TImageReaderP ir = lr->getFrameReader(frames[f]);

			TImageP img = ir->load();

			if (!img)

				continue;

			TRasterImageP ri = img;

			if (!ri)

				continue;

			TRaster32P raster = ri->getRaster(); // Converts only 32-bit images, it seems...

			if (!raster)						 //

				continue;						 //

			converter.process(raster);

			if (TToonzImageP dstImg = converter.makeTlv(false)) // Opaque synthetic inks

			{

				if (converter.getPalette() == 0)

					converter.setPalette(dstImg->getPalette());

				if (!lw)					  // Initialize output file only on a sure write

					lw = TLevelWriterP(dest); //

				TImageWriterP iw = lw->getFrameWriter(frames[f]);

				iw->save(dstImg);

			} else {

				DVGui::warning(QObject::tr(

										   "The source image seems not suitable for this kind of conversion"));

				frameNotifier->notifyError();

			}

		} catch (...) {

		}

		frameNotifier->notifyFrameCompleted(100 * (f + 1) / frames.size());

	}

}

//=============================================================================

#define ZOOMLEVELS 13

#define NOZOOMINDEX 6

double ZoomFactors[ZOOMLEVELS] = {0.015625, 0.03125, 0.0625, 0.125, 0.25,

								  0.5, 1, 2, 4, 8, 16, 32, 64};

double getQuantizedZoomFactor(double zf, bool forward)

{

	if (forward && (zf > ZoomFactors[ZOOMLEVELS - 1] || areAlmostEqual(zf, ZoomFactors[ZOOMLEVELS - 1], 1e-5)))

		return zf;

	else if (!forward && (zf < ZoomFactors[0] || areAlmostEqual(zf, ZoomFactors[0], 1e-5)))

		return zf;

	assert((!forward && zf > ZoomFactors[0]) || (forward && zf < ZoomFactors[ZOOMLEVELS - 1]));

	int i = 0;

	for (i = 0; i <= ZOOMLEVELS - 1; i++)

		if (areAlmostEqual(zf, ZoomFactors[i], 1e-5))

			zf = ZoomFactors[i];

	if (forward && zf < ZoomFactors[0])

		return ZoomFactors[0];

	else if (!forward && zf > ZoomFactors[ZOOMLEVELS - 1])

		return ZoomFactors[ZOOMLEVELS - 1];

	for (i = 0; i < ZOOMLEVELS - 1; i++)

		if (ZoomFactors[i + 1] - zf >= 0 && zf - ZoomFactors[i] >= 0) {

			if (forward && ZoomFactors[i + 1] == zf)

				return ZoomFactors[i + 2];

			else if (!forward && ZoomFactors[i] == zf)

				return ZoomFactors[i - 1];

			else

				return forward ? ZoomFactors[i + 1] : ZoomFactors[i];

		}

	return ZoomFactors[NOZOOMINDEX];

}

} // namespace ImageUtils

namespace

{

void getViewerShortcuts(int &zoomIn, int &zoomOut, int &zoomReset, int &zoomFit, int &showHideFullScreen, int &actualPixelSize)

{

	CommandManager *cManager = CommandManager::instance();

	zoomIn = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomIn));

	zoomOut = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomOut));

	zoomReset = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomReset));

	zoomFit = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ZoomFit));

	showHideFullScreen = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ShowHideFullScreen));

	actualPixelSize = cManager->getKeyFromShortcut(cManager->getShortcutFromId(V_ActualPixelSize));

}

} //namespace

//--------------------------------------------------------------------------

namespace ImageUtils

{

ShortcutZoomer::ShortcutZoomer(QWidget *zoomingWidget)

	: m_widget(zoomingWidget)

{

}

//--------------------------------------------------------------------------

bool ShortcutZoomer::exec(QKeyEvent *event)

{

	int zoomInKey, zoomOutKey, zoomResetKey, zoomFitKey, showHideFullScreenKey, actualPixelSize;

	getViewerShortcuts(zoomInKey, zoomOutKey, zoomResetKey, zoomFitKey, showHideFullScreenKey, actualPixelSize);

	int key = event->key();

	if (key == Qt::Key_Control || key == Qt::Key_Shift || key == Qt::Key_Alt)

		return false;

	key = key | event->modifiers() & (~0xf0000000); // Ignore if the key is a numpad key

	return (key == showHideFullScreenKey) ? toggleFullScreen() : (key == Qt::Key_Escape) ? toggleFullScreen(true) : (key == actualPixelSize) ? setActualPixelSize() : (key == zoomFitKey) ? fit() : (key == zoomInKey ||

																																																	 key == zoomOutKey ||

																																																	 key == zoomResetKey)

																																																		? zoom(key == zoomInKey, key == zoomResetKey)

																																																		: false;

}

//*********************************************************************************************

//    FullScreenWidget  implementation

//*********************************************************************************************

FullScreenWidget::FullScreenWidget(QWidget *parent)

	: QWidget(parent)

{

	QHBoxLayout *layout = new QHBoxLayout(this);

	layout->setMargin(0);

	layout->setSpacing(0);

	setLayout(layout);

}

//---------------------------------------------------------------------------------

void FullScreenWidget::setWidget(QWidget *widget)

{

	QLayout *layout = this->layout();

	delete layout->takeAt(0);

	if ((m_widget = widget))

		layout->addWidget(m_widget);

}

//---------------------------------------------------------------------------------

bool FullScreenWidget::toggleFullScreen(bool quit)

{

	if (windowState() & Qt::WindowFullScreen) {

		hide();

		setWindowFlags(windowFlags() & ~(Qt::Window | Qt::WindowStaysOnTopHint));

		showNormal();

		setContentsMargins(0, 0, 0, 0); // ...

		m_widget->setFocus();

		return true;

	} else if (!quit) {

		setContentsMargins(0, 0, 1, 1); // QTBUG #7556

		setWindowFlags(windowFlags() | Qt::Window | Qt::WindowStaysOnTopHint);

		showFullScreen();

		return true;

	}

	return false;

}

} //imageutils