bool NemoCalendarImportModel::importToNotebook(const QString ¬ebookUid)
{
mKCal::ExtendedCalendar::Ptr calendar(new mKCal::ExtendedCalendar(KDateTime::Spec::LocalZone()));
mKCal::ExtendedStorage::Ptr storage = calendar->defaultStorage(calendar);
if (!storage->open()) {
qWarning() << "Unable to open calendar DB";
return false;
}
if (!notebookUid.isEmpty()) {
if (! (storage->defaultNotebook() && storage->defaultNotebook()->uid() == notebookUid)) {
mKCal::Notebook::Ptr notebook = storage->notebook(notebookUid);
if (notebook) {
// TODO: should we change default notebook back if we change it?
storage->setDefaultNotebook(notebook);
} else {
qWarning() << "Invalid notebook UID" << notebookUid;
return false;
}
}
}
if (importFromFile(mFileName, calendar))
storage->save();
storage->close();
return true;
}
void Surface_Radiance_Plugin::importFromFileDialog()
{
QStringList fileNames = QFileDialog::getOpenFileNames(m_schnapps, "Import surface with radiance", m_schnapps->getAppPath(), "Surface with radiance Files (*.ply)");
QStringList::Iterator it = fileNames.begin();
while(it != fileNames.end()) {
importFromFile(*it);
++it;
}
}
MStatus FileTranslator::reader ( const MFileObject& file,
const MString& options,
MPxFileTranslator::FileAccessMode mode )
{
MStatus status ( MS::kSuccess );
try
{
#if MAYA_API_VERSION >= 800
if ( mode == MPxFileTranslator::kReferenceAccessMode )
{
int optionValue;
MGlobal::executeCommand ( "optionVar -q \"referenceOptionsSharedReference\";", optionValue );
if ( optionValue != 0 )
{
#ifdef WIN32
MessageBox ( NULL, "Maya may now hang. Do disable the reference option named: \"Shared Reference Nodes\".", "POSSIBLE HANG", MB_OK );
#endif
}
}
#endif // Maya 8.0 and 8.5
#if defined (OSMac_)
char nameBuffer[MAXPATHLEN];
strcpy ( nameBuffer, file.fullName().asChar() );
const MString filename ( nameBuffer );
#else
const MString filename = file.fullName();
#endif // OSMac
// Process the import options
ImportOptions::set ( options, mode );
if (ImportOptions::hasError()) status = MStatus::kFailure;
// Import the COLLADA DAE file
status = importFromFile ( filename.asChar() );
}
catch ( COLLADABU::Exception* exception )
{
MGlobal::displayWarning ( exception->getMessage().c_str() );
}
catch ( ... )
{
MGlobal::displayWarning ( "ColladaMaya has thrown an exception!" );
}
return status;
}
KrBookmarkHandler::KrBookmarkHandler(FileManagerWindow *mainWindow) : QObject(mainWindow->widget()),
_mainWindow(mainWindow), _middleClick(false), _mainBookmarkPopup(0), _specialBookmarks()
{
// create our own action collection and make the shortcuts apply only to parent
_privateCollection = new KActionCollection(this);
_collection = _mainWindow->actions();
// create _root: father of all bookmarks. it is a dummy bookmark and never shown
_root = new KrBookmark(i18n("Bookmarks"));
_root->setParent(this);
// load bookmarks
importFromFile();
// hack
QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + BOOKMARKS_FILE;
manager = KBookmarkManager::managerForFile(filename, QStringLiteral("krusader"));
connect(manager, SIGNAL(changed(const QString&, const QString&)), this, SLOT(bookmarksChanged(const QString&, const QString&)));
}
bool NemoCalendarImportModel::importToMemory(const QString &fileName)
{
if (!mEventList.isEmpty())
mEventList.clear();
beginResetModel();
KCalCore::MemoryCalendar::Ptr cal(new KCalCore::MemoryCalendar(KDateTime::Spec::LocalZone()));
importFromFile(fileName, cal);
KCalCore::Incidence::List incidenceList = cal->incidences();
for (int i = 0; i < incidenceList.size(); i++) {
KCalCore::Incidence::Ptr incidence = incidenceList.at(i);
if (incidence->type() == KCalCore::IncidenceBase::TypeEvent)
mEventList.append(incidence.staticCast<KCalCore::Event>());
}
if (!mEventList.isEmpty())
qSort(mEventList.begin(), mEventList.end(), incidenceLessThan);
endResetModel();
emit countChanged();
return true;
}
/** The main program. */
int main(int argc, char *argv[])
{
Parameters param(argc, argv); // parse the command-line arguments
if(param.noOfNodes() == std::numeric_limits<unsigned int>::max() || param.noOfEdges() ==std::numeric_limits<unsigned int>::max())
{
STXXL_MSG("Either number of vertices or edges is not speicifed. Exiting!!!");
return 0;
}
Graph inputGraph(param.noOfNodes(),param.noOfEdges());
if (param.randomGraph())
{
STXXL_MSG("Generating random graph");
inputGraph.generateGraph();
inputGraph.printGraph();
}
else if (param.importInputFilename() != "")
{
// import graph from file
STXXL_MSG("Import graph" << std::endl );
if(param.otherGraph())
importFromFile(param.importInputFilename(),inputGraph );
else
importEdgeVector( param.importInputFilename(),inputGraph );
}
// export input graph
if (param.outputFilename() != "")
{
STXXL_MSG("Export graph" << std::endl );
std::ofstream outFile(param.outputFilename().c_str());
exportEdgeVector(outFile, inputGraph);
}
stxxl::stats_data stats_begin(*stxxl::stats::get_instance());
stxxl::timer Timer;
MST mst(inputGraph.getNoVertices());
mst.clearMST();
float B = (float) BLOCK_SIZE/(float)(sizeof(Edge));
float M = (10 * 1024 * 1024)/(float)(sizeof(Edge));
float N = param.noOfNodes()+2*param.noOfEdges();
STXXL_MSG("N: "<<N<<" M: "<<M<<" B: "<<B<<" Sizeof Edge: "<<sizeof(Edge));
if(N > M)
{
stxxl::stats_data stats_begin(*stxxl::stats::get_instance());
Timer.reset();
Timer.start();
stage(inputGraph,mst);
STXXL_MSG("Part-1 build elapsed time: " << (Timer.mseconds() / 1000.) <<" seconds : " << (double(inputGraph.getNoEdges()) / (Timer.mseconds() / 1000.)) << " edges per sec");
std::cout << stats_total;
}
if(inputGraph.getNoEdges() != 0)
{
stats_begin = *stxxl::stats::get_instance();
Timer.reset();
Timer.start();
ExternalPrim prim;
prim.buildMST(inputGraph,mst);
STXXL_MSG("MST build elapsed time: " << (Timer.mseconds() / 1000.) <<" seconds : " << (double(inputGraph.getNoEdges()) / (Timer.mseconds() / 1000.)) << " edges per sec");
std::cout << stxxl::stats_data(*stxxl::stats::get_instance()) - stats_begin;
}
mst.printMST();
return 0;
}
TranslationMatrix::TranslationMatrix(const string& inputFile)
{
importFromFile(inputFile);
}
int
main (int argc, char **argv) {
char tmpName[FILENAME_MAX] = {0};
char *gkpName = NULL;
char *tigName = NULL;
int32 tigVers = -1;
int32 tigPart = -1;
int64 ctgBgn = -1;
int64 ctgEnd = -1;
char *ctgName = NULL;
char *outName = NULL;
char *inName = NULL;
bool forceCompute = false;
int32 numFailures = 0;
int32 numSkipped = 0;
bool useUnitig = false;
bool showResult = false;
CNS_Options options = { CNS_OPTIONS_SPLIT_ALLELES_DEFAULT,
CNS_OPTIONS_MIN_ANCHOR_DEFAULT,
CNS_OPTIONS_DO_PHASING_DEFAULT };
// Comminucate to MultiAlignment_CNS.c that we are doing consensus and not cgw.
thisIsConsensus = 1;
argc = AS_configure(argc, argv);
int arg=1;
int err=0;
while (arg < argc) {
if (strcmp(argv[arg], "-g") == 0) {
gkpName = argv[++arg];
} else if (strcmp(argv[arg], "-t") == 0) {
tigName = argv[++arg];
tigVers = atoi(argv[++arg]);
tigPart = atoi(argv[++arg]);
} else if (strcmp(argv[arg], "-c") == 0) {
AS_UTL_decodeRange(argv[++arg], ctgBgn, ctgEnd);
} else if (strcmp(argv[arg], "-T") == 0) {
ctgName = argv[++arg];
} else if (strcmp(argv[arg], "-O") == 0) {
outName = argv[++arg];
} else if (strcmp(argv[arg], "-I") == 0) {
inName = argv[++arg];
} else if (strcmp(argv[arg], "-f") == 0) {
forceCompute = true;
} else if (strcmp(argv[arg], "-U") == 0) {
useUnitig = true;
} else if (strcmp(argv[arg], "-v") == 0) {
showResult = true;
} else if (strcmp(argv[arg], "-V") == 0) {
VERBOSE_MULTIALIGN_OUTPUT++;
} else if (strcmp(argv[arg], "-w") == 0) {
options.smooth_win = atoi(argv[++arg]);
} else if (strcmp(argv[arg], "-P") == 0) {
options.do_phasing = atoi(argv[++arg]);
} else {
fprintf(stderr, "%s: Unknown option '%s'\n", argv[0], argv[arg]);
err++;
}
arg++;
}
if ((err) || (gkpName == NULL) || (tigName == NULL)) {
fprintf(stderr, "usage: %s -g gkpStore -t tigStore version partition [opts]\n", argv[0]);
fprintf(stderr, " -c b Compute only contig ID 'b' (must be in the correct partition!)\n");
fprintf(stderr, " -c b-e Compute only contigs from ID 'b' to ID 'e'\n");
fprintf(stderr, "\n");
fprintf(stderr, " -T file Test the computation of the contig layout in 'file'\n");
fprintf(stderr, "\n");
fprintf(stderr, " -f Recompute contigs that already have a multialignment\n");
fprintf(stderr, "\n");
fprintf(stderr, " -U Reuse the unitig consensus for contigs with only a single\n");
fprintf(stderr, " unitig (EXPERIMENTAL!)\n");
fprintf(stderr, "\n");
fprintf(stderr, " -O file Don't update tigStore, dump a binary file instead.\n");
fprintf(stderr, " -I file Import binary file into tigStore\n");
fprintf(stderr, "\n");
fprintf(stderr, " -v Show multialigns.\n");
fprintf(stderr, " -V Enable debugging option 'verbosemultialign'.\n");
fprintf(stderr, "\n");
fprintf(stderr, " -w ws Smoothing window size\n");
fprintf(stderr, "\n");
exit(1);
}
// Open both stores for read only.
gkpStore = new gkStore(gkpName, false, false);
tigStore = new MultiAlignStore(tigName, tigVers, 0, tigPart, false, false, false);
gkpStore->gkStore_loadPartition(tigPart);
// Decide on what to compute. Either all contigs, or a single contig, or a special case test.
uint32 b = 0;
uint32 e = tigStore->numContigs();
if (ctgBgn != -1) {
b = ctgBgn;
e = ctgEnd + 1;
}
FORCE_UNITIG_ABUT = 1;
if (ctgName != NULL) {
errno = 0;
FILE *F = fopen(ctgName, "r");
if (errno)
fprintf(stderr, "Failed to open input contig file '%s': %s\n", ctgName, strerror(errno)), exit(1);
MultiAlignT *ma = CreateEmptyMultiAlignT();
bool isUnitig = false;
while (LoadMultiAlignFromHuman(ma, isUnitig, F) == true) {
if (ma->maID < 0)
ma->maID = (isUnitig) ? tigStore->numUnitigs() : tigStore->numContigs();
if (MultiAlignContig(ma, gkpStore, &options)) {
if (showResult)
PrintMultiAlignT(stdout, ma, gkpStore, false, false, AS_READ_CLEAR_LATEST);
} else {
fprintf(stderr, "MultiAlignContig()-- contig %d failed.\n", ma->maID);
numFailures++;
}
}
DeleteMultiAlignT(ma);
b = e = 0;
}
// Reopen for writing, if we have work to do.
if (((inName) || (b < e)) && (outName == NULL)) {
delete tigStore;
tigStore = new MultiAlignStore(tigName, tigVers, 0, tigPart, true, false, true);
}
if (inName) {
importFromFile(inName, tigPart);
b = e = 0;
}
// Now the usual case. Iterate over all contigs, compute and update.
for (uint32 i=b; i<e; i++) {
MultiAlignT *cma = tigStore->loadMultiAlign(i, false);
if (cma == NULL) {
// Not in our partition, or deleted.
continue;
}
bool exists = (cma->consensus != NULL) && (GetNumchars(cma->consensus) > 1);
if ((forceCompute == false) && (exists == true)) {
// Already finished contig consensus.
fprintf(stderr, "Working on contig %d (%d unitigs and %d fragments) - already computed, skipped\n",
cma->maID, cma->data.num_unitigs, cma->data.num_frags);
numSkipped++;
tigStore->unloadMultiAlign(cma->maID, false);
continue;
}
int32 uID = GetIntUnitigPos(cma->u_list, 0)->ident;
// If this is a surrogate, we CANNOT reuse the unitig. We need to process the contig so that
// the unplaced reads are stripped out. A surrogate should have different contig and unitig
// IDs; we could also check the contig status.
if ((cma->data.num_unitigs == 1) &&
(cma->maID == uID) &&
(useUnitig == true)) {
fprintf(stderr, "Working on contig %d (%d unitigs and %d fragments) - reusing unitig %d consensus\n",
cma->maID, cma->data.num_unitigs, cma->data.num_frags, uID);
MultiAlignT *uma = tigStore->loadMultiAlign(uID, true);
uma->data = cma->data;
tigStore->unloadMultiAlign(cma->maID, false);
if (outName)
writeToOutFile(outName, tigPart, uma);
else
tigStore->insertMultiAlign(uma, false, false);
tigStore->unloadMultiAlign(uma->maID, true);
continue;
}
fprintf(stderr, "Working on contig %d (%d unitigs and %d fragments)%s\n",
cma->maID, cma->data.num_unitigs, cma->data.num_frags,
(exists) ? " - already computed, recomputing" : "");
if (MultiAlignContig(cma, gkpStore, &options)) {
if (outName)
writeToOutFile(outName, tigPart, cma);
else
tigStore->insertMultiAlign(cma, false, true);
if (showResult)
PrintMultiAlignT(stdout, cma, gkpStore, false, false, AS_READ_CLEAR_LATEST);
tigStore->unloadMultiAlign(cma->maID, false);
} else {
fprintf(stderr, "MultiAlignContig()-- contig %d failed.\n", cma->maID);
numFailures++;
}
}
delete tigStore;
fprintf(stderr, "\n");
fprintf(stderr, "NumColumnsInUnitigs = %d\n", NumColumnsInUnitigs);
fprintf(stderr, "NumGapsInUnitigs = %d\n", NumGapsInUnitigs);
fprintf(stderr, "NumRunsOfGapsInUnitigReads = %d\n", NumRunsOfGapsInUnitigReads);
fprintf(stderr, "NumColumnsInContigs = %d\n", NumColumnsInContigs);
fprintf(stderr, "NumGapsInContigs = %d\n", NumGapsInContigs);
fprintf(stderr, "NumRunsOfGapsInContigReads = %d\n", NumRunsOfGapsInContigReads);
fprintf(stderr, "NumAAMismatches = %d\n", NumAAMismatches);
fprintf(stderr, "NumVARRecords = %d\n", NumVARRecords);
fprintf(stderr, "NumVARStringsWithFlankingGaps = %d\n", NumVARStringsWithFlankingGaps);
fprintf(stderr, "NumUnitigRetrySuccess = %d\n", NumUnitigRetrySuccess);
fprintf(stderr, "\n");
if (numFailures) {
fprintf(stderr, "WARNING: Total number of contig failures = %d\n", numFailures);
fprintf(stderr, "\n");
fprintf(stderr, "Consensus did NOT finish successfully.\n");
return(1);
}
fprintf(stderr, "Consensus finished successfully. Bye.\n");
return(0);
}
void ewol::resource::DistanceFieldFont::init(const std::string& _fontName) {
std11::unique_lock<std11::recursive_mutex> lock(m_mutex);
ewol::resource::Texture::init(_fontName);
std::string localName = _fontName;
std::vector<std::string> folderList;
if (true == ewol::getContext().getFontDefault().getUseExternal()) {
#if defined(__TARGET_OS__Android)
folderList.push_back("ROOT:system/fonts");
#elif defined(__TARGET_OS__Linux)
folderList.push_back("ROOT:usr/share/fonts/truetype");
#endif
}
std::string applicationBaseFont = ewol::getContext().getFontDefault().getFolder();
std::vector<std::string> applicationBaseFontList = etk::FSNodeExplodeMultiplePath(applicationBaseFont);
for (auto &it : applicationBaseFontList) {
folderList.push_back(it);
}
for (size_t folderID = 0; folderID < folderList.size() ; folderID++) {
etk::FSNode myFolder(folderList[folderID]);
// find the real Font name :
std::vector<std::string> output;
myFolder.folderGetRecursiveFiles(output);
std::vector<std::string> split = etk::split(localName, ';');
EWOL_INFO("try to find font named : " << split << " in: " << myFolder);
//EWOL_CRITICAL("parse string : " << split);
bool hasFindAFont = false;
for (size_t jjj=0; jjj<split.size(); jjj++) {
EWOL_INFO(" try with : '" << split[jjj] << "'");
for (size_t iii=0; iii<output.size(); iii++) {
//EWOL_DEBUG(" file : " << output[iii]);
if( true == etk::end_with(output[iii], split[jjj]+"-"+"regular"+".ttf", false)
|| true == etk::end_with(output[iii], split[jjj]+"-"+"r"+".ttf", false)
|| true == etk::end_with(output[iii], split[jjj]+"regular"+".ttf", false)
|| true == etk::end_with(output[iii], split[jjj]+"r"+".ttf", false)
|| true == etk::end_with(output[iii], split[jjj]+".ttf", false)) {
EWOL_INFO(" find Font [Regular] : " << output[iii]);
m_fileName = output[iii];
hasFindAFont=true;
break;
}
}
if (hasFindAFont == true) {
EWOL_INFO(" find this font : '" << split[jjj] << "'");
break;
} else if (jjj == split.size()-1) {
EWOL_ERROR("Find NO font in the LIST ... " << split);
}
}
if (hasFindAFont == true) {
EWOL_INFO(" find this font : '" << folderList[folderID] << "'");
break;
} else if (folderID == folderList.size()-1) {
EWOL_ERROR("Find NO font in the LIST ... " << folderList);
}
}
if (m_fileName.size() == 0) {
EWOL_ERROR("can not load FONT name : '" << m_fileName << "'" );
m_font = nullptr;
return;
}
EWOL_INFO("Load FONT name : '" << m_fileName << "'");
m_font = ewol::resource::FontFreeType::create(m_fileName);
if (m_font == nullptr) {
EWOL_ERROR("Pb Loading FONT name : '" << m_fileName << "'" );
}
// set the bassic charset:
m_listElement.clear();
if (m_font == nullptr) {
return;
}
if (importFromFile() == true) {
EWOL_INFO("GET distance field from previous file");
flush();
return;
}
m_sizeRatio = ((float)SIZE_GENERATION) / ((float)m_font->getHeight(SIZE_GENERATION));
// TODO : basic font use 512 is better ... == > maybe estimate it with the dpi ???
setImageSize(ivec2(256,32));
// now we can acces directly on the image
m_data.clear(etk::Color<>(0x00000000));
// add error glyph
addGlyph(0);
// by default we set only the first AINSI char availlable
for (int32_t iii=0x20; iii<0x7F; iii++) {
addGlyph(iii);
}
flush();
//exportOnFile();
}
bool importFromFile(const std::string fileName, const std::string& xmlPath){ return importFromFile(fileName.c_str(), xmlPath); }
