bool FileType::operator==(const FileType &pFileType) const
{
// Return whether the current item is equal to the given one
return !mMimeType.compare(pFileType.mimeType())
&& !mFileExtension.compare(pFileType.fileExtension());
}
void ConsoleTools::profile(int loopCount){
clock_t msecs;
// parsers factory
ParserFactory pf(catalogPath);
// Source file text lines store.
TextLinesStore textLinesStore;
textLinesStore.loadFile(inputFileName, inputEncoding, true);
// Base editor to make primary parse
BaseEditor baseEditor(&pf, &textLinesStore);
// HRD RegionMapper linking
baseEditor.setRegionMapper(&DString("console"), hrdName);
FileType *type = selectType(pf.getHRCParser(), &textLinesStore);
type->getBaseScheme();
baseEditor.setFileType(type);
msecs = clock();
while(loopCount--){
baseEditor.modifyLineEvent(0);
baseEditor.lineCountEvent(textLinesStore.getLineCount());
baseEditor.validate(-1, false);
}
msecs = clock() - msecs;
printf("%ld\n", (msecs*1000)/CLOCKS_PER_SEC );
}
bool FileGroup::AddFile(const FileType &NewFile)
// Never will there be duplicate files within a FileGroup...
// It is just not gonna be allowed by definition.
{
if (NewFile.IsValid())
{
if (!binary_search(myFiles.begin(), myFiles.end(), NewFile))
{
myFiles.insert(lower_bound(myFiles.begin(), myFiles.end(), NewFile),
NewFile);
}
else
{
// If the filenames are the same, then check to see which one is bigger (filesize-wise)
// and keep that one.
FileIter FileIter = lower_bound(myFiles.begin(), myFiles.end(), NewFile);
if (NewFile.GiveFileSize() > FileIter->GiveFileSize())
{
// The NewFile's filesize is larger than the one I already have. Replace it!
*FileIter = NewFile;
}
}
return(true);
}
else
{
return(false);
}
}
void ConsoleTools::listTypes(bool load, bool useNames){
Writer *writer = null;
try{
writer = new StreamWriter(stdout, outputEncodingIndex, bomOutput);
ParserFactory pf(catalogPath);
HRCParser *hrcParser = pf.getHRCParser();
fprintf(stderr, "\nloading file types...\n");
for(int idx = 0;; idx++){
FileType *type = hrcParser->enumerateFileTypes(idx);
if (type == null) break;
if (useNames){
writer->write(StringBuffer(type->getName())+"\n");
}else{
if (type->getGroup() != null){
writer->write(StringBuffer(type->getGroup()) + ": ");
}
writer->write(type->getDescription());
writer->write(DString("\n"));
}
if (load) type->getBaseScheme();
}
delete writer;
}catch(Exception &e){
delete writer;
fprintf(stderr, "%s\n", e.getMessage()->getChars());
}
}
FileType *ColorerFilter::selectType(HRCParser *hrcParser, String *fline)
{
FileType *type = null;
if (typeDescription != null) {
type = hrcParser->getFileType(typeDescription);
if (type == null) {
for(int idx = 0;; idx++)
{
type = hrcParser->enumerateFileTypes(idx);
if (type == null) {
break;
}
if (type->getDescription() != null &&
type->getDescription()->length() >= typeDescription->length() &&
DString(type->getDescription(), 0, typeDescription->length()).equalsIgnoreCase(typeDescription)) {
break;
}
if (type->getName()->length() >= typeDescription->length() &&
DString(type->getName(), 0, typeDescription->length()).equalsIgnoreCase(typeDescription)) {
break;
}
type = null;
}
}
}
if (typeDescription == null || type == null) {
type = hrcParser->chooseFileType(inputFileName, fline, 0);
}
return type;
}
FileType *ConsoleTools::selectType(HRCParser *hrcParser, LineSource *lineSource){
FileType *type = null;
if (typeDescription != null){
type = hrcParser->getFileType(typeDescription);
if (type == null){
for(int idx = 0;; idx++){
type = hrcParser->enumerateFileTypes(idx);
if (type == null) break;
if (type->getDescription() != null &&
type->getDescription()->length() >= typeDescription->length() &&
DString(type->getDescription(), 0, typeDescription->length()).equalsIgnoreCase(typeDescription))
break;
if (type->getName()->length() >= typeDescription->length() &&
DString(type->getName(), 0, typeDescription->length()).equalsIgnoreCase(typeDescription))
break;
type = null;
}
}
}
if (typeDescription == null || type == null){
StringBuffer textStart;
int totalLength = 0;
for(int i = 0; i < 4; i++){
String *iLine = lineSource->getLine(i);
if (iLine == null) break;
textStart.append(iLine);
textStart.append(DString("\n"));
totalLength += iLine->length();
if (totalLength > 500) break;
}
type = hrcParser->chooseFileType(inputFileName, &textStart, 0);
}
return type;
}
FileType *BaseEditor::chooseFileType(const String *fileName)
{
if (lineSource == null)
{
currentFileType = hrcParser->chooseFileType(fileName, null);
}
else
{
int chooseStr=CHOOSE_STR, chooseLen=CHOOSE_LEN;
DString dsd("default");
FileType *def = hrcParser->getFileType(&dsd);
if(def)
{
chooseStr = def->getParamValueInt(DString("firstlines"), chooseStr);
chooseLen = def->getParamValueInt(DString("firstlinebytes"), chooseLen);
}
currentFileType = chooseFileTypeCh(fileName, chooseStr, chooseLen);
}
setFileType(currentFileType);
return currentFileType;
}
void loadInitialMaps_(vector<MapType>& maps, StringList& ins,
FileType& input_file)
{
// custom progress logger for this task:
ProgressLogger progresslogger;
progresslogger.setLogType(TOPPMapAlignerBase::log_type_);
progresslogger.startProgress(0, ins.size(), "loading input files");
for (Size i = 0; i < ins.size(); ++i)
{
progresslogger.setProgress(i);
input_file.load(ins[i], maps[i]);
}
progresslogger.endProgress();
}
bool FileInfo::IsImageFile(FileType fileType)
{
switch(fileType.ToInt())
{
case FileType::jpeg.IntValue:
case FileType::png.IntValue:
case FileType::pvr.IntValue:
case FileType::gif.IntValue:
return true;
default:
return false;
}
}
void storeTransformedMaps_(vector<MapType>& maps, StringList& outs,
FileType& output_file)
{
// custom progress logger for this task:
ProgressLogger progresslogger;
progresslogger.setLogType(log_type_);
progresslogger.startProgress(0, outs.size(), "writing output files");
for (Size i = 0; i < outs.size(); ++i)
{
progresslogger.setProgress(i);
// annotate output with data processing info:
addDataProcessing_(maps[i],
getProcessingInfo_(DataProcessing::ALIGNMENT));
output_file.store(outs[i], maps[i]);
}
progresslogger.endProgress();
}
template<class FileType> void ZMO::init(FileType& file) {
char buf[0x10] = { 0x00 };
file.readStringWithGivenLength(8, buf);
if (_stricmp("ZMO0002", buf))
return;
this->animationInfo.framesPerSecond = static_cast<word_t>(file.read<dword_t>());
this->animationInfo.framesInTotal = static_cast<word_t>(file.read<dword_t>())+1;
this->animationInfo.defaultTime = static_cast<word_t>(static_cast<float>(this->animationInfo.framesInTotal) / static_cast<float>(this->animationInfo.framesPerSecond) * 1000);
//last 4 bytes are the ZMO-version type (e.g. 3ZMO)
//The previous 10 bytes: an offset or anything of the sorts seems to be hiddin in there.
file.setPosition(file.getTotalSize() - 14 - sizeof(word_t)*this->animationInfo.framesInTotal);
#ifdef __ROSE_ZMO_OUTPUT__
std::cout << "[" << this->filePath.c_str() << "] Total time: " << this->animationInfo.defaultTime << "\n";
#endif
word_t *newContent = new word_t[this->animationInfo.framesInTotal];
for (unsigned int i = 0; i < this->animationInfo.framesInTotal; i++) {
word_t currentType = file.read<word_t>();
newContent[i] = currentType;
if (i > 0 && (currentType >= 21 && currentType <= 29)) { //Dunno what this means, but it seems to be a valid indicator?
/* current frame - 3, because the server may need up to 100ms to perform the actual action.
(3 * (1000ms / 30FPS) = 100ms -> the offset we need.
*/
float percentage = static_cast<float>(i-3) / static_cast<float>(this->animationInfo.framesInTotal);
ZMO::TimingInfo::Frame newFrame;
dword_t storedPosition = file.getPosition();
file.setPosition(storedPosition - sizeof(word_t)*3);
newFrame.motionType = file.read<word_t>();
file.setPosition(storedPosition);
newFrame.timeToReach = static_cast<word_t>(percentage * this->animationInfo.defaultTime);
this->timingInfo.attacksAtFrames.insert(std::pair<word_t, ZMO::TimingInfo::Frame>(i - 3, newFrame));
#ifdef __ROSE_ZMO_OUTPUT__
auto it = this->timingInfo.attacksAtFrames.at(i - 3);
std::cout << "Found attackPattern at " << percentage * 100.0f << "%\t| " << it.timeToReach << "ms\n";
#endif
}
}
this->content.init(newContent, this->animationInfo.framesInTotal);
delete[] newContent;
newContent = nullptr;
this->animationInfo.framesInTotal--;
#ifdef __ROSE_ZMO_OUTPUT__
std::cout << "\n";
#endif
}
void
SessionImpl::RegisterFileType (/*[in]*/ FileType fileType,
/*[in]*/ const char * lpszFileType,
/*[in]*/ const char * lpszApplication,
/*[in]*/ const char * lpszFileNameExtensions,
/*[in]*/ const char * lpszAlternateExtensions,
/*[in]*/ const char * lpszDefaultSearchPath,
/*[in]*/ const char * lpszEnvVarNames)
{
MIKTEX_ASSERT_STRING (lpszFileType);
MIKTEX_ASSERT_STRING_OR_NIL (lpszApplication);
InternalFileTypeInfo fti;
fti.fileType = fileType;
fti.fileTypeString = lpszFileType;
if (lpszApplication != 0)
{
fti.applicationName = lpszApplication;
}
string section = "ft.";
section += lpszFileType;
fti.fileNameExtensions =
GetConfigValue(section.c_str(),
"extensions",
lpszFileNameExtensions );
fti.alternateExtensions = GetConfigValue(section.c_str(),
"alternate_extensions",
lpszAlternateExtensions == 0 ? "" : lpszAlternateExtensions);
fti.searchPath =
GetConfigValue(section.c_str(),
"path",
lpszDefaultSearchPath);
fti.envVarNames =
GetConfigValue(section.c_str(),
"env",
lpszEnvVarNames);
fileTypes.resize (FileType::E_N_D);
fileTypes[fileType.Get()] = fti;
}
void NewFileChooser::setFileTypes(QPtrList<FileType> filetypes) {
for(FileType * filetype = filetypes.first();
filetype;
filetype=filetypes.next()) {
if (filetype->enabled()) {
if (filetype->subtypes().count()==0)
addType(filetype);
QPtrList<FileType> subtypes = filetype->subtypes();
for(FileType * subtype = subtypes.first();
subtype;
subtype=subtypes.next()) {
if (subtype->enabled())
addType(subtype);
}
}
}
}
void FarEditor::reloadTypeSettings()
{
FileType *ftype = baseEditor->getFileType();
HRCParser *hrcParser = parserFactory->getHRCParser();
FileType *def = hrcParser->getFileType(&DString("default"));
if (def == null){
throw Exception(DString("No 'default' file type found"));
}
int backparse = 2000;
UnicodeTools::getNumber(def->getParamValue(DString("backparse")), &backparse);
UnicodeTools::getNumber(def->getParamValue(DString("maxlinelength")), &maxLineLength);
UnicodeTools::getNumber(def->getParamValue(DString("default-fore")), &newfore);
UnicodeTools::getNumber(def->getParamValue(DString("default-back")), &newback);
const String *value;
value = def->getParamValue(DString("fullback"));
if (value != null && value->equals("no")) fullBackground = false;
value = def->getParamValue(DString("show-cross"));
if (value != null && value->equals("none")){
showHorizontalCross = false;
showVerticalCross = false;
};
if (value != null && value->equals("vertical")){
showHorizontalCross = false;
showVerticalCross = true;
};
if (value != null && value->equals("horizontal")){
showHorizontalCross = true;
showVerticalCross = false;
};
if (value != null && value->equals("both")){
showHorizontalCross = true;
showVerticalCross = true;
};
value = def->getParamValue(DString("cross-zorder"));
if (value != null && value->equals("top")) crossZOrder = 1;
// installs custom file properties
UnicodeTools::getNumber(ftype->getParamValue(DString("backparse")), &backparse);
UnicodeTools::getNumber(ftype->getParamValue(DString("maxlinelength")), &maxLineLength);
UnicodeTools::getNumber(ftype->getParamValue(DString("default-fore")), &newfore);
UnicodeTools::getNumber(ftype->getParamValue(DString("default-back")), &newback);
value = ftype->getParamValue(DString("fullback"));
if (value != null && value->equals("no")) fullBackground = false;
value = ftype->getParamValue(DString("show-cross"));
if (value != null && value->equals("none")){
showHorizontalCross = false;
showVerticalCross = false;
};
if (value != null && value->equals("vertical")){
showHorizontalCross = false;
showVerticalCross = true;
};
if (value != null && value->equals("horizontal")){
showHorizontalCross = true;
showVerticalCross = false;
};
if (value != null && value->equals("both")){
showHorizontalCross = true;
showVerticalCross = true;
};
value = ftype->getParamValue(DString("cross-zorder"));
if (value != null && value->equals("top")) crossZOrder = 1;
baseEditor->setBackParse(backparse);
}
bool
SessionImpl::TryCreateFile (/*[in]*/ const char * lpszFileName,
/*[in]*/ FileType fileType)
{
CommandLineBuilder commandLine;
PathName makeUtility;
char szBasename[BufferSizes::MaxPath];
PathName::Split (lpszFileName, 0, 0, szBasename, BufferSizes::MaxPath, 0, 0);
switch (fileType.Get())
{
case FileType::BASE:
case FileType::FMT:
if (! FindFile(MIKTEX_INITEXMF_EXE, FileType::EXE, makeUtility))
{
FATAL_MIKTEX_ERROR ("SessionImpl::TryCreateFile",
T_("The MiKTeX configuration utility could not be found."),
0);
}
commandLine.AppendOption ("--dump-by-name=", szBasename);
if (fileType == FileType::FMT)
{
commandLine.AppendOption ("--engine=", GetEngine());
}
break;
case FileType::TFM:
if (! FindFile(MIKTEX_MAKETFM_EXE, FileType::EXE, makeUtility))
{
FATAL_MIKTEX_ERROR ("SessionImpl::TryCreateFile",
T_("The MakeTFM utility could not be found."),
0);
}
commandLine.AppendOption ("-v");
commandLine.AppendArgument (szBasename);
break;
default:
return (false);
}
const size_t BUF_SIZE = 50000;
char * szBuf = reinterpret_cast<char*>(malloc(BUF_SIZE));
if (szBuf == 0)
{
OUT_OF_MEMORY ("malloc");
}
AutoMemoryPointer xxx (szBuf);
size_t size = BUF_SIZE;
int exitCode;
if (! Process::Run(makeUtility,
commandLine.Get(),
szBuf,
&size,
&exitCode))
{
return (false);
}
if (exitCode != 0)
{
TraceError (T_("Make failed; output follows"));
TraceError ("%.*s", static_cast<int>(size), szBuf);
return (false);
}
return (true);
}
void FileType::setSubtypesEnabled(bool enabled) {
for(FileType * subtype = m_subtypes.first();
subtype;subtype=m_subtypes.next())
subtype->setEnabled(enabled);
}
const bool operator ==(const FileType& file, const std::wstring& type)
{
return file.RelationType() == type;
}
const bool operator ==(const std::wstring& type, const FileType& file)
{
return type == file.RelationType();
}
void ConsoleTools::genOutput(bool useTokens){
try{
// Source file text lines store.
TextLinesStore textLinesStore;
textLinesStore.loadFile(inputFileName, inputEncoding, true);
// parsers factory
ParserFactory pf(catalogPath);
// HRC loading
HRCParser *hrcParser = pf.getHRCParser();
// HRD RegionMapper creation
bool useMarkup = false;
RegionMapper *mapper = null;
if (!useTokens){
try{
mapper = pf.createStyledMapper(&DString("rgb"), hrdName);
}catch(ParserFactoryException &){
useMarkup = true;
mapper = pf.createTextMapper(hrdName);
}
}
// Base editor to make primary parse
BaseEditor baseEditor(&pf, &textLinesStore);
// Using compact regions
baseEditor.setRegionCompact(true);
baseEditor.setRegionMapper(mapper);
baseEditor.lineCountEvent(textLinesStore.getLineCount());
// Choosing file type
FileType *type = selectType(hrcParser, &textLinesStore);
baseEditor.setFileType(type);
// writing result into HTML colored stream...
const RegionDefine *rd = null;
if (mapper != null) rd = baseEditor.rd_def_Text;
Writer *escapedWriter = null;
Writer *commonWriter = null;
try{
if (outputFileName != null) commonWriter = new FileWriter(outputFileName, outputEncodingIndex, bomOutput);
else commonWriter = new StreamWriter(stdout, outputEncodingIndex, bomOutput);
if (htmlEscaping) escapedWriter = new HtmlEscapesWriter(commonWriter);
else escapedWriter = commonWriter;
}catch(Exception &e){
fprintf(stderr, "can't open file '%s' for writing:\n", outputFileName->getChars());
fprintf(stderr, e.getMessage()->getChars());
return;
}
if (htmlWrapping && useTokens){
commonWriter->write(DString("<html>\n<head>\n<style></style>\n</head>\n<body><pre>\n"));
}else if (htmlWrapping && rd != null){
if (useMarkup){
commonWriter->write(TextRegion::cast(rd)->stext);
}else{
commonWriter->write(DString("<html><body style='"));
ParsedLineWriter::writeStyle(commonWriter, StyledRegion::cast(rd));
commonWriter->write(DString("'><pre>\n"));
}
}
if (copyrightHeader){
commonWriter->write(DString("Created with colorer-take5 library. Type '"));
commonWriter->write(type->getName());
commonWriter->write(DString("'\n\n"));
}
int lni = 0;
int lwidth = 1;
int lncount = textLinesStore.getLineCount();
for(lni = lncount/10; lni > 0; lni = lni/10, lwidth++);
for(int i = 0; i < lncount; i++){
if (lineNumbers){
int iwidth = 1;
for(lni = i/10; lni > 0; lni = lni/10, iwidth++);
for(lni = iwidth; lni < lwidth; lni++) commonWriter->write(0x0020);
commonWriter->write(SString(i));
commonWriter->write(DString(": "));
}
if (useTokens){
ParsedLineWriter::tokenWrite(commonWriter, escapedWriter, docLinkHash, textLinesStore.getLine(i), baseEditor.getLineRegions(i));
}else if (useMarkup){
ParsedLineWriter::markupWrite(commonWriter, escapedWriter, docLinkHash, textLinesStore.getLine(i), baseEditor.getLineRegions(i));
}else{
ParsedLineWriter::htmlRGBWrite(commonWriter, escapedWriter, docLinkHash, textLinesStore.getLine(i), baseEditor.getLineRegions(i));
}
commonWriter->write(DString("\n"));
}
if (htmlWrapping && useTokens){
commonWriter->write(DString("</pre></body></html>\n"));
}else if (htmlWrapping && rd != null){
if (useMarkup){
commonWriter->write(TextRegion::cast(rd)->etext);
}else{
commonWriter->write(DString("</pre></body></html>\n"));
}
}
if (htmlEscaping) delete commonWriter;
delete escapedWriter;
delete mapper;
}catch(Exception &e){
fprintf(stderr, "%s\n", e.getMessage()->getChars());
}catch(...){
fprintf(stderr, "unknown exception ...\n");
}
}
void
SessionImpl::RegisterFileType (/*[in]*/ FileType fileType)
{
if (fileType.Get() >= fileTypes.size())
{
fileTypes.resize (FileType::E_N_D);
}
if (fileTypes[fileType.Get()].fileType == fileType.Get())
{
// already registered
return;
}
switch (fileType.Get())
{
case FileType::AFM:
RegisterFileType (
FileType::AFM,
"afm",
0,
".afm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_AFM_DIR)),
P2_("AFMFONTS", "TEXFONTS"));
break;
case FileType::BASE:
RegisterFileType (
FileType::BASE,
"base",
"METAFONT",
".base",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_BASE_DIR)),
"");
break;
case FileType::BIB:
RegisterFileType (
FileType::BIB,
"bib",
"BibTeX",
".bib",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib")),
P2_("BIBINPUTS", "TEXBIB"));
break;
case FileType::BST:
RegisterFileType (
FileType::BST,
"bst",
"BibTeX",
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{bst,csf}")),
"BSTINPUTS");
break;
case FileType::CID:
RegisterFileType (
FileType::CID,
"cid maps",
0,
P2_(".cid", ".cidmap"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CIDMAP_DIR)),
"FONTCIDMAPS");
break;
case FileType::CLUA:
RegisterFileType (
FileType::CLUA,
"clua",
0,
P2_(".dll", ".so"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/lua")),
"CLUAINPUTS");
break;
case FileType::CNF:
RegisterFileType (
FileType::CNF,
"cnf",
0,
".cnf",
S_(MIKTEX_PATH_WEB2C_DIR),
"TEXMFCNF");
break;
case FileType::CMAP:
RegisterFileType (
FileType::CMAP,
"cmap files",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CMAP_DIR)),
P2_("CMAPFONTS", "TEXFONTS"));
break;
case FileType::CWEB:
RegisterFileType (
FileType::CWEB,
"cweb",
"CWeb",
".w",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_CWEB_DIR)),
"CWEBINPUTS");
break;
case FileType::DB:
RegisterFileType (
FileType::DB,
"ls-R",
0,
"",
"",
"TEXMFDBS");
break;
case FileType::DVI:
RegisterFileType (
FileType::DVI,
"dvi",
0,
".dvi",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_DOC_DIR)),
"");
break;
case FileType::DVIPSCONFIG:
RegisterFileType (
FileType::DVIPSCONFIG,
"dvips config",
"Dvips",
"",
R_(MIKTEX_PATH_DVIPS_DIR),
"TEXCONFIG");
break;
case FileType::ENC:
RegisterFileType (
FileType::ENC,
"enc",
0,
".enc",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("ENCFONTS", "TEXFONTS"));
break;
case FileType::EXE:
#if defined(MIKTEX_WINDOWS)
case FileType::WindowsCommandScriptFile:
#endif
{
string extensions;
#if defined(MIKTEX_WINDOWS)
if (! Utils::GetEnvironmentString("PATHEXT", extensions)
|| extensions.empty())
{
extensions = P3_(".com",".exe", ".bat");
}
#elif defined(MIKTEX_EXE_FILE_SUFFIX)
extensions = MIKTEX_EXE_FILE_SUFFIX;
#endif
string exePath;
PathName userBinDir = GetSpecialPath(SpecialPath::UserInstallRoot);
userBinDir += MIKTEX_PATH_BIN_DIR;
userBinDir.Canonicalize ();
if (! IsAdminMode()
&& ! Utils::Contains(exePath.c_str(),
userBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += userBinDir.Get();
}
PathName commonBinDir = GetSpecialPath(SpecialPath::CommonInstallRoot);
commonBinDir += MIKTEX_PATH_BIN_DIR;
commonBinDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
commonBinDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += commonBinDir.Get();
}
string str;
if (Utils::GetEnvironmentString(MIKTEX_ENV_BIN_DIR, str))
{
PathName binDir = str;
binDir.Canonicalize ();
if (! Utils::Contains(exePath.c_str(),
binDir.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += binDir.Get();
}
}
PathName myLocation = GetMyLocation(true);
if (! Utils::Contains(exePath.c_str(),
myLocation.Get(),
PATH_DELIMITER_STRING))
{
if (! exePath.empty())
{
exePath += PATH_DELIMITER;
}
exePath += myLocation.Get();
}
if (fileType.Get() == FileType::EXE)
{
RegisterFileType (
FileType::EXE,
"exe",
0,
extensions.c_str(),
exePath.c_str(),
"");
}
#if defined(MIKTEX_WINDOWS)
else if (fileType.Get() == FileType::WindowsCommandScriptFile)
{
RegisterFileType (
FileType::WindowsCommandScriptFile,
"Windows command script file",
0,
P2_(".bat", ".cmd"),
P_(R_(MIKTEX_PATH_SCRIPT_DIR), exePath.c_str()),
"");
}
#endif
break;
}
case FileType::FEA:
RegisterFileType (
FileType::FEA,
"font feature files",
0,
".fea",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_FEATURE_DIR)),
"FONTFEATURES");
break;
case FileType::FMT:
RegisterFileType (
FileType::FMT,
"fmt",
"TeX",
".fmt",
P2_(CURRENT_DIRECTORY, s_(MIKTEX_PATH_FMT_DIR "/{$engine,}")),
"");
break;
case FileType::GF:
RegisterFileType (
FileType::GF,
"gf",
0,
".gf",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// <todo/>
P3_("GFFONTS", "GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GLYPHFONT:
RegisterFileType (
FileType::GLYPHFONT,
"bitmap font",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
P2_("GLYPHFONTS", "TEXFONTS"));
break;
case FileType::GRAPHICS:
RegisterFileType (
FileType::GRAPHICS,
"graphic/figure",
0,
P3_(".eps", ".epsi",".png"),
P4_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
P2_("TEXPICTS", "TEXINPUTS"));
break;
case FileType::HBF:
RegisterFileType (
FileType::HBF,
"hbf",
0,
".hbf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_HBF_DIR),
R_(MIKTEX_PATH_TYPE1_DIR)),
"");
break;
case FileType::IST:
RegisterFileType (
FileType::IST,
"ist",
"MakeIndex",
".ist",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MAKEINDEX_DIR)),
P2_("TEXINDEXSTYLE", "INDEXSTYLE"));
break;
case FileType::LIG:
RegisterFileType (
FileType::LIG,
"lig files",
0,
".lig",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_LIG_DIR)),
"TEXFONTS");
break;
case FileType::LUA:
RegisterFileType (
FileType::LUA,
"lua",
0,
P7_(".lua", ".luatex", ".luc", ".luctex", ".texlua", ".texluc", ".tlu"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}/{lua,}"),
GetFileTypeInfo(FileType::TEX).searchPath.c_str()),
"LUAINPUTS");
break;
case FileType::MAP:
RegisterFileType (
FileType::MAP,
"map",
0,
".map",
P6_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MAP_DIR "/{$progname,pdftex,dvips,}"),
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR)),
P2_("TEXFONTMAPS", "TEXFONTS"));
break;
case FileType::MEM:
RegisterFileType (
FileType::MEM,
"mem",
"MetaPost",
".mem",
CURRENT_DIRECTORY,
"");
break;
case FileType::MF:
RegisterFileType (
FileType::MF,
"mf",
"METAFONT",
".mf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_METAFONT_DIR),
R_(MIKTEX_PATH_FONT_SOURCE_DIR)),
"MFINPUTS");
break;
case FileType::MFPOOL:
RegisterFileType (
FileType::MFPOOL,
"mfpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MFPOOL", "TEXMFINI"));
break;
case FileType::MFT:
RegisterFileType (
FileType::MFT,
"mft",
0,
".mft",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MFT_DIR)),
"MFTINPUTS");
break;
case FileType::MISCFONT:
RegisterFileType (
FileType::MISCFONT,
"misc fonts",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MISCFONTS_DIR)),
P2_("MISCFONTS","TEXFONTS"));
break;
case FileType::MLBIB:
RegisterFileType (
FileType::MLBIB,
"mlbib",
0,
P2_(".mlbib", ".bib"),
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/bib/{mlbib,}")),
P3_("MLBIBINPUTS", "BIBINPUTS", "TEXBIB"));
break;
case FileType::MLBST:
RegisterFileType (
FileType::MLBST,
"mlbst",
0,
".bst",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_BIBTEX_DIR "/{mlbst,bst}")),
P2_( "MLBSTINPUTS", "BSTINPUTS"));
break;
case FileType::MP:
RegisterFileType (
FileType::MP,
"mp",
"MetaPost",
".mp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_METAPOST_DIR)),
"MPINPUTS");
break;
case FileType::MPPOOL:
RegisterFileType (
FileType::MPPOOL,
"mppool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("MPPOOL", "TEXMFINI"));
break;
case FileType::MPSUPPORT:
RegisterFileType (
FileType::MPSUPPORT,
"MetaPost support",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_MPSUPPORT_DIR)),
"MPSUPPORT");
break;
case FileType::OCP:
RegisterFileType (
FileType::OCP,
"ocp",
"Omega",
".ocp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OCP_DIR)),
"OCPINPUTS");
break;
case FileType::OFM:
RegisterFileType (
FileType::OFM,
"ofm",
"Omega",
P2_(".ofm", ".tfm"),
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OFM_DIR),
R_(MIKTEX_PATH_TFM_DIR)),
P2_("OFMFONTS", "TEXFONTS"));
break;
case FileType::OPL:
RegisterFileType (
FileType::OPL,
"opl",
0,
".opl",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OPL_DIR)),
P2_("OPLFONTS", "TEXFONTS"));
break;
case FileType::OTP:
RegisterFileType (
FileType::OTP,
"otp",
"otp2ocp",
".otp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OTP_DIR)),
"OTPINPUTS");
break;
case FileType::OTF:
RegisterFileType (
FileType::OTF,
"opentype fonts",
0,
".otf",
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OPENTYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("OPENTYPEFONTS", "TEXFONTS"));
break;
case FileType::OVF:
RegisterFileType (
FileType::OVF,
"ovf",
0,
".ovf",
P3_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_OVF_DIR),
R_(MIKTEX_PATH_VF_DIR)),
P2_("OVFFONTS", "TEXFONTS"));
break;
case FileType::OVP:
RegisterFileType (
FileType::OVP,
"ovp",
0,
".ovp",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_OVP_DIR)),
P2_("OVPFONTS", "TEXFONTS"));
break;
case FileType::PDFTEXCONFIG:
RegisterFileType (
FileType::PDFTEXCONFIG,
"pdftex config",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_PDFTEX_DIR "/{$progname,}")),
"PDFTEXCONFIG");
break;
case FileType::PERLSCRIPT:
RegisterFileType (
FileType::PERLSCRIPT,
"perlscript",
0,
".pl",
P8_(R_(MIKTEX_PATH_SCRIPT_DIR),
R_(MIKTEX_PATH_CONTEXT_DIR),
R_(MIKTEX_PATH_MIKTEX_DIR),
R_(MIKTEX_PATH_NTS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_PSUTILS_DIR),
R_(MIKTEX_PATH_SOURCE_DIR),
R_(MIKTEX_PATH_TEX_DIR)),
"");
break;
case FileType::PK:
RegisterFileType (
FileType::PK,
"pk",
0,
".pk",
// <todo>
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_FONT_DIR)),
// </todo>
"");
break;
case FileType::PROGRAMBINFILE:
RegisterFileType (
FileType::PROGRAMBINFILE,
"other binary files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PROGRAMTEXTFILE:
RegisterFileType (
FileType::PROGRAMTEXTFILE,
"other text files",
0,
"",
P2_(CURRENT_DIRECTORY, R_("/$progname")),
"");
break;
case FileType::PSHEADER:
RegisterFileType (
FileType::PSHEADER,
"PostScript header",
0,
P2_(".pro", ".enc"),
P10_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
R_(MIKTEX_PATH_DVIPS_DIR),
R_(MIKTEX_PATH_PDFTEX_DIR),
R_(MIKTEX_PATH_DVIPDFM_DIR),
R_(MIKTEX_PATH_ENC_DIR),
R_(MIKTEX_PATH_TYPE1_DIR),
R_(MIKTEX_PATH_TYPE42_DIR),
R_(MIKTEX_PATH_TYPE3_DIR),
"$psfontdirs"),
P2_("TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::SCRIPT:
RegisterFileType (
FileType::SCRIPT,
"texmfscripts",
0,
"",
R_(MIKTEX_PATH_SCRIPT_DIR "/{$progname,$engine,}"),
"TEXMFSCRIPTS");
break;
case FileType::SFD:
RegisterFileType (
FileType::SFD,
"subfont definition files",
0,
".sfd",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SFD_DIR)),
P2_("SFDFONTS", "TEXFONTS"));
break;
case FileType::TCX:
RegisterFileType (
FileType::TCX,
"tcx",
0,
".tcx",
P3_(CURRENT_DIRECTORY,
S_(MIKTEX_PATH_MIKTEX_CONFIG_DIR),
S_(MIKTEX_PATH_WEB2C_DIR)),
"");
break;
case FileType::TEX:
RegisterFileType (
FileType::TEX,
"tex",
"TeX",
".tex",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TEX_DIR "/{$progname,generic,}")),
"TEXINPUTS");
break;
case FileType::TEXPOOL:
RegisterFileType (
FileType::TEXPOOL,
"texpool",
0,
".pool",
CURRENT_DIRECTORY,
P2_("TEXPOOL", "TEXMFINI"));
break;
case FileType::TEXSOURCE:
RegisterFileType (
FileType::TEXSOURCE,
"TeX system sources",
0,
"",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_SOURCE_DIR)),
"TEXSOURCES");
break;
case FileType::TEXSYSDOC:
RegisterFileType (
FileType::TEXSYSDOC,
"TeX system documentation",
0,
#if defined(MIKTEX_WINDOWS)
P6_(".chm", ".dvi", ".html", ".txt", ".pdf", ".ps"),
#else
P5_(".dvi", ".html", ".txt", ".pdf", ".ps"),
#endif
P2_(R_(MIKTEX_PATH_MIKTEX_DOC_DIR),
R_(MIKTEX_PATH_DOC_DIR)),
"TEXDOCS");
break;
case FileType::TFM:
RegisterFileType (
FileType::TFM,
"tfm",
0,
".tfm",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TFM_DIR)),
P2_("TFMFONTS", "TEXFONTS"));
break;
case FileType::TROFF:
RegisterFileType (
FileType::TROFF,
"troff fonts",
0,
"",
"",
"TRFONTS");
break;
case FileType::TTF:
RegisterFileType (
FileType::TTF,
"truetype fonts",
0,
P2_(".ttf", ".ttc"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TRUETYPE_DIR),
GetLocalFontDirectories().c_str()),
P2_("TTFONTS", "TEXFONTS"));
break;
case FileType::TYPE1:
RegisterFileType (
FileType::TYPE1,
"type1 fonts",
0,
P2_(".pfb", ".pfa"),
P_(CURRENT_DIRECTORY,
R_(MIKTEX_PATH_TYPE1_DIR),
GetLocalFontDirectories().c_str()),
P5_("T1FONTS", "T1INPUTS", "TEXFONTS", "TEXPSHEADERS", "PSHEADERS"));
break;
case FileType::TYPE42:
RegisterFileType (
FileType::TYPE42,
"type42 fonts",
0,
#if defined(MIKTEX_WINDOWS)
".t42",
#else
P2_(".t42", ".T42"),
#endif
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_TYPE42_DIR)),
P2_("T42FONTS", "TEXFONTS"));
break;
case FileType::VF:
RegisterFileType (
FileType::VF,
"vf",
0,
".vf",
P2_(CURRENT_DIRECTORY, R_(MIKTEX_PATH_VF_DIR)),
P2_("VFFONTS", "TEXFONTS"));
break;
case FileType::WEB:
RegisterFileType (
FileType::WEB,
"web",
0,
".web",
R_(MIKTEX_PATH_WEB_DIR),
"WEBINPUTS");
break;
case FileType::WEB2C:
RegisterFileType (
FileType::WEB2C,
"web2c files",
0,
"",
R_(MIKTEX_PATH_WEB2C_DIR),
"");
break;
default:
UNEXPECTED_CONDITION ("SessionImpl::RegisterFileType");
}
}
void FarEditor::reloadTypeSettings()
{
FileType *ftype = baseEditor->getFileType();
HRCParser *hrcParser = parserFactory->getHRCParser();
DString ds("default") ;
FileType *def = hrcParser->getFileType(&ds);
if (def == nullptr){
throw Exception(DString("No 'default' file type found"));
}
int backparse = def->getParamValueInt(DBackparse, 2000);
maxLineLength = def->getParamValueInt(DMaxLen, 0);
newfore = def->getParamValueInt(DDefFore, -1);
newback = def->getParamValueInt(DDefBack, -1);
const String *value;
value = def->getParamValue(DFullback);
if (value != nullptr && value->equals(&DNo)){
fullBackground = false;
}
value = def->getParamValue(DShowCross);
if (drawCross==2 && value != nullptr){
if (value->equals(&DNone)){
showHorizontalCross = false;
showVerticalCross = false;
};
if (value->equals(&DVertical)){
showHorizontalCross = false;
showVerticalCross = true;
};
if (value->equals(&DHorizontal)){
showHorizontalCross = true;
showVerticalCross = false;
};
if (value->equals(&DBoth)){
showHorizontalCross = true;
showVerticalCross = true;
};
}
value = def->getParamValue(DCrossZorder);
if (value != nullptr && value->equals(&DTop)){
crossZOrder = 1;
}
// installs custom file properties
backparse = ftype->getParamValueInt(DBackparse, backparse);
maxLineLength = ftype->getParamValueInt(DMaxLen, maxLineLength);
newfore = ftype->getParamValueInt(DDefFore, newfore);
newback = ftype->getParamValueInt(DDefBack, newback);
value = ftype->getParamValue(DFullback);
if (value != nullptr && value->equals(&DNo)){
fullBackground = false;
}
value = ftype->getParamValue(DShowCross);
if (drawCross==2 && value != nullptr){
if (value->equals(&DNone)){
showHorizontalCross = false;
showVerticalCross = false;
};
if (value->equals(&DVertical)){
showHorizontalCross = false;
showVerticalCross = true;
};
if (value->equals(&DHorizontal)){
showHorizontalCross = true;
showVerticalCross = false;
};
if (value->equals(&DBoth)){
showHorizontalCross = true;
showVerticalCross = true;
};
}
value = ftype->getParamValue(DCrossZorder);
if (value != nullptr && value->equals(&DTop)){
crossZOrder = 1;
}
baseEditor->setBackParse(backparse);
}
int InteractiveApplication::run(int argc, char** argv)
{
// Generate the XML files
if (generateXml() == false)
{
return -1;
}
// Set the application to run in interactive mode
ApplicationServicesImp* pApp = ApplicationServicesImp::instance();
if (pApp != NULL)
{
pApp->setInteractive();
}
// Initialize the Qt application
QApplication& qApplication = dynamic_cast<QApplication&>(getQApp());
#if !defined(LINUX)
qApplication.setFont(QFont("Tahoma", 8));
#endif
bool configSettingsValid = false;
string configSettingsErrorMsg = "";
ConfigurationSettingsImp* pConfigSettings = ConfigurationSettingsImp::instance();
if (pConfigSettings != NULL)
{
configSettingsValid = pConfigSettings->isInitialized();
if (pConfigSettings->getInitializationErrorMsg() != NULL)
{
configSettingsErrorMsg = pConfigSettings->getInitializationErrorMsg();
}
if (configSettingsValid)
{
pConfigSettings->validateInitialization();
configSettingsValid = pConfigSettings->isInitialized();
if (pConfigSettings->getInitializationErrorMsg() != NULL)
{
configSettingsErrorMsg = pConfigSettings->getInitializationErrorMsg();
}
}
}
if (!configSettingsValid)
{
if (configSettingsErrorMsg.empty())
{
configSettingsErrorMsg = "Unable to locate configuration settings";
}
reportError(configSettingsErrorMsg);
return -1;
}
else
{
if (!configSettingsErrorMsg.empty())
{
reportWarning(configSettingsErrorMsg);
}
}
{ // scope the lifetime of the lock
SessionSaveLock lock;
// Create a progress object
mpProgress = new ProgressAdapter();
// Splash screen
Q_INIT_RESOURCE(Application);
SplashScreen* pSplash = new SplashScreen(mpProgress);
vector<string> splashPaths = Service<InstallerServices>()->getSplashScreenPaths();
pSplash->setSplashImages(list<string>(splashPaths.begin(), splashPaths.end()));
pSplash->show();
qApplication.processEvents();
// process pending extension uninstalls
InstallerServicesImp::instance()->processPending(mpProgress);
string errMsg;
if(!ConfigurationSettingsImp::instance()->loadSettings(errMsg))
{
if (QMessageBox::warning(pSplash, "Error loading configuration settings",
QString("Warning: unable to reload application settings.\n%1\nContinue loading Opticks?").arg(QString::fromStdString(errMsg)),
QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::No)
{
pSplash->close();
delete pSplash;
return -1;
}
}
// Initialization
int iReturn = Application::run(argc, argv);
if (iReturn == -1)
{
pSplash->close();
delete pSplash;
return -1;
}
qApplication.processEvents();
// process auto-installs
QDirIterator autos(QString::fromStdString(ConfigurationSettingsImp::instance()->getSettingExtensionFilesPath()->getFullPathAndName())
+ "/AutoInstall", QStringList() << "*.aeb", QDir::Files);
vector<string> pendingInstall;
while (autos.hasNext())
{
pendingInstall.push_back(autos.next().toStdString());
}
bool autoInstallOccurred = false;
InstallerServicesImp::instance()->setPendingInstall(pendingInstall);
for (vector<string>::iterator autoIter = pendingInstall.begin();
autoIter != pendingInstall.end();
++autoIter)
{
bool success = InstallerServicesImp::instance()->installExtension(*autoIter, mpProgress);
if(!success)
{
QFileInfo autoInfo(QString::fromStdString(*autoIter));
// Attempt to parse the AEB so we can get a better name
string extName = autoInfo.fileName().toStdString();
{ // scope the AebIo so we don't hold a handle to the aeb file and can delete it below
Aeb extension;
AebIo io(extension);
string errMsg; // ignored
if (io.fromFile(autoInfo.filePath().toStdString(), errMsg))
{
extName = extension.getName();
}
}
if(DesktopServicesImp::instance()->showMessageBox("Installation error", "Unable to install " + extName
+ "\nWould you like to delete the file?", "Yes", "No") == 0)
{
QFile::remove(QString::fromStdString(*autoIter));
}
}
else
{
autoInstallOccurred = true;
QFile::remove(QString::fromStdString(*autoIter));
}
}
InstallerServicesImp::instance()->setPendingInstall();
if (autoInstallOccurred)
{
// rescan the plug-ins
PlugInManagerServicesImp::instance()->buildPlugInList(Service<ConfigurationSettings>()->getPlugInPath());
}
// Create the main GUI window
mpProgress->updateProgress("Creating the main application window...", 0, NORMAL);
ApplicationWindow* pAppWindow = new ApplicationWindow(pSplash);
qApplication.processEvents();
// Execute startup plug-ins
PlugInManagerServicesImp* pManager = PlugInManagerServicesImp::instance();
if (pManager != NULL)
{
pManager->executeStartupPlugIns(mpProgress);
qApplication.processEvents();
}
// Restore the previous position and visibility state of the toolbars and dock windows
pAppWindow->restoreConfiguration();
// Keep the splash screen up until all images have been shown to the user.
while (!pSplash->canClose()) {}
// Display the main application window
pAppWindow->show();
// Destroy the splash screen
pSplash->close();
delete pSplash;
// Create a progress dialog
ProgressDlg* pProgressDlg = new ProgressDlg(APP_NAME, pAppWindow);
mpProgress->attach(SIGNAL_NAME(Subject, Modified), Slot(pProgressDlg, &ProgressDlg::progressUpdated));
mpProgress->attach(SIGNAL_NAME(Subject, Deleted), Slot(pProgressDlg, &ProgressDlg::progressDeleted));
// Load files specified on the command line
ArgumentList* pArgList(ArgumentList::instance());
if (pArgList != NULL)
{
FileType fileType;
vector<string> filenames(pArgList->getOptions(""));
for (vector<string>::size_type i = 0; i < filenames.size(); ++i)
{
FilenameImp filename(filenames[i]);
QString strFilename = QString::fromStdString(filename.getFullPathAndName());
if (strFilename.isEmpty() == false)
{
QFileInfo info(strFilename);
if ((info.suffix() == "wiz") || (info.suffix() == "batchwiz"))
{
if ((fileType.isValid() == true) && (fileType != WIZARD_FILES))
{
fileType = EnumWrapper<FileTypeEnum>();
break;
}
fileType = WIZARD_FILES;
}
else if (info.suffix() == "session")
{
if (fileType.isValid() == true)
{
fileType = EnumWrapper<FileTypeEnum>();
break;
}
fileType = SESSION_FILE;
}
else
{
if ((fileType.isValid() == true) && (fileType != DATASET_FILES))
{
fileType = EnumWrapper<FileTypeEnum>();
break;
}
fileType = DATASET_FILES;
}
}
}
if (fileType.isValid() == true)
{
// Check for valid filenames
vector<string> validFilenames;
for (vector<string>::size_type i = 0; i < filenames.size(); ++i)
{
FilenameImp filename(filenames[i]);
string normalizedFilename = filename.getFullPathAndName();
if (normalizedFilename.empty() == false)
{
QString strFilename = QString::fromStdString(normalizedFilename);
QFileInfo info(strFilename);
if ((info.isFile() == true) && (info.exists() == true))
{
validFilenames.push_back(normalizedFilename);
}
else
{
reportWarning("The specified file '" + normalizedFilename +
"' does not exist and cannot be loaded.");
}
}
}
// Load the files
switch (fileType)
{
case WIZARD_FILES:
{
for (vector<string>::size_type i = 0; i < validFilenames.size(); ++i)
{
string filename = validFilenames[i];
QString strFilename = QString::fromStdString(filename);
QFileInfo info(strFilename);
if (info.suffix() == "wiz")
{
pAppWindow->runWizard(strFilename);
}
else if (info.suffix() == "batchwiz")
{
vector<string> batchFiles;
batchFiles.push_back(filename);
WizardUtilities::runBatchFiles(batchFiles, mpProgress);
}
}
break;
}
case SESSION_FILE:
{
if (validFilenames.empty() == false)
{
VERIFYRV(validFilenames.size() == 1, -1);
string filename = validFilenames.front();
string saveKey = SessionManager::getSettingQueryForSaveKey();
SessionSaveType saveType = SESSION_DONT_AUTO_SAVE;
DataVariant dvSaveType(saveType);
pConfigSettings->adoptTemporarySetting(saveKey, dvSaveType);
pAppWindow->openSession(QString::fromStdString(filename));
pConfigSettings->deleteTemporarySetting(saveKey);
}
break;
}
case DATASET_FILES:
{
if (validFilenames.empty() == false)
{
ImporterResource importer("Auto Importer", validFilenames, mpProgress, false);
importer->execute();
}
break;
}
default:
break;
}
}
else if (filenames.empty() == false)
{
string msg = "Unable to import the files specified on the command line. " + string(APP_NAME) +
" supports loading one session file, one or more wizard files, or one or more data set files.";
mpProgress->updateProgress(msg, 0, ERRORS);
}
}
// If there are any wizards, run them
executeStartupBatchWizards();
// Destroy the progress object and progress dialog
delete dynamic_cast<ProgressAdapter*>(mpProgress);
vector<string> autoExitOptions = pArgList->getOptions("autoExit");
if (autoExitOptions.empty() == false)
{
SessionSaveType tempSettingQueryForSave = SESSION_DONT_AUTO_SAVE;
const string sessionFilename = autoExitOptions.front();
if (sessionFilename.empty() == false)
{
tempSettingQueryForSave = SESSION_AUTO_SAVE;
pAppWindow->setSessionFilename(FilenameImp(sessionFilename).getFullPathAndName());
}
DataVariant dvTempSettingQueryForSave(tempSettingQueryForSave);
pConfigSettings->adoptTemporarySetting(SessionManager::getSettingQueryForSaveKey(), dvTempSettingQueryForSave);
pAppWindow->close();
return iReturn;
}
// Set the application window to auto-generate textures
QTimer textureGenerationTimer;
bool generation = RasterLayer::getSettingBackgroundTileGeneration();
if (generation == true)
{
textureGenerationTimer.setInterval(100);
pAppWindow->connect(&textureGenerationTimer, SIGNAL(timeout()), SLOT(pregenerateTexture()));
}
}
// Initiate the GUI event loop, which returns when the user exits the application
return qApplication.exec();
}
FileID_t GenerateID(const FileType &AFile)
{
return(AFile.GiveFileName());
}
