bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
{
#if defined(HAVE_STATFS) || defined(HAVE_STATVFS)
// the case to "char *" is needed for AIX 4.3
wxStatfs_t fs;
if ( wxStatfs((char *)(const char*)path.fn_str(), &fs) != 0 )
{
wxLogSysError( wxT("Failed to get file system statistics") );
return false;
}
// under Solaris we also have to use f_frsize field instead of f_bsize
// which is in general a multiple of f_frsize
#ifdef HAVE_STATVFS
wxLongLong blockSize = fs.f_frsize;
#else // HAVE_STATFS
wxLongLong blockSize = fs.f_bsize;
#endif // HAVE_STATVFS/HAVE_STATFS
if ( pTotal )
{
*pTotal = wxLongLong(fs.f_blocks) * blockSize;
}
if ( pFree )
{
*pFree = wxLongLong(fs.f_bavail) * blockSize;
}
return true;
#else // !HAVE_STATFS && !HAVE_STATVFS
return false;
#endif // HAVE_STATFS
}
wxString wxDownloadThread::GetRemainingTime() const
{
wxASSERT(IsDownloading());
wxLongLong sec = GetElapsedMSec()/1000;
if (sec <= 0)
return wxT("not available"); // avoid division by zero
// remaining time is the number of bytes we still need to download
// divided by our download speed...
wxLongLong nBytesPerSec = wxLongLong(GetCurrDownloadedBytes()) / sec;
if (nBytesPerSec <= 0)
return wxT("not available"); // avoid division by zero
long remsec = (wxLongLong(m_nFinalSize-GetCurrDownloadedBytes())/nBytesPerSec).ToLong();
if (remsec < 0)
return wxT("not available");
if (remsec < 60)
return wxString::Format(wxT("%li sec"), remsec);
else if (remsec < 60*60)
return wxString::Format(wxT("%li min, %li sec"), remsec/60, remsec%60);
else if (remsec < 60*60*24)
return wxString::Format(wxT("%li hours, %li min, %li sec"),
remsec/3600, (remsec/60)%60, (remsec/3600)%60);
else
return wxT("not available");
}
void CUpdateWizard::SetTransferStatus(const CTransferStatus* pStatus)
{
if (!pStatus)
{
if (m_statusTimer.IsRunning())
m_statusTimer.Stop();
return;
}
wxTimeSpan elapsed = wxDateTime::Now().Subtract(pStatus->started);
int elapsedSeconds = elapsed.GetSeconds().GetLo(); // Assume GetHi is always 0
wxString text;
if (elapsedSeconds)
{
wxFileOffset rate = (pStatus->currentOffset - pStatus->startOffset) / elapsedSeconds;
CSizeFormat::_format format = static_cast<CSizeFormat::_format>(COptions::Get()->GetOptionVal(OPTION_SIZE_FORMAT));
if (format == CSizeFormat::bytes)
format = CSizeFormat::iec;
const wxString ratestr = CSizeFormat::Format(rate, true,
format,
COptions::Get()->GetOptionVal(OPTION_SIZE_USETHOUSANDSEP) != 0,
COptions::Get()->GetOptionVal(OPTION_SIZE_DECIMALPLACES));
text.Printf(_("%s bytes (%s/s)"), wxLongLong(pStatus->currentOffset).ToString().c_str(), ratestr.c_str());
if (pStatus->totalSize > 0 && rate > 0)
{
int left = ((pStatus->totalSize - pStatus->startOffset) / rate) - elapsedSeconds;
if (left < 0)
left = 0;
wxTimeSpan timeLeft(0, 0, left);
text += timeLeft.Format(_(", %H:%M:%S left"));
}
else
{
text += _(", --:--:-- left");
}
}
else
text.Format(_("%s bytes"), wxLongLong(pStatus->currentOffset).ToString().c_str());
XRCCTRL(*this, "ID_DOWNLOADPROGRESSTEXT", wxStaticText)->SetLabel(text);
m_pages[2]->GetSizer()->Layout();
if (pStatus->totalSize > 0)
{
int percent = (pStatus->currentOffset * 100) / pStatus->totalSize;
if (percent > 100)
percent = 100;
XRCCTRL(*this, "ID_DOWNLOADPROGRESS", wxGauge)->SetValue(percent);
}
if (!m_statusTimer.IsRunning())
m_statusTimer.Start(100);
}
void WXMSearchReplaceDialog::UpdateSearchInSelection(bool check)
{
WxEditFrom->Enable(check);
WxEditTo->Enable(check);
if (check && g_active_wxmedit!=nullptr)
{
WxEditFrom->SetValue(wxLongLong(g_active_wxmedit->GetSelectionBeginPos()).ToString());
WxEditTo->SetValue(wxLongLong(g_active_wxmedit->GetSelectionEndPos()).ToString());
}
}
void AnimationSetItem::Init(int start, int end, float rate,int idx, SkeletonMeshEditor* pEditor)
{
m_staticText1->SetLabel(wxLongLong(start).ToString());
m_staticText2->SetLabel(wxLongLong(end).ToString());
m_staticText3->SetLabel(wxString::FromDouble(rate));
m_Index = idx;
m_pSkeletonMeshEditor = pEditor;
m_pSkeletonMeshEditor->FocusAnimation(m_Index);
FocusThis(true);
}
void MadReplaceDialog::UpdateSearchInSelection(bool check)
{
WxEditFrom->Enable(check);
WxEditTo->Enable(check);
extern MadEdit *g_ActiveMadEdit;
if(check && g_ActiveMadEdit!=NULL)
{
WxEditFrom->SetValue(wxLongLong(g_ActiveMadEdit->GetSelectionBeginPos()).ToString());
WxEditTo->SetValue(wxLongLong(g_ActiveMadEdit->GetSelectionEndPos()).ToString());
}
}
// Declared const due to design error in wxWidgets.
// Won't be fixed since a fix would break backwards compatibility
// Both functions use a const_cast<CLocalListView *>(this) and modify
// the instance.
wxString CLocalListView::OnGetItemText(long item, long column) const
{
CLocalListView *pThis = const_cast<CLocalListView *>(this);
t_fileData *data = pThis->GetData(item);
if (!data)
return _T("");
if (!column)
return data->name;
else if (column == 1)
{
if (data->size < 0)
return _T("");
else
return wxLongLong(data->size).ToString();
}
else if (column == 2)
{
if (!item && m_hasParent)
return _T("");
if (data->fileType == _T(""))
data->fileType = pThis->GetType(data->name, data->dir);
return data->fileType;
}
else if (column == 3)
{
if (!data->hasTime)
return _T("");
return data->lastModified.Format(_T("%c"));
}
return _T("");
}
wxString wxFileData::GetHint() const
{
wxString s = m_filePath;
s += wxT(" ");
if (IsDir())
s += _("<DIR>");
else if (IsLink())
s += _("<LINK>");
else if (IsDrive())
s += _("<DRIVE>");
else // plain file
s += wxString::Format(wxPLURAL("%ld byte", "%ld bytes", m_size),
wxLongLong(m_size).ToString().c_str());
s += wxT(' ');
if ( !IsDrive() )
{
s << GetModificationTime()
<< wxT(" ")
<< m_permissions;
}
return s;
}
wxString wxFileData::GetEntry( fileListFieldType num ) const
{
wxString s;
switch ( num )
{
case FileList_Name:
s = m_fileName;
break;
case FileList_Size:
if (!IsDir() && !IsLink() && !IsDrive())
s = wxLongLong(m_size).ToString();
break;
case FileList_Type:
s = GetFileType();
break;
case FileList_Time:
if (!IsDrive())
s = GetModificationTime();
break;
#if defined(__UNIX__) || defined(__WIN32__)
case FileList_Perm:
s = m_permissions;
break;
#endif // defined(__UNIX__) || defined(__WIN32__)
default:
wxFAIL_MSG( wxT("unexpected field in wxFileData::GetEntry()") );
}
return s;
}
void PHPEntityVariable::Store(wxSQLite3Database& db)
{
// we keep only the function arguments in the databse and globals
if(IsFunctionArg() || IsMember()) {
try {
wxSQLite3Statement statement =
db.PrepareStatement("INSERT OR REPLACE INTO VARIABLES_TABLE VALUES (NULL, "
":SCOPE_ID, :FUNCTION_ID, :NAME, :FULLNAME, :SCOPE, :TYPEHINT, "
":FLAGS, :DOC_COMMENT, :LINE_NUMBER, :FILE_NAME)");
statement.Bind(statement.GetParamIndex(":SCOPE_ID"), IsMember() ? Parent()->GetDbId() : wxLongLong(-1));
statement.Bind(statement.GetParamIndex(":FUNCTION_ID"),
IsFunctionArg() ? Parent()->GetDbId() : wxLongLong(-1));
statement.Bind(statement.GetParamIndex(":NAME"), GetShortName());
statement.Bind(statement.GetParamIndex(":FULLNAME"), GetFullName());
statement.Bind(statement.GetParamIndex(":SCOPE"), GetScope());
statement.Bind(statement.GetParamIndex(":TYPEHINT"), GetTypeHint());
statement.Bind(statement.GetParamIndex(":FLAGS"), (int)GetFlags());
statement.Bind(statement.GetParamIndex(":DOC_COMMENT"), GetDocComment());
statement.Bind(statement.GetParamIndex(":LINE_NUMBER"), GetLine());
statement.Bind(statement.GetParamIndex(":FILE_NAME"), GetFilename().GetFullPath());
statement.ExecuteUpdate();
SetDbId(db.GetLastRowId());
} catch(wxSQLite3Exception& exc) {
wxUnusedVar(exc);
}
}
}
bool wxTarOutputStream::SetHeaderNumber(int id, wxTarNumber n)
{
if (m_hdr->SetOctal(id, n)) {
return true;
} else {
SetExtendedHeader(m_hdr->Name(id), wxLongLong(n).ToString());
return false;
}
}
void wxStopWatch::Start(long t0)
{
// Calling Start() makes the stop watch run however many times it was
// paused before.
m_pauseCount = 0;
DoStart();
m_t0 -= (wxLongLong(t0)*GetClockFreq())/MILLISECONDS_PER_SECOND;
}
NS_IMETHODIMP ProgressListenerAdaptor::OnProgressChange64(
nsIWebProgress* web_progress,
nsIRequest* request,
PRInt64 cur_self_progress,
PRInt64 max_self_progress,
PRInt64 cur_total_progress,
PRInt64 max_total_progress)
{
if (m_progress)
{
m_progress->OnProgressChange(wxLongLong(cur_self_progress),
wxLongLong(max_self_progress));
if (m_progress->IsCancelled())
request->Cancel(0x804b0002 /*NS_BINDING_ABORTED*/);
}
return NS_OK;
}
bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))
{
#ifdef __WXWINCE__
// TODO-CE
return false;
#else
if ( path.empty() )
return false;
ULARGE_INTEGER bytesFree, bytesTotal;
// may pass the path as is, GetDiskFreeSpaceEx() is smart enough
if ( !::GetDiskFreeSpaceEx(path.t_str(),
&bytesFree,
&bytesTotal,
NULL) )
{
wxLogLastError(wxT("GetDiskFreeSpaceEx"));
return false;
}
// ULARGE_INTEGER is a union of a 64 bit value and a struct containing
// two 32 bit fields which may be or may be not named - try to make it
// compile in all cases
#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
#define UL(ul) ul.u
#else // anon union
#define UL(ul) ul
#endif
if ( pTotal )
{
#if wxUSE_LONGLONG
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
#else
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
#endif
}
if ( pFree )
{
#if wxUSE_LONGLONG
*pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
#else
*pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
#endif
}
return true;
#endif
// __WXWINCE__
}
void COptionsPageSizeFormatting::UpdateExamples()
{
XRCCTRL(*this, "ID_EXAMPLE1", wxStaticText)->SetLabel(FormatSize(12));
XRCCTRL(*this, "ID_EXAMPLE2", wxStaticText)->SetLabel(FormatSize(100));
XRCCTRL(*this, "ID_EXAMPLE3", wxStaticText)->SetLabel(FormatSize(1234));
XRCCTRL(*this, "ID_EXAMPLE4", wxStaticText)->SetLabel(FormatSize(1058817));
XRCCTRL(*this, "ID_EXAMPLE5", wxStaticText)->SetLabel(FormatSize(123456789));
XRCCTRL(*this, "ID_EXAMPLE6", wxStaticText)->SetLabel(FormatSize(wxLongLong(0x39E9, 0x4F995A72)));
GetSizer()->Layout();
}
wxString wxDownloadThread::GetDownloadSpeed() const
{
wxASSERT(IsDownloading());
wxLongLong msec = GetElapsedMSec();
if (msec <= 0)
return wxT("0 KB/s"); // avoid division by zero
wxLongLong nBytesPerMilliSec = wxLongLong(GetCurrDownloadedBytes()) / msec;
// we don't like bytes per millisecond as measure unit !
long nKBPerSec = (nBytesPerMilliSec * 1000/1024).ToLong(); // our conversion factor
return wxString::Format(wxT("%li KB/s"), nKBPerSec);
}
void DataStreamTestCase::LongLongRW()
{
TestMultiRW<wxLongLong>::ValueArray ValuesLL;
TestMultiRW<wxULongLong>::ValueArray ValuesULL;
ValuesLL.push_back(wxLongLong(0l));
ValuesLL.push_back(wxLongLong(1l));
ValuesLL.push_back(wxLongLong(-1l));
ValuesLL.push_back(wxLongLong(0x12345678l));
ValuesLL.push_back(wxLongLong(0x12345678l, 0xabcdef01l));
ValuesULL.push_back(wxULongLong(0l));
ValuesULL.push_back(wxULongLong(1l));
ValuesULL.push_back(wxULongLong(0x12345678l));
ValuesULL.push_back(wxULongLong(0x12345678l, 0xabcdef01l));
CPPUNIT_ASSERT( TestRW(wxLongLong(0x12345678l)) == wxLongLong(0x12345678l) );
CPPUNIT_ASSERT( TestRW(wxLongLong(0x12345678l, 0xabcdef01l)) == wxLongLong(0x12345678l, 0xabcdef01l) );
CPPUNIT_ASSERT( TestMultiRW<wxLongLong>(ValuesLL, &wxDataOutputStream::WriteLL, &wxDataInputStream::ReadLL).IsOk() );
CPPUNIT_ASSERT( TestMultiRW<wxULongLong>(ValuesULL, &wxDataOutputStream::WriteLL, &wxDataInputStream::ReadLL).IsOk() );
}
wxDateTime wxTarInputStream::GetHeaderDate(const wxString& key) const
{
wxString value(GetExtendedHeader(key));
// try extended header, stored as decimal seconds since the epoch
if (!value.empty()) {
wxLongLong ll;
ll.Assign(wxAtof(value) * 1000.0);
return ll;
}
if (key == wxT("mtime"))
return wxLongLong(m_hdr->GetOctal(TAR_MTIME)) * 1000L;
return wxDateTime();
}
void wxTarOutputStream::SetHeaderDate(const wxString& key,
const wxDateTime& datetime)
{
wxLongLong ll = datetime.IsValid() ? datetime.GetValue() : wxLongLong(0);
wxLongLong secs = ll / 1000L;
if (key != wxT("mtime")
|| !m_hdr->SetOctal(TAR_MTIME, wxTarNumber(secs.GetValue()))
|| secs <= 0 || secs >= 0x7fffffff)
{
wxString str;
if (ll >= LONG_MIN && ll <= LONG_MAX) {
str.Printf(wxT("%g"), ll.ToLong() / 1000.0);
} else {
str = ll.ToString();
str.insert(str.end() - 3, '.');
}
SetExtendedHeader(key, str);
}
}
bool WXCTimer::Start (const wxDateTime& timeNextWakeUp)
{
timeNextWakeUp_ = wxInvalidDateTime;
// valid?
if (timeNextWakeUp < wxDateTime::Now())
return false;
// get intervall in milliseconds
wxLongLong llMsec = timeNextWakeUp.Subtract(wxDateTime::Now()).GetMilliseconds();
// take care of the maximum value for 'int'
if (llMsec > wxLongLong(0, INT_MAX))
{
timeNextWakeUp_ = timeNextWakeUp;
return wxTimer::Start(INT_MAX, wxTIMER_ONE_SHOT);
}
return wxTimer::Start(llMsec.ToLong(), wxTIMER_ONE_SHOT);
}
bool PreferenceFileUtil::saveAccessToken(const AccessToken& accessToken, bool overWrite) {
wxFile file;
if(!file.Create(ACCESS_TOKEN_SAVE_FILE,overWrite)){
//ファイルの作成に失敗
return false;
}
//ファイルに書き出すための文字列を作る
wxString str = wxLongLong(accessToken.getUserId()).ToString();
str += "\t";
str += *accessToken.getScreenName();
str += "\t";
str += *accessToken.getToken();
str += "\t";
str += *accessToken.getTokenSecret();
file.Write(str);
file.Close();
return true;
}
/* static */
void VSTEffect::Scan()
{
wxArrayString audacityPathList = wxGetApp().audacityPathList;
wxArrayString pathList;
wxArrayString files;
// Check for the VST_PATH environment variable
wxString vstpath = wxGetenv(wxT("VST_PATH"));
if (!vstpath.IsEmpty()) {
wxGetApp().AddUniquePathToPathList(vstpath, pathList);
}
// Add Audacity specific paths
for (size_t i = 0; i < audacityPathList.GetCount(); i++) {
wxString prefix = audacityPathList[i] + wxFILE_SEP_PATH;
wxGetApp().AddUniquePathToPathList(prefix + VSTPLUGINTYPE,
pathList);
wxGetApp().AddUniquePathToPathList(prefix + wxT("plugins"),
pathList);
wxGetApp().AddUniquePathToPathList(prefix + wxT("plug-ins"),
pathList);
}
#if defined(__WXMAC__)
#define VSTPATH wxT("/Library/Audio/Plug-Ins/VST")
// Look in /Library/Audio/Plug-Ins/VST and $HOME/Library/Audio/Plug-Ins/VST
wxGetApp().AddUniquePathToPathList(VSTPATH, pathList);
wxGetApp().AddUniquePathToPathList(wxString(wxGetenv(wxT("HOME"))) + VSTPATH,
pathList);
// Recursively search all paths for Info.plist files. This will identify all
// bundles.
wxGetApp().FindFilesInPathList(wxT("Info.plist"), pathList, files, wxDIR_DEFAULT);
// Remove the 'Contents/Info.plist' portion of the names
for (size_t i = 0, cnt = files.GetCount(); i < cnt; i++) {
files[i] = wxPathOnly(wxPathOnly(files[i]));
}
#elif defined(__WXMSW__)
TCHAR dpath[MAX_PATH];
TCHAR tpath[MAX_PATH];
DWORD len = WXSIZEOF(tpath);
// Setup the default VST path.
dpath[0] = '\0';
ExpandEnvironmentStrings(wxT("%ProgramFiles%\\Steinberg\\VSTPlugins"),
dpath,
WXSIZEOF(dpath));
// Check registry for the real path
if (SHRegGetUSValue(wxT("Software\\VST"),
wxT("VSTPluginsPath"),
NULL,
tpath,
&len,
FALSE,
dpath,
(DWORD) _tcslen(dpath)) == ERROR_SUCCESS) {
tpath[len] = 0;
ExpandEnvironmentStrings(tpath, dpath, WXSIZEOF(dpath));
wxGetApp().AddUniquePathToPathList(LAT1CTOWX(dpath), pathList);
}
// Recursively scan for all DLLs
wxGetApp().FindFilesInPathList(wxT("*.dll"), pathList, files, wxDIR_DEFAULT);
#else
// Recursively scan for all shared objects
wxGetApp().FindFilesInPathList(wxT("*.so"), pathList, files);
#endif
// This is a hack to allow for long paths in the progress dialog. The
// progress dialog should really truncate the message if it's too wide
// for the dialog.
size_t cnt = files.GetCount();
wxString longest;
// JKC: Let's not show the progress dialog if there are no
// files to test.
if( cnt <= 0 )
return;
for (size_t i = 0; i < cnt; i++) {
if (files[i].Length() > longest.Length()) {
longest = files[i];
}
}
ProgressDialog *progress = new ProgressDialog(_("Scanning VST Plugins"),
longest,
pdlgHideStopButton);
// progress->SetSize(wxSize(500, -1));
progress->CenterOnScreen();
const wxChar * argv[4];
argv[0] = PlatformCompatibility::GetExecutablePath().c_str();
argv[1] = VSTCMDKEY;
argv[2] = NULL;
argv[3] = NULL;
for (size_t i = 0; i < cnt; i++) {
wxString file = files[i];
int status = progress->Update(wxLongLong(i),
wxLongLong(cnt),
wxString::Format(_("Checking %s"), file.c_str()));
if (status != eProgressSuccess) {
break;
}
argv[2] = file.c_str();
// ToDo: do we need a try--catch around this in case a bad plug-in
// fails? (JKC Nov09)
wxExecute((wxChar **) argv, wxEXEC_SYNC | wxEXEC_NODISABLE, NULL);
}
delete progress;
}
bool CLocalFileSystem::GetNextFile(wxString& name, bool &isLink, bool &is_dir, wxLongLong* size, CDateTime* modificationTime, int* mode)
{
#ifdef __WXMSW__
if (!m_found)
return false;
do
{
if (!m_find_data.cFileName[0]) {
m_found = FindNextFile(m_hFind, &m_find_data) != 0;
return true;
}
if (m_dirs_only && !(m_find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
continue;
if (m_find_data.cFileName[0] == '.' && (!m_find_data.cFileName[1] || (m_find_data.cFileName[1] == '.' && !m_find_data.cFileName[2])))
continue;
name = m_find_data.cFileName;
is_dir = (m_find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
isLink = (m_find_data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
if (isLink) {
HANDLE hFile = is_dir ? INVALID_HANDLE_VALUE : CreateFile(m_find_path + name, FILE_READ_ATTRIBUTES | FILE_READ_EA, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE) {
BY_HANDLE_FILE_INFORMATION info{};
int ret = GetFileInformationByHandle(hFile, &info);
CloseHandle(hFile);
if (ret != 0 && !(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
if (modificationTime) {
if (!ConvertFileTimeToCDateTime(*modificationTime, info.ftLastWriteTime))
ConvertFileTimeToCDateTime(*modificationTime, info.ftCreationTime);
}
if (mode)
*mode = (int)info.dwFileAttributes;
is_dir = (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
if (size) {
if (is_dir) {
*size = -1;
}
else {
*size = wxLongLong(info.nFileSizeHigh, info.nFileSizeLow);
}
}
m_found = FindNextFile(m_hFind, &m_find_data) != 0;
return true;
}
}
if (m_dirs_only && !is_dir) {
continue;
}
if (size)
*size = -1;
if (mode)
*mode = 0;
if (modificationTime)
*modificationTime = CDateTime();
}
else {
if (modificationTime)
ConvertFileTimeToCDateTime(*modificationTime, m_find_data.ftLastWriteTime);
if (mode)
*mode = (int)m_find_data.dwFileAttributes;
if (size) {
if (is_dir) {
*size = -1;
}
else {
*size = wxLongLong(m_find_data.nFileSizeHigh, m_find_data.nFileSizeLow);
}
}
}
m_found = FindNextFile(m_hFind, &m_find_data) != 0;
return true;
} while ((m_found = FindNextFile(m_hFind, &m_find_data) != 0));
return false;
#else
if (!m_dir)
return false;
struct dirent* entry;
while ((entry = readdir(m_dir)))
{
if (!entry->d_name[0] ||
!strcmp(entry->d_name, ".") ||
!strcmp(entry->d_name, ".."))
continue;
#if HAVE_STRUCT_DIRENT_D_TYPE
if (m_dirs_only)
{
if (entry->d_type == DT_LNK)
{
AllocPathBuffer(entry->d_name);
strcpy(m_file_part, entry->d_name);
enum local_fileType type = GetFileInfo(m_raw_path, isLink, size, modificationTime, mode);
if (type != dir)
continue;
name = wxString(entry->d_name, *wxConvFileName);
is_dir = true;
return true;
}
else if (entry->d_type != DT_DIR)
continue;
}
#endif
AllocPathBuffer(entry->d_name);
strcpy(m_file_part, entry->d_name);
enum local_fileType type = GetFileInfo(m_raw_path, isLink, size, modificationTime, mode);
if (type == unknown) // Happens for example in case of permission denied
{
#if HAVE_STRUCT_DIRENT_D_TYPE
type = entry->d_type == DT_DIR ? dir : file;
#else
type = file;
#endif
isLink = 0;
if (size)
*size = -1;
if (modificationTime)
*modificationTime = CDateTime();
if (mode)
*mode = 0;
}
if (m_dirs_only && type != dir)
continue;
is_dir = type == dir;
name = wxString(entry->d_name, *wxConvFileName);
return true;
}
return false;
#endif
}
enum CLocalFileSystem::local_fileType CLocalFileSystem::GetFileInfo(const wxString& path, bool &isLink, wxLongLong* size, CDateTime* modificationTime, int *mode)
{
#ifdef __WXMSW__
if (path.Last() == wxFileName::GetPathSeparator() && path != wxFileName::GetPathSeparator()) {
wxString tmp = path;
tmp.RemoveLast();
return GetFileInfo(tmp, isLink, size, modificationTime, mode);
}
isLink = false;
WIN32_FILE_ATTRIBUTE_DATA attributes;
BOOL result = GetFileAttributesEx(path, GetFileExInfoStandard, &attributes);
if (!result) {
if (size)
*size = -1;
if (mode)
*mode = 0;
if (modificationTime)
*modificationTime = CDateTime();
return unknown;
}
bool is_dir = (attributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
if (attributes.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
isLink = true;
HANDLE hFile = is_dir ? INVALID_HANDLE_VALUE : CreateFile(path, FILE_READ_ATTRIBUTES | FILE_READ_EA, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hFile != INVALID_HANDLE_VALUE) {
BY_HANDLE_FILE_INFORMATION info{};
int ret = GetFileInformationByHandle(hFile, &info);
CloseHandle(hFile);
if (ret != 0 && !(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
if (modificationTime) {
if (!ConvertFileTimeToCDateTime(*modificationTime, info.ftLastWriteTime))
ConvertFileTimeToCDateTime(*modificationTime, info.ftCreationTime);
}
if (mode)
*mode = (int)info.dwFileAttributes;
if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
if (size)
*size = -1;
return dir;
}
if (size)
*size = wxLongLong(info.nFileSizeHigh, info.nFileSizeLow);
return file;
}
}
if (size)
*size = -1;
if (mode)
*mode = 0;
if (modificationTime)
*modificationTime = CDateTime();
return is_dir ? dir : unknown;
}
if (modificationTime) {
if (!ConvertFileTimeToCDateTime(*modificationTime, attributes.ftLastWriteTime))
ConvertFileTimeToCDateTime(*modificationTime, attributes.ftCreationTime);
}
if (mode)
*mode = (int)attributes.dwFileAttributes;
if (is_dir) {
if (size)
*size = -1;
return dir;
}
else {
if (size)
*size = wxLongLong(attributes.nFileSizeHigh, attributes.nFileSizeLow);
return file;
}
#else
if (path.Last() == '/' && path != _T("/"))
{
wxString tmp = path;
tmp.RemoveLast();
return GetFileInfo(tmp, isLink, size, modificationTime, mode);
}
const wxCharBuffer p = path.fn_str();
return GetFileInfo((const char*)p, isLink, size, modificationTime, mode);
#endif
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
// Compute the total number of elements in all array dimensions
int cElements = 1;
for ( int cDims = 0; cDims < oleVariant.parray->cDims; cDims++ )
cElements *= oleVariant.parray->rgsabound[cDims].cElements;
// Get a pointer to the data
void* pvdata;
HRESULT hr = SafeArrayAccessData(oleVariant.parray, &pvdata);
if ( FAILED(hr) )
return false;
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_VARIANT:
{
variant.ClearList();
VARIANTARG *variant_data=(VARIANTARG*)pvdata;
for ( int i = 0; i < cElements; i++ )
{
VARIANTARG& oleElement = variant_data[i];
wxVariant vElement;
if ( !wxConvertOleToVariant(oleElement, vElement) )
{
ok = false;
variant.ClearList();
break;
}
variant.Append(vElement);
}
}
break;
case VT_BSTR:
{
wxArrayString strings;
BSTR *string_val=(BSTR*)pvdata;
for ( int i = 0; i < cElements; ++i )
{
wxString str=wxConvertStringFromOle(*string_val);
strings.Add(str);
++string_val;
}
variant=strings;
}
break;
default:
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
ok = false;
break;
}
SafeArrayUnaccessData(oleVariant.parray);
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
// See the comment before the __VISUALC6__ test above.
#if wxUSE_LONGLONG && !defined(__VISUALC6__)
case VT_I8:
variant = wxLongLong(oleVariant.llVal);
break;
#endif // wxUSE_LONGLONG
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R4:
variant = oleVariant.fltVal;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
variant.MakeNull();
break;
case VT_EMPTY:
break; // Ignore Empty Variant, used only during destruction of objects
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
// TODO: We currently return arrays as wxVariant of the list type
// containing the flattened form of array but we should allow
// getting it as wxVariantDataSafeArray instead. Doing this is
// simple, we'd just need to do something like this:
//
// if ( oleVariant.parray && SafeArrayGetDim(oleVariant.parray) > 1 )
// {
// variant.SetData(new wxVariantDataSafeArray(oleVariant.parray));
// }
//
// but currently we don't do it for compatibility reasons.
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_I2:
ok = wxSafeArray<VT_I2>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_I4:
ok = wxSafeArray<VT_I4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R4:
ok = wxSafeArray<VT_R4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R8:
ok = wxSafeArray<VT_R8>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_VARIANT:
ok = wxSafeArray<VT_VARIANT>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_BSTR:
{
wxArrayString strings;
if ( wxSafeArray<VT_BSTR>::ConvertToArrayString(oleVariant.parray, strings) )
variant = strings;
else
ok = false;
}
break;
default:
ok = false;
break;
}
if ( !ok )
{
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
}
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_ERROR:
variant.SetData(new wxVariantDataErrorCode(oleVariant.scode));
break;
case VT_CY:
variant.SetData(new wxVariantDataCurrency(oleVariant.cyVal));
break;
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
// See the comment before the __VISUALC6__ test above.
#if wxUSE_LONGLONG && !defined(__VISUALC6__)
case VT_I8:
variant = wxLongLong(oleVariant.llVal);
break;
#endif // wxUSE_LONGLONG
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R4:
variant = oleVariant.fltVal;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
variant.MakeNull();
break;
case VT_EMPTY:
break; // Ignore Empty Variant, used only during destruction of objects
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
bool wxGetDiskSpace(const wxString& WXUNUSED_IN_WINCE(path),
wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pTotal),
wxDiskspaceSize_t *WXUNUSED_IN_WINCE(pFree))
{
#ifdef __WXWINCE__
// TODO-CE
return false;
#else
if ( path.empty() )
return false;
// old w32api don't have ULARGE_INTEGER
#if defined(__WIN32__) && \
(!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION( 0, 3 ))
// GetDiskFreeSpaceEx() is not available under original Win95, check for
// it
typedef BOOL (WINAPI *GetDiskFreeSpaceEx_t)(LPCTSTR,
PULARGE_INTEGER,
PULARGE_INTEGER,
PULARGE_INTEGER);
GetDiskFreeSpaceEx_t
pGetDiskFreeSpaceEx = (GetDiskFreeSpaceEx_t)::GetProcAddress
(
::GetModuleHandle(_T("kernel32.dll")),
#if wxUSE_UNICODE
"GetDiskFreeSpaceExW"
#else
"GetDiskFreeSpaceExA"
#endif
);
if ( pGetDiskFreeSpaceEx )
{
ULARGE_INTEGER bytesFree, bytesTotal;
// may pass the path as is, GetDiskFreeSpaceEx() is smart enough
if ( !pGetDiskFreeSpaceEx(path,
&bytesFree,
&bytesTotal,
NULL) )
{
wxLogLastError(_T("GetDiskFreeSpaceEx"));
return false;
}
// ULARGE_INTEGER is a union of a 64 bit value and a struct containing
// two 32 bit fields which may be or may be not named - try to make it
// compile in all cases
#if defined(__BORLANDC__) && !defined(_ANONYMOUS_STRUCT)
#define UL(ul) ul.u
#else // anon union
#define UL(ul) ul
#endif
if ( pTotal )
{
#if wxUSE_LONGLONG
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).HighPart, UL(bytesTotal).LowPart);
#else
*pTotal = wxDiskspaceSize_t(UL(bytesTotal).LowPart);
#endif
}
if ( pFree )
{
#if wxUSE_LONGLONG
*pFree = wxLongLong(UL(bytesFree).HighPart, UL(bytesFree).LowPart);
#else
*pFree = wxDiskspaceSize_t(UL(bytesFree).LowPart);
#endif
}
}
else
#endif // Win32
{
// there's a problem with drives larger than 2GB, GetDiskFreeSpaceEx()
// should be used instead - but if it's not available, fall back on
// GetDiskFreeSpace() nevertheless...
DWORD lSectorsPerCluster,
lBytesPerSector,
lNumberOfFreeClusters,
lTotalNumberOfClusters;
// FIXME: this is wrong, we should extract the root drive from path
// instead, but this is the job for wxFileName...
if ( !::GetDiskFreeSpace(path,
&lSectorsPerCluster,
&lBytesPerSector,
&lNumberOfFreeClusters,
&lTotalNumberOfClusters) )
{
wxLogLastError(_T("GetDiskFreeSpace"));
return false;
}
wxDiskspaceSize_t lBytesPerCluster = (wxDiskspaceSize_t) lSectorsPerCluster;
lBytesPerCluster *= lBytesPerSector;
if ( pTotal )
{
*pTotal = lBytesPerCluster;
*pTotal *= lTotalNumberOfClusters;
}
if ( pFree )
{
*pFree = lBytesPerCluster;
*pFree *= lNumberOfFreeClusters;
}
}
return true;
#endif
// __WXWINCE__
}
void wxAnyTestCase::wxVariantConversions()
{
#if wxUSE_VARIANT
//
// Test various conversions to and from wxVariant
//
bool res;
// Prepare wxVariants
wxVariant vLong(123L);
wxVariant vString("ABC");
wxVariant vDouble(TEST_FLOAT_CONST);
wxVariant vBool((bool)true);
wxVariant vChar('A');
#ifdef wxLongLong_t
wxVariant vLongLong(wxLongLong(wxLL(0xAABBBBCCCC)));
wxVariant vULongLong(wxULongLong(wxULL(123456)));
#endif
wxArrayString arrstr;
arrstr.push_back("test string");
wxVariant vArrayString(arrstr);
wxVariant vDateTime(m_testDateTime);
wxVariant vVoidPtr(dummyVoidPointer);
wxVariant vCustomType(new wxMyVariantData(MyClass(101)));
wxVariant vList;
vList.NullList();
vList.Append(15);
vList.Append("abc");
// Convert to wxAnys, and then back to wxVariants
wxVariant variant;
wxAny any(vLong);
CPPUNIT_ASSERT(any == 123L);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant == 123L);
// Make sure integer variant has correct type information
CPPUNIT_ASSERT(variant.GetLong() == 123);
CPPUNIT_ASSERT(variant.GetType() == "long");
// Unsigned long wxAny should convert to "ulonglong" wxVariant
any = 1000UL;
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "ulonglong");
CPPUNIT_ASSERT(variant.GetLong() == 1000);
any = vString;
CPPUNIT_ASSERT(any == "ABC");
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetString() == "ABC");
// Must be able to build string wxVariant from wxAny built from
// string literal
any = "ABC";
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "string");
CPPUNIT_ASSERT(variant.GetString() == "ABC");
any = L"ABC";
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "string");
#if wxUSE_UNICODE
CPPUNIT_ASSERT(variant.GetString() == L"ABC");
#endif
any = vDouble;
double d = wxANY_AS(any, double);
CPPUNIT_ASSERT_DOUBLES_EQUAL(d, TEST_FLOAT_CONST, FEQ_DELTA);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT_DOUBLES_EQUAL(variant.GetDouble(),
TEST_FLOAT_CONST,
FEQ_DELTA);
any = vBool;
CPPUNIT_ASSERT(wxANY_AS(any, bool) == true);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetBool() == true);
any = wxAny(vChar);
//CPPUNIT_ASSERT(wxANY_AS(any, wxUniChar) == 'A');
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetChar() == 'A');
#ifdef wxLongLong_t
any = wxAny(vLongLong);
CPPUNIT_ASSERT(any == wxLL(0xAABBBBCCCC));
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "longlong");
CPPUNIT_ASSERT(variant.GetLongLong() == wxLongLong(wxLL(0xAABBBBCCCC)));
#if LONG_MAX == wxINT64_MAX
// As a sanity check, test that wxVariant of type 'long' converts
// seamlessly to 'longlong' (on some 64-bit systems)
any = 0xAABBBBCCCCL;
res = any.GetAs(&variant);
CPPUNIT_ASSERT(variant.GetLongLong() == wxLongLong(wxLL(0xAABBBBCCCC)));
#endif
any = wxAny(vULongLong);
CPPUNIT_ASSERT(any == wxLL(123456));
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "ulonglong");
CPPUNIT_ASSERT(variant.GetULongLong() == wxULongLong(wxULL(123456)));
#endif
// Cannot test equality for the rest, just test that they convert
// back correctly.
any = wxAny(vArrayString);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
wxArrayString arrstr2 = variant.GetArrayString();
CPPUNIT_ASSERT(arrstr2 == arrstr);
any = m_testDateTime;
CPPUNIT_ASSERT(wxANY_AS(any, wxDateTime) == m_testDateTime);
any = wxAny(vDateTime);
CPPUNIT_ASSERT(wxANY_AS(any, wxDateTime) == m_testDateTime);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant == m_testDateTime);
any = wxAny(vVoidPtr);
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetVoidPtr() == dummyVoidPointer);
any = wxAny(vList);
CPPUNIT_ASSERT(wxANY_CHECK_TYPE(any, wxAnyList));
wxAnyList anyList = wxANY_AS(any, wxAnyList);
CPPUNIT_ASSERT(anyList.GetCount() == 2);
CPPUNIT_ASSERT(wxANY_AS((*anyList[0]), int) == 15);
CPPUNIT_ASSERT(wxANY_AS((*anyList[1]), wxString) == "abc");
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "list");
CPPUNIT_ASSERT(variant.GetCount() == 2);
CPPUNIT_ASSERT(variant[0].GetLong() == 15);
CPPUNIT_ASSERT(variant[1].GetString() == "abc");
any = wxAny(vCustomType);
CPPUNIT_ASSERT(wxANY_CHECK_TYPE(any, wxVariantData*));
res = any.GetAs(&variant);
CPPUNIT_ASSERT(res);
CPPUNIT_ASSERT(variant.GetType() == "MyClass");
#endif // wxUSE_VARIANT
}
WXDLLEXPORT bool
wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant, long flags)
{
bool ok = true;
if ( oleVariant.vt & VT_ARRAY )
{
if ( flags & wxOleConvertVariant_ReturnSafeArrays )
{
variant.SetData(new wxVariantDataSafeArray(oleVariant.parray));
}
else
{
switch (oleVariant.vt & VT_TYPEMASK)
{
case VT_I2:
ok = wxSafeArray<VT_I2>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_I4:
ok = wxSafeArray<VT_I4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R4:
ok = wxSafeArray<VT_R4>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_R8:
ok = wxSafeArray<VT_R8>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_VARIANT:
ok = wxSafeArray<VT_VARIANT>::ConvertToVariant(oleVariant.parray, variant);
break;
case VT_BSTR:
{
wxArrayString strings;
if ( wxSafeArray<VT_BSTR>::ConvertToArrayString(oleVariant.parray, strings) )
variant = strings;
else
ok = false;
}
break;
default:
ok = false;
break;
}
if ( !ok )
{
wxLogDebug(wxT("unhandled VT_ARRAY type %x in wxConvertOleToVariant"),
oleVariant.vt & VT_TYPEMASK);
variant = wxVariant();
}
}
}
else if ( oleVariant.vt & VT_BYREF )
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_VARIANT:
{
VARIANTARG& oleReference = *((LPVARIANT)oleVariant.byref);
if (!wxConvertOleToVariant(oleReference,variant))
return false;
break;
}
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: [as yet] unhandled reference %X"),
oleVariant.vt);
return false;
}
}
else // simply type (not array or reference)
{
switch ( oleVariant.vt & VT_TYPEMASK )
{
case VT_ERROR:
variant.SetData(new wxVariantDataErrorCode(oleVariant.scode));
break;
case VT_CY:
variant.SetData(new wxVariantDataCurrency(oleVariant.cyVal));
break;
case VT_BSTR:
{
wxString str(wxConvertStringFromOle(oleVariant.bstrVal));
variant = str;
}
break;
case VT_DATE:
#if wxUSE_DATETIME
{
SYSTEMTIME st;
VariantTimeToSystemTime(oleVariant.date, &st);
wxDateTime date;
date.SetFromMSWSysTime(st);
variant = date;
}
#endif // wxUSE_DATETIME
break;
#if wxUSE_LONGLONG
case VT_I8:
variant = wxLongLong(oleVariant.llVal);
break;
#endif // wxUSE_LONGLONG
case VT_I4:
variant = (long) oleVariant.lVal;
break;
case VT_I2:
variant = (long) oleVariant.iVal;
break;
case VT_BOOL:
variant = oleVariant.boolVal != 0;
break;
case VT_R4:
variant = oleVariant.fltVal;
break;
case VT_R8:
variant = oleVariant.dblVal;
break;
case VT_DISPATCH:
variant = (void*) oleVariant.pdispVal;
break;
case VT_NULL:
case VT_EMPTY:
variant.MakeNull();
break;
default:
wxLogError(wxT("wxAutomationObject::ConvertOleToVariant: Unknown variant value type %X -> %X"),
oleVariant.vt,oleVariant.vt&VT_TYPEMASK);
return false;
}
}
return ok;
}
int main(int argc, char **argv) {
wxInitializer wx_initializer;
if ( !wx_initializer ) {
fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
return -1;
}
wxCmdLineParser cmd_parser(cmdLineDesc, argc, argv);
long run_count = 10;
wxString grid_path, dict_path;
bool is_rand = false;
bool is_verbose = false;
switch ( cmd_parser.Parse() ) {
case -1:
return 0;
case 0:
cmd_parser.Found(wxT("count"), &run_count);
is_rand = cmd_parser.Found(wxT("rand"));
is_verbose = cmd_parser.Found(wxT("verbose"));
grid_path = cmd_parser.GetParam(0);
dict_path = cmd_parser.GetParam(1);
wxLogDebug(wxT("grid_path = ") + grid_path + wxT("\n"));
wxLogDebug(wxT("dict_path = ") + dict_path + wxT("\n"));
wxLogDebug(wxT("run_count = %d\n"), run_count);
break;
default:
return 0;
}
std::vector< wxLongLong > durs(run_count); // durations
std::vector< wxString > words_out;
DictType dict;
GridType grid;
AllWordsType all_words;
CharsTransType trans_type;
readDict(dict_path, dict);
generateAllWords(dict, all_words, trans_type);
readGrid(grid_path, grid);
if ( is_rand )
srand(time(NULL));
for (long i = 0; i < run_count; ++i) {
if ( !is_rand )
srand(42);
words_out.clear();
durs.at(i) = wxGetLocalTimeMillis();
generateCross(grid,all_words,trans_type,words_out);
if ( words_out.size() == 0 )
wxPrintf(wxT("Error in creating #%-2i!\n"),i+1);
durs.at(i) = wxGetLocalTimeMillis() - durs.at(i);
if ( is_verbose )
wxPrintf(wxT("Time to generate #%-2i is ")
+ durs.at(i).ToString() + wxT(" ms\n"), i+1);
}
wxLongLong tm_total = std::accumulate(durs.begin(),durs.end(), wxLongLong(0,0));
wxLongLong tm_mean = (tm_total + run_count/2) / run_count;
wxPrintf(wxT("Total time = ") + tm_total.ToString() + wxT(" ms.\nMean time = ")
+ tm_mean.ToString() + wxT(" ms.\n"));
return 0;
}
