#include "casmconfigpanel.h"
#include "filebrowserpopup.h"
#include "application.h"

#include "tw/mainshell.h"
#include "tw/textfield.h"
#include "tw/label.h"
#include "tw/optionmenu.h"
#include "tw/button.h"
#include "tw/checkbox.h"

#include "tconvert.h"
#include "util.h"
#include "tsystem.h"

#include "tw/message.h"

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

CasmTask::CasmTask()
{
	setdefaultValue();
}

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

CasmTask::CasmTask(const string &s, const string &setupFilePath)
	: m_setupFile(setupFilePath)
{
	setCommandLine(s);
}

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

void CasmTask::setdefaultValue()
{
	m_taskChunksize = 1;
	m_start = 0;
	m_end = 9999;
	m_step = 1;
	m_casmFile = "";
	m_outname = "";
	m_firstFrame = 0;
	m_lastFrame = 0;
	m_reduction = 1;
	m_moveType = M_BG_FRACMOVE;
	m_prec = 32;
	m_renderTile = 1.;
	m_memChunk = 4.;
	m_multimedia = false;
	m_logfile = false;
	m_cf = false;
	m_restype = RES_TYPE_STANDARD;
	m_noOverwrite = false;
	m_clap = false;
	m_mprocess = false;
	m_numColumn = -1;
	m_lineart = -1;
	m_edgeAliasing = -1;
	m_gamma = -1.;
	m_bcScript = "";
	m_acScript = "";
	m_outputScript = "";
	m_outputScriptArgument = "";
	m_setupFile = "";
	xsize = 0;
	ysize = 0;
}

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

string CasmTask::getCommandLine() const
{
	string qualifiers, prgname, dirname, biname;

	if (m_reduction != 1)
		qualifiers += " -shrink " + toString(m_reduction) + " ";

	if (m_moveType != moveType::M_BG_FRACMOVE)
		qualifiers += (m_moveType == moveType::M_FRACMOVE) ? " -fracmove " : " -intmove ";
	if (m_prec == 64)
		qualifiers += " -64bit";
	else
		qualifiers += " -32bit";

	qualifiers += " -tile " + toString(m_renderTile) + " ";

	qualifiers += " -mem " + toString(m_memChunk) + " ";

	if (m_multimedia) {
		if (m_numColumn < 0)
			qualifiers += " -mm ";
		else
			qualifiers += " -mmsingle " + toString(m_numColumn) + " ";
	}

	if (m_logfile)
		qualifiers += " -logfile +output/casm_batches.log ";

	if (m_lineart > -1)
		qualifiers += " -lineart " + toString(m_lineart) + " ";
	if (m_edgeAliasing > -1)
		qualifiers += " -edgealiasing " + toString(m_edgeAliasing) + " ";
	if (m_gamma > -1.0)
		qualifiers += " -gamma " + toString(m_gamma) + " ";

	switch (m_restype) {
		CASE RES_TYPE_STANDARD : qualifiers += " -sq ";
		CASE RES_TYPE_IMPROVED : qualifiers += " -iq ";
		CASE RES_TYPE_HIGH : qualifiers += " -hq ";
	}

	if (m_cf)
		qualifiers += " -cf ";

	if (m_noOverwrite)
		qualifiers += " -no_overwrite ";

	if (m_clap)
		qualifiers += " -clap ";

	if (m_bcScript != "")
		qualifiers += " -bc " + m_bcScript + " ";

	if (m_acScript != "" && m_outputScript == "")
		qualifiers += " -ac " + m_acScript + " ";

	if (m_outputScript != "") {
		bool outputToDdr = (m_outputScript ==
							DDR_OUTPUTSCRIPT_FILENAME);

		if (!outputToDdr)
			qualifiers += " -ac " + m_outputScript + " ";
		if (m_outputScriptArgument != "") {
			string entry_point = m_outputScriptArgument;
			string parity = "odd";
			int i;
			i = entry_point.size();
			if (i > 0 && entry_point[i - 1] == '+') {
				parity = "even";
				entry_point[i - 1] = '\0';
			}
			//convert_timecode_to_frame (entry_point);//??????
			if (outputToDdr)
				qualifiers += " -ddr " + entry_point + " ";
			else {
				string app;
#ifdef WIN32
				app = " -ac_args \"$filename $count " + entry_point;
				app += " " + parity;
				app += " $total\" ";
				qualifiers += app;
#else
				app = " -ac_args '$filename $count " + entry_point;
				app += " " + parity;
				app += " $total' ";
				qualifiers += " app;
#endif
			}
		} else {
			if (outputToDdr)
				qualifiers += " -ddr " + toString(0) + " ";
			else
#ifdef WIN32
				qualifiers += " -ac_args \"$filename $count $total\" ";
#else
				qualifiers += " -ac_args '$filename $count $total' ";
#endif
		}
	}

	qualifiers += "  -step " + toString(m_step);

	if (m_start > m_firstFrame || m_end < m_lastFrame)
		qualifiers += " -range " + toString(m_start) + " " + toString(m_end) + " ";

	//qualifiers += " -chunk "+toString(m_taskChunksize)+" ";

	return qualifiers;
}

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

static bool is_num(string word)
{
	string::iterator it = word.begin();
	while (it != word.end()) {
		if ((*it < '0' || *it > '9') && *it != '.')
			return false;
		it++;
	}
	return true;
}

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

static string cpy_word(string &word, string s)
{
	/* salto gli spazi bianchi iniziali */
	string::iterator it = s.begin();
	word = "";
	string::iterator it2 = word.begin();
	while (s[0] == ' ' || s[0] == '\t')
		it++;
	if (s[0] == '\'' || s[0] == '\"') {
		/* argomento fra virgolette */
		char quote = *it++;
		while (*it && *it != '\n') {
			if (*it == '\\') {
				it++;
				if (*it == '\0' || *it == '\n')
					break;
				switch (*it) {
					CASE '\\' : *it2++ = '\\';
				DEFAULT:
					*it2++ = *it;
				}
				it++;
			} else if (*it == quote) {
				it++;
				break;
			} else
				*it2++ = *it++;
		}
	} else {
		/* argomento senza virgolette */
		while (*it && *it != ' ' && *it != '\t' && *it != '\n')
			*it2++ = *it++;
	}
	//*word = '\0';

	/* salto gli spazi bianchi finali */
	while (*it == ' ' || *it == '\t')
		it++;
	return s.erase(s.begin(), it);
}

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

void CasmTask::setCommandLine(const string &cmdLine)
{
	if (cmdLine.empty())
		return;

	setdefaultValue();
	string s = cmdLine;
	string::iterator it = s.begin();
	string word;
	while (it != s.end()) {
		s = cpy_word(word, s);

		if (word == "-64bit")
			m_prec = 64;
		else if (word == "-32bit")
			m_prec = 32;
		else if (word == "-sq")
			m_restype = RES_TYPE_STANDARD;
		else if (word == "-iq")
			m_restype = RES_TYPE_IMPROVED;
		else if (word == "-hq")
			m_restype = RES_TYPE_HIGH;
		else if (word == "-step") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_step = atoi(word.c_str());
		} else if (word == "-range") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_start = atoi(word.c_str());
			s = cpy_word(word, s);
			if (is_num(word))
				m_end = atoi(word.c_str());
		} else if (word == "-shrink") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_reduction = atoi(word.c_str());
		} else if (word == "-fracmove") {
			m_moveType = M_FRACMOVE;
		} else if (word == "-intmove") {
			m_moveType = M_INTMOVE;
		}
		/*     else
     if (STR_EQ(word, "-64bit"))
        task->prec = 64;
     else 
     if (STR_EQ(word, "-32bit"))
        task->prec = 32;*/
		else if (word == "-tile") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_renderTile = atof(word.c_str());
		} else if (word == "-mem") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_taskChunksize = atoi(word.c_str());
		} else if (word == "-chunk") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_memChunk = atof(word.c_str());
		} else if (word == "-mm") {
			m_multimedia = true;
			m_numColumn = -1;
		} else if (word == "-mmsingle") {
			m_multimedia = true;
			s = cpy_word(word, s);
			if (is_num(word))
				m_numColumn = atoi(word.c_str());
		} else if (word == "-lineart") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_lineart = atoi(word.c_str());
		} else if (word == "-edgealiasing") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_edgeAliasing = atoi(word.c_str());
		} else if (word == "-gamma") {
			s = cpy_word(word, s);
			if (is_num(word))
				m_gamma = atof(word.c_str());
		} else if (word == "-cf") {
			m_cf = true;
		} else if (word == "-no_overwrite") {
			m_noOverwrite = true;
		} else if (word == "-clap") {
			m_clap = true;
		} else if (word == "-bc") {
			s = cpy_word(word, s);
			m_bcScript = word;
		} else if (word == "-ac") {
			s = cpy_word(word, s);
			m_outputScript = word;
		} else if (word == "-ac_args") { /*
       char output_script_argument[1024];
       s = cpy_word(word, s);
       if(parse_ac_args(output_script_argument, word))
         task->output_script_argument = strsave(output_script_argument);*/
		} else if (word == "-logfile") {
			s = cpy_word(word, s);
			m_logfile = true;
		}
		/*     else
     if (!word.compare("-range"))
      {
	s = cpy_word(word, s);
        if (is_num(word))
	   task->start = atoi(word);
	else
         {
           delete_job((TASK *)task);
           return NULL;
         }
       s = cpy_word(word, s);
       if (is_num(word))
          task->end = atoi(word);
       else
        {
          delete_job((TASK *)task);
          return NULL;
        }
      }*/
		/*     else
     if (*word!='\n' && *word!='\0')
      {
        t = tim_get_type(word);
        if (*t == '.') t++;
        if (FILESTR_NE(t, "casm")) 
         {
           delete_job((TASK *)task);
//           return NULL;
         }
        else
         {
	   TCALLOC(task->casm_file, strlen(word)+1);
	   strcpy(task->casm_file, word);
	   compute_casm_range(task->casm_file, &(task->first_frame), &(task->last_frame), &dummy); 
	   if (task->start<task->first_frame) 
	      task->start=task->first_frame;
	   if (task->end>task->last_frame) 
	      task->end=task->last_frame;
           task->xsize = task->ysize = 0;
           casm_camera_size(task->casm_file, &task->xsize, &task->ysize);
  

         }
      }*/
		it = s.begin();
	}
}

//==============================================================================
enum numFieldType {
	M_FROM = 0,
	M_TO,
	M_STEP,
	M_SHRINK,
	M_RTILE,
	M_MCHUNK,
	M_COLUMN,
	M_THICK,
	M_GAMMA,
	M_CHUNKSIZE
};

class NumFieldChanger : public TNumField::Action
{
	CasmConfigPanel *m_ccp;
	numFieldType m_typeField;

public:
	NumFieldChanger(CasmConfigPanel *ccp, numFieldType type)
		: m_ccp(ccp), m_typeField(type)
	{
	}

	void sendCommand(const TNumField::Event &ev)
	{
		m_ccp->onNumField(ev.m_value, m_typeField);
	}
};

class ColumnFieldChanger : public TTextField::Action
{
	CasmConfigPanel *m_ccp;

public:
	ColumnFieldChanger(CasmConfigPanel *ccp)
		: m_ccp(ccp)
	{
	}

	void sendCommand(std::wstring value)
	{
		m_ccp->onColumnField(value);
	}
};

class NumFieldChanger2 : public TNumField::Action
{
public:
	NumFieldChanger2(CasmConfigPanel *ccp, double CasmTask::*)
	{
	}

	void sendCommand(double value)
	{
		//*m_member = value;
	}

	double CasmTask::*m_member;
};

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

CasmConfigPanel::CasmConfigPanel(TWidget *parent)
	: TWidget(parent)
{
	m_task = new CasmTask();

	m_chunkSizeLabel = new TLabel(this);
	m_chunkSizeLabel->setText("Task Chunk Size:");
	m_chunkSize = new TNumField(this);
	m_chunkSize->setIsInteger(true);
	m_chunkSize->setRange(1, std::numeric_limits<int>::max());
	m_chunkSize->addAction(new NumFieldChanger(this, M_CHUNKSIZE));

	m_setupLabel = new TLabel(this);
	m_setupLabel->setText("Setup Path:");
	m_setupTextField = new TTextField(this);
	m_setupBrowseBtn = new TButton(this);
	m_setupBrowseBtn->setTitle("...");
	tconnect(*m_setupBrowseBtn, this, &CasmConfigPanel::browseSetupFiles);

	m_fromLabel = new TLabel(this);
	m_fromLabel->setText("From:");
	m_from = new TNumField(this);
	m_from->setIsInteger(true);
	m_from->addAction(new NumFieldChanger(this, M_FROM));

	m_toLabel = new TLabel(this);
	m_toLabel->setText("To:");
	m_to = new TNumField(this);
	m_to->setIsInteger(true);
	m_to->addAction(new NumFieldChanger(this, M_TO));

	m_stepLabel = new TLabel(this);
	m_stepLabel->setText("Step:");
	m_step = new TNumField(this);
	m_step->setIsInteger(true);
	m_step->addAction(new NumFieldChanger(this, M_STEP));

	m_shrinkLabel = new TLabel(this);
	m_shrinkLabel->setText("Shrink:");
	m_shrink = new TNumField(this);
	m_shrink->setIsInteger(true);
	m_shrink->addAction(new NumFieldChanger(this, M_SHRINK));

	m_renderTileLabel = new TLabel(this);
	m_renderTileLabel->setText("Render Tile:");
	m_renderTile = new TNumField(this);
	m_renderTile->setIsInteger(true);
	m_renderTile->addAction(new NumFieldChanger(this, M_RTILE));

	m_memChunkLabel = new TLabel(this);
	m_memChunkLabel->setText("Mem Chunk:");
	m_memChunk = new TNumField(this);
	m_memChunk->setIsInteger(true);
	m_memChunk->addAction(new NumFieldChanger(this, M_MCHUNK));

	m_subPixelMoveLabel = new TLabel(this);
	m_subPixelMoveLabel->setText("Subpixel Move:");
	m_subPixelMove = new TOptionMenu(this);
	m_subPixelMove->addOption("None");
	m_subPixelMove->addOption("RGB");
	m_subPixelMove->addOption("All");
	m_subPixelMove->setAction(new TOptionMenuAction<CasmConfigPanel>(this, &CasmConfigPanel::onSubPixelMove));

	m_processingLabel = new TLabel(this);
	m_processingLabel->setText("Processing:");
	m_processing = new TOptionMenu(this);
	m_processing->addOption("32 Bit");
	m_processing->addOption("64 Bit");
	m_processing->setAction(new TOptionMenuAction<CasmConfigPanel>(this, &CasmConfigPanel::onProcessing));

	m_resampleQualityLabel = new TLabel(this);
	m_resampleQualityLabel->setText("Resample Quality:");
	m_resampleQuality = new TOptionMenu(this);
	m_resampleQuality->addOption("Standard");
	m_resampleQuality->addOption("Improved");
	m_resampleQuality->addOption("High");
	m_resampleQuality->setAction(new TOptionMenuAction<CasmConfigPanel>(this, &CasmConfigPanel::onResampleQuality));

	m_focus = new TCheckBox(this, "Constant Focus");
	tconnect<CasmConfigPanel>(*m_focus, this, onConstantFocus);
	m_noOverwrite = new TCheckBox(this, "No Overwrite");
	tconnect<CasmConfigPanel>(*m_noOverwrite, this, onOverwrite);
	m_multimedia = new TCheckBox(this, "Multimedia");
	tconnect<CasmConfigPanel>(*m_multimedia, this, onMultimedia);

	m_column = new TTextField(this);
	m_column->setText("All");
	m_column->disable();
	m_column->addAction(new ColumnFieldChanger(this));
	m_lineart = new TCheckBox(this, "Lineart");
	m_lineart->disable();
	tconnect<CasmConfigPanel>(*m_lineart, this, onLineart);
	m_edgeAliasing = new TCheckBox(this, "Edge Aliasing");
	m_edgeAliasing->disable();
	tconnect<CasmConfigPanel>(*m_edgeAliasing, this, onEdgeAliasing);
	m_thickness = new TNumField(this);
	m_thickness->setIsInteger(true);
	m_thickness->setRange(0, 15);
	m_thickness->setValue(8);
	m_thickness->disable();
	m_thickness->addAction(new NumFieldChanger(this, M_THICK));

	m_gamma = new TCheckBox(this, "Gamma");
	tconnect<CasmConfigPanel>(*m_gamma, this, onGamma);
	m_gammaValue = new TNumField(this);
	m_gammaValue->setValue(0);
	m_gammaValue->disable();
	m_gammaValue->addAction(new NumFieldChanger(this, M_GAMMA));

	m_clap = new TCheckBox(this, "Add Clap");
	//tconnect<CasmConfigPanel>(*m_clap, this, onClap);
	/*
  m_outputScriptLabel = new TLabel(this);
  m_outputScriptLabel->setText("Output Script:");
  m_outputScript = new TOptionMenu(this);
  m_outputScript->addOption("None");
  //m_subPixelMove->setAction(new TOptionMenuAction<CasmConfigPanel>(this, &CasmConfigPanel::onOutputScript));
  m_entryPointLabel = new TLabel(this);
  m_entryPointLabel->setText("Entry Point:");
  m_entryPoint = new TTextField(this);
  m_entryPoint->setText("");
  */
}

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

void CasmConfigPanel::configureNotify(const TDimension &d)
{
	int x0 = 20;
	int y = d.ly - 1 - 10;

	int x = x0;

	m_setupLabel->setGeometry(x, y - 15, x + 100, y);
	m_setupTextField->setGeometry(x + 104, y - 15, x + 650, y);
	m_setupBrowseBtn->setGeometry(x + 660, y - 15, x + 680, y);

	y -= 60;

	m_chunkSizeLabel->setGeometry(x, y - 15, x + 100, y);
	m_chunkSize->setGeometry(x + 110, y - 15, x + 156, y);

	y -= 40;

	m_fromLabel->setGeometry(x, y - 15, x + 50, y);
	m_from->setGeometry(x + 54, y - 15, x + 100, y);
	x += 120;

	m_toLabel->setGeometry(x, y - 15, x + 80, y);
	m_to->setGeometry(x + 84, y - 15, x + 130, y);
	x += 150;

	m_stepLabel->setGeometry(x, y - 15, x + 80, y);
	m_step->setGeometry(x + 84, y - 15, x + 130, y);

	///
	x = x0;
	y -= 40;

	m_shrinkLabel->setGeometry(x, y - 15, x + 50, y);
	m_shrink->setGeometry(x + 54, y - 15, x + 100, y);
	x += 120;

	m_renderTileLabel->setGeometry(x, y - 15, x + 80, y);
	m_renderTile->setGeometry(x + 84, y - 15, x + 130, y);
	x += 150;

	m_memChunkLabel->setGeometry(x, y - 15, x + 80, y);
	m_memChunk->setGeometry(x + 84, y - 15, x + 130, y);

	x = x0;
	y -= 40;

	m_subPixelMoveLabel->setGeometry(x, y - 15, x + 94, y);
	m_subPixelMove->setGeometry(x + 98, y - 15, x + 160, y);
	x += 180;

	m_processingLabel->setGeometry(x, y - 15, x + 74, y);
	m_processing->setGeometry(x + 78, y - 15, x + 140, y);
	x += 160;

	m_resampleQualityLabel->setGeometry(x, y - 15, x + 114, y);
	m_resampleQuality->setGeometry(x + 118, y - 15, x + 200, y);

	x = x0;
	y -= 40;

	m_focus->setGeometry(x, y - 15, x + 90, y);
	x += 120;
	m_noOverwrite->setGeometry(x, y - 15, x + 80, y);
	x += 110;
	m_multimedia->setGeometry(x, y - 15, x + 80, y);
	x += 90;
	m_column->setGeometry(x, y - 15, x + 20, y);
	x += 30;
	m_lineart->setGeometry(x, y - 15, x + 60, y);
	x += 65;
	m_edgeAliasing->setGeometry(x, y - 15, x + 80, y);
	x += 90;
	m_thickness->setGeometry(x, y - 15, x + 30, y);
	x += 50;
	m_gamma->setGeometry(x, y - 15, x + 60, y);
	x += 70;
	m_gammaValue->setGeometry(x, y - 15, x + 30, y);

	x = x0;
	y -= 40;

	m_clap->setGeometry(x, y - 15, x + 90, y);
	/*
  x += 120;
  m_outputScriptLabel->setGeometry(x, y-15, x+94, y);
  m_outputScript->setGeometry(x+98, y-15, x+160, y);
  x +=180;

  m_entryPointLabel->setGeometry(x, y-15, x+94, y);
  m_entryPoint->setGeometry(x+98, y-15, x+160, y);
  */
}

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

void CasmConfigPanel::setTask(CasmTask *task)
{
	m_task = task;

	m_chunkSize->setValue(m_task->m_taskChunksize);
	m_from->setValue(m_task->m_start);
	m_to->setValue(m_task->m_end);
	m_step->setValue(m_task->m_step);

	m_shrink->setValue(m_task->m_reduction);
	m_renderTile->setValue(m_task->m_renderTile);
	m_memChunk->setValue(m_task->m_memChunk);

	string move;
	if (m_task->m_moveType == CasmTask::M_INTMOVE)
		move = "None";
	else if (m_task->m_moveType == CasmTask::M_BG_FRACMOVE)
		move = "RGB";
	else
		move = "All";
	m_subPixelMove->setText(move);

	string bits;
	if (m_task->m_prec == 32)
		bits = "32 Bit";
	else
		bits = "64 Bit";
	m_processing->setText(bits);

	string quality = "";
	if (m_task->m_restype == CasmTask::RES_TYPE_STANDARD)
		quality = "Standard";
	else if (m_task->m_restype == CasmTask::RES_TYPE_IMPROVED)
		quality = "Improved";
	else if (m_task->m_restype == CasmTask::RES_TYPE_HIGH)
		quality = "High";
	m_resampleQuality->setText(quality);

	m_focus->select(m_task->m_cf);
	m_noOverwrite->select(m_task->m_noOverwrite);
	m_multimedia->select(m_task->m_multimedia);

	if (m_task->m_numColumn < 0)
		m_column->setText("All");
	else
		m_column->setText(toString(m_task->m_numColumn));

	if (m_task->m_lineart < 0) {
		m_lineart->disable();
		m_lineart->select(false);
	} else {
		m_lineart->enable();
		m_lineart->select(true);
	}

	if (m_task->m_edgeAliasing < 0) {
		m_edgeAliasing->disable();
		m_edgeAliasing->select(false);
	} else {
		m_edgeAliasing->enable();
		m_edgeAliasing->select(true);
	}
	if (m_task->m_edgeAliasing >= 0 || m_task->m_lineart >= 0)
		m_thickness->setValue(tmax(m_task->m_edgeAliasing, m_task->m_lineart));
	else
		m_thickness->setValue(8);

	if (m_task->m_gamma < 0.) {
		m_gamma->select(false);
		m_gammaValue->setValue(0.0);
		m_gammaValue->disable();
	} else {
		m_gamma->select(true);
		m_gammaValue->setValue(m_task->m_gamma);
		m_gammaValue->enable();
	}
}

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

CasmTask *CasmConfigPanel::getTask() const
{
	return m_task;
}

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

void CasmConfigPanel::onNumField(double v, int type)
{
	switch (type) {
	case M_FROM:
		m_task->m_start = (int)v;
		break;
	case M_TO:
		m_task->m_end = (int)v;
		break;
	case M_STEP:
		m_task->m_step = (int)v;
		break;
	case M_SHRINK:
		m_task->m_reduction = (int)v;
		break;
	case M_RTILE:
		m_task->m_renderTile = (int)v;
		break;
	case M_MCHUNK:
		m_task->m_memChunk = (int)v;
		break;
	case M_THICK:
		if (m_lineart->isSelected())
			m_task->m_lineart = (int)v;
		if (m_edgeAliasing->isSelected())
			m_task->m_edgeAliasing = (int)v;
		break;
	case M_GAMMA:
		m_task->m_gamma = v;
		break;
	case M_CHUNKSIZE:
		m_task->m_taskChunksize = (int)v;
		break;
	}
}

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

void CasmConfigPanel::onColumnField(std::wstring value)
{
	if (value == toWideString("") ||
		value == toWideString("ALL") ||
		value == toWideString("All") ||
		value == toWideString("all") ||
		value == toWideString("AL") ||
		value == toWideString("Al") ||
		value == toWideString("a") ||
		value == toWideString("A"))
		m_task->m_numColumn = -1;
	else if (is_num(toString(value)))
		m_task->m_numColumn = atoi(toString(value).c_str());
	else {
		m_task->m_numColumn = -1;
		m_column->setText("All");
		TMessage::error("Only \"All\" or a number is a valid argument");
	}
}

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

void CasmConfigPanel::browseSetupFiles()
{
	static FileBrowserPopup *popup = 0;

	if (!popup) {
		CasmConfigPanel *csp = this;
		vector<string> fileTypes;
		fileTypes.push_back("setup");
		popup = new FileBrowserPopup(csp, fileTypes);

		popup->setOkAction(
			new TFileBrowserPopupAction<CasmConfigPanel>(csp, &CasmConfigPanel::loadSetup));
	}

	if (!popup)
		return;

	TFilePath fp = Application::instance()->getCurrentFolder();
	if (fp != TFilePath())
		popup->setCurrentDir(fp);

	TDimension d = TMainshell::getMainshell()->getSize();
#ifdef WIN32
	HDC hdc = GetDC(0);
	d.lx = GetDeviceCaps(hdc, HORZRES);
	d.ly = GetDeviceCaps(hdc, VERTRES);
	ReleaseDC(0, hdc);
#endif

	d -= popup->getSize();
	//TDimension d = TMainshell::getMainshell()->getSize() - popup->getSize();
	popup->popup(TPoint(d.lx / 2, d.ly / 2));
	popup->setCaption("Load Setup");
}

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

void CasmConfigPanel::loadSetup(const TFilePath &fp)
{
	if (!TFileStatus(fp).doesExist()) {
		string msg = toString(fp.getWideString()) + "\n";
		msg += "File not found\n";
		msg += "Please verify that the path and file name are correct";
		m_setupTextField->setText("");
		TMessage::error(msg);
		return;
	}
	Application::instance()->setCurrentFolder(fp.getParentDir());

	string uncString = convertToUncString(fp);

	m_setupTextField->setText(uncString);

#ifdef WIN32
	int x = uncString.find("\\", 2);
	while (x != string::npos) {
		uncString.replace(x, 1, "/", 0, 1);
		x = uncString.find("\\", x + 1);
	}
#endif

	m_task->m_setupFile = uncString;
}

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

void CasmConfigPanel::onMultimedia(TCheckBox *box, bool on)
{
	if (on) {
		m_task->m_multimedia = true;
		m_column->enable();
		m_lineart->enable();
		m_edgeAliasing->enable();
		if (m_lineart->isSelected() || m_edgeAliasing->isSelected())
			m_thickness->enable();
		else
			m_thickness->disable();
	} else {
		m_task->m_multimedia = false;
		m_column->disable();
		m_lineart->disable();
		m_lineart->select(false);
		m_edgeAliasing->disable();
		m_edgeAliasing->select(false);
		m_thickness->setValue(8);
		m_thickness->disable();
		m_task->m_lineart = m_task->m_edgeAliasing = -1;
	}
}

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

void CasmConfigPanel::onLineart(TCheckBox *box, bool on)
{
	if (on) {
		m_task->m_lineart = (int)m_thickness->getValue();
		m_task->m_edgeAliasing = -1;
		m_lineart->enable();
		m_edgeAliasing->disable();
		m_thickness->enable();
	} else {
		m_task->m_lineart = -1;
		m_lineart->enable();
		m_edgeAliasing->enable();
		m_thickness->disable();
	}
}

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

void CasmConfigPanel::onEdgeAliasing(TCheckBox *box, bool on)
{
	if (on) {
		m_task->m_edgeAliasing = (int)m_thickness->getValue();
		m_task->m_lineart = -1;
		m_lineart->disable();
		m_edgeAliasing->enable();
		m_thickness->enable();
	} else {
		m_task->m_edgeAliasing = -1;
		m_lineart->enable();
		m_edgeAliasing->enable();
		m_thickness->disable();
	}
}

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

void CasmConfigPanel::onConstantFocus(TCheckBox *box, bool on)
{
	m_task->m_cf = on;
}

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

void CasmConfigPanel::onOverwrite(TCheckBox *box, bool on)
{
	m_task->m_noOverwrite = on;
}

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

void CasmConfigPanel::onGamma(TCheckBox *box, bool on)
{
	if (on)
		m_task->m_gamma = m_gammaValue->getValue();
	else
		m_task->m_gamma = -1.;
}

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

void CasmConfigPanel::onSubPixelMove(string move)
{
	if (move == "None")
		m_task->m_moveType = CasmTask::M_INTMOVE;
	else if (move == "RGB")
		m_task->m_moveType = CasmTask::M_BG_FRACMOVE;
	else
		m_task->m_moveType = CasmTask::M_FRACMOVE;
}

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

void CasmConfigPanel::onProcessing(string bits)
{
	if (bits == "32 Bit")
		m_task->m_prec = 32;
	else
		m_task->m_prec = 64;
}

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

void CasmConfigPanel::onResampleQuality(string quality)
{
	if (quality == "Standard")
		m_task->m_restype = CasmTask::RES_TYPE_STANDARD;
	else if (quality == "Improved")
		m_task->m_restype = CasmTask::RES_TYPE_IMPROVED;
	else if (quality == "High")
		m_task->m_restype = CasmTask::RES_TYPE_HIGH;
	else
		m_task->m_restype = CasmTask::RES_TYPE_NONE;
}