void PropertyTreeViewer::tabChanged(int _newNum)
{
    QWidget* w = m_ui->tabWidget->widget(_newNum);
    if(!w)
        return;

    if(!isServiceTab(m_currentTab) && !isNormalised())
        saveValuesFromUi();

    if(w == m_ui->average)
    {
        displayValuesForArithmeticalMean();
        w->layout()->addWidget(m_treePropertyWidget);
        m_currentTab = _newNum;
    }
    else if(w == m_ui->add)
    {
        addTab();
        return;
    }
    else if(w == m_ui->import)
    {
        import();
        return;
    }
    else
    {
        m_treePropertyWidget->setValues(m_values[_newNum]);
        m_currentTab = _newNum;
    }

    setActiveTab(w);
    normalise(isNormalised());
}
void ImportSelectionDlg::on_button_import_variables(wxCommandEvent &event)
{
    int count_user = list_ctrl_env_vars_user_->GetSelectedItemCount();
    int count_system = list_ctrl_env_vars_system_->GetSelectedItemCount();

    if (count_user + count_system == 0)
    {
        wxMessageBox("Nothing to import.\n\n"
                     "You must select variables to import.",
                    "Importing environment variables",
                    wxOK | wxICON_WARNING);

        return;
    }

    if (count_user)
    {
        import(list_ctrl_env_vars_user_, env_vars_user_);
    }

    if (count_system)
    {
        import(list_ctrl_env_vars_system_, env_vars_system_);
    }

    this->Destroy();
}
Exemple #3
0
Pulsar::PhaseVsPlot::Interface::Interface (PhaseVsPlot* instance)
{
  if (instance)
    set_instance (instance);

  // import the interface of the base class
  import( PhasePlot::Interface() );

  add( &PhaseVsPlot::get_rows,
       &PhaseVsPlot::set_rows,
       "rows", "Select rows to be plotted");

  import( "z", PlotScale::Interface(), &PhaseVsPlot::get_z_scale );

  add( &PhaseVsPlot::get_style,
       &PhaseVsPlot::set_style,
       "style", "Plot style: image or line");

  add( &PhaseVsPlot::get_crop,
       &PhaseVsPlot::set_crop,
       "crop", "Crop the data at this percentage of max" );

  import("cmap", pgplot::ColourMap::Interface(), &PhaseVsPlot::get_colour_map);

}
Exemple #4
0
int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow )
{
    import( rb_core );
    import( rb_ui );
    import( rb_extui );

    JCore* pCore = new JCore();
    pCore->Init();

    UnitTest::RunAllTests();
    return 0;
}
 inline XERCES_CPP_NAMESPACE::DOMNode& import( XERCES_CPP_NAMESPACE::DOMDocument& document,
                                               const XERCES_CPP_NAMESPACE::DOMNode& from,
                                               XERCES_CPP_NAMESPACE::DOMNode& to )
 {
     if( from.getNodeType() == XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_NODE )
     {
         if( from.getFirstChild() )
             import( document, *from.getFirstChild(), to );
         return document;
     }
     XERCES_CPP_NAMESPACE::DOMNode& added = detail::clone( document, from, to );
     import( document, from.getFirstChild(), added );
     return added;
 }
Exemple #6
0
int main(int argc, char const *argv[])
{
	if(argc != 2){
		printf("Useage: %s inputfile.txt\n",argv[0]);
		exit(-1);
	}

	input_file =fopen(argv[1],"r");
	output_file =fopen("simulation.txt","w");
	
	import(input_file);
	ini_context();

	int i;
	for(i=1;i<32;i++){
		clone();
		fetch_decode(i);
		issue();
		alu1();
		alu2();
		memory();
		wb();
		cout_state(i,output_file);
	}

	return 0;
}
void UmlAccessVariableValueAction::import_it(FileIn & in, Token & token)
{
    WrapperStr s = token.valueOf("variable");

    if (! s.isEmpty())
        setVariable(s);

    if (! token.closed()) {
        WrapperStr k = token.what();
        const char * kstr = k;

        while (in.read(), !token.close(kstr)) {
            s = token.what();

            if (s == "variable") {
                setVariable(token.xmiIdref());

                if (! token.closed())
                    in.finish("variable");
            }
            else
                import(in, token);
        }
    }
}
Exemple #8
0
void FitsKernel::setupSelfBefore()
{
    ConvolutionKernel::setupSelfBefore();

    // Import the kernel
    import(this, _filename);
}
Exemple #9
0
Pulsar::MultiPhase::Interface::Interface (MultiPhase* instance)
{
  if (instance)
    set_instance (instance);

  import( "x", PhaseScale::Interface(), &MultiPhase::get_scale );
}
Exemple #10
0
struct jstruct_result
_jstruct_import(struct json_object *obj, const void *data,
        const struct jstruct_object_property *properties, struct json_object *errors) {
    _init_importers();
    if (errors != NULL && json_object_get_type(errors) != json_type_array) {
        return jstruct_error_new(jstruct_error_errors_not_array_or_null, NULL, json_object_get_type(errors));
    }
    const struct jstruct_object_property *property;
    struct json_object *prop;
    struct jstruct_result result = JSTRUCT_OK;
    result.allocated = array_list_new(jstruct_allocated_free);
    for (property = properties; property->name; ++property) {
        void *ptr = jstruct_prop_ptr(data, property, JSTRUCT_PROP_PTR_GET_NO_DEREF);
        struct jstruct_result err;
        if (json_object_object_get_ex(obj, property->name, &prop)) {
            if (json_object_get_type(prop) != property->type.json) {
                err = jstruct_error_new(jstruct_error_incorrect_type, property->name, json_object_get_type(prop));
            } else {
                jstruct_import_importer import = importers[json_type_index(property->type.json)];
                err = import(prop, data, ptr, property);
            }
        } else {
            if (!set_null(ptr, property)) {
                err = jstruct_error_array_add(errors, jstruct_error_not_nullable, property->name, 0);
            }
        }
        jstruct_error_consume(&result, &err, errors, property->name, -1);
    }
    if (result.allocated->length == 0) {
        array_list_free(result.allocated);
        result.allocated = NULL;
    }
    return result;
}
Exemple #11
0
// Parses a multi-import statement.
void parse_multi_import(Parser *parser) {
    Lexer *lexer = parser->lexer;

    // Ensure there's at least one string within the
    // parentheses
    EXPECT(TOKEN_STRING, "Expected package name after `(`");

    // Expect a comma separated list of strings
    while (lexer->token == TOKEN_STRING) {
        // Import the package
        char *name = lexer_extract_string(lexer->value.identifier);
        import(parser, name);

        // Consume the string
        lexer_next(lexer);

        // Expect a comma
        EXPECT(TOKEN_COMMA, "Expected `,` after package name");
        lexer_next(lexer);
    }

    // Expect a close parenthesis
    EXPECT(TOKEN_CLOSE_PARENTHESIS, "Expected `)` to close import list");
    lexer_next(lexer);
}
Exemple #12
0
void VoxelImporter::import() {
    switch (_importDialog.getMode()) {
        case loadingMode:
            _importDialog.setMode(placeMode);
            return;
        case placeMode:
            // Means the user chose to import
            _didImport = true;
            _importDialog.close();
            return;
        case importMode:
        default:
            QString filename = _importDialog.getCurrentFile();
            // if it's not a file, we ignore the call
            if (!QFileInfo(filename).isFile()) {
                return;
            }
            
            // Let's prepare the dialog window for import
            _importDialog.setMode(loadingMode);
            
            // If not already done, we switch to the local tree
            if (Application::getInstance()->getSharedVoxelSystem()->getTree() != &_voxelTree) {
                Application::getInstance()->getSharedVoxelSystem()->changeTree(&_voxelTree);
            }
            
            // Creation and launch of the import task on the thread pool
            _task = new ImportTask(filename);
            connect(_task, SIGNAL(destroyed()), SLOT(import()));
            QThreadPool::globalInstance()->start(_task);
            break;
    }
}
bool TSShapeImport::import(const char* file,ITRGeometry* geometry)
{
	TSInit();
	TSShape* shape = TSShape::load(file);
	AssertFatal(shape != 0,"TSShapeImport::import: Could not load shape file");
	return import(shape,geometry);
}
bool loadBulletFile(std::string name, btBvhTriangleMeshShape*& trimeshShape)
{
    btBulletWorldImporter import(0);//don't store info into the world
    // import.setVerboseMode(0xFF);
    if (import.loadFile(name.c_str()))
    {
        int numBvh = import.getNumBvhs();
        int numBRB = import.getNumRigidBodies();
        //if (numBvh)
        //{
        //    btOptimizedBvh* bvh = import.getBvhByIndex(0);
        //    btVector3 aabbMin(-1000,-1000,-1000),aabbMax(1000,1000,1000);

        //    trimeshShape  = new btBvhTriangleMeshShape(m_indexVertexArrays,useQuantizedAabbCompression,aabbMin,aabbMax,false);
        //    trimeshShape->setOptimizedBvh(bvh);

        //}
        //btCompoundShape* cs;
        int numShape = import.getNumCollisionShapes();
        if (numShape)
        {
            //trimeshShape = (btBvhTriangleMeshShape*)import.getCollisionShapeByIndex(0);

            ////if you know the name, you can also try to get the shape by name:
            //const char* meshName = import.getNameForPointer(trimeshShape);
            //if (meshName)
            trimeshShape = (btBvhTriangleMeshShape*)import.getCollisionShapeByName("lod3");
        }

        return true;
    }

    return false;
}
bool PGNImporter::importFromFile(const QString& fileName)
{
    pgn::GameCollection games;

    std::ifstream pgnfile(fileName.toStdString().c_str());

    std::cout << "\"" << fileName.toStdString() << "\"" << std::endl;
    std::cout << "Called: " << pgnfile.is_open() << std::endl;
    emit onProgress(1);


    try
    {
        pgnfile >> games;
    }
    catch(pgn::ParseException& ex)
    {
        std::clog << "Parse error: " << ex.what() << std::endl;

        QMessageBox msg;
        msg.setIcon(QMessageBox::Critical);
        msg.setText(QString("Parse error: \"%1\" - document can not be imported").arg(ex.what()));
        msg.exec();

        return false;
    }

    return import(games);
}
void reFBXAsset::load()
{
	clearChildren();
	bool importNeeded = true;
	ifstream ifs(metaPath().toStdString().c_str(), ios::in);
	if (!ifs.fail())
	{
		Json::Reader reader;
		Json::Value root;
		reader.parse(ifs, root);
		QString hash = root["hash"].asString().c_str();
		if (fileHash() == hash) 
		{
			loadJson(root);
			importNeeded = false;
		}
	}

	if (importNeeded)
		import();

	loadNodeAssets();

	Json::StyledWriter writer;
	ofstream fs(metaPath().toStdString().c_str(), ios::out);
	fs << writer.write(getJson());
	fs.close();
}
Pulsar::StokesFluctPlot::Interface::Interface (StokesFluctPlot* instance)
{
  if (instance)
    set_instance (instance);

  import ( FluctPlot::Interface() );

  remove ("pol");

  add( &StokesFluctPlot::get_plot_last_harmonic,
       &StokesFluctPlot::set_plot_last_harmonic,
       "last", "Plot the last harmonic marker" );

  add( &StokesFluctPlot::get_plot_values,
       &StokesFluctPlot::set_plot_values,
       "val", "Values to be plotted (IQUVLpS)" );

  add( &StokesFluctPlot::get_plot_colours,
       &StokesFluctPlot::set_plot_colours,
       "sci", "PGPLOT colour index for each value" );
 
  add( &StokesFluctPlot::get_plot_lines,
       &StokesFluctPlot::set_plot_lines,
       "sls", "PGPLOT line style for each value" );

}
Exemple #18
0
void testExecute(const char *source, bool verbose){
    LOG("testExecuteSecond", "begin");
    Context *globalContext = context_new();
    context_enterScope(globalContext); 
    LOG("testExecuteSecond", "filling op table");
    fillOpTable(globalContext);
    LOG("testExecuteSecond", "loading extensions");
    int ext_num = loadExtensions(EXT_LOCATION, globalContext);
    printf("Loaded %d extensions\n", ext_num);
    LOG("testExecuteSecond", "op table filled");
    import(globalContext, "stl.x");
    TokenStream ts;
    LOG("testExecuteSecond", "starting fill token stream");
    fillTokenStream(&ts, source); 
    LOG("testExecuteSecond", "token stream filled");
    while(!isEndOfStream(&ts)){
        LOG("testExecuteSecond", "calling parse");
        Node head = parse(&ts, 0);
        LOG("testExecuteSecond", "returning form parse");
        LOG("TestExecuteSecond", "calling execute");
        if(verbose)
            printTree(head, 0);
        LOG("testExecuteSecond", "calling execute");
        ObjectNode *node = execute(globalContext, &head);
        if(verbose){
            printf("res>");
            printObjectNode(node);
            printf("\n");
        }
    }
//    closeExtensions(lib_handle, ext_num);
    context_leaveScope(globalContext);
}
Exemple #19
0
void REPL(bool verbose){
    Context *globalContext = context_new();
    context_enterScope(globalContext); 
    fillOpTable(globalContext);
    int ext_num = loadExtensions(EXT_LOCATION, globalContext);
    printf("Loaded %d extensions\n", ext_num);
    import(globalContext, "stl.x");
    int n_bytes = 100;
    char *source = malloc(n_bytes + 1);
    for(int i = 0;i < n_bytes + 1;i++) source[i] = 0;
    while (1){
        getline(&source, &n_bytes, stdin);
        //printf("%s\n", source);
        TokenStream ts;
        fillTokenStream(&ts, source); 
        while(!isEndOfStream(&ts)){
            Node head = parse(&ts, 0);
            if(verbose)
                printTree(head, 0);
            ObjectNode *node = execute(globalContext, &head);
            printf("res>");
            printObjectNode(node);
            printf("\n");
        }
    }
//    closeExtensions(lib_handle, ext_num);
    context_leaveScope(globalContext);
}
bool TSShapeImport::import(TSShape* shape,ITRGeometry* geometry)
{
	//
	printf("TSShape Import\n");

	//
	VectorPtr<TSPartList*> partStack;
	partStack.push_back(dynamic_cast<TSPartList*>(shape));
	while (!partStack.empty()) {
		TSPartList& partList = *partStack.last();
		partStack.decrement();
		for (int i = 0; i < partList.getPartCount(); i++)
			if (TSPartList *pl = dynamic_cast<TSPartList*>(partList[i]))
				partStack.push_back(pl);
			else
				if (TSMesh* pm = dynamic_cast<TSMesh*>(partList[i])) {
					if (!import(pm,shape->getMaterialList(),geometry))
						return false;
				}
	}

	printf("   Vertices: %d\n",geometry->point3List.size());
	printf("   Surfaces: %d\n",geometry->surfaceList.size());
	printf("   Polygons: %d\n",geometry->polyList.size());
	printf("   Planes: %d\n",geometry->planeList.size());
	return true;
}
Exemple #21
0
ImportDialog::ImportDialog(QWidget *parent)
    : QFileDialog(parent, WINDOW_NAME, DESKTOP_LOCATION, IMPORT_FILE_TYPES),
      _importButton      (IMPORT_BUTTON_NAME, this),
      _clipboardImportBox(IMPORT_TO_CLIPBOARD_CHECKBOX_STRING, this),
      _previewBox        (PREVIEW_CHECKBOX_STRING, this),
      _previewBar        (this),
      _glPreview         (new GLWidget(this)) {
    setOption(QFileDialog::DontUseNativeDialog, true);
    setFileMode(QFileDialog::ExistingFile);
    setViewMode(QFileDialog::Detail);

    QGridLayout* gridLayout = (QGridLayout*) layout();
    gridLayout->addWidget(&_importButton      , 2, 2);
    gridLayout->addWidget(&_clipboardImportBox, 2, 3);
    gridLayout->addWidget(&_previewBox        , 3, 3);
    gridLayout->addWidget(&_previewBar        , 0, 3);
    gridLayout->addWidget(_glPreview          , 1, 3);
    gridLayout->setColumnStretch(3, 1);

    _previewBar.setVisible(false);
    _previewBar.setRange(0, 100);
    _previewBar.setValue(0);

    connect(&_importButton, SIGNAL(pressed()), SLOT(import()));
    connect(&_previewBox, SIGNAL(toggled(bool)), SIGNAL(previewToggled(bool)));
    connect(&_previewBox, SIGNAL(toggled(bool)), SLOT(preview(bool)));

    connect(this, SIGNAL(currentChanged(QString)), SLOT(saveCurrentFile(QString)));
    connect(&_glTimer, SIGNAL(timeout()), SLOT(timer()));
}
Exemple #22
0
void CImportDlg::import()
{
	for(size_t i = 0; i < m_files.size(); i++)
	{
		import(m_files[i].c_str());
	}
}
Exemple #23
0
FXint GMSyncTask::run() {
  FXASSERT(database);
  try {
    dbtracks.init(database,options.album_format_grouping);

    setID3v1Encoding();

    if (options_sync.remove_all) {
      remove_missing();
      }
    else if (options_sync.import_new) {

      if (options_sync.update)
        import_and_update();
      else
        import();

      if (options_sync.remove_missing)
        remove_missing();
      }
    else if (options_sync.update) {
      update();
      }
    else if (options_sync.remove_missing) {
      remove_missing();
      }

    GMTag::setID3v1Encoding(nullptr);
    }
  catch(GMDatabaseException&) {
    database->rollbackTask();
    return 1;
    }
  return 0;
  }
Exemple #24
0
Pulsar::StokesPlot::Interface::Interface (StokesPlot* instance)
{
  if (instance)
    set_instance (instance);

  import ( FluxPlot::Interface() );

  remove ("pol");

  add( &StokesPlot::get_plot_values,
       &StokesPlot::set_plot_values,
       "val", "Values to be plotted (IQUVLp)" );

  add( &StokesPlot::get_plot_colours,
       &StokesPlot::set_plot_colours,
       "ci", "PGPLOT colour index for each value" );

  add( &StokesPlot::get_plot_lines,
       &StokesPlot::set_plot_lines,
       "ls", "PGPLOT line style for each value" );

  add( &StokesPlot::get_plot_widths,
       &StokesPlot::set_plot_widths,
       "lw", "PGPLOT line width for each value" );

  add( &StokesPlot::get_pav_bias,
       &StokesPlot::set_pav_bias,
       "pav", "Handle bias as done in pav" );

}
int
rt_obj_import(struct rt_db_internal *ip, const struct bu_external *ep, const mat_t mat, const struct db_i *dbip, struct resource *resp)
{
    int id;
    const struct rt_functab *ft;
    int (*import)(struct rt_db_internal *, const struct bu_external *, const mat_t, const struct db_i *, struct resource *);

    if (!ip || !ep || !dbip)
	return -1;

    RT_CK_DB_INTERNAL(ip);
    BU_CK_EXTERNAL(ep);
    RT_CK_DBI(dbip);
    if (resp) RT_CK_RESOURCE(resp);

    id = ip->idb_minor_type;
    if (id < 0)
	return -2;

    ft = &OBJ[id];
    if (!ft)
	return -3;

    if (dbip->dbi_version < 5) {
	import = ft->ft_import4;
    } else {
	import = ft->ft_import5;
    }

    if (!import)
	return -4;

    return import(ip, ep, mat, dbip, resp);
}
// ---------------------------------------------------------------------------
// 
// ------------
bool bXMapMMTImport::process(int msg, void* prm){
	switch(msg){
		case kExtProcessCallFromIntf:
			import();
			break;
		case kExtProcessCallWithParams:
			import((import_prm*)prm);
			break;
		case kExtProcessCallWithXMLTree:
			import(true);
			break;
		default:
			break;
	}
	return(true);
}
Exemple #27
0
void Map::loadPrefabAt(const Vector3& targetCoords)
{
    std::string filename =
        MapFileManager::getMapFilename(true, _("Load Prefab"), "prefab");

    if (!filename.empty()) {
        UndoableCommand undo("loadPrefabAt");

        // Deselect everything
        GlobalSelectionSystem().setSelectedAll(false);

        // Now import the prefab (imported items get selected)
        import(filename);

        // Switch texture lock on
        bool prevTexLockState = GlobalBrush().textureLockEnabled();
        GlobalBrush().setTextureLock(true);

        // Translate the selection to the given point
        GlobalSelectionSystem().translateSelected(targetCoords);

        // Revert to previous state
        GlobalBrush().setTextureLock(prevTexLockState);
    }
}
 std::string writeTag( const std::string& tag, const std::string& label, persistency::Session& session, std::string tmpDir ){
   session.transaction().start();
   persistency::IOVProxy p = session.readIov( tag, true );
   std::cout <<"    "<<p.loadedSize()<<" iovs loaded."<<std::endl;
   std::string destFile = label+".db";
   boost::filesystem::path destFilePath( destFile );
   if( !tmpDir.empty() ) {
     destFilePath = boost::filesystem::path( tmpDir ) / destFilePath;
   }
   destFile = destFilePath.string();
   persistency::ConnectionPool localPool;
   persistency::Session writeSession = localPool.createSession( "sqlite_file:"+destFile, true );
   writeSession.transaction().start( false );
   persistency::IOVEditor writeEditor = writeSession.createIov( p.payloadObjectType(), tag, p.timeType(), p.synchronizationType() );
   writeEditor.setValidationMode();
   writeEditor.setDescription("Validation");
   for( auto iov : p ){
     std::pair<std::string,boost::shared_ptr<void> > readBackPayload = fetch( iov.payloadId, session );
     cond::Hash ph = import( session, iov.payloadId, readBackPayload.first, readBackPayload.second.get(), writeSession );
     writeEditor.insert( iov.since, ph );
   }
   writeEditor.flush();
   writeSession.transaction().commit();
   session.transaction().commit();
   return destFile;
 }
medPacsWidget::medPacsWidget(QWidget *parent) : QTreeWidget(parent), d(new medPacsWidgetPrivate)
{
    this->setFrameStyle(QFrame::NoFrame);
    this->setAttribute(Qt::WA_MacShowFocusRect, false);
    this->setUniformRowHeights(true);
    this->setAlternatingRowColors(true);
    this->setSortingEnabled(true);
    this->setContextMenuPolicy(Qt::CustomContextMenu);
    this->setSelectionMode(QAbstractItemView::ExtendedSelection);

    this->setHeaderLabels(QStringList() << "Name" << "Description" << "Id" << "Modality");

    d->find = NULL;
    d->echo = NULL;
    d->server = medAbstractPacsFactory::instance()->createStoreScp("dcmtkStoreScp");
    if (!d->server) {
        qWarning() << "Unable to find a valid implementation of the store scp service.";
        return;
    }

    connect(this, SIGNAL(itemExpanded(QTreeWidgetItem *)), this, SLOT(onItemExpanded(QTreeWidgetItem *)));
    connect(this, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(updateContextMenu(const QPoint&)));
    connect(this->d->server, SIGNAL(endOfStudy(QString)), this, SIGNAL(import(QString)));

    this->readSettings();
    d->start();
    d->selectedNodes = d->nodes;

}
Exemple #30
0
ImportDialog::ImportDialog(QWidget* parent) :
    QFileDialog(parent, WINDOW_NAME, DESKTOP_LOCATION, NULL),
    _importButton(IMPORT_BUTTON_NAME, this),
    _cancelButton(CANCEL_BUTTON_NAME, this),
    fileAccepted(false) {

    setOption(QFileDialog::DontUseNativeDialog, true);
    setFileMode(QFileDialog::ExistingFile);
    setViewMode(QFileDialog::Detail);

#ifdef Q_OS_MAC
    QString cmdString = ("Command");
#else
    QString cmdString = ("Control");
#endif
    QLabel* infoLabel = new QLabel(QString(INFO_LABEL_TEXT).arg(cmdString));
    infoLabel->setObjectName("infoLabel");

    QGridLayout* gridLayout = (QGridLayout*) layout();
    gridLayout->addWidget(infoLabel, 2, 0, 2, 1);
    gridLayout->addWidget(&_cancelButton, 2, 1, 2, 1);
    gridLayout->addWidget(&_importButton, 2, 2, 2, 1);

    setImportTypes();
    setLayout();

    connect(&_importButton, SIGNAL(pressed()), SLOT(import()));
    connect(this, SIGNAL(currentChanged(QString)), SLOT(saveCurrentFile(QString)));

    connect(&_cancelButton, SIGNAL(pressed()), SLOT(close()));
    connect(this, SIGNAL(currentChanged(QString)), SLOT(saveCurrentFile(QString)));
}