//----------------------------------------------------------------------------
void medHTMLTemplateParserBlock::PushBlock( wxString name, int blockType )
//----------------------------------------------------------------------------
{
    int varPos=SubstitutionPos(&name);
    int blockPos;

    //blocks can be pushed only on loop blocks
    if (m_BlockType!=MED_HTML_TEMPLATE_LOOP)
    {
        mafLogMessage("HTML Template ERROR: You can push sub-blocks only on Loop blocks, , use AddBLock instead");
        return;
    }
    //we need to set the loop number before any push
    else if (m_LoopsNumber<0)
    {
        mafLogMessage("HTML Template ERROR: You must set the loops number before push any sub-block");
        return;
    }
    //if the block does not exists i need to create the array entry
    if (varPos<0)
    {
        //creating the new array for this block and
        //adding the substitution in the substitution table
        std::vector<medHTMLTemplateParserBlock *> newArray;
        m_SubBlocksArray.push_back(newArray);

        HTMLTemplateSubstitution subst;
        subst.Name=name;
        subst.Pos=m_SubBlocksArray.size()-1;
        subst.Type=MED_HTML_SUBSTITUTION_BLOCK_ARRAY;

        varPos=m_SubstitutionTable.size();
        m_SubstitutionTable.push_back(subst);
    }
    //if the block already exist there are already the correspondent array
    //and the relative substitution so we don't need to add it

    blockPos=m_SubstitutionTable[varPos].Pos;

    //checking if the existent substitution refers to a block array to
    if (m_SubstitutionTable[varPos].Type!=MED_HTML_SUBSTITUTION_BLOCK_ARRAY)
    {
        mafLogMessage("HTML Template ERROR: Array: \"%s\" has incompatible type",name.ToAscii());
        return;
    }
    //checking if there are free slots for pushing blocks
    else if (m_SubBlocksArray[blockPos].size()>m_LoopsNumber)
    {
        mafLogMessage("HTML Template ERROR: to many push for: '%s'",name.ToAscii());
        return;
    }
    else
    {
        medHTMLTemplateParserBlock *newBlock;
        newBlock=new medHTMLTemplateParserBlock(blockType, name);
        newBlock->SetFather(this);
        m_SubBlocksArray[blockPos].push_back(newBlock);
    }

}
Example #2
0
void Trace::layoutGraph(wxString infile, wxString outfile)
{
	char tmpinfile[FILELEN] = {0};
	char tmpoutfile[FILELEN] = {0};

	strncpy(tmpinfile, infile.ToAscii(), sizeof(tmpinfile) - 1);
	strncpy(tmpoutfile, outfile.ToAscii(), sizeof(tmpoutfile) - 1);

	this->layoutGraph(tmpinfile, tmpoutfile);
}
//----------------------------------------------------------------------------
void medHTMLTemplateParserBlock::PushVar( wxString name, wxString varValue )
//----------------------------------------------------------------------------
{
    int varPos=SubstitutionPos(&name);
    int blockPos;

    //We can push Variables only to the loops block
    if (m_BlockType!=MED_HTML_TEMPLATE_LOOP)
    {
        mafLogMessage("HTML Template ERROR: You can push variables only on Loop blocks, use AddVar instead");
        return;
    }
    //We need to set the loop number before pushing anything to the loop
    else if (m_LoopsNumber<0)
    {
        mafLogMessage("HTML Template ERROR: You must set the loops number before push any variable");
        return;
    }

    //if the vars does not exists i need to create the array entry
    if (varPos<0)
    {
        std::vector<wxString> newArray;
        m_VariablesArray.push_back(newArray);

        HTMLTemplateSubstitution subst;
        subst.Name=name;
        subst.Pos=m_VariablesArray.size()-1;
        subst.Type=MED_HTML_SUBSTITUTION_VARIABLE_ARRAY;

        //if a new entry is created in the substitution table the position is
        //equal at the size before the push
        varPos=m_SubstitutionTable.size();
        m_SubstitutionTable.push_back(subst);
    }

    blockPos=m_SubstitutionTable[varPos].Pos;

    //checking substitusion type before push
    if (m_SubstitutionTable[varPos].Type!=MED_HTML_SUBSTITUTION_VARIABLE_ARRAY)
    {
        mafLogMessage("HTML Template ERROR: Array: \"%s\" has incompatible type",name.ToAscii());
        return;
    }
    //checking if there are free slots for pushing vars
    else if (m_VariablesArray[blockPos].size()>m_LoopsNumber)
    {
        mafLogMessage("HTML Template ERROR: to many push for: '%s'",name.ToAscii());
        return;
    }

    m_VariablesArray[blockPos].push_back(varValue);
}
/*!   Converts multiple files
 *
 *    @param dirPath    - path to directory
 *
 *    @param filename   - name of file, may include wild-cards
 */
int convertDirectory(const wxString &dirPath, const wxString &filename, MyTraverser &converter ) {
   wxDir directory(dirPath);

   fprintf(stdout, "------------------------------------------------------------------\n");
   fprintf(stdout, "   convertDirectory(): \n"
                   "      dirPath = \'%s\'\n"
                   "      filename = \'%s\'\n",
                   (const char *)dirPath.ToAscii(),
                   (const char *)filename.ToAscii() );
//   printf("Processing Pattern %s\n", (const char *)dirPath.ToAscii());
   directory.Traverse(converter, filename, wxDIR_FILES);
   fprintf(stdout, "------------------------------------------------------------------\n");
   return converter.getRc();
}
Example #5
0
// private utility function which returns output of the given command, removing
// the trailing newline
static wxString wxGetCommandOutput(const wxString &cmd)
{
    FILE *f = popen(cmd.ToAscii(), "r");
    if ( !f )
    {
        wxLogSysError(wxT("Executing \"%s\" failed"), cmd.c_str());
        return wxEmptyString;
    }

    wxString s;
    char buf[256];
    while ( !feof(f) )
    {
        if ( !fgets(buf, sizeof(buf), f) )
            break;

        s += wxString::FromAscii(buf);
    }

    pclose(f);

    if ( !s.empty() && s.Last() == wxT('\n') )
        s.RemoveLast();

    return s;
}
Example #6
0
// Wrapper for wxWidgets
void Trace::writeGmlFile(wxString infile)
{
	char gmlfile[FILELEN] = {0};

	strncpy(gmlfile, infile.ToAscii(), sizeof(gmlfile));
	this->writeGmlFile(gmlfile);
}
Example #7
0
/**
    @brief
    Function Resolve the hostname to ip
*/
bool turbotrace::resolve_host(wxString host)
{
    //Get hostname as a char pointer
    char *target = strdup( (char*) host.ToAscii().data());

    log( _("Will now resolve : ") + wxString(target , wxConvUTF8) );

    //Is it just a simple IP
	if( inet_addr( target ) != INADDR_NONE)
	{
		dest_ip.s_addr = inet_addr( target );
		tlog(_("Valid IP provided"));
	}
	//Domain name , resolve it
	else
	{
		char *ip = iputils::hostname_to_ip( (char*) target );

		if(ip != NULL)
		{
			tlog( wxString(target , wxConvUTF8) + _(" resolved to ") + wxString(ip , wxConvUTF8));

			//Convert domain name to IP
			dest_ip.s_addr = inet_addr( ip );
		}
		else
		{
			tlog( _("Unable to resolve hostname : ") + wxString(target , wxConvUTF8) );
			return false;
		}
	}
	return true;
}
Example #8
0
wxString CSourceDataGenerator::GetFontDefinition(const EMGL_font_t *font, const wxString &name)
{
	wxString result;
	result += wxString::Format("const EMGL_font_t font_%s = {%d, %u, %u, codePageTable};\n",
		name.ToAscii(), font->ascender, font->bpp, font->numCodepages);
	return result;
}
Example #9
0
bool isoimage::OpenImage(const wxString &filename)
{
    const wxCharBuffer buffer = filename.ToAscii();
    const char *path = buffer.data();

    return m_image.open(path, ISO_EXTENSION_ALL);
}
Example #10
0
static void runTest(const wxString inputLine)
{
    done = false;
    time(&startTime);

    TestCommand command = parseInputLine(std::string(inputLine.ToAscii()));
    string& pathOrURL = command.pathOrURL;
    dumpPixelsForCurrentTest = command.shouldDumpPixels;
    
    // CURL isn't happy if we don't have a protocol.
    size_t http = pathOrURL.find("http://");
    if (http == string::npos)
        pathOrURL.insert(0, "file://");
    
    gTestRunner = TestRunner::create(pathOrURL, command.expectedPixelHash);
    if (!gTestRunner) {
        wxTheApp->ExitMainLoop();
    }

    WorkQueue::shared()->clear();
    WorkQueue::shared()->setFrozen(false);

    webView->LoadURL(wxString(pathOrURL.c_str(), wxConvUTF8));
    
    // wait until load completes and the results are dumped
    while (!done)
        wxSafeYield();
}
Example #11
0
bool isoimage::ReadDir(const wxString &path, stat_vector_t& stat_vector)
{
    const wxCharBuffer buffer = path.ToAscii();
    const char *spath = buffer.data();

    return m_image.readdir(spath, stat_vector);
}
void ProfileFindInFilesCodeMode() {
    printf("*******\n");
    wxLongLong time = wxGetLocalTimeMillis();
    t4p::DirectorySearchClass directorySearch;
    t4p::SourceClass src;
    src.RootDirectory.AssignDir(DirName);
    src.SetIncludeWildcards(wxT("*.php"));
    std::vector<t4p::SourceClass> sources;
    sources.push_back(src);
    if (directorySearch.Init(sources)) {
        t4p::FindInFilesClass findInFiles;
        findInFiles.Expression = UNICODE_STRING_SIMPLE("class Db");
        findInFiles.Mode = t4p::FinderClass::EXACT;
        if (findInFiles.Prepare()) {
            while (directorySearch.More()) {
                directorySearch.Walk(findInFiles);
            }
            std::vector<wxString> matchedFiles = directorySearch.GetMatchedFiles();
            for (size_t i = 0; i < matchedFiles.size(); ++i) {
                printf("Found at least one match in file %s.\n", (const char*)matchedFiles[i].ToUTF8());
            }
            time = wxGetLocalTimeMillis() - time;
            printf("time for findInFiles Code Mode:%ld ms\n", time.ToLong());
        } else {
            puts("Invalid expression: class Db\n");
        }
    } else {
        printf("Could not open Directory: %s\n", (const char*)DirName.ToAscii());
    }
}
void ProfileFindInFilesExactMode() {
    printf("*******\n");
    wxLongLong time = wxGetLocalTimeMillis();
    t4p::DirectorySearchClass directorySearch;
    if (directorySearch.Init(DirName)) {
        t4p::FindInFilesClass findInFiles;
        findInFiles.Expression = UNICODE_STRING_SIMPLE("class Db");
        findInFiles.Mode = t4p::FinderClass::EXACT;
        if (findInFiles.Prepare()) {
            while (directorySearch.More()) {
                directorySearch.Walk(findInFiles);
            }
            std::vector<wxString> matchedFiles = directorySearch.GetMatchedFiles();
            for (size_t i = 0; i < matchedFiles.size(); ++i) {
                printf("Found at least one match in file %s.\n", (const char*)matchedFiles[i].ToUTF8());
            }
            time = wxGetLocalTimeMillis() - time;
            printf("time for findInFiles Exact Mode:%ld ms \n", time.ToLong());
        } else {
            puts("Invalid expression: class Db\n");
        }
    } else {
        printf("Could not open Directory: %s\n", (const char*)DirName.ToAscii());
    }
}
Example #14
0
void wxDataFormat::SetId( const wxString& id )
{
#if !wxUSE_NANOX
    PrepareFormats();
    m_type = wxDF_PRIVATE;
    m_format = XInternAtom( (Display*) wxGetDisplay(), id.ToAscii(), FALSE );
#endif
}
Example #15
0
double StrToDouble(const wxString &value)
{
	wxCharBuffer buf = value.ToAscii();
	char *p = (char *)strchr(buf, '.');
	if (p)
		*p = localeconv()->decimal_point[0];

	return strtod(buf, 0);
}
Example #16
0
Object RaceAnalyzerComm::ParseJSON(wxString &json){

	Object root;
	std::stringstream stream;
	for (size_t i = 0; i < json.Len(); i++){
		stream.put(json.ToAscii()[i]);
	}
	Reader::Read(root, stream);
	return root;
}
Example #17
0
wxString RaceAnalyzerComm::SendCommand(CComm *comPort, const wxString &buffer, size_t timeout){

	wxMutexLocker lock(_commMutex);
	wxString response;

	try{
		VERBOSE(FMT("Send Cmd (%d): '%s'",buffer.Len(), buffer.ToAscii()));
		size_t bufferSize = 8192;
		comPort->sendCommand(buffer.ToAscii(),wxStringBuffer(response,bufferSize),bufferSize,timeout,true);
		VERBOSE(FMT("Cmd Response: %s", response.ToAscii()));
	}
	catch(SerialException &e){
		throw CommException(e.GetErrorStatus(), e.GetErrorDetail());
	}
	catch(...){
		throw CommException(-1, "Unknown exception while sending command");
	}
	return response.Trim(true).Trim(false);
}
Example #18
0
void wxMessageOutputStderr::Output(const wxString& str)
{
    const wxString strWithLF = AppendLineFeedIfNeeded(str);
    const wxWX2MBbuf buf = strWithLF.mb_str();

    if ( buf )
        fprintf(stderr, "%s", (const char*) buf);
    else // print at least something
        fprintf(stderr, "%s", (const char*) strWithLF.ToAscii());
}
Example #19
0
void wxTopLevelWindowX11::SetTitle(const wxString& title)
{
    m_title = title;

    if (X11GetMainWindow())
    {
#if wxUSE_UNICODE
        //  I wonder of e.g. Metacity takes UTF-8 here
        XStoreName(wxGlobalDisplay(), (Window) X11GetMainWindow(),
            (const char*) title.ToAscii() );
        XSetIconName(wxGlobalDisplay(), (Window) X11GetMainWindow(),
            (const char*) title.ToAscii() );
#else
        XStoreName(wxGlobalDisplay(), (Window) X11GetMainWindow(),
            (const char*) title);
        XSetIconName(wxGlobalDisplay(), (Window) X11GetMainWindow(),
            (const char*) title);
#endif
    }
}
Example #20
0
void SerialConnection::SendNMEAMessage( wxString &message, wxString &source )
{
    if ( !IsOpen() )
        return;
    if ( FilterOutput( message, source ) )
    {
        wxCharBuffer buffer = message.ToAscii();
        WriteDevice( buffer.data(), strlen( buffer.data() ) );
        buffer = m_EOS.ToAscii();
        WriteDevice( buffer.data(), strlen( buffer.data() ) );
    }
}
Example #21
0
void CppCheck::DoCppCheckAnalysis(const wxString& Xml)
{
    // clear the list
    m_ListLog->Clear();

    TiXmlDocument Doc;
    Doc.Parse( Xml.ToAscii() );
    if ( Doc.Error() )
    {
        wxString msg = _("Failed to parse cppcheck XML file.\nProbably it's not produced correctly.");
        AppendToLog(msg);
        cbMessageBox(msg, _("Error"), wxICON_ERROR | wxOK, Manager::Get()->GetAppWindow());
    }
    else
    {
        TiXmlHandle Handle(&Doc);
        Handle = Handle.FirstChildElement("results");

        bool ErrorsPresent = false;
        TiXmlElement* resultNode = Handle.ToElement();
        if (nullptr!=resultNode->Attribute("version"))
        {
            wxString Version = wxString::FromAscii(resultNode->Attribute("version"));
            if ( Version.IsSameAs(wxT("2")) )
                ErrorsPresent = DoCppCheckParseXMLv2(Handle);
            else
            {
                cbMessageBox(_("Unsupported XML file version of CppCheck."),
                             _("Error"), wxICON_ERROR | wxOK, Manager::Get()->GetAppWindow());
            }
        }
        else
        {
            ErrorsPresent = DoCppCheckParseXMLv1(Handle);
        }

        if (ErrorsPresent)
        {
            if ( Manager::Get()->GetLogManager() )
            {
                CodeBlocksLogEvent evtSwitch(cbEVT_SWITCH_TO_LOG_WINDOW, m_ListLog);
                Manager::Get()->ProcessEvent(evtSwitch);
            }
        }

        if ( !Doc.SaveFile("CppCheckResults.xml") )
        {
            cbMessageBox(_("Failed to create output file 'CppCheckResults.xml' for cppcheck.\nPlease check file/folder access rights."),
                         _("Error"), wxICON_ERROR | wxOK, Manager::Get()->GetAppWindow());
        }
    }
}
Example #22
0
static bool needsQuoting(wxString &value, bool forTypes)
{
	// Is it a number?
	if (value.IsNumber())
		return true;
	else
	{
		// certain types should not be quoted even though it contains a space. Evilness.
		wxString valNoArray;
		if (forTypes && value.Right(2) == wxT("[]"))
			valNoArray = value.Mid(0, value.Len() - 2);
		else
			valNoArray = value;

		if (forTypes &&
		        (!valNoArray.CmpNoCase(wxT("character varying")) ||
		         !valNoArray.CmpNoCase(wxT("\"char\"")) ||
		         !valNoArray.CmpNoCase(wxT("bit varying")) ||
		         !valNoArray.CmpNoCase(wxT("double precision")) ||
		         !valNoArray.CmpNoCase(wxT("timestamp without time zone")) ||
		         !valNoArray.CmpNoCase(wxT("timestamp with time zone")) ||
		         !valNoArray.CmpNoCase(wxT("time without time zone")) ||
		         !valNoArray.CmpNoCase(wxT("time with time zone")) ||
		         !valNoArray.CmpNoCase(wxT("\"trigger\"")) ||
		         !valNoArray.CmpNoCase(wxT("\"unknown\""))))
			return false;

		int pos = 0;
		while (pos < (int)valNoArray.length())
		{
			wxChar c = valNoArray.GetChar(pos);
			if (!((pos > 0) && (c >= '0' && c <= '9')) &&
			        !(c >= 'a' && c  <= 'z') &&
			        !(c == '_'))
			{
				return true;
			}
			pos++;
		}
	}

	// is it a keyword?
	const ScanKeyword *sk = ScanKeywordLookup(value.ToAscii());
	if (!sk)
		return false;
	if (sk->category == UNRESERVED_KEYWORD)
		return false;
	if (forTypes && sk->category == COL_NAME_KEYWORD)
		return false;
	return true;
}
Example #23
0
Trace::Trace(wxString tracefile, wxString orig_exe_file, wxString outputfile)
{
	char tfile[FILELEN] = {0};
	char ogfile[FILELEN] = {0};
	char opfile[FILELEN] = {0};

	doColorBlind = false;
	graphColoringAlgorithm = GRAPH_COLOR_PACKER;

	strncpy(this->tracefile, tracefile.ToAscii(), sizeof(this->tracefile) - 1);
	if (orig_exe_file.length() > 0) // Zero length string means don't process the exe
	{
		doProcessExe = true;
		strncpy(this->orig_exe_file, orig_exe_file.ToAscii(), sizeof(this->orig_exe_file) - 1);
	}
	else
	{
		doProcessExe = false;
	}
	strncpy(this->outputfile, outputfile.ToAscii(), sizeof(this->outputfile) -1);

	this->parseFiles();
}
//----------------------------------------------------------------------------
void medHTMLTemplateParserBlock::AddVar( wxString name, wxString varValue )
//----------------------------------------------------------------------------
{
    //if Variable already exists we dont add it again
    if (SubstitutionPos(&name)>0)
        mafLogMessage("HTML Template ERROR: Variable: \"%s\" already exists",name.ToAscii());
    else
    {
        //Adding the Variable to the array and the relative substitution to the substitution table
        HTMLTemplateSubstitution subst;
        subst.Name=name;
        subst.Pos=m_Variables.size();
        subst.Type=MED_HTML_SUBSTITUTION_VARIABLE;
        m_SubstitutionTable.push_back(subst);
        m_Variables.push_back(varValue);
    }
}
Example #25
0
wxString ExecProcess(const wxString &cmd)
{
	wxString res;
	FILE *f = popen(cmd.ToAscii(), "r");

	if (f)
	{
		char buffer[1024];
		int cnt;
		while ((cnt = fread(buffer, 1, 1024, f)) > 0)
		{
			res += wxString::FromAscii(buffer);
		}
		pclose(f);
	}
	return res;
}
Example #26
0
bool wxCurlHTTP::AddForm(const bool& bClear, const wxString& szName,
                        struct curl_forms* pForms, CURLFORMcode* outErr)
{
    if(bClear)
        ResetPostData();

    CURLFORMcode res = CURL_FORMADD_OK;

    res = curl_formadd(&m_pPostHead, &m_pPostTail, CURLFORM_COPYNAME,
                       (const char*)szName.ToAscii(),
                       CURLFORM_ARRAY, pForms, CURLFORM_END);

    if (outErr != NULL)
        *outErr = res;  // sometimes you want to/need to see what's going on

    return (res == CURL_FORMADD_OK);
}
//----------------------------------------------------------------------------
medHTMLTemplateParserBlock::HTMLTemplateSubstitution medHTMLTemplateParserBlock::GetSubstitution( wxString name )
//----------------------------------------------------------------------------
{
    HTMLTemplateSubstitution retValue;
    int retPos;
    //get the position of the substitution
    retPos=SubstitutionPos(&name);
    if (retPos>=0)
    {
        retValue=m_SubstitutionTable[retPos];
    }
    else
    {
        mafLogMessage("HTML Template ERROR: Substitution: \"%s\" not found",name.ToAscii());
    }

    return retValue;
}
Example #28
0
void CreateCodeDialog::PressOK(wxCommandEvent& ev)
{
	const wxString code_name = textctrl_name->GetValue();
	if (code_name.empty())
	{
		PanicAlertT("You must enter a name!");
		return;
	}

	long code_value;
	if (!textctrl_value->GetValue().ToLong(&code_value, 10 + checkbox_use_hex->GetValue()*6))
	{
		PanicAlertT("Invalid Value!");
		return;
	}

	//wxString full_code = textctrl_code->GetValue();
	//full_code += wxT(' ');
	//full_code += wxString::Format(wxT("0x%08x"), code_value);

	// create the new code
	ActionReplay::ARCode new_cheat;
	new_cheat.active = false;
	new_cheat.name = std::string(code_name.ToAscii());
	const ActionReplay::AREntry new_entry(code_address, code_value);
	new_cheat.ops.push_back(new_entry);

	// pretty hacky - add the code to the gameini
	{
	CISOProperties isoprops(SConfig::GetInstance().m_LastFilename, this);
	// add the code to the isoproperties arcode list
	arCodes.push_back(new_cheat);
	// save the gameini
	isoprops.SaveGameConfig();
	isoprops.ActionReplayList_Load();	// loads the new arcodes
	//ActionReplay::UpdateActiveList();
	}

	// refresh arcode list in other tab
	::g_cheat_window->Load_ARCodes();

	Close();
}
Example #29
0
wxSocketClientPtr SocketTestCase::GetHTTPSocket(int flags) const
{
    wxSockAddressPtr addr = GetServer();
    if ( !addr.get() )
        return wxSocketClientPtr();

    wxSocketClient *sock = new wxSocketClient(flags);
    sock->SetTimeout(1);
    CPPUNIT_ASSERT( sock->Connect(*addr) );

    const wxString httpGetRoot =
        "GET / HTTP/1.1\r\n"
        "Host: " + gs_serverHost + "\r\n"
        "\r\n";

    sock->Write(httpGetRoot.ToAscii(), httpGetRoot.length());

    return wxSocketClientPtr(sock);
}
Example #30
0
bool wxCurlHTTP::AddBufferToForm(const bool& bClear, const wxString& szName,
                                char* buffer, size_t len, CURLFORMcode* outErr)
{
    if(bClear)
        ResetPostData();

    CURLFORMcode res = CURL_FORMADD_OK;

    res = curl_formadd(&m_pPostHead, &m_pPostTail, CURLFORM_COPYNAME,
                       (const char*)szName.ToAscii(),
                       CURLFORM_COPYCONTENTS, buffer, CURLFORM_CONTENTSLENGTH,
                       len, CURLFORM_END);

    if (outErr != NULL)
        *outErr = res;  // sometimes you want to/need to see what's going on

    return (res == CURL_FORMADD_OK);


}