wxString ClangPlugin::GetSourceOf(cbEditor* ed) { cbProject* project = nullptr; ProjectFile* opf = ed->GetProjectFile(); if (opf) project = opf->GetParentProject(); if (!project) project = Manager::Get()->GetProjectManager()->GetActiveProject(); wxFileName theFile(ed->GetFilename()); wxFileName candidateFile; bool isCandidate; wxArrayString fileArray; wxDir::GetAllFiles(theFile.GetPath(wxPATH_GET_VOLUME), &fileArray, theFile.GetName() + wxT(".*"), wxDIR_FILES | wxDIR_HIDDEN); wxFileName currentCandidateFile = FindSourceIn(fileArray, theFile, isCandidate); if (isCandidate) candidateFile = currentCandidateFile; else if (currentCandidateFile.IsOk()) return currentCandidateFile.GetFullPath(); fileArray.Clear(); EditorManager* edMgr = Manager::Get()->GetEditorManager(); for (int i = 0; i < edMgr->GetEditorsCount(); ++i) { cbEditor* edit = edMgr->GetBuiltinEditor(i); if (!edit) continue; ProjectFile* pf = edit->GetProjectFile(); if (!pf) continue; fileArray.Add(pf->file.GetFullPath()); } currentCandidateFile = FindSourceIn(fileArray, theFile, isCandidate); if (!isCandidate && currentCandidateFile.IsOk()) return currentCandidateFile.GetFullPath(); if (project) { fileArray.Clear(); for (FilesList::const_iterator it = project->GetFilesList().begin(); it != project->GetFilesList().end(); ++it) { ProjectFile* pf = *it; if (!pf) continue; fileArray.Add(pf->file.GetFullPath()); } currentCandidateFile = FindSourceIn(fileArray, theFile, isCandidate); if (isCandidate && !candidateFile.IsOk()) candidateFile = currentCandidateFile; else if (currentCandidateFile.IsOk()) return currentCandidateFile.GetFullPath(); wxArrayString dirs = project->GetIncludeDirs(); for (int i = 0; i < project->GetBuildTargetsCount(); ++i) { ProjectBuildTarget* target = project->GetBuildTarget(i); if (target) { for (size_t ti = 0; ti < target->GetIncludeDirs().GetCount(); ++ti) { wxString dir = target->GetIncludeDirs()[ti]; if (dirs.Index(dir) == wxNOT_FOUND) dirs.Add(dir); } } } for (size_t i = 0; i < dirs.GetCount(); ++i) { wxString dir = dirs[i]; Manager::Get()->GetMacrosManager()->ReplaceMacros(dir); wxFileName dname(dir); if (!dname.IsAbsolute()) dname.Normalize(wxPATH_NORM_ALL & ~wxPATH_NORM_CASE, project->GetBasePath()); fileArray.Clear(); wxDir::GetAllFiles(dname.GetPath(), &fileArray, theFile.GetName() + wxT(".*"), wxDIR_FILES | wxDIR_HIDDEN); currentCandidateFile = FindSourceIn(fileArray, theFile, isCandidate); if (isCandidate) candidateFile = currentCandidateFile; else if (currentCandidateFile.IsOk()) return currentCandidateFile.GetFullPath(); } } if (candidateFile.IsOk()) return candidateFile.GetFullPath(); return wxEmptyString; }
/* Reads a file called fileName into an IndexInterface using rapidxml @param fileName - the name of the file to index @param index - the index to populate with information from the file */ bool XMLParser::readFileToIndex(string fileName, IndexInterface* index){ /* This is a block of setup code for rapidxml so that I can parse through the xml file efficiently */ rapidxml::xml_document<> doc; rapidxml::xml_node<> * root_node; ifstream theFile (fileName); vector<char> buffer((istreambuf_iterator<char>(theFile)), istreambuf_iterator<char>()); buffer.push_back('\0'); // Parse the buffer using the xml file parsing library into doc doc.parse<0>(&buffer[0]); // Find our root node root_node = doc.first_node("mediawiki"); //Save the number of documents that have been indexed int num = 0; for (rapidxml::xml_node<> * document_node = root_node->first_node("page"); document_node; document_node = document_node->next_sibling()){ //The text element of the current document node rapidxml::xml_node<> * text; //Grab the text and document name of the current document text = document_node->first_node("revision")->first_node("text"); string docName = document_node->first_node("title")->value(); //Ignore documents called user or file. They're garbage if(docName.substr(0, 4) == "User" || docName.substr(0,4) == "File") continue; //Find and save the author of the last revision string docAuthor; if(document_node->first_node("revision")->first_node("contributor") != nullptr && document_node->first_node("revision")->first_node("contributor")->first_node("username") != nullptr) docAuthor = document_node->first_node("revision")->first_node("contributor")->first_node("username")->value(); else docAuthor = "No author information given"; //Find and save the timestamp for the last revision string timestamp; if(document_node->first_node("revision")->first_node("timestamp") != nullptr) timestamp = document_node->first_node("revision")->first_node("timestamp")->value(); else timestamp = "No timestamp given"; string fileName = "SearchDocs/"; string docNameCopy = docName; replace(docNameCopy.begin(), docNameCopy.end(), '/', '.'); replace(docNameCopy.begin(), docNameCopy.end(), ' ', '_'); fileName = fileName + docNameCopy; ofstream writeDocFile(fileName); //Add this document to the index and save it's index in the index number-name registry int indexOfDoc = index->addDocument(docName, docAuthor, timestamp); //If we've successfully found a text node for this document if(text){ //Calculate file name for document file docNameCopy = docName; replace(docNameCopy.begin(), docNameCopy.end(), '/', ' '); replace(docNameCopy.begin(), docNameCopy.end(), ':', '.'); stringstream titleStream(docNameCopy); while(!titleStream.eof()){ //save the current word and add it to the index for the current document number string word; titleStream >> word; writeDocFile << word << " "; //Check if the word is a stop word or xml garbage if(!isStopWord(word) && !isXMLTag(word)){ //If not, remove capitalization, stem it, and index it word[0] = tolower(word[0]); Porter2Stemmer::stem(word); index->addWordForDocument(indexOfDoc, word); } } //Make a stringstream of the text element of the document node stringstream ss(text->value()); //Parse through the whole stringstream while(!ss.eof()){ //save the current word and add it to the index for the current document number string word; ss >> word; writeDocFile << word << " "; //Check if the word is a stop word or xml garbage if(!isStopWord(word) && !isXMLTag(word)){ //If not, remove capitalization, stem it, and index it word[0] = tolower(word[0]); Porter2Stemmer::stem(word); index->addWordForDocument(indexOfDoc, word); } } } //close ofstream for this doc writeDocFile.close(); cout << num++ << docName << endl; } return true; }
void drawHFPosition(char file[100]="hf.out", int save=0) { setTDRStyle(); std::ifstream theFile(file); static const int NPMAX=20000; int etaIndex[NPMAX], phiIndex[NPMAX], depths[NPMAX], np=0; float radiusT[NPMAX], radiusH[NPMAX], phiH[NPMAX]; double deg=3.1415926/180.; while (theFile) { int ieta, iphi, idep; float etaR, rr, phideg; theFile >> ieta >> iphi >> idep >> etaR >> rr >> phideg; if (np < NPMAX) { etaIndex[np] = ieta; phiIndex[np] = iphi; depths[np] = idep; radiusT[np] = etaR; radiusH[np] = rr; if (phideg < 0) phideg += 360; int iphi = (int)(phideg/20); float phi = (phideg - iphi*20.0); if (phi > 10) phi -= 20; phiH[np] = phi*deg; np++; } } std::cout << np << " points found\n"; // for (int i=0; i<np; i++) std::cout << std::setw(4) << i << " " << std::setw(3) << etaIndex[i] << " " << std::setw(3) << phiIndex[i] << " " << depths[i] << " " << std::setw(6) << radiusT[i] << " " << std::setw(6) << radiusH[i] << " " << std::setw(6) << phiH[i] << "\n"; int symbol[14] = {20,21,22,23,24,25,26,27,28,29,30,3,5,2}; int colr[3] = {2,4,1}; TGraph *gr[3][14]; float x1[NPMAX], y1[NPMAX], x2[NPMAX], y2[NPMAX], x3[NPMAX], y3[NPMAX]; int np1, np2, np3; for (int i=0; i<13; i++) { np1 = np2 = np3 = 0; for (int j=0; j<np; j++) { if (etaIndex[j] == (i+29)) { int k = 2; if (depths[j] == 3) k = 0; else if (depths[j] == 4) k = 1; if (k == 0) { x1[np1] = radiusH[j]*cos(phiH[j]); y1[np1] = radiusH[j]*sin(phiH[j]); np1++; // if (np1 == 1) std::cout << i << " 0 " <<x1[0] << " " <<y1[0] << "\n"; } else if (k==1) { x2[np2] = radiusH[j]*cos(phiH[j]); y2[np2] = radiusH[j]*sin(phiH[j]); np2++; // if (np2 == 1) std::cout << i << " 1 " <<x2[0] << " " <<y2[0] << "\n"; } else { x3[np3] = radiusH[j]*cos(phiH[j]); y3[np3] = radiusH[j]*sin(phiH[j]); np3++; } } } // std::cout << "i " << i << " " <<np1 << " " <<np2 << " " <<np3 <<"\n"; if (np1 > 0) { gr[0][i] = new TGraph(np1,x1,y1); gr[0][i]->SetTitle(""); gr[0][i]->SetMarkerStyle(symbol[i]); gr[0][i]->SetMarkerColor(colr[0]); } else gr[0][i] = 0; if (np2 > 0) { gr[1][i] = new TGraph(np2,x2,y2); gr[1][i]->SetTitle(""); gr[1][i]->SetMarkerStyle(symbol[i]); gr[1][i]->SetMarkerColor(colr[1]); } else gr[1][i] = 0; if (np3 > 0) { gr[2][i] = new TGraph(np3,x3,y3); gr[2][i]->SetTitle(""); gr[2][i]->SetMarkerStyle(symbol[i]); gr[2][i]->SetMarkerColor(colr[2]); } else gr[2][i] = 0; } np1 = np2 = np3 = 0; for (int j=0; j<np; j++) { if (etaIndex[j] < 29 || etaIndex[j] > 41) { int k = 2; if (depths[j] == 3) k = 0; else if (depths[j] == 4) k = 1; if (k == 0) { x1[np1] = radiusH[j]*cos(phiH[j]); y1[np1] = radiusH[j]*sin(phiH[j]); np1++; if (np1 == 1) std::cout << i << " 0 " <<x1[0] << " " <<y1[0] << "\n"; } else if (k==1) { x2[np2] = radiusH[j]*cos(phiH[j]); y2[np2] = radiusH[j]*sin(phiH[j]); np2++; if (np2 == 1) std::cout << i << " 1 " <<x2[0] << " " <<y2[0] << "\n"; } else { x3[np3] = radiusH[j]*cos(phiH[j]); y3[np3] = radiusH[j]*sin(phiH[j]); np3++; } } } // std::cout << "i " << i << " " <<np1 << " " <<np2 << " " <<np3 <<"\n"; if (np1 > 0) { gr[0][13] = new TGraph(np1,x1,y1); gr[0][13]->SetTitle(""); gr[0][13]->SetMarkerStyle(symbol[13]); gr[0][13]->SetMarkerColor(colr[0]); } else gr[0][13] = 0; if (np2 > 0) { gr[1][13] = new TGraph(np2,x2,y2); gr[1][13]->SetTitle(""); gr[1][13]->SetMarkerStyle(symbol[13]); gr[1][13]->SetMarkerColor(colr[1]); } else gr[1][13] = 0; if (np3 > 0) { gr[2][13] = new TGraph(np3,x3,y3); gr[2][13]->SetTitle(""); gr[2][13]->SetMarkerStyle(symbol[13]); gr[2][13]->SetMarkerColor(colr[2]); } else gr[2][13] = 0; TCanvas *c0 = new TCanvas("c0","PMT Hits",800,600); TH1F *vFrame = c0->DrawFrame(1000.0,-250.0,1500.0,250.0); vFrame->SetXTitle("x (mm)"); vFrame->SetYTitle("y (mm)"); for (int i=0; i<=13; i++) { for (int j=0; j<3; j++) { if (gr[j][i] != 0) { gr[j][i]->Draw("p"); gr[j][i]->SetLineColor(colr[j]); gr[j][i]->SetLineWidth(2); // std::cout << "Next " << i << " " << j << "\n"; } } } TLegend *leg1 = new TLegend(0.75,0.55,0.90,0.90); char list[40]; for (i=0; i<= 13; i++) { if (i < 13) sprintf (list, "#eta = %d", i+29); else sprintf (list, "Unknown #eta"); if (gr[0][i] != 0) leg1->AddEntry(gr[0][i], list, "P"); else if (gr[1][i] != 0) leg1->AddEntry(gr[1][i], list, "P"); } for (i=0; i<2; i++) { if (i == 0) sprintf (list, "Long Fibre"); else sprintf (list, "Short Fibre"); if (gr[i][0] != 0) leg1->AddEntry(gr[i][0], list, "L"); else if (gr[i][1] != 0) leg1->AddEntry(gr[i][1], list, "L"); else if (gr[i][2] != 0) leg1->AddEntry(gr[i][2], list, "L"); } leg1->SetFillColor(0); leg1->SetTextSize(0.03); leg1->SetBorderSize(1); leg1->Draw(); if (save != 0) { if (save > 0) c0->SaveAs("PMTHits.eps"); else c0->SaveAs("PMTHits.gif"); } }
/** * GetFtpDirectory * * Description: 1) Conect to ftp server, change directory. * 2) Get dir listing. * 3) Read existing listing file, * 4) If listing has changed, write new dir listing file. * * Parameters: CConnection - describes ftp connection info, user, host etc. * dir - ftp remote directory * ftpClient - optional ftpclient. if null, will create, connect and close. * Return: * bool - success * ??? was it updated? */ bool CFtpManager::GetFtpDirectory(CConnection * con, CString &directory, CRealFtpClient * ftpClient) { bool result = false; //TRACE1(" con %s \n ", con->name); //Connect(con, m_ftpClient); //if(!m_ftpClient.IsConnected()) // Not connected //{ // return; //} bool closeConnection = false; if(!ftpClient) { ftpClient = new CRealFtpClient(); closeConnection = true; } if(!ftpClient->IsConnected()) // Not connected { int retcode = 11; retcode = ftpClient->FTPConnect(con->host, con->user, con->password, _T("")); if(retcode == UTE_SUCCESS) { ftpClient->SetFireWallMode(TRUE); } } //m_ftpClient.SetFireWallMode(TRUE); //ftpClient->SetFireWallMode(TRUE); CString localStorePath; GetLocalStorePath(con, localStorePath); localStorePath = localStorePath + directory + CString(_T("")); localStorePath.Replace('/', '\\'); CString dirContentListing(_T("")); CString fileListing(_T("")); CString folderListing(_T("")); CUT_DIRINFO di; _TCHAR entry[HISTORY_ENTRY_SIZE]; _TCHAR dir[MAX_PATH]; int valRet; { valRet = ftpClient->ChDir( directory ); if (valRet != UTE_SUCCESS){ //m_history.AddLine(CUT_ERR::GetErrorString (valRet)); TRACE1(" chdir failed: %s \n ", CUT_ERR::GetErrorString(valRet) ); } else { int dirInfo = ftpClient->GetDirInfo(); int count = ftpClient->GetDirInfoCount(); for(int t=0;t<count;t++){ ftpClient->GetDirEntry(t, &di); // v4.2 dir info now has _TCHAR // Format: Name,size,time, time display _sntprintf(entry, sizeof(entry)/sizeof(_TCHAR), _T("<n>%s</n><s>%ld</s><d>%2.2d/%2.2d/%2.2d %2.2d:%2.2d</d><p>%d</p><o>%s</o><g>%s</g>"), di.fileName, di.fileSize, di.year, di.month, di.day, di.hour, di.minute, di.permissions, di.owner, di.group); //m_history.AddLine(entry); if(di.isDir) { CString folderPath(localStorePath + _T("") + di.fileName ); if(GetFileAttributes(folderPath) == INVALID_FILE_ATTRIBUTES){ CreateDirectory(folderPath, NULL); } CString fileInfo(_T("")); fileInfo = fileInfo + CString(_T("<t>d</t>")) + CString(entry) + _T("\n"); folderListing = folderListing + fileInfo; } else { // File CString fileInfo(_T("")); fileInfo = fileInfo + CString(_T("<t>f</t>")) + CString(entry) + _T("\n"); fileListing = fileListing + fileInfo; } } dirContentListing = CString(folderListing + fileListing); // write dir descriptor // dirContentListing CString dirContentFile(localStorePath + _T(".files.rftp")); // Check existing files.rftp. Don't rewrite if its the same. SSD safety. CString existingListing(_T("")); CFileStatus status; if(CFile::GetStatus(dirContentFile, status)) { CStdioFile file (dirContentFile, CStdioFile::modeRead | CFile::shareDenyNone); CString buffer; while (file.ReadString(buffer)) { existingListing = existingListing + buffer + _T("\n"); } } if(existingListing.Compare(dirContentListing) != 0) { CFile theFile(dirContentFile, CFile::modeReadWrite | CFile::modeCreate); char buffer[200000]; sprintf(buffer, "%S", dirContentListing); // CString to char * int len = strlen(buffer); //theFile.Write( (LPCTSTR) dirContentListing, dirContentListing.GetLength() * sizeof(TCHAR)); // // Error here *********** // CString buffy(dirContentFile); if(buffy.Find(CString(_T("newsletter-form"))) != 1){ int i = 0; } theFile.Write(buffer, len); TRACE0(" GetFtpDirectory Updated \n"); m_directoryUpdated = true; } else { //TRACE0(" GetFtpDirectory Allready up to date \n"); m_directoryUpdated = false; } //TRACE1(" file: %s \n", entry); result = true; } // chdir success } if(closeConnection){ ftpClient->Close(); delete ftpClient; } return result; }
std::ofstream fileFactory(std::string filename){ std::ofstream theFile(filename.c_str()); return theFile; }
VexEditorComponent::VexEditorComponent (VexFilter* const ownerFilter) : AudioProcessorEditor(ownerFilter) { //Comboboxes, wave selection addAndMakeVisible (comboBox = new ComboBox (String::empty)); comboBox->setEditableText (false); comboBox->setJustificationType (Justification::centredLeft); comboBox->setTextWhenNothingSelected (String(T("silent"))); comboBox->setTextWhenNoChoicesAvailable (String(T("silent"))); comboBox->addListener (this); comboBox->setColour(ComboBox::backgroundColourId, Colours::black); comboBox->setColour(ComboBox::textColourId, Colours::lightgrey); comboBox->setColour(ComboBox::outlineColourId, Colours::grey); comboBox->setColour(ComboBox::buttonColourId, Colours::grey); comboBox->setWantsKeyboardFocus(false); comboBox->setLookAndFeel(&mlaf); addAndMakeVisible (comboBox2 = new ComboBox (String::empty)); comboBox2->setEditableText (false); comboBox2->setJustificationType (Justification::centredLeft); comboBox2->setTextWhenNothingSelected (String(T("silent"))); comboBox2->setTextWhenNoChoicesAvailable (String(T("silent"))); comboBox2->addListener (this); comboBox2->setColour(ComboBox::backgroundColourId, Colours::black); comboBox2->setColour(ComboBox::textColourId, Colours::lightgrey); comboBox2->setColour(ComboBox::outlineColourId, Colours::grey); comboBox2->setColour(ComboBox::buttonColourId, Colours::grey); comboBox2->setWantsKeyboardFocus(false); comboBox2->setLookAndFeel(&mlaf); addAndMakeVisible (comboBox3 = new ComboBox (String::empty)); comboBox3->setEditableText (false); comboBox3->setJustificationType (Justification::centredLeft); comboBox3->setTextWhenNothingSelected (String(T("silent"))); comboBox3->setTextWhenNoChoicesAvailable (String(T("silent"))); comboBox3->addListener (this); comboBox3->setColour(ComboBox::backgroundColourId, Colours::black); comboBox3->setColour(ComboBox::textColourId, Colours::lightgrey); comboBox3->setColour(ComboBox::outlineColourId, Colours::grey); comboBox3->setColour(ComboBox::buttonColourId, Colours::grey); comboBox3->setWantsKeyboardFocus(false); comboBox3->setLookAndFeel(&mlaf); #if 0 File location = (File::getSpecialLocation(File::userHomeDirectory)).getChildFile(".vex"); if (! location.exists ()) location.createDirectory (); DBG (location.getFullPathName()); String filePath = location.getFullPathName(); DirectoryIterator iter (File(filePath), true, "*.raw"); int i = 1; while (iter.next()) { File theFile(iter.getFile()); if (theFile.hasFileExtension (T("raw"))) { i++; comboBox->addItem (theFile.getFileNameWithoutExtension(), i); comboBox2->addItem (theFile.getFileNameWithoutExtension(), i); comboBox3->addItem (theFile.getFileNameWithoutExtension(), i); } } #endif int tableSize = waveRenderer::getWaveTableSize (); for (int i = 0; i < tableSize; i++) { String tableName (waveRenderer::getWaveTableName (i)); comboBox->addItem (tableName, i + 1); comboBox2->addItem (tableName, i + 1); comboBox3->addItem (tableName, i + 1); } //Make sliders for (int i = 0; i < 89; i++) { addAndMakeVisible (sliders[i] = new SnappingSlider (T("s"))); sliders[i]->setSliderStyle(Slider::RotaryVerticalDrag); sliders[i]->setRange (0, 1, 0); sliders[i]->setSnap(0.0f, 0.0f); sliders[i]->setLookAndFeel(&mlaf); sliders[i]->addListener (this); } //Adjust the center of some sliders[1]->setRange (0, 1, 0.25f); sliders[1]->setSnap(0.5f, 0.05f); sliders[2]->setSnap(0.5f, 0.05f); sliders[3]->setSnap(0.5f, 0.05f); sliders[4]->setSnap(0.5f, 0.05f); sliders[8]->setSnap(0.5f, 0.05f); sliders[13]->setSnap(0.5f, 0.05f); sliders[18]->setSnap(0.5f, 0.05f); int tmp = 24; sliders[1 + tmp]->setRange (0, 1, 0.25f); sliders[1 + tmp]->setSnap(0.5f, 0.05f); sliders[2 + tmp]->setSnap(0.5f, 0.05f); sliders[3 + tmp]->setSnap(0.5f, 0.05f); sliders[4 + tmp]->setSnap(0.5f, 0.05f); sliders[8 + tmp]->setSnap(0.5f, 0.05f); sliders[13 + tmp]->setSnap(0.5f, 0.05f); sliders[18 + tmp]->setSnap(0.5f, 0.05f); tmp = 48; sliders[1 + tmp]->setRange (0, 1, 0.25f); sliders[1 + tmp]->setSnap(0.5f, 0.05f); sliders[2 + tmp]->setSnap(0.5f, 0.05f); sliders[3 + tmp]->setSnap(0.5f, 0.05f); sliders[4 + tmp]->setSnap(0.5f, 0.05f); sliders[8 + tmp]->setSnap(0.5f, 0.05f); sliders[13 + tmp]->setSnap(0.5f, 0.05f); sliders[18 + tmp]->setSnap(0.5f, 0.05f); sliders[83]->setSnap(0.5f, 0.05f); sliders[84]->setSnap(0.5f, 0.05f); sliders[85]->setSnap(0.5f, 0.05f); sliders[75]->setSnap(0.0f, 0.05f); sliders[78]->setSnap(0.0f, 0.05f); sliders[82]->setSnap(0.0f, 0.05f); //PART ON/OFF addAndMakeVisible (TB = new TextButton (T("new button"))); TB->setButtonText (String::empty); TB->addButtonListener (this); TB->setColour (TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f)); TB->setColour(TextButton::buttonOnColourId, Colours::red); TB->setClickingTogglesState(true); TB->setToggleState(false,false); addAndMakeVisible (TB2 = new TextButton (T("new button"))); TB2->setButtonText (String::empty); TB2->addButtonListener (this); TB2->setColour (TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f)); TB2->setColour(TextButton::buttonOnColourId, Colours::red); TB2->setClickingTogglesState(true); TB2->setToggleState(false,false); addAndMakeVisible (TB3 = new TextButton (T("new button"))); TB3->setButtonText (String::empty); TB3->addButtonListener (this); TB3->setColour (TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f)); TB3->setColour(TextButton::buttonOnColourId, Colours::red); TB3->setClickingTogglesState(true); TB3->setToggleState(false,false); //Peggy ON/OFF addAndMakeVisible (TB4 = new TextButton (T("new button"))); TB4->setButtonText (String::empty); TB4->addButtonListener (this); TB4->setColour (TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f)); TB4->setColour(TextButton::buttonOnColourId, Colours::blue); TB4->setClickingTogglesState(true); TB4->setToggleState(false,false); addAndMakeVisible (TB5 = new TextButton (T("new button"))); TB5->setButtonText (String::empty); TB5->addButtonListener (this); TB5->setColour (TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f)); TB5->setColour(TextButton::buttonOnColourId, Colours::blue); TB5->setClickingTogglesState(true); TB5->setToggleState(false,false); addAndMakeVisible (TB6 = new TextButton (T("new button"))); TB6->setButtonText (String::empty); TB6->addButtonListener (this); TB6->setColour (TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f)); TB6->setColour(TextButton::buttonOnColourId, Colours::blue); TB6->setClickingTogglesState(true); TB6->setToggleState(false,false); addChildComponent(p1 = new PeggyViewComponent(ownerFilter, 1)); p1->setLookAndFeel(&mlaf); addChildComponent(p2 = new PeggyViewComponent(ownerFilter, 2)); p2->setLookAndFeel(&mlaf); addChildComponent(p3 = new PeggyViewComponent(ownerFilter, 3)); p3->setLookAndFeel(&mlaf); internalCachedImage1 = ImageCache::getFromMemory (Resources::vex3_png, Resources::vex3_pngSize); ownerFilter->addChangeListener (this); setSize(800,500); updateParametersFromFilter(true);
int main(int argc, char *argv[]) { Foam::timeSelector::addOptions(false); Foam::argList::validArgs.append("expressionDict"); # include "addRegionOption.H" argList::validOptions.insert("noDimensionChecking",""); argList::validOptions.insert("foreignMeshesThatFollowTime", "<list of mesh names>"); # include "setRootCase.H" printSwakVersion(); IFstream theFile(args.args()[1]); dictionary theExpressions(theFile); wordList foreignMeshesThatFollowTime(0); if (!args.options().found("time") && !args.options().found("latestTime")) { FatalErrorIn("main()") << args.executable() << ": time/latestTime option is required" << endl << exit(FatalError); } if(args.options().found("noDimensionChecking")) { dimensionSet::debug=0; } if(args.options().found("foreignMeshesThatFollowTime")) { string followMeshes( args.options()["foreignMeshesThatFollowTime"] ); IStringStream followStream("("+followMeshes+")"); foreignMeshesThatFollowTime=wordList(followStream); } # include "createTime.H" Foam::instantList timeDirs = Foam::timeSelector::select0(runTime, args); # include "createNamedMesh.H" forAllConstIter(IDLList<entry>, theExpressions, iter) { const dictionary &dict=iter().dict(); CommonValueExpressionDriver::readForeignMeshInfo(dict); } forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Foam::Info << "\nTime = " << runTime.timeName() << Foam::endl; mesh.readUpdate(); forAll(foreignMeshesThatFollowTime,i) { const word &name=foreignMeshesThatFollowTime[i]; if(MeshesRepository::getRepository().hasMesh(name)) { Info << "Setting mesh " << name << " to current Time" << endl; MeshesRepository::getRepository().setTime( name, runTime.value() ); } else { FatalErrorIn(args.executable()) << "No mesh with name " << name << " declared. " << nl << "Can't follow current time" << endl << exit(FatalError); } } forAllConstIter(IDLList<entry>, theExpressions, iter) { Info << iter().keyword() << " : " << flush; const dictionary &dict=iter().dict(); autoPtr<CommonValueExpressionDriver> driver= CommonValueExpressionDriver::New(dict,mesh); wordList accumulations(dict.lookup("accumulations")); driver->setSearchBehaviour( true, true, true // search on disc ); driver->clearVariables(); driver->parse(string(dict.lookup("expression"))); word rType=driver->CommonValueExpressionDriver::getResultType(); if(rType==pTraits<scalar>::typeName) { writeData<scalar>(driver(),accumulations); } else if(rType==pTraits<vector>::typeName) { writeData<vector>(driver(),accumulations); } else if(rType==pTraits<tensor>::typeName) { writeData<tensor>(driver(),accumulations); } else if(rType==pTraits<symmTensor>::typeName) { writeData<symmTensor>(driver(),accumulations); } else if(rType==pTraits<sphericalTensor>::typeName) { writeData<sphericalTensor>(driver(),accumulations); } else { WarningIn(args.executable()) << "Don't know how to handle type " << rType << endl; } Info << endl; }
MapTile::MapTile(int pX, int pZ, const std::string& pFilename, bool pBigAlpha) { this->modelCount = 0; this->mPositionX = pX; this->mPositionZ = pZ; this->changed = 0; this->xbase = mPositionX * TILESIZE; this->zbase = mPositionZ * TILESIZE; this->mBigAlpha = pBigAlpha; for (int i = 0; i < 16; ++i) { for (int j = 0; j < 16; j++) { mChunks[i][j] = NULL; } } mFilename = pFilename; MPQFile theFile(mFilename); Log << "Opening tile " << mPositionX << ", " << mPositionZ << " (\"" << mFilename << "\") from " << (theFile.isExternal() ? "disk" : "MPQ") << "." << std::endl; // - Parsing the file itself. -------------------------- // We store this data to load it at the end. uint32_t lMCNKOffsets[256]; std::vector<ENTRY_MDDF> lModelInstances; std::vector<ENTRY_MODF> lWMOInstances; uint32_t fourcc; uint32_t size; MHDR Header; // - MVER ---------------------------------------------- uint32_t version; theFile.read(&fourcc, 4); theFile.seekRelative(4); theFile.read(&version, 4); assert(fourcc == 'MVER' && version == 18); // - MHDR ---------------------------------------------- theFile.read(&fourcc, 4); theFile.seekRelative(4); assert(fourcc == 'MHDR'); theFile.read(&Header, sizeof(MHDR)); mFlags = Header.flags; // - MCIN ---------------------------------------------- theFile.seek(Header.mcin + 0x14); theFile.read(&fourcc, 4); theFile.seekRelative(4); assert(fourcc == 'MCIN'); for (int i = 0; i < 256; ++i) { theFile.read(&lMCNKOffsets[i], 4); theFile.seekRelative(0xC); } // - MTEX ---------------------------------------------- theFile.seek(Header.mtex + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MTEX'); { char* lCurPos = reinterpret_cast<char*>(theFile.getPointer()); char* lEnd = lCurPos + size; while (lCurPos < lEnd) { mTextureFilenames.push_back(std::string(lCurPos)); lCurPos += strlen(lCurPos) + 1; } } // - MMDX ---------------------------------------------- theFile.seek(Header.mmdx + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MMDX'); { char* lCurPos = reinterpret_cast<char*>(theFile.getPointer()); char* lEnd = lCurPos + size; while (lCurPos < lEnd) { mModelFilenames.push_back(std::string(lCurPos)); lCurPos += strlen(lCurPos) + 1; } } // - MWMO ---------------------------------------------- theFile.seek(Header.mwmo + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MWMO'); { char* lCurPos = reinterpret_cast<char*>(theFile.getPointer()); char* lEnd = lCurPos + size; while (lCurPos < lEnd) { mWMOFilenames.push_back(std::string(lCurPos)); lCurPos += strlen(lCurPos) + 1; } } // - MDDF ---------------------------------------------- theFile.seek(Header.mddf + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MDDF'); ENTRY_MDDF* mddf_ptr = reinterpret_cast<ENTRY_MDDF*>(theFile.getPointer()); for (unsigned int i = 0; i < size / 36; ++i) { lModelInstances.push_back(mddf_ptr[i]); } // - MODF ---------------------------------------------- theFile.seek(Header.modf + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MODF'); ENTRY_MODF* modf_ptr = reinterpret_cast<ENTRY_MODF*>(theFile.getPointer()); for (unsigned int i = 0; i < size / 64; ++i) { lWMOInstances.push_back(modf_ptr[i]); } // - MISC ---------------------------------------------- //! \todo Parse all chunks in the new style! // - MH2O ---------------------------------------------- if (Header.mh2o != 0) { theFile.seek(Header.mh2o + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); int ofsW = Header.mh2o + 0x14 + 0x8; assert(fourcc == 'MH2O'); Water = new TileWater(this, xbase, zbase); //has water Water->readFromFile(theFile, ofsW); //reading MH2O data at separated class... } else{ Water = new TileWater(this, xbase, zbase); //empty water tile } // - MFBO ---------------------------------------------- if (mFlags & 1) { theFile.seek(Header.mfbo + 0x14); theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MFBO'); int16_t mMaximum[9], mMinimum[9]; theFile.read(mMaximum, sizeof(mMaximum)); theFile.read(mMinimum, sizeof(mMinimum)); static const float xPositions[] = { this->xbase, this->xbase + 266.0f, this->xbase + 533.0f }; static const float yPositions[] = { this->zbase, this->zbase + 266.0f, this->zbase + 533.0f }; for (int y = 0; y < 3; y++) { for (int x = 0; x < 3; x++) { int pos = x + y * 3; mMinimumValues[pos * 3 + 0] = xPositions[x]; mMinimumValues[pos * 3 + 1] = mMinimum[pos]; mMinimumValues[pos * 3 + 2] = yPositions[y]; mMaximumValues[pos * 3 + 0] = xPositions[x]; mMaximumValues[pos * 3 + 1] = mMaximum[pos]; mMaximumValues[pos * 3 + 2] = yPositions[y]; } } } // - MTFX ---------------------------------------------- /* //! \todo Implement this or just use Terrain Cube maps? Log << "MTFX offs: " << Header.mtfx << std::endl; if(Header.mtfx != 0){ Log << "Try to load MTFX" << std::endl; theFile.seek( Header.mtfx + 0x14 ); theFile.read( &fourcc, 4 ); theFile.read( &size, 4 ); assert( fourcc == 'MTFX' ); { char* lCurPos = reinterpret_cast<char*>( theFile.getPointer() ); char* lEnd = lCurPos + size; int tCount = 0; while( lCurPos < lEnd ) { int temp = 0; theFile.read(&temp, 4); Log << "Adding to " << mTextureFilenames[tCount].first << " texture effect: " << temp << std::endl; mTextureFilenames[tCount++].second = temp; lCurPos += 4; } } }*/ // - Done. --------------------------------------------- // - Load textures ------------------------------------- //! \note We no longer pre load textures but the chunks themselves do. // - Load WMOs ----------------------------------------- for (std::vector<ENTRY_MODF>::iterator it = lWMOInstances.begin(); it != lWMOInstances.end(); ++it) { gWorld->mWMOInstances.insert(std::pair<int, WMOInstance>(it->uniqueID, WMOInstance(WMOManager::add(mWMOFilenames[it->nameID]), &(*it)))); } // - Load M2s ------------------------------------------ for (std::vector<ENTRY_MDDF>::iterator it = lModelInstances.begin(); it != lModelInstances.end(); ++it) { gWorld->mModelInstances.insert(std::pair<int, ModelInstance>(it->uniqueID, ModelInstance(ModelManager::add(mModelFilenames[it->nameID]), &(*it)))); } // - Load chunks --------------------------------------- for (int nextChunk = 0; nextChunk < 256; ++nextChunk) { theFile.seek(lMCNKOffsets[nextChunk]); mChunks[nextChunk / 16][nextChunk % 16] = new MapChunk(this, &theFile, mBigAlpha); } theFile.close(); // - Really done. -------------------------------------- LogDebug << "Done loading tile " << mPositionX << "," << mPositionZ << "." << std::endl; }
void produceMikeTables(int LHCsqrts = 7, string sample = "gg") { cout << "FIRST RUN source changeCinZero.csh!" << endl; string Sources[6] = {"","","","","","",""}; if (sample == "gg") { Sources[0] = "Resummation"; Sources[1] = "TopMass"; } if (sample == "zz" && LHCsqrts == 7) { Sources[0] = "SingleZ"; } if (sample == "zz" && LHCsqrts == 8) { Sources[0] = "UnbRegion"; } ofstream *mikeFile; char fileName[200]; sprintf(fileName,"text/paramShifts_%s_%dTeV.txt",sample.c_str(),LHCsqrts); mikeFile = new ofstream(fileName); char thePar[10]; char equalS[1]; char dashS[1]; char pmS[3]; char theLimit1[10]; char theLimit2[10]; float fitted, error; const int nPars = 7; string parNames[nPars] = {"m","n","n2","bb","bb2","fexp","T"}; float parVal[nPars]; float upVar[nPars]; float downVar[nPars]; // Inizia sprintf(fileName,"text/paramsCJLST_%s_%dTeV_default.txt",sample.c_str(),LHCsqrts); ifstream theFile(fileName); while (theFile >> thePar >> equalS >> fitted >> pmS >> error >> theLimit1 >> dashS >> theLimit2) { cout << thePar << " " << fitted << " " << error << endl; for (int ii = 0; ii < nPars; ii++) { if (!strcmp(thePar,parNames[ii].c_str())) { parVal[ii] = fitted; upVar[ii] = error*error; downVar[ii] = error*error; } } } theFile.close(); for (int jj = 0; jj < 6; jj++) { if (Sources[jj] != "") { cout << "Systematics n. " << jj+1 << " : " << Sources[jj] << endl; sprintf(fileName,"text/paramsCJLST_%s_%dTeV_%s.txt",sample.c_str(),LHCsqrts,Sources[jj].c_str()); ifstream theFile(fileName); while (theFile >> thePar >> equalS >> fitted >> pmS >> error >> theLimit1 >> dashS >> theLimit2) { cout << thePar << " " << fitted << " " << error << endl; for (int ii = 0; ii < nPars; ii++) { if (!strcmp(thePar,parNames[ii].c_str())) { if (fitted > parVal[ii]) upVar[ii] += (fitted - parVal[ii])*(fitted - parVal[ii]); if (fitted < parVal[ii]) downVar[ii] += (fitted - parVal[ii])*(fitted - parVal[ii]); } } } theFile.close(); } }
MapIndex::MapIndex(const std::string &pBasename) : mHasAGlobalWMO(false) , mBigAlpha(false) , noadt(false) , changed(false) , cx(-1) , cz(-1) , basename(pBasename) { std::stringstream filename; filename << "World\\Maps\\" << basename << "\\" << basename << ".wdt"; MPQFile theFile(filename.str()); uint32_t fourcc; uint32_t size; // - MVER ---------------------------------------------- uint32_t version; theFile.read(&fourcc, 4); theFile.read(&size, 4); theFile.read(&version, 4); //! \todo find the correct version of WDT files. assert( fourcc == 'MVER' && version == 18 ); // - MHDR ---------------------------------------------- theFile.read(&fourcc, 4); theFile.read(&size, 4); assert( fourcc == 'MPHD' ); theFile.read(&mphd, sizeof(MPHD)); mHasAGlobalWMO = mphd.flags & 1; mBigAlpha = mphd.flags & 4; // - MAIN ---------------------------------------------- theFile.read( &fourcc, 4 ); theFile.seekRelative( 4 ); assert( fourcc == 'MAIN' ); /// this is the theory. Sadly, we are also compiling on 64 bit machines with size_t being 8 byte, not 4. Therefore, we can't do the same thing, Blizzard does in its 32bit executable. //theFile.read( &(mTiles[0][0]), sizeof( 8 * 64 * 64 ) ); for( int j = 0; j < 64; ++j ) { for( int i = 0; i < 64; ++i ) { theFile.read(&mTiles[j][i].flags, 4); theFile.seekRelative( 4 ); std::stringstream filename; filename << "World\\Maps\\" << basename << "\\" << basename << "_" << i << "_" << j << ".adt"; mTiles[j][i].tile = NULL; mTiles[j][i].onDisc = MPQFile::existsOnDisk(filename.str()); if(mTiles[j][i].onDisc && !(mTiles[j][i].flags & 1)) { mTiles[j][i].flags |= 1; changed = true; } } } if(!theFile.isEof() && mHasAGlobalWMO) { //! \note We actually don't load WMO only worlds, so we just stop reading here, k? //! \bug MODF reads wrong. The assertion fails every time. Somehow, it keeps being MWMO. Or are there two blocks? //! \nofuckingbug on eof read returns just without doing sth to the var and some wdts have a MWMO without having a MODF so only checking for eof above is not enough mHasAGlobalWMO = false; // - MWMO ---------------------------------------------- theFile.read(&fourcc, 4); theFile.read(&size, 4); assert(fourcc == 'MWMO'); globalWMOName = std::string(theFile.getPointer(), size); theFile.seekRelative(size); // - MODF ---------------------------------------------- theFile.read(&fourcc, 4); theFile.read(&size, 4); assert( fourcc == 'MODF' ); theFile.read(&wmoEntry, sizeof(ENTRY_MODF)); } // ----------------------------------------------------- theFile.close(); }
P<BundleData> DirBundleLoader::loadBundle(String location) { P<BundleData> bundleData = new BundleData(); bundleData->setLocation(location); String path = location; path.append(L"\\META-INF\\MANIFEST.MF"); P<File> file = new File(path); P<Manifest> mf = new Manifest(file); P<Map<String,String>> entries = mf->getEntries(); String symbolicName = entries->get(Constants::BUNDLE_SYMBOLICNAME); if (symbolicName == (String)null || symbolicName.equals(L"") ) { throw BundleException(String(L"Bundle symbolic name not found: ") + file->getAbsolutePath()); } //if (framework->getBundle(symbolicName) != null) //{ // throw BundleException(String(L"Bundle(SymbolicName: ") + symbolicName + String(L") already exists: ") + file->getAbsolutePath()); // } bundleData->setSymbolicName(symbolicName); //get Bundle-Name String name = entries->get(Constants::BUNDLE_NAME); if (name == (String)null || name.equals(L"")) { name = File(location).getName(); } bundleData->setName(name); // Validate the bundle activator. String activator = entries->get(Constants::BUNDLE_ACTIVATOR); if (activator == (String)null || symbolicName.equals(L"") ) { throw BundleException(String(L"Bundle activator definition not found: ") + file->getAbsolutePath()); } bundleData->setActivator(activator); String nativeLib = entries->get(Constants::BUNDLE_NATIVE_LIB); if (nativeLib == (String)null || nativeLib.equals(L"") ) { nativeLib = name + String(L".dll"); } nativeLib = String(location) + String(L"\\") + nativeLib; bundleData->setNativeLib(nativeLib); //P<Library> lib= new DllLibrary(); //lib->load(this->nativeLib); //if (!lib->containsClass(activator)) //{ // throw BundleException(String(L"Bundle activator class(\"") + activator + String(L"\") not found: ") + file->getAbsolutePath()); // } //lib->free(); String description = entries->get(Constants::BUNDLE_DESCRIPTION); if (description == (String)null || description.equals(L"")) { description = L""; } bundleData->setDescription(description); // Parse classpaths String classpath = entries->get(Constants::BUNDLE_CLASSPATH); P<Array<String>> classPaths = null; if (classpath != null) { Array<String> theClassPaths =classpath.split(L","); int size = theClassPaths.size(); classPaths = new Array<String>(size); for (int i = 0; i < size; i++) { String theClassPath =theClassPaths.get(i); // Check the classpath entry bool entryExists = false; String theRealPath = generateURL(location, theClassPath); File theFile(theRealPath); entryExists = theFile.exists(); if (entryExists) { classPaths->set(i, theFile.getCanonicalPath()); } else { throw BundleException(String(L"Classpath(\"") + theClassPath + String(L"\") not found: ") + file->getAbsolutePath()); } } } else { classPaths = new Array<String>(); } bundleData->setClassPaths(classPaths); // Parse export packages String exportPackages = entries->get(Constants::EXPORT_PACKAGE); Array<String> exportedPackages; if (exportPackages != null) { exportedPackages =exportPackages.split(L","); } else { exportedPackages = Array<String>(); } bundleData->setExportedPackages(new Array<String>(exportedPackages)); // Parse import packages, nee String importpackages = entries->get(Constants::IMPORT_PACKAGE); Array<String> importedPackages; if (importpackages != null) { importedPackages =importpackages.split(L","); } else { importedPackages = Array<String>(); } bundleData->setImportedPackages(new Array<String>(importedPackages)); // Parse reuqired extensions String requiredbundles = entries->get(Constants::REQUIRE_BUNDLE); Array<String> requiredBundles; if (requiredbundles != null) { requiredBundles =requiredbundles.split(L","); } else { requiredBundles = Array<String>(); } bundleData->setRequiredBundles(new Array<String>(requiredBundles)); return bundleData; }
int AIShapeImport::DoImport(const TCHAR *filename,ImpInterface *i,Interface *gi, BOOL suppressPrompts) { // Get a scale factor from points (the file storage) to our units double mScale = GetMasterScale(UNITS_INCHES); float scaleFactor = float((1.0 / mScale) / 72.0); // Set a global prompt display switch showPrompts = suppressPrompts ? FALSE : TRUE; WorkFile theFile(filename,_T("rb")); if(suppressPrompts) { } else { if (!DialogBox(hInstance, MAKEINTRESOURCE(IDD_MERGEORREPL), gi->GetMAXHWnd(), ImportDlgProc)) return IMPEXP_CANCEL; } dStream = i->DumpFile(); if(!(stream = theFile.Stream())) { if(showPrompts) MessageBox(IDS_TH_ERR_OPENING_FILE, IDS_TH_3DSIMP); return 0; // Didn't open! } // Got the file -- Now put up the options dialog! if(showPrompts) { int result = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_SHAPEIMPORTOPTIONS), gi->GetMAXHWnd(), ShapeImportOptionsDlgProc, (LPARAM)this); if(result <= 0) return IMPEXP_CANCEL; } else { // Set default parameters here importType = MULTIPLE_SHAPES; } if (replaceScene) { if (!i->NewScene()) return IMPEXP_CANCEL; } theShapeImport = this; int line,count,status,phase,buflen, reason; float x1,y1,x2,y2,x3,y3; char buffer[256]; phase=0; count=0; line=0; gotStuff = FALSE; GetDecSymbolFromRegistry(); loop: line++; if((status=getaline(stream,buffer,255,0))<0) { reason = IDS_TH_LINE_TOO_LONG; corrupted: if(showPrompts) MessageBox(reason, IDS_TH_3DSIMP); FinishWorkingShape(TRUE, i); return gotStuff; } if(status==0) { FinishWorkingShape(TRUE, i); return gotStuff; // EOF } /* Look for appropriate section of file */ buflen=static_cast<int>(strlen(buffer)); // SR DCAST64: Downcast to 2G limit. switch(phase) { case 0: /* Looking for the path */ buffer[10]=0; if(stricmp(buffer,"%%endsetup")==0) phase=1; break; case 1: /* Loading the path data -- looking for initial 'm' */ if(buflen<2) break; if(buffer[buflen-2]==' ' && buffer[buflen-1]=='m') { phase=2; goto phase2; } break; case 2: phase2: if(buflen<2) break; if(buffer[buflen-2]!=' ') break; switch(buffer[buflen-1]) { case 'm': { /* Moveto */ FixDecimalSymbol(buffer); if(sscanf(buffer,"%f %f",&x1,&y1)!=2) { #ifdef DBG1 DebugPrint("Moveto buffer:%s\n",buffer); #endif bad_file: reason = IDS_TH_INVALIDFILE; goto corrupted; } // If had one working, wrap it up FinishWorkingShape(FALSE, i); // Start this new spline if(!StartWorkingShape()) { reason = IDS_TH_NO_RAM; goto corrupted; } Point3 p(x1 * scaleFactor, y1 * scaleFactor, 0.0f); SplineKnot k(KTYPE_BEZIER, LTYPE_CURVE, p, p, p); spline->AddKnot(k); } break; case 'l': /* Lineto */ case 'L': { /* Lineto corner */ FixDecimalSymbol(buffer); if(sscanf(buffer,"%f %f",&x1,&y1)!=2) { #ifdef DBG1 DebugPrint("Lineto buffer:%s\n",buffer); #endif goto bad_file; } Point3 p(x1 * scaleFactor, y1 * scaleFactor, 0.0f); SplineKnot k(KTYPE_BEZIER, LTYPE_CURVE, p, p, p); spline->AddKnot(k); } break; case 'c': /* Curveto */ case 'C': { /* Curveto corner */ FixDecimalSymbol(buffer); if(sscanf(buffer,"%f %f %f %f %f %f",&x1,&y1,&x2,&y2,&x3,&y3)!=6) { #ifdef DBG1 DebugPrint("Curveto buffer:%s\n",buffer); #endif goto bad_file; } int lastKnot = spline->KnotCount() - 1; spline->SetOutVec(lastKnot, Point3(x1 * scaleFactor, y1 * scaleFactor, 0.0f)); Point3 p(x3 * scaleFactor, y3 * scaleFactor, 0.0f); Point3 in(x2 * scaleFactor, y2 * scaleFactor, 0.0f); SplineKnot k(KTYPE_BEZIER, LTYPE_CURVE, p, in, p); spline->AddKnot(k); } break; case 'v': /* Current/vec */ case 'V': { /* Current/vec corner */ FixDecimalSymbol(buffer); if(sscanf(buffer,"%f %f %f %f",&x2,&y2,&x3,&y3)!=4) { #ifdef DBG1 DebugPrint("Current/vec buffer:%s\n",buffer); #endif goto bad_file; } Point3 p(x3 * scaleFactor, y3 * scaleFactor, 0.0f); Point3 in(x2 * scaleFactor, y2 * scaleFactor, 0.0f); SplineKnot k(KTYPE_BEZIER, LTYPE_CURVE, p, in, p); spline->AddKnot(k); } break; case 'y': /* Vec/next */ case 'Y': { /* Vec/next corner */ FixDecimalSymbol(buffer); if(sscanf(buffer,"%f %f %f %f",&x1,&y1,&x3,&y3)!=4) { #ifdef DBG1 DebugPrint("vec/next buffer:%s\n",buffer); #endif goto bad_file; } int lastKnot = spline->KnotCount() - 1; spline->SetOutVec(lastKnot, Point3(x1 * scaleFactor, y1 * scaleFactor, 0.0f)); Point3 p(x3 * scaleFactor, y3 * scaleFactor, 0.0f); SplineKnot k(KTYPE_BEZIER, LTYPE_CURVE, p, p, p); spline->AddKnot(k); } break; } break; } count++; goto loop; }
StageStartingAttributesParser::StageStartingAttributesParser(const char * path){ xmlFilePath = path; rapidxml::xml_document<> doc; //open path and read std::ifstream theFile (xmlFilePath); std::vector<char> buffer = std::vector<char>((std::istreambuf_iterator<char>(theFile)), std::istreambuf_iterator<char>()); buffer.push_back('\0'); //parse doc.parse<0>( &buffer[0] ); DNEWPTR( rapidxml::xml_node<>, rootNode); rootNode = doc.first_node("StartingSprites"); DASSERT( rootNode ); int totealStages = GetGetIntAtrr( rootNode, "totalStages" ); DASSERT(totealStages>0); attributes.resize(totealStages); positions.resize(totealStages); int stages = 0; attributeMap attrMap; positionMap posMap; for(rapidxml::xml_node<>* stagesIterate = rootNode->first_node(); stagesIterate; stagesIterate = stagesIterate->next_sibling()){ int currStage = GetGetIntAtrr( stagesIterate, "stageNum" ); ++stages; DASSERT( currStage == stages); attrMap.clear(); posMap.clear(); std::list<StartingAttributes_t> charAttrs; charAttrs.push_front(getNewAttribute( stagesIterate->first_node("BubXY") )); attrMap["BubXY"] = charAttrs; charAttrs.clear(); charAttrs.push_front(getNewAttribute( stagesIterate->first_node("BobXY") )); attrMap["BobXY"] = charAttrs; charAttrs.clear(); for(rapidxml::xml_node<>* charAttrsIterate = stagesIterate->first_node("ZenChanXY")->first_node(); charAttrsIterate; charAttrsIterate = charAttrsIterate->next_sibling()){ charAttrs.push_front(getNewAttribute( charAttrsIterate )); } attrMap["ZenChanXY"] = charAttrs; charAttrs.clear(); for(rapidxml::xml_node<>* charAttrsIterate = stagesIterate->first_node("MightaXY")->first_node(); charAttrsIterate; charAttrsIterate = charAttrsIterate->next_sibling()){ charAttrs.push_front(getNewAttribute( charAttrsIterate )); } attrMap["MightaXY"] = charAttrs; charAttrs.clear(); for(rapidxml::xml_node<>* charAttrsIterate = stagesIterate->first_node("PowerUpXY")->first_node(); charAttrsIterate; charAttrsIterate = charAttrsIterate->next_sibling()){ charAttrs.push_front(getNewAttribute( charAttrsIterate )); } attrMap["PowerUpXY"] = charAttrs; std::list<StartingPosition_t> charPoss; for(rapidxml::xml_node<>* charAttrsIterate = stagesIterate->first_node("BubbleDrivers")->first_node(); charAttrsIterate; charAttrsIterate = charAttrsIterate->next_sibling()){ charPoss.push_front( getNewPosition(charAttrsIterate) ); } posMap["BubbleDrivers"] = charPoss; attributes[stages-1] = attrMap; positions[stages-1] = posMap; } }
void QWzmViewer::actionOpen() { static QString lastDir; // Convenience HACK to remember last succesful directory a model was loaded from. filename = QFileDialog::getOpenFileName(this, tr("Choose a PIE or WZM file"), lastDir, tr("All Compatible (*.wzm *.pie);;WZM models (*.wzm);;PIE models (*.pie)")); if (!filename.isEmpty()) { QFileInfo theFile(filename); MODEL *tmpModel = NULL; if (theFile.completeSuffix().compare(QString("wzm"), Qt::CaseInsensitive) == 0) { tmpModel = readModel(filename.toAscii().constData(), 0); } else if (theFile.completeSuffix().compare(QString("pie"), Qt::CaseInsensitive) == 0) { tmpModel = loadPIE(filename); } else { return; } if (tmpModel) { QFileInfo texPath(theFile.absoluteDir(), tmpModel->texPath); // Try to find texture automatically if (!texPath.exists()) { texPath.setFile(QString("../../data/base/texpages/"), tmpModel->texPath); if (!texPath.exists()) { texPath.setFile(QFileDialog::getExistingDirectory(this, tr("Specify texture directory"), QString::null), tmpModel->texPath); if (!texPath.exists()) { QMessageBox::warning(this, tr("Oops..."), "Could not find texture", QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton); freeModel(tmpModel); return; } } } if (psModel) { freeModel(psModel); } psModel = tmpModel; setModel(texPath); ui->actionSave->setEnabled(true); lastDir = theFile.absolutePath(); fileNameLabel->setText(theFile.fileName()); fileNameLabel->setToolTip(filename); } else { qWarning("Failed to create model!"); ui->statusBar->showMessage(tr("Failed to create model!"), 3000); } } }
int NECOutputParser(NECOutput * theNECOutput, QString theFileName) { //NEC's outputs seem to be written with the C locale QLocale::setDefault(QLocale::C); QFile theFile(theFileName); //RadiationPattern * nullRP; //nullRP = new RadiationPattern(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 0.0, 0.0, 0.0, 0.0); //Let's check that the file exists if ( !theFile.exists() ) { //The file does not exists qDebug("NEC output parser - The file does not exist\n"); return 1; } //The file exists, but can we read it? if (!theFile.open(QIODevice::ReadOnly | QIODevice::Text)) { //We can not read the file qDebug("NEC output parser - I can not read the file\n"); return 1; } //We generate the stream from the file QTextStream text(&theFile); //And we need some extra variables QString line; QStringList dataList; QString elDato; int sense = 0; //We opened the file, but is it empty? if(text.atEnd()) { qDebug("The file is empty\n"); return 1; } line = ""; /* We search for the beggining of the radiation patterns The headers of the radiation patterns of nec2 and nec2++ differ in the seventh word, so I include both of them. */ while((!text.atEnd()) && (line != "DEGREES DEGREES DB DB DB RATIO DEG. VOLTS/M DEGREES VOLTS/M DEGREES") && (line != "DEGREES DEGREES DB DB DB RATIO DEGREES VOLTS/M DEGREES VOLTS/M DEGREES") &&(!line.contains("GEOMETRY DATA CARD ERROR")) ) { //We read a single line line = text.readLine(); line = line.simplified(); } if (line.contains("GEOMETRY DATA CARD ERROR")) { qDebug("Geometry data card error\n"); return 1; } else if (text.atEnd()) { qDebug("Radiation pattern data from nec2++ is missing\n"); return 1; } else { RadiationPattern * newRP; //We scan the radiation patterns for data line = text.readLine(); // We now check which kind of alignment we have sense = cleanRadiationPatternLine(line,dataList); // And now we check that we didn't have any errors if( sense == -1 ) return 1; /* We scan the data until Theta <= 180, because all the rest of the data is redundant. For making the plotting of the surface much easier, we will need an extra set of data {(Theta == 180) == (Theta == 0) }. If we don't have Theta == 180, we will make one more iteration, which is considered below. */ bool exists180 = false; while(!text.atEnd() && line !="" && dataList.at(1).toDouble()<=180.0) { if(sense != 3) { newRP = new RadiationPattern(dataList.at(0).toDouble(), dataList.at(1).toDouble(), dataList.at(2).toDouble(), dataList.at(3).toDouble(), dataList.at(4).toDouble(), dataList.at(5).toDouble(), dataList.at(6).toDouble(), sense, dataList.at(8).toDouble(), dataList.at(9).toDouble(), dataList.at(10).toDouble(), dataList.at(11).toDouble()); } else { // We don't have a Sense field newRP = new RadiationPattern(dataList.at(0).toDouble(), dataList.at(1).toDouble(), dataList.at(2).toDouble(), dataList.at(3).toDouble(), dataList.at(4).toDouble(), dataList.at(5).toDouble(), dataList.at(6).toDouble(), sense, dataList.at(7).toDouble(), dataList.at(8).toDouble(), dataList.at(9).toDouble(), dataList.at(10).toDouble()); } theNECOutput->setRadiationPattern(newRP); line = text.readLine(); // We now check which kind of alignment we have if(line != "") sense = cleanRadiationPatternLine(line,dataList); // And now we check that we didn't have any errors if( sense == -1 ) return 1; // Check if we have theta == 180 if(dataList.at(1).toDouble() == 180.0) exists180 = true; } /* Now we must take into account the case in which we don't have Theta == 180 but a bigger number. Take into account that now Theta can't be less than 180. */ double stop = 0.0; if(!exists180) stop = dataList.at(1).toDouble(); while(!text.atEnd() && line !="" && dataList.at(1).toDouble()==stop) { if(sense != 3) { newRP = new RadiationPattern(dataList.at(0).toDouble(), dataList.at(1).toDouble(), dataList.at(2).toDouble(), dataList.at(3).toDouble(), dataList.at(4).toDouble(), dataList.at(5).toDouble(), dataList.at(6).toDouble(), sense, dataList.at(8).toDouble(), dataList.at(9).toDouble(), dataList.at(10).toDouble(), dataList.at(11).toDouble()); } else { // We don't have a Sense field newRP = new RadiationPattern(dataList.at(0).toDouble(), dataList.at(1).toDouble(), dataList.at(2).toDouble(), dataList.at(3).toDouble(), dataList.at(4).toDouble(), dataList.at(5).toDouble(), dataList.at(6).toDouble(), sense, dataList.at(7).toDouble(), dataList.at(8).toDouble(), dataList.at(9).toDouble(), dataList.at(10).toDouble()); } theNECOutput->setRadiationPattern(newRP); line = text.readLine(); // We now check which kind of alignment we have if(line != "") sense = cleanRadiationPatternLine(line,dataList); // And now we check that we didn't have any errors if( sense == -1 ) return 1; } } //All that has been opened must be closed before leaving theFile.close(); return 0; }// ParserNecOutput
bool BmpFile::loadData(std::string * fileName) { std::ifstream theFile(fileName->c_str(), std::ios::binary); this->fileName = * fileName; if (!theFile.good()) { std::cout << "Couldn't file the file\n"; return false; } theFile.read(reinterpret_cast<char *>(&magicNum), sizeof(magicNumber)); theFile.read(reinterpret_cast<char *>(&head), sizeof(fileHeader)); theFile.read(reinterpret_cast<char *>(&info), sizeof(infoHeader)); // now to pass the file stream to an appropiate loading function printFileStats(); width = info.width; height = info.height; bitsPerPixel = info.bitsPerPixel; bytesPerPixel = bitsPerPixel / 8; // rember it's bgr not rgb! std::cout << "After reading in the headers the reader is " << theFile.tellg() << " bytes in.\n The offset for the start of the imaeg data is: " << head.bmpOffset << " bytes in.\n"; theFile.seekg(head.bmpOffset); // move to reader to the start of image data std::cout << "After moving the reader, its at " << theFile.tellg() << " bytes in.\n"; std::cout << "This is a " << info.bitsPerPixel << " bit bitmap file\n"; if (info.bitsPerPixel == 8) { std::cout << "This is a 8 bit bitmap image, ony 24 bit and 32 bit will be supported\n"; return false; } else if(info.bitsPerPixel == 16) { std::cout << "This is a 16 bit bitmap image, ony 24 bit and 32 bit will be supported\n"; return false; } else if (info.bitsPerPixel == 24) // 24 bit colour { if (info.compressionType == BMP_RGB) // uncompressed { return loadUncompressed24Bit(&theFile); } else if (info.compressionType == BMP_RLE4) // 4 bit rle commands { std::cout << "The file uses 4 bit RLE compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_RLE8) // 8 bit rle commands { std::cout << "The file uses 4 bit RLE compression.\n"; } else if (info.compressionType == BMP_BITFIELDS) { std::cout << "The file uses bitfields compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_JPEG) { std::cout << "The file uses jpeg compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_PNG) { std::cout << "The file uses png compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_ALPHABITFIELDS) { std::cout << "The file uses alpha bit fields compression which is unsupported.\n"; return false; } else { std::cout << "The file uses unknown compression which is unsupported.\n"; return false; } } else if(info.bitsPerPixel == 32) // 32 bit colour { if (info.compressionType == BMP_RGB) // uncompressed { return loadUncompressed32Bit(&theFile); } else if (info.compressionType == BMP_RLE4) // 4 bit rle commands { std::cout << "The file uses 4 bit RLE compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_RLE8) // 8 bit rle commands { std::cout << "The file uses 4 bit RLE compression.\n"; } else if (info.compressionType == BMP_BITFIELDS) { std::cout << "The file uses bitfields compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_JPEG) { std::cout << "The file uses jpeg compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_PNG) { std::cout << "The file uses png compression which is unsupported.\n"; return false; } else if (info.compressionType == BMP_ALPHABITFIELDS) { std::cout << "The file uses alpha bit fields compression which is unsupported.\n"; return false; } else { std::cout << "The file uses unknown compression which is unsupported.\n"; return false; } } theFile.close(); return true; }