Value* RornUtils_ExportCompileAndView_cf(Value** arg_list, int count)
{
check_arg_count(RornUtils_ExportCompileAndView, 1, count);
Value* exportPathValue = arg_list[0];
Rorn::Text::ci_string exportPath( exportPathValue->to_string() );
SceneExporter exporter(GetCOREInterface());
exporter.ExportScene( exportPath );
// compile
std::string modelCompilerPathname;
Rorn::WindowsRegistry::GetRegistryTextValue(Rorn::WindowsRegistry::LocalMachine, "SOFTWARE\\Riversoft\\Rorn", "ModelCompilerPathname", modelCompilerPathname);
Rorn::Text::ci_string compiledModelPathname = Rorn::Text::Path::ChangeExtension(exportPath, "model");
std::stringstream compilerArgumentsStream;
compilerArgumentsStream << "\"" << modelCompilerPathname.c_str() << "\" \"" << exportPath.c_str() << "\" \"" << compiledModelPathname.c_str() << "\"";
std::string modelCompilerOutput;
int compilerExitCode = Rorn::Process::RunCommandLineApplication(modelCompilerPathname.c_str(), compilerArgumentsStream.str().c_str(), modelCompilerOutput);
// view
std::string modelViewerPathname;
Rorn::WindowsRegistry::GetRegistryTextValue(Rorn::WindowsRegistry::LocalMachine, "SOFTWARE\\Riversoft\\Rorn", "ModelViewerPathname", modelViewerPathname);
Rorn::Process::LaunchApplication(modelViewerPathname.c_str(), compiledModelPathname.c_str());
return &ok;
}
void Plot::exportToPng()
{
const QString filter = tr("Images") + "(*.png);;" + Path::getTemplate(Path::ALL_FILES);
Path exportPath("paths/exportPath");
if(exportPath.setSaveFileName(this, tr("Export current plot to image"), filter)){
QwtPlotRenderer renderer;
exportToPng(renderer, exportPath.getPath());
}
}
Value* RornUtils_Export_cf(Value** arg_list, int count)
{
check_arg_count(RornUtils_Export, 1, count);
Value* exportPathValue = arg_list[0];
Rorn::Text::ci_string exportPath( exportPathValue->to_string() );
SceneExporter exporter(GetCOREInterface());
exporter.ExportScene( exportPath );
return &ok;
}
void ExtractPath()
{
vector<point3d> currPath;
Node *s = startNode;
int currX = startNode->x;
int currY = startNode->y;
Pave_Libraries_Geometry::point3d p;
p.x = currX * costmapXUnit + costmapXMin;
p.y = currY * costmapYUnit + costmapYMin;
currPath.push_back(p);
//exportGValues(memory, 2000, 2000, 2300, 2200);
do {
s = s->bptr;
currX = s->x;
currY = s->y;
p.x = currX * costmapXUnit + costmapXMin;
p.y = currY * costmapYUnit + costmapYMin;
currPath.push_back(p);
//if (abs(s->g - s->rhs) > 0.01) {
// dump(memory, costmap, currX, currY, 0, 0);
//}
} while (s != goalNode);
prevPath = currPath;
#ifndef DEBUGMAP
list_point3d container;
container.numPoints = (int)currPath.size();
container.points = &currPath[0];
SpeedFinder(container);
//cout << "publishing path update... \n";
Messages::PathUpdate.publish(&container);
//exportPath(currPath);
#else
exportPath(currPath);
#endif
}
bool RDReport::ExportMusicPlayout(const QDate &startdate,const QDate &enddate,
const QString &mixtable)
{
QString sql;
RDSqlQuery *q;
FILE *f;
QString cut;
QString str;
QString cart_fmt;
QString cart_num;
#ifdef WIN32
QString filename=RDDateDecode(exportPath(RDReport::Windows),startdate);
#else
QString filename=RDDateDecode(exportPath(RDReport::Linux),startdate);
#endif
QFile file(filename);
if((f=fopen((const char *)filename,"w"))==NULL) {
report_error_code=RDReport::ErrorCantOpen;
return false;
}
if(useLeadingZeros()) {
cart_fmt=QString().sprintf("%%0%uu",cartDigits());
}
else {
cart_fmt="%6u";
}
sql=QString("select ")+
"`"+mixtable+"_SRT`.LENGTH,"+ // 00
"`"+mixtable+"_SRT`.CART_NUMBER,"+ // 01
"`"+mixtable+"%s_SRT`.EVENT_DATETIME,"+ // 02
"`"+mixtable+"_SRT`.EXT_EVENT_ID,"+ // 03
"`"+mixtable+"_SRT`.TITLE,"+ // 04
"`"+mixtable+"_SRT`.CUT_NUMBER,"+ // 05
"`"+mixtable+"_SRT`.ARTIST,"+ // 06
"`"+mixtable+"_SRT`.ALBUM,"+ // 07
"`"+mixtable+"_SRT`.LABEL "+ // 08
"from `"+mixtable+"_SRT` left join CART "+
"on `"+mixtable+"_SRT`.CART_NUMBER=CART.NUMBER "+
"order by EVENT_DATETIME";
q=new RDSqlQuery(sql);
//
// Write File Header
//
if(startdate==enddate) {
fprintf(f," Rivendell RDAirPlay Music Playout Report for %s\n",
(const char *)startdate.toString("MM/dd/yyyy"));
}
else {
fprintf(f," Rivendell RDAirPlay Music Playout Report for %s - %s\n",
(const char *)startdate.toString("MM/dd/yyyy"),
(const char *)enddate.toString("MM/dd/yyyy"));
}
str=QString().sprintf("%s -- %s\n",(const char *)name(),
(const char *)description());
for(int i=0;i<(180-str.length())/2;i++) {
fprintf(f," ");
}
fprintf(f,"%s\n",(const char *)str);
fprintf(f,"--Time-- -Cart- Cut A-Len --Title----------------------- --Artist---------------------- --Album------------------ --Label-------------\n");
//
// Write Data Rows
//
while(q->next()) {
if(q->value(5).toInt()>0) {
cut=QString().sprintf("%03d",q->value(5).toInt());
}
else {
if((RDAirPlayConf::TrafficAction)q->value(6).toInt()==
RDAirPlayConf::TrafficMacro) {
cut="rml";
}
else {
cut=" ";
}
}
cart_num=QString().sprintf(cart_fmt,q->value(1).toUInt());
fprintf(f,"%8s %6s %3s %5s %-30s %-30s %-25s %-20s\n",
(const char *)q->value(2).toDateTime().time().toString("hh:mm:ss"),
(const char *)cart_num,
(const char *)cut,
(const char *)RDGetTimeLength(q->value(0).toInt(),true,false).
right(5),
(const char *)StringField(q->value(4).toString().left(30)),
(const char *)StringField(q->value(6).toString().left(30)),
(const char *)StringField(q->value(7).toString().left(25)),
(const char *)StringField(q->value(8).toString().left(20)));
}
delete q;
fclose(f);
report_error_code=RDReport::ErrorOk;
return true;
}
bool RDReport::ExportRadioTraffic(const QDate &startdate,const QDate &enddate,
const QString &mixtable)
{
QString sql;
RDSqlQuery *q;
FILE *f;
QString air_fmt;
#ifdef WIN32
QString filename=RDDateDecode(exportPath(RDReport::Windows),startdate);
#else
QString filename=RDDateDecode(exportPath(RDReport::Linux),startdate);
#endif
QFile file(filename);
if((f=fopen((const char *)filename,"w"))==NULL) {
report_error_code=RDReport::ErrorCantOpen;
return false;
}
if(useLeadingZeros()) {
air_fmt=QString().sprintf("%%0%uu ",cartDigits());
}
else {
air_fmt=QString().sprintf("%%%-uu ",cartDigits());
}
sql=QString().sprintf("select `%s_SRT`.LENGTH,`%s_SRT`.CART_NUMBER,\
`%s_SRT`.EVENT_DATETIME,`%s_SRT`.EVENT_TYPE,\
`%s_SRT`.EXT_START_TIME,`%s_SRT`.EXT_LENGTH,\
`%s_SRT`.EXT_DATA,`%s_SRT`.EXT_EVENT_ID,\
`%s_SRT`.EXT_ANNC_TYPE,`%s_SRT`.TITLE,\
`%s_SRT`.EXT_CART_NAME from `%s_SRT` \
left join CART on\
`%s_SRT`.CART_NUMBER=CART.NUMBER\
order by EVENT_DATETIME",
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable,
(const char *)mixtable);
q=new RDSqlQuery(sql);
//
// Write Data Rows
//
while(q->next()) {
fprintf(f,"%s ",(const char *)q->value(4).toTime().toString("hh:mm:ss"));
fprintf(f,"%s ",(const char *)q->value(2).toDateTime().
toString("hh:mm:ss"));
if(q->value(5).toInt()>0) {
fprintf(f,"0%s ",(const char *)RDGetTimeLength(q->value(5).toInt(),
true,false));
}
else {
fprintf(f,"00:00:00 ");
}
if(q->value(0).toInt()>0) {
fprintf(f,"0%s ",(const char *)RDGetTimeLength(q->value(0).toInt(),
true,false));
}
else {
fprintf(f,"00:00:00 ");
}
fprintf(f,air_fmt,q->value(1).toUInt());
fprintf(f,"%-34s ",(const char *)q->value(9).toString().left(34));
if(q->value(6).toString().isEmpty()) {
fprintf(f," ");
}
else {
fprintf(f,"%-32s",(const char *)q->value(6).toString().left(32).
stripWhiteSpace());
}
fprintf(f,"\r\n");
}
delete q;
fclose(f);
report_error_code=RDReport::ErrorOk;
return true;
}
void TransferFunctionEditor::starting() throw( ::fwTools::Failed )
{
SLM_TRACE_FUNC();
this->create();
// Get the Qt container
::fwGuiQt::container::QtContainer::sptr qtContainer = ::fwGuiQt::container::QtContainer::dynamicCast(this->getContainer());
m_container = qtContainer->getQtContainer();
SLM_ASSERT("Sorry, the qt container is not valid", m_container);
// Buttons creation
m_pTransferFunctionPreset = new QComboBox(m_container);
::boost::filesystem::path deletePath ("Bundles/uiTF_" + std::string(UITF_VER) + "/delete.png");
m_deleteButton = new QPushButton(QIcon(deletePath.string().c_str()), "", m_container);
m_deleteButton->setToolTip(QString("Delete"));
::boost::filesystem::path newPath ("Bundles/uiTF_" + std::string(UITF_VER) + "/new.png");
m_newButton = new QPushButton(QIcon(newPath.string().c_str()), "", m_container);
m_newButton->setToolTip(QString("New"));
::boost::filesystem::path reinitializePath ("Bundles/uiTF_" + std::string(UITF_VER) + "/reinitialize.png");
m_reinitializeButton = new QPushButton(QIcon(reinitializePath.string().c_str()), "", m_container);
m_reinitializeButton->setToolTip(QString("Reinitialize"));
::boost::filesystem::path renamePath ("Bundles/uiTF_" + std::string(UITF_VER) + "/rename.png");
m_renameButton = new QPushButton(QIcon(renamePath.string().c_str()), "", m_container);
m_renameButton->setToolTip(QString("Rename"));
::boost::filesystem::path importPath ("Bundles/uiTF_" + std::string(UITF_VER) + "/import.png");
m_importButton = new QPushButton(QIcon(importPath.string().c_str()), "", m_container);
m_importButton->setToolTip(QString("Import"));
::boost::filesystem::path exportPath ("Bundles/uiTF_" + std::string(UITF_VER) + "/export.png");
m_exportButton = new QPushButton(QIcon(exportPath.string().c_str()), "", m_container);
m_exportButton->setToolTip(QString("Export"));
// Layout management
QBoxLayout* layout = new QBoxLayout(QBoxLayout::LeftToRight, m_container);
layout->addWidget(m_pTransferFunctionPreset);
layout->addWidget(m_deleteButton);
layout->addWidget(m_newButton);
layout->addWidget(m_reinitializeButton);
layout->addWidget(m_renameButton);
layout->addWidget(m_importButton);
layout->addWidget(m_exportButton);
m_container->setLayout(layout);
// Qt signals management ( connection to buttons )
QObject::connect(m_pTransferFunctionPreset, SIGNAL( activated(int)), this, SLOT(presetChoice(int)));
QObject::connect(m_deleteButton, SIGNAL( clicked()), this, SLOT(deleteTF()));
QObject::connect(m_newButton, SIGNAL( clicked()), this, SLOT(newTF()));
QObject::connect(m_reinitializeButton, SIGNAL( clicked()), this, SLOT(reinitializeTFPool()));
QObject::connect(m_renameButton, SIGNAL( clicked()), this, SLOT(renameTF()));
QObject::connect(m_importButton, SIGNAL( clicked()), this, SLOT(importTF()));
QObject::connect(m_exportButton, SIGNAL( clicked()), this, SLOT(exportTF()));
// preset initialization
this->initTransferFunctions();
}
bool ExportCommand::Execute()
{
bool bRet = false;
// When the user clicked on a working copy, we know that the export should
// be done from that. We then have to ask where the export should go to.
// If however the user clicked on an unversioned folder, we assume that
// this is where the export should go to and have to ask from where
// the export should be done from.
bool bURL = !!SVN::PathIsURL(cmdLinePath);
svn_wc_status_kind s = SVNStatus::GetAllStatus(cmdLinePath);
if ((bURL)||(s == svn_wc_status_unversioned)||(s == svn_wc_status_none))
{
// ask from where the export has to be done
CExportDlg dlg;
if (bURL)
dlg.m_URL = cmdLinePath.GetSVNPathString();
else
dlg.m_strExportDirectory = cmdLinePath.GetWinPathString();
if (parser.HasKey(_T("revision")))
{
SVNRev Rev = SVNRev(parser.GetVal(_T("revision")));
dlg.Revision = Rev;
}
dlg.m_blockPathAdjustments = parser.HasKey(L"blockpathadjustments");
if (dlg.DoModal() == IDOK)
{
CTSVNPath exportPath(dlg.m_strExportDirectory);
CSVNProgressDlg progDlg;
theApp.m_pMainWnd = &progDlg;
progDlg.SetCommand(CSVNProgressDlg::SVNProgress_Export);
progDlg.SetAutoClose (parser);
DWORD options = dlg.m_bNoExternals ? ProgOptIgnoreExternals : ProgOptNone;
options |= dlg.m_bNoKeywords ? ProgOptIgnoreKeywords : ProgOptNone;
if (dlg.m_eolStyle.CompareNoCase(_T("CRLF"))==0)
options |= ProgOptEolCRLF;
if (dlg.m_eolStyle.CompareNoCase(_T("CR"))==0)
options |= ProgOptEolCR;
if (dlg.m_eolStyle.CompareNoCase(_T("LF"))==0)
options |= ProgOptEolLF;
progDlg.SetOptions(options);
progDlg.SetPathList(CTSVNPathList(exportPath));
progDlg.SetUrl(dlg.m_URL);
progDlg.SetRevision(dlg.Revision);
progDlg.SetDepth(dlg.m_depth);
progDlg.DoModal();
bRet = !progDlg.DidErrorsOccur();
}
}
else
{
// ask where the export should go to.
CBrowseFolder folderBrowser;
CString strTemp;
strTemp.LoadString(IDS_PROC_EXPORT_1);
folderBrowser.SetInfo(strTemp);
folderBrowser.m_style = BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS | BIF_VALIDATE | BIF_EDITBOX;
strTemp.LoadString(IDS_PROC_EXPORT_2);
folderBrowser.SetCheckBoxText(strTemp);
strTemp.LoadString(IDS_PROC_OMMITEXTERNALS);
folderBrowser.SetCheckBoxText2(strTemp);
folderBrowser.DisableCheckBox2WhenCheckbox1IsEnabled(true);
CRegDWORD regExtended = CRegDWORD(_T("Software\\TortoiseSVN\\ExportExtended"), FALSE);
CBrowseFolder::m_bCheck = regExtended;
TCHAR saveto[MAX_PATH];
if (folderBrowser.Show(GetExplorerHWND(), saveto, _countof(saveto))==CBrowseFolder::OK)
{
CString saveplace = CString(saveto);
if (cmdLinePath.IsEquivalentTo(CTSVNPath(saveplace)))
{
// exporting to itself:
// remove all svn admin dirs, effectively unversion the 'exported' folder.
CString msg;
msg.Format(IDS_PROC_EXPORTUNVERSION, (LPCTSTR)saveplace);
bool bUnversion = false;
if (CTaskDialog::IsSupported())
{
CTaskDialog taskdlg(msg,
CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK2)),
L"TortoiseSVN",
0,
TDF_ENABLE_HYPERLINKS|TDF_USE_COMMAND_LINKS|TDF_ALLOW_DIALOG_CANCELLATION|TDF_POSITION_RELATIVE_TO_WINDOW);
taskdlg.AddCommandControl(1, CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK3)));
taskdlg.AddCommandControl(2, CString(MAKEINTRESOURCE(IDS_PROC_EXPORTUNVERSION_TASK4)));
taskdlg.SetCommonButtons(TDCBF_CANCEL_BUTTON);
taskdlg.SetDefaultCommandControl(1);
taskdlg.SetMainIcon(TD_WARNING_ICON);
bUnversion = (taskdlg.DoModal(GetExplorerHWND()) == 1);
}
else
{
bUnversion = (MessageBox(GetExplorerHWND(), msg, _T("TortoiseSVN"), MB_ICONQUESTION|MB_YESNO) == IDYES);
}
if (bUnversion)
{
CProgressDlg progress;
progress.SetTitle(IDS_PROC_UNVERSION);
progress.SetAnimation(IDR_MOVEANI);
progress.FormatNonPathLine(1, IDS_SVNPROGRESS_EXPORTINGWAIT);
progress.SetTime(true);
progress.ShowModeless(GetExplorerHWND());
std::vector<CTSVNPath> removeVector;
CDirFileEnum lister(saveplace);
CString srcFile;
bool bFolder = false;
while (lister.NextFile(srcFile, &bFolder))
{
CTSVNPath item(srcFile);
if ((bFolder)&&(g_SVNAdminDir.IsAdminDirName(item.GetFileOrDirectoryName())))
{
removeVector.push_back(item);
}
}
DWORD count = 0;
for (std::vector<CTSVNPath>::iterator it = removeVector.begin(); (it != removeVector.end()) && (!progress.HasUserCancelled()); ++it)
{
progress.FormatPathLine(1, IDS_SVNPROGRESS_UNVERSION, (LPCTSTR)it->GetWinPath());
progress.SetProgress64(count, removeVector.size());
count++;
it->Delete(false);
}
progress.Stop();
bRet = true;
}
else
return false;
}
else
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": export %s to %s\n"), (LPCTSTR)cmdLinePath.GetUIPathString(), (LPCTSTR)saveto);
SVN svn;
if (!svn.Export(cmdLinePath, CTSVNPath(saveplace), SVNRev::REV_WC,
SVNRev::REV_WC, false, !!folderBrowser.m_bCheck2, false, svn_depth_infinity,
GetExplorerHWND(), folderBrowser.m_bCheck ? SVN::SVNExportIncludeUnversioned : SVN::SVNExportNormal))
{
svn.ShowErrorDialog(GetExplorerHWND(), cmdLinePath);
bRet = false;
}
else
bRet = true;
regExtended = CBrowseFolder::m_bCheck;
}
}
}
return bRet;
}
