936 lines
26 KiB
C++
936 lines
26 KiB
C++
|
|
|
|
#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;
|
|
}
|