void Generator::generate()
{
if (m_classes.size() == 0) {
ReportHandler::warning(QString("%1: no java classes, skipping")
.arg(metaObject()->className()));
return;
}
qStableSort(m_classes);
foreach (AbstractMetaClass *cls, m_classes) {
if (!shouldGenerate(cls))
continue;
QString fileName = fileNameForClass(cls);
ReportHandler::debugSparse(QString("generating: %1").arg(fileName));
FileOut fileOut(outputDirectory() + "/" + subDirectoryForClass(cls) + "/" + fileName);
write(fileOut.stream, cls);
if( fileOut.done() )
++m_num_generated_written;
++m_num_generated;
}
}
std::string ConvertToDDS(const char *filePath, filepath &baseDirectory, filepath &rootInputDirectory, filepath &rootOutputDirectory) {
filepath relativePath(filePath);
filepath relativeDDSPath(relativePath);
relativeDDSPath.replace_extension("dds");
// If the file already exists in the output directory, we don't need to do anything
filepath outputFilePath(rootOutputDirectory.file_string() + "\\" + relativeDDSPath.file_string());
if (exists(outputFilePath)) {
return relativeDDSPath;
}
// Guarantee the output directory exists
filepath outputDirectory(outputFilePath.parent_path());
create_directories(outputDirectory);
// If input is already dds, but doesn't exist in the output directory, just copy the file to the output
filepath inputFilePath(rootInputDirectory.file_string() + "\\" + relativePath.file_string());
if (_stricmp(relativePath.extension().c_str(), "dds") == 0) {
copy_file(inputFilePath, outputFilePath);
return relativeDDSPath;
}
// Otherwise, convert the file to DDS
std::string call = baseDirectory.file_string() + "\\texconv.exe -ft dds -o " + outputDirectory.file_string() + " " + inputFilePath.file_string() + " > NUL";
std::system(call.c_str());
return relativeDDSPath;
}
CompileResult TestCompilerC::compile(Compilation* compilation, const QStringList& files)
{
int idealProcesses = QThread::idealThreadCount();
CommandChain chain(idealProcesses > 0 ? idealProcesses : 1);
QStringList cFlags = compilation->settings()["C_FLAGS"].split(" ");
foreach(const QString& file, files) {
QFileInfo fi(file);
QString output = fi.path() + "/" + fi.baseName();
output = output.replace("/", "_");
output += ".o";
chain.add(createGccSegment(QStringList(cFlags) << "-c" << file << "-o" << output));
compilation->addFile(outputDirectory().path() + "/" + output);
}
void SkyboxBakeWidget::bakeButtonClicked() {
// make sure we have a valid output directory
QDir outputDirectory(_outputDirLineEdit->text());
outputDirectory.mkdir(".");
if (!outputDirectory.exists()) {
QMessageBox::warning(this, "Unable to create directory", "Unable to create output directory. Please create it manually or choose a different directory.");
return;
}
// make sure we have a non empty URL to a skybox to bake
if (_selectionLineEdit->text().isEmpty()) {
return;
}
// split the list from the selection line edit to see how many skyboxes we need to bake
auto fileURLStrings = _selectionLineEdit->text().split(',');
foreach (QString fileURLString, fileURLStrings) {
// construct a URL from the path in the skybox file text box
QUrl skyboxToBakeURL(fileURLString);
// if the URL doesn't have a scheme, assume it is a local file
if (skyboxToBakeURL.scheme() != "http" && skyboxToBakeURL.scheme() != "https" && skyboxToBakeURL.scheme() != "ftp") {
skyboxToBakeURL.setScheme("file");
}
// everything seems to be in place, kick off a bake for this skybox now
auto baker = std::unique_ptr<TextureBaker> {
new TextureBaker(skyboxToBakeURL, image::TextureUsage::CUBE_TEXTURE, outputDirectory.absolutePath())
};
// move the baker to a worker thread
baker->moveToThread(qApp->getNextWorkerThread());
// invoke the bake method on the baker thread
QMetaObject::invokeMethod(baker.get(), "bake");
// make sure we hear about the results of this baker when it is done
connect(baker.get(), &TextureBaker::finished, this, &SkyboxBakeWidget::handleFinishedBaker);
// add a pending row to the results window to show that this bake is in process
auto resultsWindow = qApp->getMainWindow()->showResultsWindow();
auto resultsRow = resultsWindow->addPendingResultRow(skyboxToBakeURL.fileName(), outputDirectory);
// keep a unique_ptr to this baker
// and remember the row that represents it in the results table
_bakers.emplace_back(std::move(baker), resultsRow);
}
// createSpectraSTSearchOutput - "factory" to create proper output object for different formats. Modify this if you implement
// a new outputter!
SpectraSTSearchOutput* SpectraSTSearchOutput::createSpectraSTSearchOutput(string searchFileName, SpectraSTSearchParams& searchParams) {
FileName fn;
parseFileName(searchFileName, fn);
string outputDirectory(fn.path);
if (!(searchParams.outputDirectory.empty())) {
outputDirectory = searchParams.outputDirectory;
}
string ext(searchParams.outputExtension);
if (ext == "nxls") ext = "xls";
if (ext == "ntxt") ext = "txt";
string outputFileName(outputDirectory + fn.name + "." + ext);
/*
if (searchParams.saveSpectra) {
makeDir(outputDirectory + fn.name + ".match/");
makeDir(outputDirectory + fn.name + ".query/");
}
*/
if (searchParams.outputExtension == "txt") {
return (new SpectraSTTxtSearchOutput(outputFileName, fn.ext, searchParams));
} else if (searchParams.outputExtension == "ntxt") {
return (new SpectraSTTxtSearchOutput(outputFileName, fn.ext, searchParams, false));
} else if (searchParams.outputExtension == "xls") {
return (new SpectraSTXlsSearchOutput(outputFileName, fn.ext, searchParams));
} else if (searchParams.outputExtension == "nxls") {
return (new SpectraSTXlsSearchOutput(outputFileName, fn.ext, searchParams, false));
} else if (searchParams.outputExtension == "xml" || searchParams.outputExtension == "pepXML" || searchParams.outputExtension == "pep.xml") {
return (new SpectraSTPepXMLSearchOutput(outputFileName, fn.ext, searchParams));
} else if (searchParams.outputExtension == "html") {
return (new SpectraSTHtmlSearchOutput(outputFileName, fn.ext, searchParams));
} else {
// unknown output type. should never happen.
return (new SpectraSTPepXMLSearchOutput(outputFileName, fn.ext, searchParams));
}
return (new SpectraSTPepXMLSearchOutput(outputFileName, fn.ext, searchParams));
}
void QDocGenerator::generate() {
QDir dir(outputDirectory() + "/" + subDirectoryForClass(0));
dir.mkpath(dir.absolutePath());
QFile f(dir.absoluteFilePath(fileNameForClass(0)));
if (!f.open(QIODevice::WriteOnly)) {
ReportHandler::warning(QString("failed to open file '%1' for writing")
.arg(f.fileName()));
return;
}
QTextStream s(&f);
s << "<japi>" << endl;
AbstractMetaClassList clazzes = classes();
foreach(AbstractMetaClass *cls, clazzes) {
if (shouldGenerate(cls)) {
write(s, cls);
}
}
s << "</japi>" << endl;
}
int run(int argc, char **argv)
{
if (argc < 4)
{
PRINTMSG("Usage: " << argv[0] << " <outputDir> <robotFile> <objectFile>");
return 0;
}
std::string outputDirectory(argv[1]);
std::string robotFilename(argv[2]);
std::string objectFilename(argv[3]);
PRINTMSG("Creating database");
std::string name = "Database1";
SHARED_PTR<GraspIt::GraspItSceneManager> graspitMgr(new GraspIt::GraspItSceneManagerHeadless());
SHARED_PTR<GraspIt::GraspItSimpleDBManager> mgr(new GraspIt::GraspItSimpleDBManager(name, graspitMgr));
std::string robotName("Robot1");
std::string objectName("Object1");
PRINTMSG("Now loading robot");
int robotID = -1;
int objectID = -1;
// here we'd have to put the robot joint names, we'll leave this empty for this test fle
std::vector<std::string> jointNames;
if ((robotID = mgr->loadRobotToDatabase(robotFilename, robotName, jointNames)) < 0)
{
PRINTERROR("Could not load robot");
return 0;
}
PRINTMSG("Now loading object");
if ((objectID = mgr->loadObjectToDatabase(objectFilename, objectName, true)) < 0)
{
PRINTERROR("Could not load object");
return 0;
}
// Now objects should be in the database only, but not in the world.
// Re-add them to test if the world still workds afterwards:
PRINTMSG("Now loading robot to world");
if (mgr->loadToWorld(robotID, GraspIt::EigenTransform::Identity()) != 0)
{
PRINTERROR("Could not add the robot to the graspit world");
return 0;
}
PRINTMSG("Now loading object to world");
if (mgr->loadToWorld(objectID, GraspIt::EigenTransform::Identity()) != 0)
{
PRINTERROR("Could not add the object to the graspit world");
return 0;
}
PRINTMSG("Saving world files");
// test to see if it worked: save as world
bool createDir = true; // if true, the directory will be created, if it doesn't exist.
graspitMgr->saveGraspItWorld(outputDirectory + "/dbtest/world.xml", createDir);
graspitMgr->saveInventorWorld(outputDirectory + "/dbtest/world.iv", createDir);
PRINTMSG("Quitting program.");
return 0;
}
//--------------------------------------------------------------
void testApp::update(){
for(int i = 0; i < comps.size(); i++){
comps[i]->load->enabled = viewComps || !allLoaded;
comps[i]->toggle->enabled = viewComps || !allLoaded;
}
if(shouldResetDuration){
timeline.setDurationInFrames(currentDuration);
shouldResetDuration = false;
}
if(!allLoaded) return;
if(currentLockCamera != cameraTrack.lockCameraToTrack){
if(!currentLockCamera){
cam.targetNode.setPosition(cam.getPosition());
cam.targetNode.setOrientation(cam.getOrientationQuat());
cam.rotationX = cam.targetXRot = -cam.getHeading();
cam.rotationY = cam.targetYRot = -cam.getPitch();
cam.rotationZ = -cam.getRoll();
}
cameraTrack.lockCameraToTrack = currentLockCamera;
}
if(cameraTrack.lockCameraToTrack){
cameraTrack.setTimelineInOutToTrack();
}
else{
timeline.setInOutRange(ofRange(0,1));
}
cam.applyRotation = !cameraTrack.lockCameraToTrack;
cam.applyTranslation = !cameraTrack.lockCameraToTrack;
if(enableVideoInOut){
videoTimelineElement.setInFrame(videoInPercent*lowResPlayer->getTotalNumFrames());
videoTimelineElement.setOutFrame(videoOutPercent*lowResPlayer->getTotalNumFrames());
}
else{
videoTimelineElement.setInFrame(0);
videoTimelineElement.setOutFrame(lowResPlayer->getTotalNumFrames());
}
if(startRenderMode && !hasHiresVideo){
ofSystemAlertDialog("This composition doesn't have a hi res movie so we can't render!");
startRenderMode = false;
}
if(startRenderMode){
viewComps = false;
saveComposition();
for(int i = 0; i < comps.size(); i++){
if(comps[i]->batchExport){
loadCompositionAtIndex(i);
break;
}
}
startRenderMode = false;
currentlyRendering = true;
saveFolder = currentCompositionDirectory + "rendered"+pathDelim;
ofDirectory outputDirectory(saveFolder);
if(!outputDirectory.exists()) outputDirectory.create(true);
hiResPlayer->play();
hiResPlayer->setSpeed(0);
hiResPlayer->setVolume(0);
renderer.setRGBTexture(*hiResPlayer);
renderer.setTextureScale(1.0, 1.0);
// currentSimplify = 1;
lastRenderFrame = currentRenderFrame-1;
numFramesToRender = timeline.getOutFrame() - timeline.getInFrame();
numFramesRendered = 0;
currentLockCamera = cameraTrack.lockCameraToTrack = true;
cameraTrack.setTimelineInOutToTrack();
currentRenderFrame = timeline.getInFrame();
}
if(currentlyRendering){
//hiResPlayer->setFrame(currentRenderFrame % hiResPlayer->getTotalNumFrames());
timeline.setCurrentFrame(currentRenderFrame);
videoTimelineElement.selectFrame(currentRenderFrame);
hiResPlayer->setFrame(videoTimelineElement.selectFrame(currentRenderFrame));
hiResPlayer->update();
// cout << "would have set hi res frame to " << currentRenderFrame % hiResPlayer->getTotalNumFrames() << endl;
// cout << "instead set it to " << hiResPlayer->getCurrentFrame() << endl;
////////
// char filename[512];
// sprintf(filename, "%s/TEST_FRAME_%05d_%05d_A.png", saveFolder.c_str(), currentRenderFrame, hiResPlayer->getCurrentFrame());
// savingImage.saveImage(filename);
// savingImage.setFromPixels(hiResPlayer->getPixelsRef());
// savingImage.saveImage(filename);
//
// cout << "FRAME UPDATE" << endl;
// cout << " setting frame to " << currentRenderFrame << " actual frame is " << hiResPlayer->getCurrentFrame() << endl;
// cout << " set to percent " << 1.0*currentRenderFrame/hiResPlayer->getTotalNumFrames() << " actual percent " << hiResPlayer->getPosition() << endl;
////////
updateRenderer(*hiResPlayer);
}
if(!currentlyRendering){
lowResPlayer->update();
if(!temporalAlignmentMode && lowResPlayer->isFrameNew()){
updateRenderer(*lowResPlayer);
}
if(temporalAlignmentMode && currentDepthFrame != depthSequence.getSelectedFrame()){
updateRenderer(*lowResPlayer);
}
if(sampleCamera){
cameraTrack.sample();
}
if(captureFramePair && temporalAlignmentMode){
alignmentScrubber.registerCurrentAlignment();
alignmentScrubber.save();
captureFramePair = false;
}
}
if(shouldClearCameraMoves){
cameraTrack.getCameraTrack().reset();
shouldClearCameraMoves = false;
}
if(shouldSaveCameraPoint){
//cameraRecorder.sample(lowResPlayer->getCurrentFrame());
cameraTrack.getCameraTrack().sample(timeline.getCurrentFrame());
shouldSaveCameraPoint = false;
}
if(shouldResetCamera){
cam.targetNode.setPosition(ofVec3f());
cam.targetNode.setOrientation(ofQuaternion());
cam.targetXRot = -180;
cam.targetYRot = 0;
cam.rotationZ = 0;
shouldResetCamera = false;
}
// newCompButton->enabled = viewComps;
// saveCompButton->enabled = viewComps;
if(currentXAdditiveShift != renderer.yshift ||
currentYAdditiveShift != renderer.yshift ||
currentXMultiplyShift != renderer.xmult ||
currentYMultiplyShift != renderer.ymult ||
currentXScale != renderer.xscale ||
currentYScale != renderer.yscale ||
currentRotationCompensation != renderer.rotationCompensation ||
currentSimplify != renderer.getSimplification() ||
currentEdgeCull != renderer.edgeCull ||
farClip != renderer.farClip ||
currentMirror != renderer.mirror) {
renderer.xshift = currentXAdditiveShift;
renderer.yshift = currentYAdditiveShift;
renderer.xmult = currentXMultiplyShift;
renderer.ymult = currentYMultiplyShift;
renderer.xscale = currentXScale;
renderer.yscale = currentYScale;
renderer.edgeCull = currentEdgeCull;
renderer.setSimplification(currentSimplify);
renderer.farClip = farClip;
renderer.mirror = currentMirror;
renderer.update();
}
//update shaders
renderer.fadeToWhite = timeline.getKeyframeValue("White");
if(!temporalAlignmentMode && !currentlyRendering && lowResPlayer->getSpeed() == 0.0){
videoTimelineElement.selectFrame(timeline.getCurrentFrame());
}
}
int main(int argc, char *argv[])
{
// if(argc > 0)
// g_ApplicationPath = Files::dirname(argv[0]);
// g_ApplicationPath = DirMan(g_ApplicationPath).absolutePath();
DirMan imagesDir;
std::vector<std::string> fileList;
FreeImage_Initialise();
LazyFixTool_Setup setup;
try
{
// Define the command line object.
TCLAP::CmdLine cmd(V_FILE_DESC "\n"
"Copyright (c) 2017-2019 Vitaly Novichkov <*****@*****.**>\n"
"This program is distributed under the GNU GPLv3+ license\n", ' ', V_FILE_VERSION V_FILE_RELEASE);
TCLAP::SwitchArg switchNoBackups("n", "no-backup", "Don't create backup", false);
TCLAP::SwitchArg switchDigRecursive("d", "dig-recursive", "Look for images in subdirectories", false);
TCLAP::SwitchArg switchDigRecursiveDEP("w", "dig-recursive-old", "Look for images in subdirectories [deprecated]", false);
TCLAP::ValueArg<std::string> outputDirectory("O", "output",
"path to a directory where the fixed images will be saved",
false, "", "/path/to/output/directory/");
TCLAP::UnlabeledMultiArg<std::string> inputFileNames("filePath(s)",
"Input GIF file(s)",
true,
"Input file path(s)");
cmd.add(&switchNoBackups);
cmd.add(&switchDigRecursive);
cmd.add(&switchDigRecursiveDEP);
cmd.add(&outputDirectory);
cmd.add(&inputFileNames);
cmd.parse(argc, argv);
setup.noMakeBackup = switchNoBackups.getValue();
setup.walkSubDirs = switchDigRecursive.getValue() | switchDigRecursiveDEP.getValue();
//nopause = switchNoPause.getValue();
setup.pathOut = outputDirectory.getValue();
for(const std::string &fpath : inputFileNames.getValue())
{
if(Files::hasSuffix(fpath, "m.gif"))
continue;
else if(DirMan::exists(fpath))
setup.pathIn = fpath;
else
{
fileList.push_back(fpath);
setup.listOfFiles = true;
}
}
if((argc <= 1) || (setup.pathIn.empty() && !setup.listOfFiles))
{
fprintf(stderr, "\n"
"ERROR: Missing input files!\n"
"Type \"%s --help\" to display usage.\n\n", argv[0]);
return 2;
}
}
catch(TCLAP::ArgException &e) // catch any exceptions
{
std::cerr << "Error: " << e.error() << " for arg " << e.argId() << std::endl;
return 2;
}
fprintf(stderr, "============================================================================\n"
"Lazily-made image masks fix tool by Wohlstand. Version " V_FILE_VERSION V_FILE_RELEASE "\n"
"============================================================================\n"
"This program is distributed under the GNU GPLv3 license \n"
"============================================================================\n");
fflush(stderr);
if(!setup.listOfFiles)
{
if(setup.pathIn.empty())
goto WrongInputPath;
if(!DirMan::exists(setup.pathIn))
goto WrongInputPath;
imagesDir.setPath(setup.pathIn);
setup.pathIn = imagesDir.absolutePath();
}
if(!setup.pathOut.empty())
{
if(!DirMan::exists(setup.pathOut) && !DirMan::mkAbsPath(setup.pathOut))
goto WrongOutputPath;
setup.pathOut = DirMan(setup.pathOut).absolutePath();
setup.pathOutSame = false;
}
else
{
setup.pathOut = setup.pathIn;
setup.pathOutSame = true;
}
delEndSlash(setup.pathIn);
delEndSlash(setup.pathOut);
printf("============================================================================\n"
"Converting images...\n"
"============================================================================\n");
fflush(stdout);
if(!setup.listOfFiles)
std::cout << ("Input path: " + setup.pathIn + "\n");
std::cout << ("Output path: " + setup.pathOut + "\n");
std::cout << "============================================================================\n";
std::cout.flush();
if(setup.listOfFiles)// Process a list of flies
{
for(std::string &file : fileList)
{
std::string fname = Files::basename(file);
setup.pathIn = DirMan(Files::dirname(file)).absolutePath();
if(setup.pathOutSame)
setup.pathOut = DirMan(Files::dirname(file)).absolutePath();
doLazyFixer(setup.pathIn, fname , setup.pathOut, setup);
}
}
else // Process directories with a source files
{
imagesDir.getListOfFiles(fileList, {".gif"});
if(!setup.walkSubDirs) //By directories
{
for(std::string &fname : fileList)
doLazyFixer(setup.pathIn, fname, setup.pathOut, setup);
}
else
{
imagesDir.beginWalking({".gif"});
std::string curPath;
while(imagesDir.fetchListFromWalker(curPath, fileList))
{
if(Files::hasSuffix(curPath, "/_backup"))
continue; //Skip backup directories
for(std::string &file : fileList)
{
if(setup.pathOutSame)
setup.pathOut = curPath;
doLazyFixer(curPath, file, setup.pathOut, setup);
}
}
}
}
printf("============================================================================\n"
" Conversion has been completed!\n"
"============================================================================\n"
"Successfully fixed: %d\n"
"Masks are not found: %d\n"
"Backups created: %d\n"
"Fixes failed: %d\n"
"\n",
setup.count_success,
setup.count_nomask,
setup.count_backups,
setup.count_failed);
fflush(stdout);
return (setup.count_failed == 0) ? 0 : 1;
WrongInputPath:
std::cout.flush();
std::cerr.flush();
printf("============================================================================\n"
" Wrong input path!\n"
"============================================================================\n");
fflush(stdout);
return 2;
WrongOutputPath:
std::cout.flush();
std::cerr.flush();
printf("============================================================================\n"
" Wrong output path!\n"
"============================================================================\n");
fflush(stdout);
return 2;
}
Void BonkEnc::GeneralSettingsDialog::OK()
{
Directory outputDirectory(register_layer_encoders->GetOutputDirectory().Replace("<installdrive>", Utilities::GetInstallDrive()));
if ((Setup::enableUnicode ? SetCurrentDirectoryW(String(outputDirectory)) : SetCurrentDirectoryA(String(outputDirectory))) == False)
{
Int selection = QuickMessage(BonkEnc::i18n->TranslateString("The output directory does not exist! Do you want to create it?"), BonkEnc::i18n->TranslateString("Error"), MB_YESNOCANCEL, IDI_QUESTION);
if (selection == IDYES) outputDirectory.Create();
else if (selection == IDCANCEL) return;
}
if (currentConfig->freedb_proxy_mode == 1 && register_layer_cddb->GetFreedbMode() == FREEDB_MODE_CDDBP)
{
Int selection = QuickMessage(BonkEnc::i18n->TranslateString("The freedb CDDBP protocol cannot be used over HTTP\nForward proxies!\n\nWould you like to change the protocol to HTTP?"), BonkEnc::i18n->TranslateString("Error"), MB_YESNOCANCEL, IDI_QUESTION);
if (selection == IDYES) currentConfig->freedb_mode = FREEDB_MODE_HTTP;
else if (selection == IDNO) currentConfig->freedb_mode = register_layer_cddb->GetFreedbMode();
else if (selection == IDCANCEL) return;
}
else
{
currentConfig->freedb_mode = register_layer_cddb->GetFreedbMode();
}
if (Setup::enableUnicode) SetCurrentDirectoryW(GetApplicationDirectory());
else SetCurrentDirectoryA(GetApplicationDirectory());
Bool valid = False;
String email = register_layer_cddb->GetFreedbEMail();
for (Int i = 0; i < email.Length(); i++) if (email[i] == '@') valid = True;
if (currentConfig->enable_cdrip && currentConfig->cdrip_numdrives >= 1 && !valid)
{
Utilities::ErrorMessage("Please enter a valid eMail address.");
return;
}
currentConfig->encoder = register_layer_encoders->GetSelectedEncoder();
if (BonkEnc::i18n->GetNOfLanguages() > 1)
{
if (register_layer_language->IsLanguageChanged()) currentConfig->languageChanged = true;
currentConfig->language = register_layer_language->GetSelectedLanguageID();
}
currentConfig->enc_outdir = register_layer_encoders->GetOutputDirectory();
currentConfig->enc_filePattern = register_layer_encoders->GetFilenamePattern();
currentConfig->enc_onTheFly = register_layer_encoders->GetOnTheFly();
currentConfig->writeToInputDir = register_layer_encoders->GetUseInputDirectory();
currentConfig->allowOverwrite = register_layer_encoders->GetAllowOverwrite();
currentConfig->encodeToSingleFile = register_layer_encoders->GetEncodeToSingleFile();
currentConfig->enc_keepWaves = register_layer_encoders->GetKeepWaveFiles();
currentConfig->useUnicodeNames = register_layer_encoders->GetUnicodeFilenames();
currentConfig->createPlaylist = register_layer_playlists->GetCreatePlaylists();
currentConfig->createCueSheet = register_layer_playlists->GetCreateCueSheets();
currentConfig->playlist_outdir = register_layer_playlists->GetOutputDirectory();
currentConfig->playlist_filePattern = register_layer_playlists->GetFilenamePattern();
currentConfig->playlist_useEncOutdir = register_layer_playlists->GetUseEncOutdir();
if (currentConfig->enable_cdrip && currentConfig->cdrip_numdrives >= 1) currentConfig->cdrip_activedrive = register_layer_cdrip->GetActiveDrive();
currentConfig->cdrip_paranoia = (register_layer_cdrip->GetCDParanoiaMode() != -1);
currentConfig->cdrip_paranoia_mode = (register_layer_cdrip->GetCDParanoiaMode() == -1 ? 0 : register_layer_cdrip->GetCDParanoiaMode());
currentConfig->cdrip_speed = register_layer_cdrip->GetSpeed();
currentConfig->cdrip_jitter = register_layer_cdrip->GetJitter();
currentConfig->cdrip_swapchannels = register_layer_cdrip->GetSwapChannels();
currentConfig->cdrip_locktray = register_layer_cdrip->GetLockTray();
currentConfig->cdrip_ntscsi = register_layer_cdrip->GetNTSCSI();
currentConfig->cdrip_autoRead = register_layer_cdrip->GetAutoRead();
currentConfig->cdrip_autoRip = register_layer_cdrip->GetAutoRip();
currentConfig->cdrip_autoEject = register_layer_cdrip->GetAutoEject();
currentConfig->cdrip_read_cdtext = register_layer_cdrip->GetReadCDText();
currentConfig->cdrip_read_cdplayerini = register_layer_cdrip->GetReadCDPlayerIni();
currentConfig->enable_id3v1 = register_layer_tags->GetEnableID3V1();
currentConfig->enable_id3v2 = register_layer_tags->GetEnableID3V2();
currentConfig->enable_vctags = register_layer_tags->GetEnableVCTags();
currentConfig->enable_mp4meta = register_layer_tags->GetEnableMP4Meta();
currentConfig->enable_wmatags = register_layer_tags->GetEnableWMAMeta();
currentConfig->id3v1_encoding = register_layer_tags->GetID3V1Encoding();
currentConfig->id3v2_encoding = register_layer_tags->GetID3V2Encoding();
currentConfig->vctag_encoding = register_layer_tags->GetVCTagEncoding();
currentConfig->mp4meta_encoding = register_layer_tags->GetMP4MetaEncoding();
currentConfig->wmameta_encoding = register_layer_tags->GetWMAMetaEncoding();
currentConfig->overwriteComments = register_layer_tags->GetOverwriteComments();
currentConfig->enable_local_cddb = register_layer_cddb->GetLocalCDDB();
currentConfig->enable_remote_cddb = register_layer_cddb->GetRemoteCDDB();
currentConfig->enable_auto_cddb = register_layer_cddb->GetCDDBAutoQuery();
currentConfig->enable_overwrite_cdtext = register_layer_cddb->GetCDDBOverwriteCDText();
currentConfig->enable_cddb_cache = register_layer_cddb->GetCDDBCache();
currentConfig->default_comment = register_layer_tags->GetDefaultComment();
currentConfig->freedb_dir = register_layer_cddb->GetLocalPath();
currentConfig->freedb_server = register_layer_cddb->GetFreedbServer();
currentConfig->freedb_email = register_layer_cddb->GetFreedbEMail();
if (currentConfig->freedb_mode == FREEDB_MODE_CDDBP) currentConfig->freedb_cddbp_port = register_layer_cddb->GetFreedbPort();
else if (currentConfig->freedb_mode == FREEDB_MODE_HTTP) currentConfig->freedb_http_port = register_layer_cddb->GetFreedbPort();
currentConfig->output_plugin = register_layer_plugins->GetSelectedOutputPlugin();
if (currentConfig->enc_outdir[currentConfig->enc_outdir.Length() - 1] != '\\') currentConfig->enc_outdir.Append("\\");
if (currentConfig->playlist_outdir[currentConfig->playlist_outdir.Length() - 1] != '\\') currentConfig->playlist_outdir.Append("\\");
if (currentConfig->freedb_dir[currentConfig->freedb_dir.Length() - 1] != '\\') currentConfig->freedb_dir.Append("\\");
mainWnd->Close();
}
