C++ wxString::Format方法代码示例

wxInt32 CViewMessagesGrid::FormatSeqNo(wxInt32 item, wxString& strBuffer) const {

    MESSAGE*   message = wxGetApp().GetDocument()->message(item);
    if (message) {
		strBuffer = strBuffer.Format(wxT(" %d"),message->seqno);
    }

    return 0;
}

wxString DisassembledItem::GetCodeStr()
{
    static wxString gcstr;
    uint i;
    byte b;

    gcstr.Clear();
    for (i = 0; i < opcode_size_; i++)
    {
        b = data_file_->GetData(offset_in_file_ + i);
        gcstr << gcstr.Format("%.2X ", b);
    }
    gcstr.Trim(true);
    return (gcstr);
}

wxString DisassembledItem::GetAsciiStr()
{
    static wxString gastr;
    uint i, b;

    gastr.Clear();
    for (i = 0; i < opcode_size_; i++)
    {
        b = static_cast<uint>(data_file_->GetData(offset_in_file_ + i));
        b = b & 0xFF;
        if ((b < 32) || (b > 126))
            b = '.';
        gastr << gastr.Format("%c", b);
    }
    return (gastr);
}

wxString BigGridTable::GetValue( int row, int col )
{
    static int last_row = 0;
	static VscpRXObj *pRecord = NULL;
    static wxString str;
  
	if ( ( 0 == last_row ) || ( row != last_row ) ) {
		if ( NULL == ( pRecord = readEvent( row ) ) ) return wxString(_(""));
	}	
    
    if ( NULL == pRecord ) return wxString(_(""));
  
	// Save the row
	last_row = row;
	
  switch ( col ) {
  
    case VSCP_RCVGRID_COLUMN_DIR:
      if ( VSCP_EVENT_DIRECTION_RX == pRecord->m_nDir ) {
        return wxString(_("RX"));
      }
      else {
        return wxString(_("TX"));
      }
      break;  
    
    case VSCP_RCVGRID_COLUMN_CLASS:
      if ( g_Config.m_UseSymbolicNames ) {
        wxString strClass = 
              g_vscpinfo.getClassDescription( pRecord->m_pEvent->vscp_class );
        if ( 0 == strClass.Length() ) strClass = _("Unknown class");      
        return str.Format(_("%s \n0x%04X, %d"), 
                    strClass.c_str(), 
                    pRecord->m_pEvent->vscp_class,
                    pRecord->m_pEvent->vscp_class );
      }
      else {
        return str.Format(_("0x%04X, %d"),
                    pRecord->m_pEvent->vscp_class,
                    pRecord->m_pEvent->vscp_class );
      }
      
    case VSCP_RCVGRID_COLUMN_TYPE:
      if ( g_Config.m_UseSymbolicNames ) {
        wxString strType = 
              g_vscpinfo.getTypeDescription( pRecord->m_pEvent->vscp_class,
                                              pRecord->m_pEvent->vscp_type );
        if ( 0 == strType.Length() ) strType = _("Unknown type"); 
        return str.Format(_("%s \n0x%04X, %d "), 
                    strType.c_str(), 
                    pRecord->m_pEvent->vscp_type,
                    pRecord->m_pEvent->vscp_type );
      }
      else {
        return str.Format(_("0x%04X, %d"), 
                    pRecord->m_pEvent->vscp_type,
                    pRecord->m_pEvent->vscp_type );
      }
     
    case VSCP_RCVGRID_COLUMN_NOTE:
      return pRecord->m_wxStrNote;
      
    default:
      str = _("Invalid column");
  }
  
  return str;
}

//.........这里部分代码省略.........
            strBuffer += _("Project suspended by user");
        } else if (result->suspended_via_gui) {
            strBuffer += _("Task suspended by user");
        } else if (status.task_suspend_reason && !throttled) {
            strBuffer += _("Suspended");
            if (status.task_suspend_reason & SUSPEND_REASON_BATTERIES) {
                strBuffer += _(" - on batteries");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_USER_ACTIVE) {
                strBuffer += _(" - user active");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_USER_REQ) {
                strBuffer += _(" - computation suspended");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_TIME_OF_DAY) {
                strBuffer += _(" - time of day");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_BENCHMARKS) {
                strBuffer += _(" - CPU benchmarks");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_DISK_SIZE) {
                strBuffer += _(" - need disk space");
            }
            if (status.task_suspend_reason & SUSPEND_REASON_EXCLUSIVE_APP_RUNNING) {
                strBuffer += _(" - an exclusive app is running");
            }
            if (result->resources.size()) {
                strBuffer += wxString(wxT(" (")) + wxString(result->resources.c_str(), wxConvUTF8) + wxString(wxT(")"));
            }
        } else if (result->active_task) {
            if (result->too_large) {
                strBuffer += _("Waiting for memory");
            } else if (result->needs_shmem) {
                strBuffer += _("Waiting for shared memory");
            } else if (result->scheduler_state == CPU_SCHED_SCHEDULED) {
                if (result->edf_scheduled) {
                    strBuffer += _("Running, high priority");
                } else {
                    strBuffer += _("Running");
                }
#if 0
                // doesn't work - project pointer not there
                if (result->project->non_cpu_intensive) {
                    strBuffer += _(" (non-CPU-intensive)");
                }
#endif
            } else if (result->scheduler_state == CPU_SCHED_PREEMPTED) {
                strBuffer += _("Waiting to run");
            } else if (result->scheduler_state == CPU_SCHED_UNINITIALIZED) {
                strBuffer += _("Ready to start");
            }
            if (result->resources.size()) {
                strBuffer += wxString(wxT(" (")) + wxString(result->resources.c_str(), wxConvUTF8) + wxString(wxT(")"));
            }
        } else {
            strBuffer += _("Ready to start");
        }
        if (result->gpu_mem_wait) {
            strBuffer += _(" (waiting for GPU memory)");
        }
        break;
    case RESULT_COMPUTE_ERROR:
        strBuffer += _("Computation error");
        break;
    case RESULT_FILES_UPLOADING:
        if (result->ready_to_report) {
            strBuffer += _("Upload failed");
        } else {
            strBuffer += _("Uploading");
            if (status.network_suspend_reason) {
                strBuffer += _(" (suspended)");
            }
        }
        break;
    case RESULT_ABORTED:
        switch(result->exit_status) {
        case ERR_ABORTED_VIA_GUI:
            strBuffer += _("Aborted by user");
            break;
        case ERR_ABORTED_BY_PROJECT:
            strBuffer += _("Aborted by project");
            break;
        case ERR_UNSTARTED_LATE:
            strBuffer += _("Aborted: not started by deadline");
            break;
        default:
            strBuffer += _("Aborted");
        }
        break;
    default:
        if (result->got_server_ack) {
            strBuffer += _("Acknowledged");
        } else if (result->ready_to_report) {
            strBuffer += _("Ready to report");
        } else {
            strBuffer.Format(_("Error: invalid state '%d'"), result->state);
        }
        break;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////
/// \return     a wxString which will contain the error message for any error occuring, 
///             otherwise a null string is returned
/// \param      tablePathName   -> the path to the consistent changes (.cct) file to be loaded
/// \remarks
/// Called from: The App's OnToolsDefineCC() menu event handler.
/// The loadTableFromFile() function calls ccModule->CCLoadTable() and 
/// ccModule->CCSetUTF8Encoding() to make the consistent changes facilities available to the
/// application.
////////////////////////////////////////////////////////////////////////////////////////////
wxString CConsistentChanger::loadTableFromFile(wxString tablePathName) // caller supplies a CString, so LPCTSTR needed here
{
	// The wx version of loadTableFromFile returns any error as a formatted error string to the caller.
	//---- LOAD THE CC TABLE INTO THE BUFFER
	// wx version: we can't use MFC specific functions; so we'll just try to open the file for reading
	// and consider it an error if f.Open() returns false.
	wxFile f;
	if (!f.Open(tablePathName,wxFile::read))
	{
		ccErrorStr = ccErrorStr.Format(_("The CC-Table \"%s\" could not be found or opened.\n"), tablePathName.c_str());
		return ccErrorStr;	
	}
	else
	{
		f.Close();
	}

	// BEW 15Oct07, a long path will crash the CCLoadTable() call, so I've built a function to copy the table
	// data to a temporary "_tbl_.cct" file at the CSIDL_PERSONAL folder, which is the My Documents folder or
	// the Documents folder in Vista, and I'll have subsequent code below access that instead, and removing the
	// temporary file when done. The effect of this is that the CC32.DLL never accesses a cct file buried so
	// deep in the folder hierachy that the DLL code fails due to its small internal buffer for the path
	wxString pathToPersonalFolder = CopyTableToPersonalFolder(tablePathName);
	wxString lpPath = pathToPersonalFolder; // use this one below, not tablePathName

	// we don't expect the table file copy to the personal folder to fail, but check for it just in case and if it
	// did (the returned pathInRoot wxString will be empty) then tell the user and abort the load operation
	if (pathToPersonalFolder.IsEmpty())
	{
		// for some reason the CopyTableToPersonalFolder() function failed, a hard coded English message will suffice
		wxString aPath = tablePathName;
		wxString s;
		s = s.Format(_T("Relocating the CC table file in loadTableFromFile failed, so cc processing is disabled; original table's path was: %s"),aPath.c_str());
		wxMessageBox(s,_T(""), wxICON_EXCLAMATION | wxOK);
		return s ; // MFC note: we really need to return BOOL -- add this change later
	}

	int iResult2;
	int iResult;

#ifdef _UNICODE

	// whm: one method of conversion is to use the .mb_str() method of wxString as illustrated in the
	// two commented out lines below:
	//wxCharBuffer tempBuff = lpPath.mb_str(wxConvUTF8);
	//CBString psz(tempBuff);
	// whm: an easier method of conversion is just to use the wxString constructor with wxConvUTF8 conversion parameter
	// whm 8Jun12 modified. The lpPath is already a wxString, so it doesn't need any further conversion with wxConvUTF8
	iResult = ccModule->CCLoadTable(lpPath);

	// make the environment enabled for UTF-8 support
	iResult2 = ccModule->CCSetUTF8Encoding(TRUE);

#else // ANSI

	iResult = ccModule->CCLoadTable(lpPath);

	// make the environment disabled for UTF-8 support
	iResult2 = ccModule->CCSetUTF8Encoding(FALSE);

#endif

	// get rid of the temporary file _tbt_.cct in the data folder
	if (!::wxRemoveFile(lpPath))
	{
		wxString aPath = tablePathName;
		wxString s;
		s = s.Format(_T("CopyTableToPersonalFolder() failed to remove the temporary file for path %s (so remove it manually using Win Explorer)"),aPath.c_str());
		wxMessageBox(s,_T(""), wxICON_EXCLAMATION | wxOK);
	}

	if(iResult)
	{
		// Instead of throwing Exceptions, the wx version of loadTableFromFile() returns the error result
		// returned by the CC function.
		ccErrorStr = ccErrorStr.Format(_("CC couldn't load the table: %s.  Got error code: %d.  Check the syntax of the table."),
							tablePathName.c_str(), iResult);
		return ccErrorStr; //throw ccErrorStr;
	}

	if(iResult2)
	{
		ccErrorStr = ccErrorStr.Format(_("CC environment did not accept CCSetUTR8Encoding() call: Got error code: %d."), 
							 iResult2);
		return ccErrorStr; //throw ccErrorStr;
	}

	// if we get here all was successful and ccErrorStr should still be empty
	return ccErrorStr;
}