int SQY_h5_query_dtype(const char* fname,
const char* dname,
unsigned* dtype){
#ifndef _SQY_DEBUG_
H5::Exception::dontPrint();
#endif
bfs::path lpath = fname;
sqy::h5_file loaded(lpath);
if(!loaded.ready())
return 1;
else{
std::string dn = dname;
*dtype = 0;
if(loaded.is_integer(dn)){
*dtype += 1;
if(loaded.is_signed(dn))
*dtype += 1;
}
}
return 0;
}
int SQY_h5_read_UI16(const char* fname,
const char* dname,
unsigned short* data){
int rvalue = 1;
#ifndef _SQY_DEBUG_
H5::Exception::dontPrint();
#endif
bfs::path lpath = fname;
sqy::h5_file loaded(lpath);
if(!loaded.ready())
return rvalue;
if(!loaded.has_h5_item(dname))
return rvalue;
else{
std::vector<int> shape;
rvalue = loaded.read_nd_dataset(dname,
data,
shape);
}
return rvalue;
}
int SQY_h5_query_shape(const char* fname,
const char* dname,
unsigned* shape){
int rvalue = 1;
#ifndef _SQY_DEBUG_
H5::Exception::dontPrint();
#endif
bfs::path lpath = fname;
sqy::h5_file loaded(lpath);
if(!loaded.ready())
return rvalue;
else{
std::string dn = dname;
*shape = 0;
std::vector<int> local;
loaded.shape(local, dn);
rvalue = local.empty();
std::copy(local.begin(), local.end(), shape);
}
return rvalue;
}
int SQY_h5_query_ndims(const char* fname,
const char* dname,
unsigned* ndims){
int rvalue = 1;
#ifndef _SQY_DEBUG_
H5::Exception::dontPrint();
#endif
bfs::path lpath = fname;
sqy::h5_file loaded(lpath);
if(!loaded.ready())
return rvalue;
else{
std::string dn = dname;
*ndims = 0;
std::vector<int> shape;
loaded.shape(shape, dn);
rvalue = shape.empty();
*ndims = shape.size();
}
return rvalue;
}
FunctionManager::FunctionManager(QQuickView *view, Doc *doc, QObject *parent)
: QObject(parent)
, m_view(view)
, m_doc(doc)
, m_viewPosition(0)
, m_previewEnabled(false)
, m_filter(0)
, m_searchFilter(QString())
{
m_sceneCount = m_chaserCount = m_sequenceCount = m_efxCount = 0;
m_collectionCount = m_rgbMatrixCount = m_scriptCount = 0;
m_showCount = m_audioCount = m_videoCount = 0;
m_currentEditor = NULL;
m_sceneEditor = NULL;
m_view->rootContext()->setContextProperty("functionManager", this);
qmlRegisterUncreatableType<Collection>("org.qlcplus.classes", 1, 0, "Collection", "Can't create a Collection");
qmlRegisterUncreatableType<Chaser>("org.qlcplus.classes", 1, 0, "Chaser", "Can't create a Chaser");
qmlRegisterUncreatableType<RGBMatrix>("org.qlcplus.classes", 1, 0, "RGBMatrix", "Can't create a RGBMatrix");
qmlRegisterUncreatableType<EFX>("org.qlcplus.classes", 1, 0, "EFX", "Can't create an EFX");
// register SceneValue to perform QVariant comparisons
qRegisterMetaType<SceneValue>();
QMetaType::registerComparators<SceneValue>();
m_functionTree = new TreeModel(this);
QQmlEngine::setObjectOwnership(m_functionTree, QQmlEngine::CppOwnership);
QStringList treeColumns;
treeColumns << "classRef";
m_functionTree->setColumnNames(treeColumns);
m_functionTree->enableSorting(true);
connect(m_doc, SIGNAL(loaded()), this, SLOT(slotDocLoaded()));
connect(m_doc, SIGNAL(functionAdded(quint32)), this, SLOT(slotFunctionAdded(quint32)));
}
osg::ref_ptr<const NifOsg::KeyframeHolder> SceneManager::getKeyframes(const std::string &name)
{
std::string normalized = name;
mVFS->normalizeFilename(normalized);
KeyframeIndex::iterator it = mKeyframeIndex.find(normalized);
if (it == mKeyframeIndex.end())
{
Files::IStreamPtr file = mVFS->get(normalized);
std::string ext = getFileExtension(normalized);
if (ext != "nif" && ext != "kf")
return NULL;
osg::ref_ptr<NifOsg::KeyframeHolder> loaded (new NifOsg::KeyframeHolder);
NifOsg::Loader::loadKf(Nif::NIFFilePtr(new Nif::NIFFile(file, normalized)), *loaded.get());
mKeyframeIndex[normalized] = loaded;
return loaded;
}
else
return it->second;
}
FunctionManager::FunctionManager(QQuickView *view, Doc *doc, QObject *parent)
: QObject(parent)
, m_view(view)
, m_doc(doc)
, m_viewPosition(0)
, m_previewEnabled(false)
{
m_filter = 0;
m_sceneCount = m_chaserCount = m_efxCount = 0;
m_collectionCount = m_rgbMatrixCount = m_scriptCount = 0;
m_showCount = m_audioCount = m_videoCount = 0;
m_currentEditor = NULL;
qmlRegisterUncreatableType<Collection>("com.qlcplus.classes", 1, 0, "Collection", "Can't create a Collection");
qmlRegisterUncreatableType<Chaser>("com.qlcplus.classes", 1, 0, "Chaser", "Can't create a Chaser");
qmlRegisterUncreatableType<RGBMatrix>("com.qlcplus.classes", 1, 0, "RGBMatrix", "Can't create a RGBMatrix");
m_functionTree = new TreeModel(this);
QQmlEngine::setObjectOwnership(m_functionTree, QQmlEngine::CppOwnership);
QStringList treeColumns;
treeColumns << "classRef";
m_functionTree->setColumnNames(treeColumns);
m_functionTree->enableSorting(true);
/*
for (int i = 0; i < 10; i++)
{
QStringList vars;
vars << QString::number(i) << 0;
m_functionTree->addItem(QString("Entry %1").arg(i), vars);
}
*/
connect(m_doc, SIGNAL(loaded()),
this, SLOT(slotDocLoaded()));
}
bool KNMusicBackendPhononThread::loadFromFile(const QString &filePath)
{
//Stop playing.
stop();
//Check if the media source is just the current file, then ignore the loading.
QUrl currentUrl=QUrl::fromLocalFile(filePath);
if(m_mediaSource==currentUrl)
{
resetState();
//Emit load succeed signal.
emit loaded();
return true;
}
//Reset the total duration and state.
m_totalDuration=-1;
resetState();
//Generate the media source.
m_mediaSource=MediaSource(currentUrl);
//Load the file to media source.
m_mediaObject->setCurrentSource(m_mediaSource);
//Set the load flag.
m_loadFlag=true;
return (m_mediaObject->errorType()==NoError);
}
void Map::MessageBroadcast(WorldObject *obj, WorldPacket *msg)
{
// sLog.outString("Map::MessageBroadcast WorldObject");
CellPair p = LeGACY::ComputeCellPair(obj->GetPositionX(), obj->GetPositionY());
if(p.x_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP || p.y_coord >= TOTAL_NUMBER_OF_CELLS_PER_MAP )
{
sLog.outError("Map::MessageBroadcast: Object " I64FMTD " have invalid coordinates X:%f Y:%f grid cell [%u,%u]", obj->GetGUID(), obj->GetPositionX(), obj->GetPositionY(), p.x_coord, p.y_coord);
return;
}
Cell cell(p);
cell.data.Part.reserved = CENTER_DISTRICT;
cell.SetNoCreate();
if( !loaded(GridPair(cell.data.Part.grid_x, cell.data.Part.grid_y)) )
return;
LeGACY::ObjectMessageDeliverer post_man(*obj, msg);
TypeContainerVisitor<LeGACY::ObjectMessageDeliverer, WorldTypeMapContainer > message(post_man);
CellLock<ReadGuard> cell_lock(cell, p);
cell_lock->Visit(cell_lock, message, *this);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
createStatusBar();
// Recent files
for (int i = 0; i < MaxRecentFiles; ++i)
{
recentFileActions[i] = new QAction(this);
recentFileActions[i]->setVisible(false);
connect(recentFileActions[i], SIGNAL(triggered()), this, SLOT(openRecentFile()));
ui->menuFile->insertAction(ui->actionExit, recentFileActions[i]);
}
recentFilesSeparator = ui->menuFile->insertSeparator(ui->actionExit);
printer = new QPrinter;
printer->setFullPage(true);
printer->setPaperSize(QPrinter::Letter);
printer->setPageMargins(.5, .5, .5, .5, QPrinter::Inch);
report = new Report(printer, this);
view = new ReportView(report, this);
preview = new QPrintPreviewWidget(printer, this);
setCentralWidget(preview);
preview->fitToWidth();
QFontComboBox* fontComboBox = new QFontComboBox;
fontComboBox->setFontFilters(QFontComboBox::MonospacedFonts | QFontComboBox::ScalableFonts);
fontComboBox->setCurrentFont(report->font().family());
ui->fontToolBar->insertWidget(ui->actionBold, fontComboBox);
connect(fontComboBox, SIGNAL(currentFontChanged(QFont)), report, SLOT(setFont(QFont)));
pageNumberComboBox = new QComboBox;
ui->viewToolBar->insertWidget(ui->actionNextPage, pageNumberComboBox);
connect(pageNumberComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(currentPageChanged(int)));
const qreal zoomFactors[] = { 12.5, 25, 50, 100, 125, 150, 200, 400, 800 };
zoomComboBox = new QComboBox;
for (unsigned int i = 0; i < sizeof(zoomFactors) / sizeof(*zoomFactors); ++i)
{
zoomComboBox->addItem(QString("%1%").arg(zoomFactors[i]));
}
zoomComboBox->setCurrentIndex(-1);
ui->viewToolBar->insertWidget(ui->actionZoomOut, zoomComboBox);
connect(zoomComboBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(zoomChanged(QString)));
QActionGroup* orientationGroup = new QActionGroup(this);
orientationGroup->addAction(ui->actionPortrait);
orientationGroup->addAction(ui->actionLandscape);
orientationChanged(report->orientation());
QActionGroup* heightGroup = new QActionGroup(this);
heightGroup->addAction(ui->action6LPI);
heightGroup->addAction(ui->action8LPI);
heightGroup->addAction(ui->action9LPI);
heightGroup->setDisabled(ui->actionStretchFont->isEnabled());
connect(ui->actionStretchFont, SIGNAL(toggled(bool)), heightGroup, SLOT(setDisabled(bool)));
QActionGroup* widthGroup = new QActionGroup(this);
widthGroup->addAction(ui->actionDefaultWidth);
widthGroup->addAction(ui->action10CPI);
widthGroup->addAction(ui->action12CPI);
widthGroup->addAction(ui->action17CPI);
widthGroup->setDisabled(ui->actionStretchFont->isEnabled());
connect(ui->actionStretchFont, SIGNAL(toggled(bool)), widthGroup, SLOT(setDisabled(bool)));
QActionGroup* pageGroup = new QActionGroup(this);
pageGroup->addAction(ui->actionSinglePage);
pageGroup->addAction(ui->actionFacingPages);
pageGroup->addAction(ui->actionAllPages);
ui->actionSinglePage->setChecked(preview->viewMode() == QPrintPreviewWidget::SinglePageView);
ui->actionFacingPages->setChecked(preview->viewMode() == QPrintPreviewWidget::FacingPagesView);
ui->actionAllPages->setChecked(preview->viewMode() == QPrintPreviewWidget::AllPagesView);
connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(about()));
connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(open()));
connect(ui->actionOpenURL, SIGNAL(triggered()), this, SLOT(openUrl()));
connect(ui->actionReload, SIGNAL(triggered()), this, SLOT(reload()));
connect(ui->actionSaveAsPDF, SIGNAL(triggered()), this, SLOT(saveAsPdf()));
connect(ui->actionPrint, SIGNAL(triggered()), this, SLOT(print()));
connect(ui->actionPageSetup, SIGNAL(triggered()), this, SLOT(pageSetup()));
connect(ui->actionEmail, SIGNAL(triggered()), this, SLOT(email()));
connect(ui->actionCopy, SIGNAL(triggered()), this, SLOT(copy()));
connect(ui->actionStretchFont, SIGNAL(toggled(bool)), report, SLOT(setStretchFont(bool)));
connect(report, SIGNAL(stretchFontChanged(bool)), ui->actionStretchFont, SLOT(setChecked(bool)));
connect(ui->actionBold, SIGNAL(toggled(bool)), report, SLOT(setBold(bool)));
connect(ui->actionStripes, SIGNAL(toggled(bool)), report, SLOT(setStripes(bool)));
connect(ui->actionStripeColor, SIGNAL(triggered()), this, SLOT(stripeColor()));
connect(ui->actionColor, SIGNAL(triggered()), this, SLOT(fontColor()));
connect(ui->action6LPI, SIGNAL(triggered()), this, SLOT(height6Lpi()));
connect(ui->action8LPI, SIGNAL(triggered()), this, SLOT(height8Lpi()));
connect(ui->action9LPI, SIGNAL(triggered()), this, SLOT(height9Lpi()));
connect(ui->actionDefaultWidth, SIGNAL(toggled(bool)), this, SLOT(widthDefault()));
connect(ui->action10CPI, SIGNAL(triggered()), this, SLOT(width10Cpi()));
connect(ui->action12CPI, SIGNAL(triggered()), this, SLOT(width12Cpi()));
connect(ui->action17CPI, SIGNAL(triggered()), this, SLOT(width17Cpi()));
connect(ui->actionFirstPage, SIGNAL(triggered()), this, SLOT(firstPage()));
connect(ui->actionPreviousPage, SIGNAL(triggered()), this, SLOT(previousPage()));
connect(ui->actionNextPage, SIGNAL(triggered()), this, SLOT(nextPage()));
connect(ui->actionLastPage, SIGNAL(triggered()), this, SLOT(lastPage()));
connect(ui->actionFitWidth, SIGNAL(triggered()), preview, SLOT(fitToWidth()));
connect(ui->actionFitHeight, SIGNAL(triggered()), preview, SLOT(fitInView()));
connect(ui->actionPortrait, SIGNAL(triggered()), preview, SLOT(setPortraitOrientation()));
connect(ui->actionLandscape, SIGNAL(triggered()), preview, SLOT(setLandscapeOrientation()));
connect(ui->actionActualSize, SIGNAL(triggered()), this, SLOT(actualSize()));
connect(ui->actionZoomIn, SIGNAL(triggered()), preview, SLOT(zoomIn()));
connect(ui->actionZoomOut, SIGNAL(triggered()), preview, SLOT(zoomOut()));
connect(ui->actionSinglePage, SIGNAL(triggered()), preview, SLOT(setSinglePageViewMode()));
connect(ui->actionFacingPages, SIGNAL(triggered()), preview, SLOT(setFacingPagesViewMode()));
connect(ui->actionAllPages, SIGNAL(triggered()), preview, SLOT(setAllPagesViewMode()));
connect(ui->actionMainToolbar, SIGNAL(triggered(bool)), this, SLOT(toggleMainToolbar(bool)));
connect(ui->actionViewToolbar, SIGNAL(triggered(bool)), this, SLOT(toggleViewToolbar(bool)));
connect(ui->actionFontToolbar, SIGNAL(triggered(bool)), this, SLOT(toggleFontToolbar(bool)));
connect(ui->actionStatusBar, SIGNAL(triggered(bool)), this, SLOT(toggleStatusBar(bool)));
connect(ui->menuToolbars, SIGNAL(aboutToShow()), this, SLOT(updateToolbarMenu()));
connect(ui->menuView, SIGNAL(aboutToShow()), this, SLOT(updateToolbarMenu()));
connect(preview, SIGNAL(previewChanged()), this, SLOT(previewChanged()));
connect(preview, SIGNAL(paintRequested(QPrinter*)), this, SLOT(paint(QPrinter*)));
connect(report, SIGNAL(loaded()), preview, SLOT(updatePreview()));
connect(report, SIGNAL(changed()), preview, SLOT(updatePreview()));
connect(report, SIGNAL(loaded()), this, SLOT(documentLoaded()));
connect(report, SIGNAL(orientationChanged(QPrinter::Orientation)), this, SLOT(orientationChanged(QPrinter::Orientation)));
connect(report, SIGNAL(lpiChanged(int)), this, SLOT(lpiChanged(int)));
connect(report, SIGNAL(cpiChanged(int)), this, SLOT(cpiChanged(int)));
connect(report, SIGNAL(boldChanged(bool)), ui->actionBold, SLOT(setChecked(bool)));
connect(report, SIGNAL(fontChanged(QFont)), fontComboBox, SLOT(setCurrentFont(QFont)));
QSettings settings;
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("state").toByteArray());
recentFiles = settings.value("recentFiles").toStringList();
currentFolder = settings.value("currentFolder").toString();
ui->statusBar->setVisible(settings.value("statusBar", true).toBool());
updateRecentFileActions();
zoomTimer = new QTimer(this);
connect(zoomTimer, SIGNAL(timeout()), this, SLOT(updateZoom()));
connect(preview, SIGNAL(previewChanged()), this, SLOT(updateZoom()));
zoomTimer->start(1000);
}
// system-config-printer --setup-printer='file:/tmp/printout' --devid='MFG:Ricoh;MDL:Aficio SP C820DN'
PageDestinations::PageDestinations(const QVariantHash &args, QWidget *parent) :
GenericPage(parent),
ui(new Ui::PageDestinations),
m_chooseLpd(new ChooseLpd(this)),
m_chooseSamba(new ChooseSamba(this)),
m_chooseSerial(new ChooseSerial(this)),
m_chooseSocket(new ChooseSocket(this)),
m_chooseUri(new ChooseUri(this)),
m_chooseLabel(new QLabel(this))
{
ui->setupUi(this);
setAttribute(Qt::WA_DeleteOnClose);
ui->stackedWidget->addWidget(m_chooseLpd);
connect(m_chooseLpd, SIGNAL(allowProceed(bool)), SIGNAL(allowProceed(bool)));
ui->stackedWidget->addWidget(m_chooseSamba);
connect(m_chooseSamba, SIGNAL(allowProceed(bool)), SIGNAL(allowProceed(bool)));
ui->stackedWidget->addWidget(m_chooseSerial);
connect(m_chooseSerial, SIGNAL(allowProceed(bool)), SIGNAL(allowProceed(bool)));
ui->stackedWidget->addWidget(m_chooseSocket);
connect(m_chooseSocket, SIGNAL(allowProceed(bool)), SIGNAL(allowProceed(bool)));
ui->stackedWidget->addWidget(m_chooseUri);
connect(m_chooseUri, SIGNAL(allowProceed(bool)), SIGNAL(allowProceed(bool)));
m_chooseLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
ui->stackedWidget->addWidget(m_chooseLabel);
// Hide the message widget
ui->messageWidget->setMessageType(KMessageWidget::Error);
ui->messageWidget->hide();
// setup default options
setWindowTitle(i18nc("@title:window", "Select a Printer to Add"));
m_model = new DevicesModel(this);
ui->devicesTV->setModel(m_model);
ui->devicesTV->setItemDelegate(new NoSelectionRectDelegate(this));
connect(ui->devicesTV->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SLOT(deviceChanged()));
connect(m_model, SIGNAL(errorMessage(QString)), ui->messageWidget, SLOT(setText(QString)));
connect(m_model, SIGNAL(errorMessage(QString)), ui->messageWidget, SLOT(animatedShow()));
// Expand when a parent is added
connect(m_model, SIGNAL(parentAdded(QModelIndex)),
ui->devicesTV, SLOT(expand(QModelIndex)));
// Update the view when the device URI combo box changed
connect(ui->connectionsCB, SIGNAL(currentIndexChanged(int)),
this, SLOT(deviceUriChanged()));
ui->connectionsGB->setVisible(false);
// Setup the busy cursor
working();
connect(m_model, SIGNAL(loaded()), this, SLOT(notWorking()));
if (!args.isEmpty()) {
// set our args
setValues(args);
}
}
KawaiiGL::KawaiiGL(QWidget *parent)
: QMainWindow(parent), m_kView(NULL), m_edDlg(NULL), m_doc(NULL)
{
ui.setupUi(this);
m_sett.loadFromReg();
connect(&m_sett, SIGNAL(changed()), &m_sett, SLOT(storeToReg()));
setWindowTitle("KawaiiGL");
show(); // needed becase we're creating display lists in the c'tor.
QDir::setCurrent(EXAMPLES_DIR); // we're reading the config and textures from there
m_progMenu = new QMenu(this);
m_modelsMenu = new QMenu(this);
m_doc = new Document(this); // adds to the menus
m_progMenu->addSeparator();
QAction *loadFromFileAct = m_progMenu->addAction("From file...");
connect(loadFromFileAct, SIGNAL(triggered(bool)), m_doc, SLOT(loadProgramFile()));
m_kView = new T2GLWidget(this, m_doc);
setCentralWidget(m_kView);
m_edDlg = new KwEdit(this, m_sett.disp, m_doc, m_kView); // need the view for tracking vec2s
m_edDlg->show();
m_edDlg->move(pos() + QPoint(width() - 20, 30));
m_control = new MyDialog(this);
QBoxLayout *control_l = new QVBoxLayout();
m_control->setLayout(control_l);
control_l->setMargin(0);
control_l->setSpacing(0);
QTabWidget *tabs = new QTabWidget();
control_l->addWidget(tabs);
m_contDlg = new ControlPanel(&m_sett.disp, this, m_doc, m_kView);
tabs->addTab(m_contDlg, "Config");
m_browse = new ProjBrowser(this, m_doc);
tabs->addTab(m_browse, "Browser");
tabs->setCurrentWidget(m_browse);
//tabs->setCurrentIndex(m_sett.gui.configWindowTab);
tabs->setCurrentIndex(0);
m_control->show();
m_control->move(pos() + QPoint(-30, 20));
m_control->resize(100, 100); // make it as small as possible
m_doc->model()->m_errAct = new ErrorHighlight(m_edDlg);
connect(m_kView, SIGNAL(message(const QString&)), this, SLOT(message(const QString&)));
connect(m_edDlg, SIGNAL(changedModel(DocSrc*)), m_doc, SLOT(calc(DocSrc*)));
connect(m_edDlg, SIGNAL(updateShaders()), m_doc, SLOT(compileShaders()));
// connect(m_kView, SIGNAL(decompProgChanged(const QString&)), m_edDlg, SLOT(curChanged(const QString&)));
connect(m_doc, SIGNAL(loaded()), m_kView, SLOT(newModelLoaded()));
//connect(m_doc, SIGNAL(loaded()), m_edDlg, SLOT(doVarsUpdate())); // parsed new text. vars defs may be wrong
connect(m_doc, SIGNAL(modelChanged()), m_kView, SLOT(updateGL()));
connect(m_doc, SIGNAL(progChanged()), m_kView, SLOT(redoFrameBuffers()));
connect(m_kView, SIGNAL(changedFBOs()), m_contDlg, SLOT(updateTexEdits()));
connect(m_kView, SIGNAL(makeGradientTex(int, const QString&)), m_contDlg, SLOT(externalGradient(int, const QString&)));
connect(m_doc, SIGNAL(progParamChanged()), m_kView, SLOT(updateGL()));
connect(m_doc, SIGNAL(addModelLine(const QString&)), m_edDlg, SLOT(addModelLine(const QString&)));
connect(m_contDlg, SIGNAL(changedRend()), m_doc, SLOT(calcNoParse())); // passes update
connect(m_contDlg, SIGNAL(changedFont()), m_kView, SLOT(updateCoordFont()));
connect(m_contDlg, SIGNAL(doUpdate()), m_kView, SLOT(updateGL())); // passes update
connect(m_contDlg, SIGNAL(resetView()), m_kView, SLOT(resetState()));
connect(m_contDlg, SIGNAL(resetLight()), m_kView, SLOT(resetLight()));
connect(m_contDlg, SIGNAL(changedTexFile(int)), m_kView, SLOT(setTexture(int)));
// connect(m_contDlg, SIGNAL(reassertTex(int)), m_kView, SLOT(rebindTexture(int)));
connect(m_contDlg, SIGNAL(saveMesh()), m_doc, SLOT(calcSave()));
connect(m_browse, SIGNAL(openDocText(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) );
connect(m_browse, SIGNAL(openPassConf(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) );
connect(m_browse, SIGNAL(commitGuiData()), m_edDlg, SLOT(commitAll()));
connect(m_doc, SIGNAL(goingToClearProg()), m_edDlg, SLOT(clearingProg()));
connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_edDlg, SLOT(readProg(ProgKeep*)) );
connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_browse, SLOT(readProg(ProgKeep*)) );
connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_browse, SLOT(readModel()) );
connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_edDlg, SLOT(readModel(DocSrc*)));
connect(&m_sett.disp.bVtxNormals, SIGNAL(changed()), m_doc, SLOT(calcNoParse())); // TBD - this is bad.
connect(m_contDlg->ui.clipSlider, SIGNAL(valueChanged(int)), m_kView, SLOT(setClipValue(int)));
m_kView->setContextMenuPolicy(Qt::ActionsContextMenu);
QPushButton *viewBot = new QPushButton("View");
viewBot->setMaximumSize(60, 19);
statusBar()->addPermanentWidget(viewBot);
QMenu *view = new QMenu("View");
viewBot->setMenu(view);
QPushButton *fpsBot = new QPushButton(QIcon(":/images/arrow-circle.png"), QString());
fpsBot->setMaximumSize(20, 19);
statusBar()->addPermanentWidget(fpsBot);
(new CheckBoxIn(&m_sett.disp.fullFps, fpsBot))->reload();
QCheckBox *vSyncBox = new QCheckBox("vSync");
vSyncBox->setMaximumHeight(19);
statusBar()->addPermanentWidget(vSyncBox);
(new CheckBoxIn(&m_sett.disp.vSync, vSyncBox))->reload();
QAction *confVis = new QAction("Display", view);
view->addAction(confVis);
m_control->connectAction(confVis);
QAction *editVis = new QAction("Edit", view);
view->addAction(editVis);
m_edDlg->connectAction(editVis);
m_kView->connectedInit();
processCmdArgs();
}
void LiteApp::load(bool bUseSession, IApplication *baseApp)
{
QSplashScreen *splash = 0;
bool bSplash = m_settings->value(LITEAPP_SPLASHVISIBLE,true).toBool();
if (baseApp) {
bSplash = false;
}
if (bSplash) {
splash = new QSplashScreen(QPixmap::fromImage(makeSplashImage(this)),Qt::WindowStaysOnTopHint);
}
if (bSplash) {
splash->show();
}
if (bSplash) {
splash->showMessage("Scanning plugins...",Qt::AlignLeft|Qt::AlignBottom);
}
qApp->processEvents();
loadMimeType();
loadPlugins();
if (bSplash) {
splash->showMessage("Loading plugins...",Qt::AlignLeft|Qt::AlignBottom);
}
qApp->processEvents();
initPlugins();
if (bSplash) {
splash->showMessage("Loading state...",Qt::AlignLeft|Qt::AlignBottom);
}
qApp->processEvents();
loadState();
if (baseApp) {
if (baseApp->mainWindow()->isMaximized()) {
m_mainwindow->resize(800,600);
m_mainwindow->show();
} else {
QRect rc = baseApp->mainWindow()->geometry();
rc.adjust(20,20,20,20);
m_mainwindow->setGeometry(rc);
m_mainwindow->show();
}
} else {
m_mainwindow->show();
}
emit loaded();
m_projectManager->setCurrentProject(0);
if (bSplash) {
splash->showMessage("Loading session...",Qt::AlignLeft|Qt::AlignBottom);
}
qApp->processEvents();
bool b = m_settings->value(LITEAPP_AUTOLOADLASTSESSION,true).toBool();
if (b && bUseSession) {
loadSession("default");
}
if (bSplash) {
m_mainwindow->raise();
splash->finish(m_mainwindow);
splash->deleteLater();
}
this->appendLog("HtmlWidgetFactory",m_htmlWidgetManager->classNameList().join(" "));
this->appendLog("DefaultHtmlWidgetFactory",m_htmlWidgetManager->defaultClassName());
m_goProxy->call("version");
appendLog("LiteApp","Finished loading");
}
hid_t seissol::checkpoint::h5::Wavefield::initFile(int odd, const char* filename)
{
hid_t h5file;
if (loaded()) {
// Open the old file
h5file = open(filename, false);
checkH5Err(h5file);
// Time
m_h5time[odd] = H5Aopen(h5file, "time", H5P_DEFAULT);
checkH5Err(m_h5time[odd]);
// Wavefield writer
m_h5timestepWavefield[odd] = H5Aopen(h5file, "timestep_wavefield", H5P_DEFAULT);
checkH5Err(m_h5timestepWavefield[odd]);
// Data
m_h5data[odd] = H5Dopen(h5file, "values", H5P_DEFAULT);
checkH5Err(m_h5data[odd]);
} else {
// Create the file
hid_t h5plist = H5Pcreate(H5P_FILE_ACCESS);
checkH5Err(h5plist);
checkH5Err(H5Pset_libver_bounds(h5plist, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST));
hsize_t align = utils::Env::get<hsize_t>("SEISSOL_CHECKPOINT_ALIGNMENT", 0);
if (align > 0)
checkH5Err(H5Pset_alignment(h5plist, 1, align));
#ifdef USE_MPI
MPIInfo info;
checkH5Err(H5Pset_fapl_mpio(h5plist, seissol::MPI::mpi.comm(), info.get()));
#endif // USE_MPI
h5file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, h5plist);
checkH5Err(h5file);
checkH5Err(H5Pclose(h5plist));
// Create scalar dataspace for attributes
hid_t h5spaceScalar = H5Screate(H5S_SCALAR);
checkH5Err(h5spaceScalar);
// Time
m_h5time[odd] = H5Acreate(h5file, "time", H5T_IEEE_F64LE, h5spaceScalar,
H5P_DEFAULT, H5P_DEFAULT);
checkH5Err(m_h5time[odd]);
// Partitions
hid_t h5partitions = H5Acreate(h5file, "partitions", H5T_STD_I32LE, h5spaceScalar,
H5P_DEFAULT, H5P_DEFAULT);
checkH5Err(h5partitions);
int p = partitions();
checkH5Err(H5Awrite(h5partitions, H5T_NATIVE_INT, &p));
checkH5Err(H5Aclose(h5partitions));
// Wavefield writer
m_h5timestepWavefield[odd] = H5Acreate(h5file, "timestep_wavefield",
H5T_STD_I32LE, h5spaceScalar, H5P_DEFAULT, H5P_DEFAULT);
checkH5Err(m_h5timestepWavefield[odd]);
int t = 0;
checkH5Err(H5Awrite(m_h5timestepWavefield[odd], H5T_NATIVE_INT, &t));
checkH5Err(H5Sclose(h5spaceScalar));
// Variable
h5plist = H5Pcreate(H5P_DATASET_CREATE);
checkH5Err(h5plist);
checkH5Err(H5Pset_layout(h5plist, H5D_CONTIGUOUS));
checkH5Err(H5Pset_alloc_time(h5plist, H5D_ALLOC_TIME_EARLY));
m_h5data[odd] = H5Dcreate(h5file, "values", H5T_IEEE_F64LE, m_h5fSpaceData,
H5P_DEFAULT, h5plist, H5P_DEFAULT);
checkH5Err(m_h5data[odd]);
checkH5Err(H5Pclose(h5plist));
}
return h5file;
}
/* returns TRUE if a user profile was unloaded; otherwise, FALSE.*/
BOOL
OwnerProfile::unload () {
dprintf ( D_FULLDEBUG, "In OwnerProfile::unload()\n" );
priv_state priv = PRIV_UNKNOWN;
BOOL profile_unloaded = FALSE,
backup_restored = FALSE,
ok = FALSE;
__try {
/* short-cut if we've already unloaded the profile */
if ( !loaded () ) {
ok = TRUE;
__leave;
}
/* we must do the following as Condor */
priv = set_condor_priv ();
/* Unload the profile */
profile_unloaded = unloadProfile ();
if ( !profile_unloaded ) {
__leave;
}
/* make sure to change state with regards to being unloaded,
as we cannot _restore_ the original while the profile is
loaded */
profile_loaded_ = FALSE;
#if 0
/* Now we have unloaded user's profile we can restore the
original cached version */
backup_restored = restore ();
dprintf (
D_FULLDEBUG,
"OwnerProfile::unload: Restoration of %s's "
"profile %s.\n",
user_name_,
backup_restored ? "succeeded" : "failed" );
/* if we were unable to create the backup, we should bail out
before we allow the user to make changes to the template
profile */
if ( !backup_restored ) {
__leave;
}
#endif
/* if we got here, then everything has been reverted */
ok = TRUE;
}
__finally {
/* return to previous privilege level */
set_priv ( priv );
}
return ok;
}
PluginLoader<T>::~PluginLoader(){
if(loaded()){
unloadPlugin();
}
return;
}
void NetworkProgram::downloadFinished(QNetworkReply* reply) {
_program = QScriptProgram(QTextStream(reply).readAll(), reply->url().toString());
reply->deleteLater();
finishedLoading(true);
emit loaded();
}
/* XXX THIS SHOULD BE IN SYSTEM !!!! */
void
erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
{
#ifdef ERTS_SMP
ErtsThrPrgrData tpd_buf; /* in case we aren't a managed thread... */
#endif
int fd;
size_t envsz;
time_t now;
char env[21]; /* enough to hold any 64-bit integer */
size_t dumpnamebufsize = MAXPATHLEN;
char dumpnamebuf[MAXPATHLEN];
char* dumpname;
int secs;
int env_erl_crash_dump_seconds_set = 1;
int i;
if (ERTS_SOMEONE_IS_CRASH_DUMPING)
return;
#ifdef ERTS_SMP
/* Order all managed threads to block, this has to be done
first to guarantee that this is the only thread to generate
crash dump. */
erts_thr_progress_fatal_error_block(&tpd_buf);
#ifdef ERTS_THR_HAVE_SIG_FUNCS
/*
* We suspend all scheduler threads so that we can dump some
* data about the currently running processes and scheduler data.
* We have to be very very careful when doing this as the schedulers
* could be anywhere.
*/
for (i = 0; i < erts_no_schedulers; i++) {
erts_tid_t tid = ERTS_SCHEDULER_IX(i)->tid;
if (!erts_equal_tids(tid,erts_thr_self()))
sys_thr_suspend(tid);
}
#endif
/* Allow us to pass certain places without locking... */
erts_smp_atomic32_set_mb(&erts_writing_erl_crash_dump, 1);
erts_smp_tsd_set(erts_is_crash_dumping_key, (void *) 1);
#else /* !ERTS_SMP */
erts_writing_erl_crash_dump = 1;
#endif /* ERTS_SMP */
envsz = sizeof(env);
/* ERL_CRASH_DUMP_SECONDS not set
* if we have a heart port, break immediately
* otherwise dump crash indefinitely (until crash is complete)
* same as ERL_CRASH_DUMP_SECONDS = 0
* - do not write dump
* - do not set an alarm
* - break immediately
*
* ERL_CRASH_DUMP_SECONDS = 0
* - do not write dump
* - do not set an alarm
* - break immediately
*
* ERL_CRASH_DUMP_SECONDS < 0
* - do not set alarm
* - write dump until done
*
* ERL_CRASH_DUMP_SECONDS = S (and S positive)
* - Don't dump file forever
* - set alarm (set in sys)
* - write dump until alarm or file is written completely
*/
if (erts_sys_getenv__("ERL_CRASH_DUMP_SECONDS", env, &envsz) != 0) {
env_erl_crash_dump_seconds_set = 0;
secs = -1;
} else {
env_erl_crash_dump_seconds_set = 1;
secs = atoi(env);
}
if (secs == 0) {
return;
}
/* erts_sys_prepare_crash_dump returns 1 if heart port is found, otherwise 0
* If we don't find heart (0) and we don't have ERL_CRASH_DUMP_SECONDS set
* we should continue writing a dump
*
* beware: secs -1 means no alarm
*/
if (erts_sys_prepare_crash_dump(secs) && !env_erl_crash_dump_seconds_set ) {
return;
}
if (erts_sys_getenv__("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
dumpname = "erl_crash.dump";
else
dumpname = &dumpnamebuf[0];
erts_fprintf(stderr,"\nCrash dump is being written to: %s...", dumpname);
fd = open(dumpname,O_WRONLY | O_CREAT | O_TRUNC,0640);
if (fd < 0)
return; /* Can't create the crash dump, skip it */
time(&now);
erts_fdprintf(fd, "=erl_crash_dump:0.3\n%s", ctime(&now));
if (file != NULL)
erts_fdprintf(fd, "The error occurred in file %s, line %d\n", file, line);
if (fmt != NULL && *fmt != '\0') {
erts_fdprintf(fd, "Slogan: ");
erts_vfdprintf(fd, fmt, args);
}
erts_fdprintf(fd, "System version: ");
erts_print_system_version(fd, NULL, NULL);
erts_fdprintf(fd, "%s\n", "Compiled: " ERLANG_COMPILE_DATE);
erts_fdprintf(fd, "Taints: ");
erts_print_nif_taints(fd, NULL);
erts_fdprintf(fd, "Atoms: %d\n", atom_table_size());
#ifdef USE_THREADS
/* We want to note which thread it was that called erl_exit */
if (erts_get_scheduler_data()) {
erts_fdprintf(fd, "Calling Thread: scheduler:%d\n",
erts_get_scheduler_data()->no);
} else {
if (!erts_thr_getname(erts_thr_self(), dumpnamebuf, MAXPATHLEN))
erts_fdprintf(fd, "Calling Thread: %s\n", dumpnamebuf);
else
erts_fdprintf(fd, "Calling Thread: %p\n", erts_thr_self());
}
#else
erts_fdprintf(fd, "Calling Thread: scheduler:1\n");
#endif
#if defined(ERTS_HAVE_TRY_CATCH)
/*
* erts_print_scheduler_info is not guaranteed to be safe to call
* here for all schedulers as we may have suspended a scheduler
* in the middle of updating the STACK_TOP and STACK_START
* variables and thus when scanning the stack we could get
* segmentation faults. We protect against this very unlikely
* scenario by using the ERTS_SYS_TRY_CATCH.
*/
for (i = 0; i < erts_no_schedulers; i++) {
ERTS_SYS_TRY_CATCH(
erts_print_scheduler_info(fd, NULL, ERTS_SCHEDULER_IX(i)),
erts_fdprintf(fd, "** crashed **\n"));
}
#endif
#ifdef ERTS_SMP
#if defined(ERTS_THR_HAVE_SIG_FUNCS)
/* We resume all schedulers so that we are in a known safe state
when we write the rest of the crash dump */
for (i = 0; i < erts_no_schedulers; i++) {
erts_tid_t tid = ERTS_SCHEDULER_IX(i)->tid;
if (!erts_equal_tids(tid,erts_thr_self()))
sys_thr_resume(tid);
}
#endif
/*
* Wait for all managed threads to block. If all threads haven't blocked
* after a minute, we go anyway and hope for the best...
*
* We do not release system again. We expect an exit() or abort() after
* dump has been written.
*/
erts_thr_progress_fatal_error_wait(60000);
/* Either worked or not... */
#endif
#ifndef ERTS_HAVE_TRY_CATCH
/* This is safe to call here, as all schedulers are blocked */
for (i = 0; i < erts_no_schedulers; i++) {
erts_print_scheduler_info(fd, NULL, ERTS_SCHEDULER_IX(i));
}
#endif
info(fd, NULL); /* General system info */
if (erts_ptab_initialized(&erts_proc))
process_info(fd, NULL); /* Info about each process and port */
db_info(fd, NULL, 0);
erts_print_bif_timer_info(fd, NULL);
distribution_info(fd, NULL);
erts_fdprintf(fd, "=loaded_modules\n");
loaded(fd, NULL);
erts_dump_fun_entries(fd, NULL);
erts_deep_process_dump(fd, NULL);
erts_fdprintf(fd, "=atoms\n");
dump_atoms(fd, NULL);
/* Keep the instrumentation data at the end of the dump */
if (erts_instr_memory_map || erts_instr_stat) {
erts_fdprintf(fd, "=instr_data\n");
if (erts_instr_stat) {
erts_fdprintf(fd, "=memory_status\n");
erts_instr_dump_stat_to_fd(fd, 0);
}
if (erts_instr_memory_map) {
erts_fdprintf(fd, "=memory_map\n");
erts_instr_dump_memory_map_to_fd(fd);
}
}
erts_fdprintf(fd, "=end\n");
close(fd);
erts_fprintf(stderr,"done\n");
}
bool CTablebases::probe(eval_t& eval, const CBoard& board)
{
if (loaded())
{
int rgiCounters[10];
for (int32 i = 0; i < 10; ++i)
rgiCounters[i] = 0;
const int rgsq_cnt = C_PIECES * 5 + 1;
square rgsqWhite[rgsq_cnt];
square rgsqBlack[rgsq_cnt];
for (int32 i = 0; i < rgsq_cnt; ++i)
rgsqWhite[i] = rgsqBlack[i] = XX;
VInitSqCtr(rgiCounters, rgsqWhite, 0, board.getPieceBits(eW_P));
VInitSqCtr(rgiCounters, rgsqWhite, 1, board.getPieceBits(eW_N));
VInitSqCtr(rgiCounters, rgsqWhite, 2, board.getPieceBits(eW_B));
VInitSqCtr(rgiCounters, rgsqWhite, 3, board.getPieceBits(eW_R));
VInitSqCtr(rgiCounters, rgsqWhite, 4, board.getPieceBits(eW_Q));
VInitSqCtr(rgiCounters + 5, rgsqBlack, 0, board.getPieceBits(eB_P));
VInitSqCtr(rgiCounters + 5, rgsqBlack, 1, board.getPieceBits(eB_N));
VInitSqCtr(rgiCounters + 5, rgsqBlack, 2, board.getPieceBits(eB_B));
VInitSqCtr(rgiCounters + 5, rgsqBlack, 3, board.getPieceBits(eB_R));
VInitSqCtr(rgiCounters + 5, rgsqBlack, 4, board.getPieceBits(eB_Q));
int iTb = IDescFindFromCounters(rgiCounters);
if (iTb)
{
bb_t wk = board.getPieceBits(eW_K);
while (wk)
rgsqWhite[C_PIECES * 5] = popFirstBit(wk);
bb_t bk = board.getPieceBits(eB_K);
while (bk)
rgsqBlack[C_PIECES * 5] = popFirstBit(bk);
color side;
int fInvert;
square* psqW;
square* psqB;
if (iTb > 0)
{
side = eWhite == board.getSide() ? x_colorWhite : x_colorBlack;
fInvert = 0;
psqW = rgsqWhite;
psqB = rgsqBlack;
}
else
{
side = eWhite == board.getSide() ? x_colorBlack : x_colorWhite;
fInvert = 1;
psqW = rgsqBlack;
psqB = rgsqWhite;
iTb = -iTb;
}
if (FRegisteredFun(iTb, side))
{
square sqEnP = eNF != board.getEp() ? board.getEp() : XX;
INDEX ind = PfnIndCalcFun(iTb, side) (psqW, psqB, sqEnP, fInvert);
int tbValue = L_TbtProbeTable(iTb, side, ind);
if (tb_broken != tbValue)
{
if (tbValue > 0)
eval = MATE_VALUE + 2 * (-tb_mate_in_1 + tbValue - 1);
else
if (tbValue < 0)
eval = -MATE_VALUE + 2 * (tb_mate_in_1 + tbValue);
else
eval = DRAW_VALUE;
++m_hits;
return (true);
}
}
}
}
return(false);
}
void
do_break(void)
{
int i;
#ifdef __WIN32__
char *mode; /* enough for storing "window" */
/* check if we're in console mode and, if so,
halt immediately if break is called */
mode = erts_read_env("ERL_CONSOLE_MODE");
if (mode && strcmp(mode, "window") != 0)
erl_exit(0, "");
erts_free_read_env(mode);
#endif /* __WIN32__ */
erts_printf("\n"
"BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded\n"
" (v)ersion (k)ill (D)b-tables (d)istribution\n");
while (1) {
if ((i = sys_get_key(0)) <= 0)
erl_exit(0, "");
switch (i) {
case 'q':
case 'a':
case '*': /*
* The asterisk is an read error on windows,
* where sys_get_key isn't that great in console mode.
* The usual reason for a read error is Ctrl-C. Treat this as
* 'a' to avoid infinite loop.
*/
erl_exit(0, "");
case 'A': /* Halt generating crash dump */
erl_exit(1, "Crash dump requested by user");
case 'c':
return;
case 'p':
process_info(ERTS_PRINT_STDOUT, NULL);
return;
case 'm':
return;
case 'o':
port_info(ERTS_PRINT_STDOUT, NULL);
return;
case 'i':
info(ERTS_PRINT_STDOUT, NULL);
return;
case 'l':
loaded(ERTS_PRINT_STDOUT, NULL);
return;
case 'v':
erts_printf("Erlang (%s) emulator version "
ERLANG_VERSION "\n",
EMULATOR);
erts_printf("Compiled on " ERLANG_COMPILE_DATE "\n");
return;
case 'd':
distribution_info(ERTS_PRINT_STDOUT, NULL);
return;
case 'D':
db_info(ERTS_PRINT_STDOUT, NULL, 1);
return;
case 'k':
process_killer();
return;
#ifdef OPPROF
case 'X':
dump_frequencies();
return;
case 'x':
{
int i;
for (i = 0; i <= HIGHEST_OP; i++) {
if (opc[i].name != NULL) {
erts_printf("%-16s %8d\n", opc[i].name, opc[i].count);
}
}
}
return;
case 'z':
{
int i;
for (i = 0; i <= HIGHEST_OP; i++)
opc[i].count = 0;
}
return;
#endif
#ifdef DEBUG
case 't':
erts_p_slpq();
return;
case 'b':
bin_check();
return;
case 'C':
abort();
#endif
case '\n':
continue;
default:
erts_printf("Eh?\n\n");
}
}
}
/* returns TRUE if the user profile directory was restored;
otherwise, FALSE.*/
BOOL
OwnerProfile::restore () {
dprintf ( D_FULLDEBUG, "In OwnerProfile::restore()\n" );
priv_state priv = PRIV_UNKNOWN;
int length = 0;
HANDLE directory = NULL;
BOOL profile_deleted = FALSE,
backup_restored = FALSE,
backup_deleted = FALSE,
ok = FALSE;
__try {
/* can't restore while the profile is loaded */
if ( loaded () ) {
dprintf (
D_FULLDEBUG,
"OwnerProfile::restore: Cannot restore the profile "
"while it is in use.\n");
__leave;
}
/* we can do the following as the Condor because our copy
mechanism is designed to preserve the directory's ACLs */
priv = set_user_priv ();
/* use the directory created by the backup() call to
roll-back the changes made during the job execution */
profile_deleted =
CondorRemoveDirectory ( profile_directory_ );
dprintf (
D_FULLDEBUG,
"OwnerProfile::restore: Deleting the "
"modified profile %s. (last-error = %u)\n",
profile_deleted ? "succeeded" : "failed",
profile_deleted ? 0 : GetLastError () );
if ( !profile_deleted ) {
__leave;
}
/* having removed the modified profile directory,
restore the back-up we made of the profile template */
backup_restored = CondorCopyDirectory (
profile_backup_,
profile_directory_ );
dprintf (
D_FULLDEBUG,
"OwnerProfile::restore: Deleting the "
"profile backup %s. (last-error = %u)\n",
backup_restored ? "succeeded" : "failed",
backup_restored ? 0 : GetLastError () );
if ( !backup_restored ) {
__leave;
}
/* finally, remove the back-up directory: this ensures
that each new job receives a fresh copy of the template */
backup_deleted =
CondorRemoveDirectory ( profile_backup_ );
dprintf (
D_FULLDEBUG,
"OwnerProfile::restore: Deleting the "
"back-up directory %s. (last-error = %u)\n",
backup_deleted ? "succeeded" : "failed",
backup_deleted ? 0 : GetLastError () );
if ( !backup_deleted ) {
__leave;
}
/* if we've arrived here, then all it well */
ok = TRUE;
}
__finally {
/* return to previous privilege level */
if ( PRIV_UNKNOWN != priv ) {
set_priv ( priv );
}
/* only if we were successful can we delete the
name this session's of profile backup directory */
if ( ok ) {
delete [] profile_backup_;
}
}
return ok;
}
/* returns TRUE if the user profile template was backup-ed up;
otherwise, FALSE.*/
BOOL
OwnerProfile::backup () {
dprintf ( D_FULLDEBUG, "In OwnerProfile::backup()\n" );
priv_state priv = PRIV_UNKNOWN;
int length = 0;
BOOL backup_created = FALSE,
ok = FALSE;
__try {
/* can't backup while in use, we'd get tons of access denied
errors, as a number of core files will be locked */
if ( loaded () ) {
dprintf (
D_FULLDEBUG,
"OwnerProfile::backup: Cannot backup the profile "
"while it is in use.\n");
__leave;
}
/* we can do the following as the Condor because our copy
mechanism is designed to preserve the directory's ACLs */
priv = set_user_priv ();
/* create a backup directory name based on the profile
directory (i.e. profile_cache_), user's login name and
the */
length = strlen ( profile_cache_ )
+ strlen ( user_name_ ) + 1
+ 20; /* +1 for \ +20 for pid */
profile_backup_ = new CHAR[length + 1];
ASSERT ( profile_backup_ );
sprintf (
profile_backup_,
"%s\\%s-%d",
profile_cache_,
user_name_,
GetCurrentProcessId () );
/* finally, copy the user's profile to the back-up directory */
backup_created = CondorCopyDirectory (
profile_directory_,
profile_backup_ );
dprintf (
D_FULLDEBUG,
"OwnerProfile::backup: Copying '%s' to '%s' %s. "
"(last-error = %u)\n",
profile_directory_,
profile_backup_,
backup_created ? "succeeded" : "failed",
backup_created ? 0 : GetLastError () );
if ( !backup_created ) {
__leave;
}
/* if we've arrived here, then all it well */
ok = TRUE;
}
__finally {
/* return to previous privilege level */
if ( PRIV_UNKNOWN != priv ) {
set_priv ( priv );
}
}
return ok;
}
T *PluginLoader<T>::createInstance(){
if(loaded()){
return (T *)mCreateFunc();
}
return NULL;
}
bool TextBuffer::load (const QString &filename, bool &encodingErrors)
{
// fallback codec must exist
Q_ASSERT (m_fallbackTextCodec);
// codec must be set!
Q_ASSERT (m_textCodec);
/**
* first: clear buffer in any case!
*/
clear ();
/**
* check if this is a normal file or not, else exit
*/
KDE_struct_stat sbuf;
if (KDE::stat(filename, &sbuf) != 0 || !S_ISREG(sbuf.st_mode))
return false;
/**
* construct the file loader for the given file, with correct prober type
*/
Kate::TextLoader file (filename, m_encodingProberType);
/**
* triple play, maximal three loading rounds
* 0) use the given encoding, be done, if no encoding errors happen
* 1) use BOM to decided if unicode or if that fails, use encoding prober, if no encoding errors happen, be done
* 2) use fallback encoding, be done, if no encoding errors happen
* 3) use again given encoding, be done in any case
*/
for (int i = 0; i < 4; ++i) {
/**
* kill all blocks beside first one
*/
for (int b = 1; b < m_blocks.size(); ++b) {
TextBlock* block = m_blocks.at(b);
block->m_lines.clear ();
delete block;
}
m_blocks.resize (1);
/**
* remove lines in first block
*/
m_blocks.last()->m_lines.clear ();
m_lines = 0;
/**
* try to open file, with given encoding
* in round 0 + 3 use the given encoding from user
* in round 1 use 0, to trigger detection
* in round 2 use fallback
*/
QTextCodec *codec = m_textCodec;
if (i == 1)
codec = 0;
else if (i == 2)
codec = m_fallbackTextCodec;
if (!file.open (codec)) {
// create one dummy textline, in any case
m_blocks.last()->appendLine (TextLine (new TextLineData()));
m_lines++;
return false;
}
// read in all lines...
encodingErrors = false;
while ( !file.eof() )
{
// read line
int offset = 0, length = 0;
bool currentError = !file.readLine (offset, length);
encodingErrors = encodingErrors || currentError;
// bail out on encoding error, if not last round!
if (encodingErrors && i < 3) {
kDebug (13020) << "Failed try to load file" << filename << "with codec" <<
(file.textCodec() ? file.textCodec()->name() : "(null)");
break;
}
// get unicode data for this line
const QChar *unicodeData = file.unicode () + offset;
// construct new text line with content from file
TextLine textLine = TextLine (new TextLineData(QString (unicodeData, length)));
// ensure blocks aren't too large
if (m_blocks.last()->lines() >= m_blockSize)
m_blocks.append (new TextBlock (this, m_blocks.last()->startLine() + m_blocks.last()->lines()));
m_blocks.last()->appendLine (textLine);
m_lines++;
}
// if no encoding error, break out of reading loop
if (!encodingErrors) {
// remember used codec
m_textCodec = file.textCodec ();
break;
}
}
// remember if BOM was found
if (file.byteOrderMarkFound ())
setGenerateByteOrderMark (true);
// remember eol mode, if any found in file
if (file.eol() != eolUnknown)
setEndOfLineMode (file.eol());
// remember mime type for filter device
m_mimeTypeForFilterDev = file.mimeTypeForFilterDev ();
// assert that one line is there!
Q_ASSERT (m_lines > 0);
// report CODEC + ERRORS
kDebug (13020) << "Loaded file " << filename << "with codec" << m_textCodec->name()
<< (encodingErrors ? "with" : "without") << "encoding errors";
// report BOM
kDebug (13020) << (file.byteOrderMarkFound () ? "Found" : "Didn't find") << "byte order mark";
// report filter device mime-type
kDebug (13020) << "used filter device for mime-type" << m_mimeTypeForFilterDev;
// emit success
emit loaded (filename, encodingErrors);
// file loading worked, modulo encoding problems
return true;
}
void PluginLoader<T>::deleteInstance(T *data){
if(loaded()){
mDestroyFunc(data);
}
return;
}
StreamsBrowsePage::StreamsBrowsePage(QWidget *p)
: SinglePageWidget(p)
, settings(0)
{
importAction = new Action(Icon("document-import"), i18n("Import Streams Into Favorites"), this);
exportAction = new Action(Icon("document-export"), i18n("Export Favorite Streams"), this);
addAction = ActionCollection::get()->createAction("addstream", i18n("Add New Stream To Favorites"), Icons::self()->addRadioStreamIcon);
editAction = new Action(Icons::self()->editIcon, i18n("Edit"), this);
searchAction = new Action(Icons::self()->searchIcon, i18n("Seatch For Streams"), this);
connect(searchAction, SIGNAL(triggered()), this, SIGNAL(searchForStreams()));
// connect(view, SIGNAL(itemsSelected(bool)), addToPlaylist, SLOT(setEnabled(bool)));
connect(view, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(itemDoubleClicked(const QModelIndex &)));
connect(view, SIGNAL(itemsSelected(bool)), SLOT(controlActions()));
connect(addAction, SIGNAL(triggered()), this, SLOT(addStream()));
connect(StreamsModel::self()->addBookmarkAct(), SIGNAL(triggered()), this, SLOT(addBookmark()));
connect(StreamsModel::self()->configureDiAct(), SIGNAL(triggered()), this, SLOT(configureDi()));
connect(StreamsModel::self()->reloadAct(), SIGNAL(triggered()), this, SLOT(reload()));
connect(editAction, SIGNAL(triggered()), this, SLOT(edit()));
connect(importAction, SIGNAL(triggered()), this, SLOT(importXml()));
connect(exportAction, SIGNAL(triggered()), this, SLOT(exportXml()));
connect(StreamsModel::self(), SIGNAL(error(const QString &)), this, SIGNAL(error(const QString &)));
connect(StreamsModel::self(), SIGNAL(loading()), view, SLOT(showSpinner()));
connect(StreamsModel::self(), SIGNAL(loaded()), view, SLOT(hideSpinner()));
connect(StreamsModel::self(), SIGNAL(categoriesChanged()), view, SLOT(closeSearch()));
connect(StreamsModel::self(), SIGNAL(favouritesLoaded()), SLOT(expandFavourites()));
connect(StreamsModel::self(), SIGNAL(addedToFavourites(QString)), SLOT(addedToFavourites(QString)));
connect(DigitallyImported::self(), SIGNAL(loginStatus(bool,QString)), SLOT(updateDiStatus()));
connect(DigitallyImported::self(), SIGNAL(updated()), SLOT(updateDiStatus()));
connect(view, SIGNAL(headerClicked(int)), SLOT(headerClicked(int)));
StreamsModel::self()->configureDiAct()->setEnabled(false);
proxy.setSourceModel(StreamsModel::self());
view->setModel(&proxy);
view->setDeleteAction(StdActions::self()->removeAction);
view->setSearchResetLevel(1);
view->alwaysShowHeader();
Configuration config(metaObject()->className());
view->setMode(ItemView::Mode_DetailedTree);
view->load(config);
MenuButton *menuButton=new MenuButton(this);
Action *configureAction=new Action(Icons::self()->configureIcon, i18n("Configure"), this);
connect(configureAction, SIGNAL(triggered()), SLOT(configure()));
menuButton->addAction(createViewMenu(QList<ItemView::Mode>() << ItemView::Mode_BasicTree << ItemView::Mode_SimpleTree
<< ItemView::Mode_DetailedTree << ItemView::Mode_List));
menuButton->addAction(configureAction);
menuButton->addAction(StreamsModel::self()->configureDiAct());
menuButton->addSeparator();
menuButton->addAction(addAction);
menuButton->addAction(StdActions::self()->removeAction);
menuButton->addAction(editAction);
menuButton->addAction(StreamsModel::self()->reloadAct());
menuButton->addSeparator();
menuButton->addAction(importAction);
menuButton->addAction(exportAction);
diStatusLabel=new ServiceStatusLabel(this);
diStatusLabel->setText("DI", i18nc("Service name", "Digitally Imported"));
connect(diStatusLabel, SIGNAL(clicked()), SLOT(diSettings()));
updateDiStatus();
ToolButton *searchButton=new ToolButton(this);
searchButton->setDefaultAction(searchAction);
init(ReplacePlayQueue, QList<QWidget *>() << menuButton << diStatusLabel, QList<QWidget *>() << searchButton);
view->addAction(editAction);
view->addAction(StdActions::self()->removeAction);
view->addAction(StreamsModel::self()->addToFavouritesAct());
view->addAction(StreamsModel::self()->addBookmarkAct());
view->addAction(StreamsModel::self()->reloadAct());
}
Test::Result
PK_Key_Generation_Test::test_key(const std::string& algo, const Botan::Private_Key& key)
{
Test::Result result(algo + " keygen");
try
{
Botan::DataSource_Memory data_src(Botan::X509::PEM_encode(key));
std::unique_ptr<Botan::Public_Key> loaded(Botan::X509::load_key(data_src));
result.test_eq("recovered public key from private", loaded.get(), true);
result.test_eq("public key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("public key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip PEM public key", e.what());
}
try
{
Botan::DataSource_Memory data_src(Botan::X509::BER_encode(key));
std::unique_ptr<Botan::Public_Key> loaded(Botan::X509::load_key(data_src));
result.test_eq("recovered public key from private", loaded.get(), true);
result.test_eq("public key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("public key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip BER public key", e.what());
}
try
{
Botan::DataSource_Memory data_src(Botan::PKCS8::PEM_encode(key));
std::unique_ptr<Botan::Private_Key> loaded(
Botan::PKCS8::load_key(data_src, Test::rng()));
result.test_eq("recovered private key from PEM blob", loaded.get(), true);
result.test_eq("reloaded key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("private key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip PEM private key", e.what());
}
try
{
Botan::DataSource_Memory data_src(Botan::PKCS8::BER_encode(key));
std::unique_ptr<Botan::Public_Key> loaded(Botan::PKCS8::load_key(data_src, Test::rng()));
result.test_eq("recovered public key from private", loaded.get(), true);
result.test_eq("public key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("public key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip BER private key", e.what());
}
const std::string passphrase = Test::random_password();
try
{
Botan::DataSource_Memory data_src(
Botan::PKCS8::PEM_encode(key, Test::rng(), passphrase,
std::chrono::milliseconds(10)));
std::unique_ptr<Botan::Private_Key> loaded(
Botan::PKCS8::load_key(data_src, Test::rng(), passphrase));
result.test_eq("recovered private key from encrypted blob", loaded.get(), true);
result.test_eq("reloaded key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("private key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip encrypted PEM private key", e.what());
}
try
{
Botan::DataSource_Memory data_src(
Botan::PKCS8::BER_encode(key, Test::rng(), passphrase,
std::chrono::milliseconds(10)));
std::unique_ptr<Botan::Private_Key> loaded(
Botan::PKCS8::load_key(data_src, Test::rng(), passphrase));
result.test_eq("recovered private key from BER blob", loaded.get(), true);
result.test_eq("reloaded key has same type", loaded->algo_name(), key.algo_name());
result.test_eq("private key passes checks", loaded->check_key(Test::rng(), false), true);
}
catch(std::exception& e)
{
result.test_failure("roundtrip encrypted BER private key", e.what());
}
return result;
}
/* returns TRUE if a user profile was loaded; otherwise, FALSE.*/
BOOL
OwnerProfile::load () {
dprintf ( D_FULLDEBUG, "In OwnerProfile::load()\n" );
HANDLE have_access = INVALID_HANDLE_VALUE;
DWORD last_error = 0,
length = 0,
i = 0;
priv_state priv = PRIV_UNKNOWN;
BOOL backup_created = FALSE,
profile_loaded = FALSE,
profile_exists = FALSE,
profile_destroyed = FALSE,
ok = FALSE;
__try {
/* short-cut if we've already loaded the profile */
if ( loaded () ) {
ok = TRUE;
__leave;
}
/* we must do the following as Condor */
priv = set_condor_priv ();
/* get the user's local profile directory (if this user
has a roaming profile, this is when it's cached locally) */
profile_directory_ = directory ();
/* if we have have a profile directory, let's make sure that
we also have permissions to it. Sometimes, if the startd were
to crash, heaven forbid, we may have access to the profile
directory, but it may still be locked by the previous login
session that was not cleaned up properly (the only resource
I know of that the system does not clean up immediately on
process termination are user login handles and their
resources). */
if ( profile_directory_ ) {
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: %s's profile directory: '%s'. "
"(last-error = %u)\n",
user_name_,
profile_directory_,
GetLastError () );
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: A profile directory is listed "
"but may not exist.\n" );
have_access = CreateFile (
profile_directory_,
GENERIC_WRITE,
0, /* magic # for NOT shared */
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, /* only take a peek */
NULL );
if ( INVALID_HANDLE_VALUE == have_access ) {
last_error = GetLastError ();
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: Failed to access '%s'. "
"(last-error = %u)\n",
profile_directory_,
last_error );
if ( ERROR_ACCESS_DENIED == last_error
|| ERROR_SHARING_VIOLATION == last_error ) {
/**************************************************
NOTE: For future implementations which allow for
any user to load their profile, what follows
bellow is known as a BAD IDEA. We'd prefer to keep
all the data, or FAIL! :)
**************************************************/
/* so we don't have access, lets just blow it away
and create a new one (see bellow) */
profile_destroyed = destroy ();
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: Destruction of %s's "
"profile %s. (last-error = %u)\n",
user_name_,
profile_destroyed ? "succeeded" : "failed",
profile_destroyed ? 0 : GetLastError () );
if ( !profile_destroyed ) {
__leave;
}
}
}
/* if we're here, then we can access the profile */
profile_exists = TRUE;
}
/* explicitly create the profile */
if ( !profile_exists ) {
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: Profile directory does not "
"exist, so we're going to create one.\n" );
/* we now create the profile, so we can backup it
up directly */
profile_exists = create ();
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: Creation of profile for %s %s. "
"(last-error = %u)\n",
user_name_,
profile_exists ? "succeeded" : "failed",
profile_exists ? 0 : GetLastError () );
/* if the profile still does not exist, then bail */
if ( !profile_exists ) {
__leave;
}
}
#if 0
/* now we transfer the user's profile directory to the cache
so that we can revert back to it once the user is done doing
their thang. */
backup_created = backup ();
dprintf (
D_FULLDEBUG,
"OwnerProfile::load: Creating a backup of %s's "
"profile %s.\n",
user_name_,
backup_created ? "succeeded" : "failed" );
/* if we were unable to create the backup, we should bail out
before we allow the user to make changes to the template
profile */
if ( !backup_created ) {
__leave;
}
#endif
/* finally, load the user's profile */
profile_loaded = loadProfile ();
if ( !profile_loaded ) {
__leave;
}
/* make sure to change state with regards to being loaded */
profile_loaded_ = TRUE;
/* everything went as expected */
ok = TRUE;
}
__finally {
/* free the attributes, if required */
if ( !ok && profile_directory_ ) {
delete [] profile_directory_;
profile_directory_ = NULL;
}
/* if we loaded the profile, but failed for some other reason,
then we should make sure to unload the profile */
if ( !ok && profile_loaded ) {
unloadProfile ();
}
/* return to previous privilege level */
set_priv ( priv );
}
return ok;
}
if (d->mediaObject)
d->mediaObject->service()->releaseControl(d->control);
}
d->control = newControl;
QMediaPlaylistProvider *playlist = d->control->playlistProvider();
connect(playlist, SIGNAL(loadFailed(QMediaPlaylist::Error,QString)),
this, SLOT(_q_loadFailed(QMediaPlaylist::Error,QString)));
connect(playlist, SIGNAL(mediaChanged(int,int)), this, SIGNAL(mediaChanged(int,int)));
connect(playlist, SIGNAL(mediaAboutToBeInserted(int,int)), this, SIGNAL(mediaAboutToBeInserted(int,int)));
connect(playlist, SIGNAL(mediaInserted(int,int)), this, SIGNAL(mediaInserted(int,int)));
connect(playlist, SIGNAL(mediaAboutToBeRemoved(int,int)), this, SIGNAL(mediaAboutToBeRemoved(int,int)));
connect(playlist, SIGNAL(mediaRemoved(int,int)), this, SIGNAL(mediaRemoved(int,int)));
connect(playlist, SIGNAL(loaded()), this, SIGNAL(loaded()));
connect(d->control, SIGNAL(playbackModeChanged(QMediaPlaylist::PlaybackMode)),
this, SIGNAL(playbackModeChanged(QMediaPlaylist::PlaybackMode)));
connect(d->control, SIGNAL(currentIndexChanged(int)),
this, SIGNAL(currentIndexChanged(int)));
connect(d->control, SIGNAL(currentMediaChanged(QMediaContent)),
this, SIGNAL(currentMediaChanged(QMediaContent)));
if (oldSize)
emit mediaRemoved(0, oldSize-1);
if (playlist->mediaCount()) {
emit mediaAboutToBeInserted(0,playlist->mediaCount()-1);
emit mediaInserted(0,playlist->mediaCount()-1);
}
void onRepaintDone()
{
emit loaded();
}