void FileProperties::Load()
{
if(!loaded)
{
loaded=true;
smallIcon=GetFileIcon(fullPath, SHGFI_SMALLICON | SHGFI_ICON);
bigIcon=GetFileIcon(fullPath, SHGFI_LARGEICON | SHGFI_ICON);
displayName=GetFileDisplayName(fullPath);
typeName=GetFileTypeName(fullPath);
lastWriteTime=GetFileLastWriteTime(fullPath);
size=GetFileSize(fullPath);
}
}
// Fill all information about a directory or a file.
FOREACH(WString, file, files)
{
Ptr<list::ListViewItem> item=new list::ListViewItem;
WString fullPath=path+L"\\"+file;
// Get large icon.
item->largeImage=GetFileIcon(fullPath, SHGFI_LARGEICON | SHGFI_ICON);
// Get small icon.
item->smallImage=GetFileIcon(fullPath, SHGFI_SMALLICON | SHGFI_ICON);
// Get display name
item->text=GetFileDisplayName(fullPath);
// Get type name
item->subItems.Add(GetFileTypeName(fullPath));
// Get last write time
item->subItems.Add(FileTimeToString(GetFileLastWriteTime(fullPath)));
// Get file size
item->subItems.Add(FileSizeToString(GetFileSize(fullPath)));
listView->GetItems().Add(item);
}
bool CPPageFormats::RegisterExt(CString ext, bool fRegister, CString PerceivedType)
{
CRegKey key;
bool bSetValue;
CString strProgID = _T("SPlayer") + ext;
CString strLabel = _T("");
if(ext == _T(".rar")){
return true;
}
if(fRegister){
//为保证成功注册清理垃圾
//AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, ext);
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("KMPlayer") + ext);
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("QQPlayer") + ext);
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("stormplayer") + ext);
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("RealPlayer") + ext+L".6");
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("RealPlayer") + ext+L".10");
AfxGetMyApp()->DelRegTree(HKEY_CLASSES_ROOT, _T("Xmp") + ext);
}
CString path, fn, cmd;
if(!MakeRegParams(ext, path, fn, strLabel, cmd))
return(false);
strLabel = GetFileTypeName(ext);
if (ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, ext))
return(false);
if (!PerceivedType.IsEmpty())
{
key.SetStringValue (L"PerceivedType", PerceivedType);
}
BOOL bIsRAR = (ext.Right(3).MakeLower() == _T("rar"));
if (bIsRAR)
return true;
if(!fRegister && !bIsRAR)
{
if(fRegister != IsRegistered(ext))
SetFileAssociation (ext, strProgID, fRegister);
key.Attach(HKEY_CLASSES_ROOT);
key.RecurseDeleteKey(strProgID);
return(true);
}
bSetValue = fRegister || (ERROR_SUCCESS != key.Open(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\open\\command"), KEY_READ));
// Create ProgID for this file type
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID)) return(false);
if(ERROR_SUCCESS != key.SetStringValue(NULL, strLabel)) return(false);
// Add to playlist option
if(f_setContextFiles || bIsRAR)
{
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\enqueue"))) return(false);
if(ERROR_SUCCESS != key.SetStringValue(NULL, ResStr(IDS_ADD_TO_PLAYLIST))) return(false);
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\enqueue\\command"))) return(false);
if(bSetValue && (ERROR_SUCCESS != key.SetStringValue(NULL, GetEnqueueCommand()))) return(false);
}
else
{
key.Attach(HKEY_CLASSES_ROOT);
key.RecurseDeleteKey(strProgID + _T("\\shell\\enqueue"));
}
// Play option
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\open"))) return(false);
if(f_setContextFiles || bIsRAR)
{
if(ERROR_SUCCESS != key.SetStringValue(NULL, ResStr(IDS_OPEN_WITH_MPC))) return(false);
}
else
{
if(ERROR_SUCCESS != key.SetStringValue(NULL, _T(""))) return(false);
}
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\open\\command"))) return(false);
if(bSetValue && (ERROR_SUCCESS != key.SetStringValue(NULL, GetOpenCommand()))) return(false);
// Play option
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\openewnd"))) return(false);
if(f_setContextFiles || bIsRAR)
{
if(ERROR_SUCCESS != key.SetStringValue(NULL, ResStr(IDS_OPEN_WITH_MPC_IN_NEW_WND))) return(false);
}
else
{
if(ERROR_SUCCESS != key.SetStringValue(NULL, _T(""))) return(false);
}
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\shell\\openewnd\\command"))) return(false);
if(bSetValue && (ERROR_SUCCESS != key.SetStringValue(NULL, GetOpenCommand(true)))) return(false);
if(ERROR_SUCCESS != key.Create(HKEY_LOCAL_MACHINE, g_strRegisteredKey + _T("\\FileAssociations"))) return(false);
if(ERROR_SUCCESS != key.SetStringValue(ext, strProgID)) return(false);
if(f_setAssociatedWithIcon && !bIsRAR)
{
CString AppIcon = GetFileIcon(ext);
TCHAR buff[MAX_PATH];
if((AppIcon.IsEmpty()) && (::GetModuleFileName(AfxGetInstanceHandle(), buff, MAX_PATH)))
{
AppIcon = buff;
AppIcon = "\""+AppIcon+"\"";
AppIcon += _T(",0");
}
if(ERROR_SUCCESS != key.Create(HKEY_CLASSES_ROOT, strProgID + _T("\\DefaultIcon"))) return(false);
if(bSetValue && (ERROR_SUCCESS != key.SetStringValue(NULL, AppIcon))) return(false);
}
else
{
key.Attach(HKEY_CLASSES_ROOT);
key.RecurseDeleteKey(strProgID + _T("\\DefaultIcon"));
}
if (fRegister && !bIsRAR)
SetFileAssociation(ext, strProgID, fRegister);
return(true);
}
void CFileDetailDialogInfo::RefreshData()
{
CString str;
if (m_paFiles->GetSize() == 1)
{
CPartFile* file = STATIC_DOWNCAST(CPartFile, (*m_paFiles)[0]);
// if file is completed, we output the 'file path' and not the 'part.met file path'
if (file->GetStatus(true) == PS_COMPLETE)
GetDlgItem(IDC_FD_X2)->SetWindowText(GetResString(IDS_DL_FILENAME));
SetDlgItemText(IDC_FNAME, file->GetFileName());
SetDlgItemText(IDC_METFILE, file->GetFullName());
SetDlgItemText(IDC_FHASH, md4str(file->GetFileHash()));
if (file->GetTransferringSrcCount() > 0)
str.Format(GetResString(IDS_PARTINFOS2), file->GetTransferringSrcCount());
else
str = file->getPartfileStatus();
SetDlgItemText(IDC_PFSTATUS, str);
str.Format(_T("%u; %s: %u (%.1f%%)"), file->GetPartCount(), GetResString(IDS_AVAILABLE) , file->GetAvailablePartCount(), (float)((file->GetAvailablePartCount()*100)/file->GetPartCount()));
SetDlgItemText(IDC_PARTCOUNT, str);
// date created
if (file->GetCrFileDate() != 0) {
str.Format(_T("%s ") + GetResString(IDS_TIMEBEFORE),
file->GetCrCFileDate().Format(thePrefs.GetDateTimeFormat()),
CastSecondsToLngHM(time(NULL) - file->GetCrFileDate()));
}
else
str = GetResString(IDS_UNKNOWN);
SetDlgItemText(IDC_FILECREATED, str);
// active download time
time_t nDlActiveTime = file->GetDlActiveTime(); //vs2005
if (nDlActiveTime)
str = CastSecondsToLngHM(nDlActiveTime);
else
str = GetResString(IDS_UNKNOWN);
SetDlgItemText(IDC_DL_ACTIVE_TIME, str);
// last seen complete
struct tm tmTemp;
struct tm* ptimLastSeenComplete = file->lastseencomplete.GetLocalTm(&tmTemp);
if (file->lastseencomplete == NULL || ptimLastSeenComplete == NULL)
str.Format(GetResString(IDS_NEVER));
else {
str.Format(_T("%s ") + GetResString(IDS_TIMEBEFORE),
file->lastseencomplete.Format(thePrefs.GetDateTimeFormat()),
CastSecondsToLngHM(time(NULL) - safe_mktime(ptimLastSeenComplete)));
}
SetDlgItemText(IDC_LASTSEENCOMPL, str);
// last receive
if (file->GetFileDate() != 0 && file->GetRealFileSize() > (uint64)0)
{
// 'Last Modified' sometimes is up to 2 seconds greater than the current time ???
// If it's related to the FAT32 seconds time resolution the max. failure should still be only 1 sec.
// Happens at least on FAT32 with very high download speed.
uint32 tLastModified = file->GetFileDate();
time_t tNow = time(NULL); //vs2005
uint32 tAgo;
if (tNow >= tLastModified)
tAgo = tNow - tLastModified;
else{
TRACE("tNow = %s\n", CTime(tNow).Format("%X"));
TRACE("tLMd = %s, +%u\n", CTime(tLastModified).Format("%X"), tLastModified - tNow);
TRACE("\n");
tAgo = 0;
}
str.Format(_T("%s ") + GetResString(IDS_TIMEBEFORE),
file->GetCFileDate().Format(thePrefs.GetDateTimeFormat()),
CastSecondsToLngHM(tAgo));
}
else
str = GetResString(IDS_NEVER);
SetDlgItemText(IDC_LASTRECEIVED, str);
// AICH Hash
switch (file->GetAICHRecoveryHashSet()->GetStatus()) {
case AICH_TRUSTED:
case AICH_VERIFIED:
case AICH_HASHSETCOMPLETE:
if (file->GetAICHRecoveryHashSet()->HasValidMasterHash()) {
SetDlgItemText(IDC_FD_AICHHASH, file->GetAICHRecoveryHashSet()->GetMasterHash().GetString());
break;
}
default:
SetDlgItemText(IDC_FD_AICHHASH, GetResString(IDS_UNKNOWN));
}
// file type
CString ext;
bool showwarning = false;
int pos = file->GetFileName().ReverseFind(_T('.'));
if (file->GetFileName().ReverseFind(_T('\\')) < pos) {
ext = file->GetFileName().Mid(pos + 1);
ext.MakeUpper();
}
EFileType bycontent = GetFileTypeEx((CKnownFile *)file, false, true);
if (bycontent != FILETYPE_UNKNOWN) {
str = GetFileTypeName(bycontent) + _T(" (");
str.Append(GetResString(IDS_VERIFIED) + _T(')'));
int extLevel = IsExtensionTypeOf(bycontent, ext);
if (extLevel == -1) {
showwarning = true;
str.Append(_T(" - "));
str.Append(GetResString(IDS_INVALIDFILEEXT) + _T(": "));
str.Append(ext);
}
else if (extLevel == 0) {
str.Append(_T(" - "));
str.Append(GetResString(IDS_UNKNOWNFILEEXT) + _T(": "));
str.Append(ext);
}
}
else {
// not verified
if (pos != -1) {
str =file->GetFileName().Mid(pos + 1);
str.MakeUpper();
str.Append(_T(" (") );
str.Append( GetResString(IDS_UNVERIFIED) + _T(')'));
}
else
str = GetResString(IDS_UNKNOWN);
}
m_bShowFileTypeWarning = showwarning;
SetDlgItemText(IDC_FD_X11,str);
}
else
{
SetDlgItemText(IDC_FNAME, sm_pszNotAvail);
SetDlgItemText(IDC_METFILE, sm_pszNotAvail);
SetDlgItemText(IDC_FHASH, sm_pszNotAvail);
SetDlgItemText(IDC_PFSTATUS, sm_pszNotAvail);
SetDlgItemText(IDC_PARTCOUNT, sm_pszNotAvail);
SetDlgItemText(IDC_FD_X11, sm_pszNotAvail);
SetDlgItemText(IDC_FILECREATED, sm_pszNotAvail);
SetDlgItemText(IDC_DL_ACTIVE_TIME, sm_pszNotAvail);
SetDlgItemText(IDC_LASTSEENCOMPL, sm_pszNotAvail);
SetDlgItemText(IDC_LASTRECEIVED, sm_pszNotAvail);
SetDlgItemText(IDC_FD_AICHHASH, sm_pszNotAvail);
}
uint64 uFileSize = 0;
uint64 uRealFileSize = 0;
uint64 uTransferred = 0;
uint64 uCorrupted = 0;
uint32 uRecoveredParts = 0;
uint64 uCompression = 0;
uint64 uCompleted = 0;
int iMD4HashsetAvailable = 0;
int iAICHHashsetAvailable = 0;
uint32 uDataRate = 0;
UINT uSources = 0;
UINT uValidSources = 0;
UINT uNNPSources = 0;
UINT uA4AFSources = 0;
for (int i = 0; i < m_paFiles->GetSize(); i++)
{
CPartFile* file = STATIC_DOWNCAST(CPartFile, (*m_paFiles)[i]);
uFileSize += (uint64)file->GetFileSize();
uRealFileSize += (uint64)file->GetRealFileSize();
uTransferred += (uint64)file->GetTransferred();
uCorrupted += file->GetCorruptionLoss();
uRecoveredParts += file->GetRecoveredPartsByICH();
uCompression += file->GetCompressionGain();
uDataRate += file->GetDatarate();
uCompleted += (uint64)file->GetCompletedSize();
iMD4HashsetAvailable += (file->GetFileIdentifier().HasExpectedMD4HashCount()) ? 1 : 0;
iAICHHashsetAvailable += (file->GetFileIdentifier().HasExpectedAICHHashCount()) ? 1 : 0;
if (file->IsPartFile())
{
uSources += file->GetSourceCount();
uValidSources += file->GetValidSourcesCount();
uNNPSources += file->GetSrcStatisticsValue(DS_NONEEDEDPARTS);
uA4AFSources += file->GetSrcA4AFCount();
}
}
str.Format(_T("%s (%s %s); %s %s"), CastItoXBytes(uFileSize, false, false), GetFormatedUInt64(uFileSize), GetResString(IDS_BYTES), GetResString(IDS_ONDISK), CastItoXBytes(uRealFileSize, false, false));
SetDlgItemText(IDC_FSIZE, str);
if (m_paFiles->GetSize() == 1)
{
if (iAICHHashsetAvailable == 0 && iMD4HashsetAvailable == 0)
SetDlgItemText(IDC_HASHSET, GetResString(IDS_NO));
else if (iAICHHashsetAvailable == 1 && iMD4HashsetAvailable == 1)
SetDlgItemText(IDC_HASHSET, GetResString(IDS_YES) + _T(" (eD2K + AICH)"));
else if (iAICHHashsetAvailable == 1)
SetDlgItemText(IDC_HASHSET, GetResString(IDS_YES) + _T(" (AICH)"));
else if (iMD4HashsetAvailable == 1)
SetDlgItemText(IDC_HASHSET, GetResString(IDS_YES) + _T(" (eD2K)"));
}
else
{
if (iAICHHashsetAvailable == 0 && iMD4HashsetAvailable == 0)
SetDlgItemText(IDC_HASHSET, GetResString(IDS_NO));
else if (iMD4HashsetAvailable == m_paFiles->GetSize() && iAICHHashsetAvailable == m_paFiles->GetSize())
SetDlgItemText(IDC_HASHSET, GetResString(IDS_YES) + + _T(" (eD2K + AICH)"));
else
SetDlgItemText(IDC_HASHSET, _T(""));
}
str.Format(GetResString(IDS_SOURCESINFO), uSources, uValidSources, uNNPSources, uA4AFSources);
SetDlgItemText(IDC_SOURCECOUNT, str);
SetDlgItemText(IDC_DATARATE, CastItoXBytes(uDataRate, false, true));
SetDlgItemText(IDC_TRANSFERRED, CastItoXBytes(uTransferred, false, false));
str.Format(_T("%s (%.1f%%)"), CastItoXBytes(uCompleted, false, false), uFileSize!=0 ? (uCompleted * 100.0 / uFileSize) : 0.0);
SetDlgItemText(IDC_COMPLSIZE, str);
str.Format(_T("%s (%.1f%%)"), CastItoXBytes(uCorrupted, false, false), uTransferred!=0 ? (uCorrupted * 100.0 / uTransferred) : 0.0);
SetDlgItemText(IDC_CORRUPTED, str);
str.Format(_T("%s (%.1f%%)"), CastItoXBytes(uFileSize - uCompleted, false, false), uFileSize!=0 ? ((uFileSize - uCompleted) * 100.0 / uFileSize) : 0.0);
SetDlgItemText(IDC_REMAINING, str);
str.Format(_T("%u %s"), uRecoveredParts, GetResString(IDS_FD_PARTS));
SetDlgItemText(IDC_RECOVERED, str);
str.Format(_T("%s (%.1f%%)"), CastItoXBytes(uCompression, false, false), uTransferred!=0 ? (uCompression * 100.0 / uTransferred) : 0.0);
SetDlgItemText(IDC_COMPRESSION, str);
}
main (int argc, char *argv[])
/*----------------------------------------------------------------------------->
/ purpose: Dump Contents of any Level 1 product
/
/ coded by: Gerhard L.H. Kruizinga 08/23/00
/
<-----------------------------------------------------------------------------*/
{
FILE *src,*dst;
FileHeader_t header;
double Acc1aZbias;
char BinFilename[HEADERMAXCHAR];
char AscFilename[HEADERMAXCHAR];
char TimeTag[HEADERMAXCHAR];
char file_format[HEADERMAXCHAR];
char NobsChar[HEADERMAXCHAR];
char FileTypeName[HEADERMAXCHAR];
char LinkTimeLabel[HEADERMAXCHAR];
char NrBytes[HEADERMAXCHAR];
long i,ShowHeader,arg_ndx,DumpNrec,AscFileDefined,HeaderOnly;
long MassTnk,MassThr,Ksnr;
long PresTnk,TempTnk,RegTnk,AdapTnk,TempRedTnk,ACC1A_count,AHK1A_vp;
long RmGdel,ACC1A_ang,ACC1A_lin;
long Ka_phase_only,K_phase_only;
/*----------------------------------------------------------------------------->
/ check usage
<-----------------------------------------------------------------------------*/
if (argc < 2)
{
fprintf(stderr,
"\n usage: %s -binfile Level1_Bin_File [-ascfile Level1_Asc_File] [-nohead] [-nrec] [-head_only]\n\n",
argv[0]);
fprintf(stderr," [-masstnk tnk_id (3=both tanks,0=none)] [-massthr tnk_id (3=both tanks,0=none)]\n");
fprintf(stderr," [-pres_tnk tnk_id] [-temp_tnk tnk_id]\n");
fprintf(stderr," [-reg_tnk tnk_id] [-adap_tnk tnk_id] [-tempred_tnk tnk_id]\n");
fprintf(stderr," [-tstart Tstart] [-tfinal Tfinal] [-acc1a_count] [-acc1a_ang] [-acc1a_lin] [-ahk1a_vp]\n");
fprintf(stderr," [-acc1a_zbias Acc1aZbias (def 0)] [-ksnr] [-ka] [-k] [-rm_gdel]\n");
fprintf(stderr," If -ascfile is not defined then output will go to standard out\n");
fprintf(stderr,"\n");
exit(1);
}
/*----------------------------------------------------------------------------->
/ Intialize Header information and other relevant info
<-----------------------------------------------------------------------------*/
InitializeHeaders();
LinkTime(LinkTimeLabel);
MassTnk = 4;
arg_ndx = FindOpt(argc,argv, "-masstnk");
if (arg_ndx != -1) MassTnk = GetLongArgv(argc,argv,"-masstnk");
MassThr = 4;
arg_ndx = FindOpt(argc,argv, "-massthr");
if (arg_ndx != -1) MassThr = GetLongArgv(argc,argv,"-massthr");
PresTnk = 0;
arg_ndx = FindOpt(argc,argv, "-pres_tnk");
if (arg_ndx != -1) PresTnk = GetLongArgv(argc,argv,"-pres_tnk");
TempTnk = 0;
arg_ndx = FindOpt(argc,argv, "-temp_tnk");
if (arg_ndx != -1) TempTnk = GetLongArgv(argc,argv,"-temp_tnk");
TempRedTnk = 0;
arg_ndx = FindOpt(argc,argv, "-tempred_tnk");
if (arg_ndx != -1) TempRedTnk = GetLongArgv(argc,argv,"-tempred_tnk");
RegTnk = 0;
arg_ndx = FindOpt(argc,argv, "-reg_tnk");
if (arg_ndx != -1) RegTnk = GetLongArgv(argc,argv,"-reg_tnk");
AdapTnk = 0;
arg_ndx = FindOpt(argc,argv, "-adap_tnk");
if (arg_ndx != -1) AdapTnk = GetLongArgv(argc,argv,"-adap_tnk");
ShowHeader = 1;
arg_ndx = FindOpt(argc,argv, "-nohead");
if (arg_ndx != -1) ShowHeader = 0;
Ksnr = 0;
arg_ndx = FindOpt(argc,argv, "-ksnr");
if (arg_ndx != -1) Ksnr = 1;
Ka_phase_only = 0;
arg_ndx = FindOpt(argc,argv, "-ka");
if (arg_ndx != -1) Ka_phase_only = 1;
K_phase_only = 0;
arg_ndx = FindOpt(argc,argv, "-k");
if (arg_ndx != -1) K_phase_only = 1;
RmGdel = 0;
arg_ndx = FindOpt(argc,argv, "-rm_gdel");
if (arg_ndx != -1) RmGdel = 1;
HeaderOnly = 0;
arg_ndx = FindOpt(argc,argv, "-head_only");
if (arg_ndx != -1) HeaderOnly = 1;
DumpNrec = DUMPALL;
arg_ndx = FindOpt(argc,argv, "-nrec");
if (arg_ndx != -1) DumpNrec = GetLongArgv(argc,argv,"-nrec");
Tstart = -1.0e32;
arg_ndx = FindOpt(argc,argv, "-tstart");
if (arg_ndx != -1) Tstart = GetDoubleArgv(argc,argv,"-tstart");
Tfinal = 1.0e32;
arg_ndx = FindOpt(argc,argv, "-tfinal");
if (arg_ndx != -1) Tfinal = GetDoubleArgv(argc,argv,"-tfinal");
Acc1aZbias = 0.0;
arg_ndx = FindOpt(argc,argv, "-acc1a_zbias");
if (arg_ndx != -1) Acc1aZbias = GetDoubleArgv(argc,argv,"-acc1a_zbias");
AscFileDefined = 0;
arg_ndx = FindOpt(argc,argv, "-ascfile");
if (arg_ndx != -1) AscFileDefined = 1;
ACC1A_count = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_count");
if (arg_ndx != -1) ACC1A_count = 1;
ACC1A_ang = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_ang");
if (arg_ndx != -1) ACC1A_ang = 1;
ACC1A_lin = 0;
arg_ndx = FindOpt(argc,argv, "-acc1a_lin");
if (arg_ndx != -1) ACC1A_lin = 1;
AHK1A_vp = 0;
arg_ndx = FindOpt(argc,argv, "-ahk1a_vp");
if (arg_ndx != -1) AHK1A_vp = 1;
/*----------------------------------------------------------------------------->
/ Open files
<-----------------------------------------------------------------------------*/
strcpy (BinFilename,GetStrArgv(argc,argv,"-binfile"));
src = fopen(BinFilename,"r");
if (src == NULL)
{
fprintf(stderr," Level 1 Product file %s cannot be opened !! \n",
BinFilename);
exit(1);
}
if (AscFileDefined == 1)
{
strcpy (AscFilename,GetStrArgv(argc,argv,"-ascfile"));
dst = fopen(AscFilename,"w");
if (dst == NULL)
{
fprintf(stderr," Level 1 Product file %s cannot be opened !! \n",
AscFilename);
exit(1);
}
}
else
{
strcpy(AscFilename,"Standard_Out");
dst = stdout;
}
/*----------------------------------------------------------------------------->
/ Read Header information and write updated header to Ascii file
<-----------------------------------------------------------------------------*/
if (ReadFileHeader(src,&header) == false)
{
fprintf(stderr,"\n Problem reading file header for file %s\n",BinFilename);
fprintf(stderr," See message above for problem\n\n");
exit(1);
}
GetUTCTimeTag(TimeTag);
strcat(TimeTag," by ");
strcat(TimeTag,getenv("LOGNAME"));
header.formattype = 1;
strcpy(NrBytes,"Not Determined because output is stdout");
if (!HeaderOnly)
{
sprintf(file_format,"%d",header.formattype);
ModifyFileHeader(&header,GetHeaderLabel("iphFileFormat"),file_format);
ModifyFileHeader(&header,GetHeaderLabel("iphFileName"),AscFilename);
ModifyFileHeader(&header,GetHeaderLabel("iphNumberBytes") , NrBytes);
}
if (ShowHeader != 0 ) WriteFileHeader(dst,&header);
if (HeaderOnly) exit(0);
/*----------------------------------------------------------------------------->
/ Based on header information Dump Records
<-----------------------------------------------------------------------------*/
if (header.filetype == GetFileType("ipGFD1XF"))
DumpGFD1XF(src,dst,DumpNrec,Ksnr,K_phase_only,Ka_phase_only);
else if (header.filetype == GetFileType("ipACC1AF"))
DumpACC1AF(src,dst,DumpNrec,ACC1A_count,AHK1A_vp,RmGdel,ACC1A_ang,ACC1A_lin,Acc1aZbias);
else if (header.filetype == GetFileType("ipACC1BF"))
DumpACC1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipGNV1AF"))
DumpGNV1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipGNV1BF"))
DumpGNV1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipKBR1BF"))
DumpKBR1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipSCA1AF"))
DumpSCA1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipSCA1BF"))
DumpSCA1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipPCI1AF"))
DumpPCI1AF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipXXXVOF"))
DumpXXXVOF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipIOA1BF"))
DumpIOA1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipOSCFQF"))
DumpOSCFQF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipMAG1XF"))
DumpMAG1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipHRT1XF"))
DumpHRT1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTHR1XF"))
DumpTHR1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipIHK1XF"))
DumpIHK1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipCLK1BF"))
DumpCLK1BF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTNK1XF"))
DumpTNK1XF(src,dst,DumpNrec, PresTnk,TempTnk,RegTnk,AdapTnk,TempRedTnk);
else if (header.filetype == GetFileType("ipMAS1XF"))
DumpMAS1XF(src,dst,DumpNrec,MassTnk,MassThr);
else if (header.filetype == GetFileType("ipILG1XF"))
DumpILG1XF(src,dst,DumpNrec);
else if (header.filetype == GetFileType("ipTIM1XF"))
DumpTIM1XF(src,dst,DumpNrec);
else
{
GetFileTypeName(header.filetype,FileTypeName);
if (strcmp(FileTypeName,"NOT_DEFINED") != 0)
{
fprintf(stderr,"File Type %s can not be converted into ascii format!!\n\n",
FileTypeName);
}
else
{
fprintf(stderr," FileTypePointer = %d is not defined or filetype pointer refers to Level1A data!!\n",
header.filetype);
fprintf(stderr," Check Header of input File!\n\n");
exit(1);
}
}
if (DumpNrec != DUMPALL)
{
sprintf(NobsChar,"%d",DumpNrec);
ModifyFileHeader(&header,GetHeaderLabel("iphNumberObs"), NobsChar);
}
GetUTCTimeTag(TimeTag);
strcat(TimeTag," by ");
strcat(TimeTag,getenv("LOGNAME"));
sprintf(NrBytes,"%d",ftell(dst));
ModifyFileHeader(&header,GetHeaderLabel("iphNumberBytes") , NrBytes);
if (ShowHeader != 0 && dst != stdout) WriteFileHeader(dst,&header);
fclose(src);
fclose(dst);
exit(0);
}
void
DoStatus (
void
) {
struct lineAttr rglaStatus[10]; /* color array for status line */
int cch;
int ilaStatus = 0; /* index into color array */
int i;
char *pchEndBuf; /* save for end of buffer */
char buf[512];
/*
* Start with filename, and file type
*/
strcpy (buf, pFileHead->pName);
strcat (buf, " (");
strcpy ((char *)strend(buf), GetFileTypeName ());
/*
* Add other file characterisctics
*/
if (!TESTFLAG (FLAGS (pFileHead), DOSFILE)) {
strcat (buf," NL");
}
if (TESTFLAG (FLAGS (pFileHead), TEMP)) {
strcat (buf, " temp");
}
if ((TESTFLAG (FLAGS (pFileHead), READONLY)) | fGlobalRO) {
strcat (buf, " No-Edit");
}
if (TESTFLAG (FLAGS (pFileHead), DISKRO)) {
strcat (buf, " RO-File");
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus++].len = (unsigned char) strlen (buf);
if (TESTFLAG (FLAGS(pFileHead), DIRTY)) {
strcat (buf, " modified");
rglaStatus[ilaStatus].attr = CINDEX(errColor);
rglaStatus[ilaStatus++].len = 9;
}
pchEndBuf = strend (buf);
sprintf (strend(buf), ") Length=%ld ", pFileHead->cLines);
/*
* Add current location
*/
if (fDisplayCursorLoc) {
sprintf (strend(buf), "Cursor=(%ld,%d)", YCUR(pInsCur)+1, XCUR(pInsCur)+1);
} else {
sprintf (strend(buf), "Window=(%ld,%d)", YWIN(pInsCur)+1, XWIN(pInsCur)+1);
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus++].len = (unsigned char) (strend(buf) - pchEndBuf);
/*
* Add global state indicators
*/
if (fInsert | fMeta | fCtrlc | fMacroRecord) {
rglaStatus[ilaStatus].attr = CINDEX(infColor);
rglaStatus[ilaStatus].len = 0;
if (fInsert) {
strcat (buf, " insert");
rglaStatus[ilaStatus].len += 7;
}
if (fMeta) {
strcat (buf, " meta");
rglaStatus[ilaStatus].len += 5;
}
if (fCtrlc) {
strcat (buf, " cancel");
rglaStatus[ilaStatus].len += 7;
fCtrlc = FALSE;
FlushInput ();
}
if (fMacroRecord) {
strcat (buf, " REC");
rglaStatus[ilaStatus].len += 4;
}
ilaStatus++;
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus].len = 0xffff;
pchEndBuf = buf;
/*
* if the net result is too long, eat the first part of the filename with
* an elipses (Leave room for BC as well).
*/
cch = strlen(buf) - (XSIZE - 4);
if (cch > 0) {
pchEndBuf = buf + cch;
pchEndBuf[0] = '.';
pchEndBuf[1] = '.';
pchEndBuf[2] = '.';
i = 0;
while ( cch && i <= ilaStatus ) {
if ( (int)rglaStatus[i].len > cch ) {
rglaStatus[i].len -= cch;
cch = 0;
} else {
cch -= rglaStatus[i].len;
rglaStatus[i].len = 0;
}
i++;
}
}
fReDraw = FALSE;
coutb (0, YSIZE+1, pchEndBuf, strlen(pchEndBuf), rglaStatus);
fReDraw = TRUE;
voutb (XSIZE-2, YSIZE+1, BTWorking() ? "BP" : " ", 2, errColor);
RSETFLAG (fDisplay, RSTATUS);
}
