home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / scrptsrc.pak / MISCSCR.CPP next >
C/C++ Source or Header  |  1997-05-06  |  11KB  |  381 lines
  1.  
  2. // Borland C++ - (C) Copyright 1991, 1996 by Borland International
  3.  
  4. //*******************************************************************
  5. //
  6. // This file contains miscellaneous functionality provided by the 
  7. // Windows API that is exposed to the IDE's scripting system.
  8. //
  9. // It is provided as a demonstraton of how functionality exposed from 
  10. // a DLL can be directly accessed from script.
  11. //
  12. //*******************************************************************
  13. #define STRICT
  14. #include "windows.h"
  15. #include "dir.h"
  16. #include "cstring.h"
  17.  
  18. // We want our own versions of these not the windows supplied Unicode 
  19. // friendly varients.  
  20. #undef CreateDirectory
  21. #undef RemoveDirectory
  22. #undef GetCurrentDirectory
  23. #undef SetCurrentDirectory
  24. #undef FindFirstFile
  25. #undef FindNextFile
  26. #undef GetEnvironmentVariable
  27. #undef PlaySound
  28. #undef CopyFile
  29. #undef DeleteFile
  30. #undef MoveFile
  31. #undef GetFileAttributes
  32. #undef SetFileAttributes
  33.  
  34.  
  35. #define EXPOSEDFUNC _export _stdcall
  36. //#define EXPOSEDFUNC _export _pascal
  37.  
  38. // a global string variable used to provide temporary storage for strings 
  39. // returned to script.
  40. static string StringReturn;
  41.  
  42. extern "C" char EXPOSEDFUNC CreateDirectory(const char * fileName){
  43.    SECURITY_ATTRIBUTES sa;
  44.    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  45.    sa.lpSecurityDescriptor = NULL;
  46.    sa.bInheritHandle = TRUE;  // why not?
  47.    return (bool)::CreateDirectoryA(fileName, &sa);
  48. }              
  49.  
  50. extern "C" char EXPOSEDFUNC RemoveDirectory(const char * fileName){
  51.    return (bool)::RemoveDirectoryA(fileName);
  52. }
  53.  
  54. extern "C" const char *EXPOSEDFUNC GetCurrentDirectory(){
  55.    char dirSpec[MAXDRIVE + MAXDIR + 1];
  56.    StringReturn = "";
  57.  
  58.    if(GetCurrentDirectoryA(sizeof(dirSpec), dirSpec)){
  59.       StringReturn = dirSpec;      
  60.    }
  61.    return StringReturn.c_str();
  62. }
  63.  
  64. extern "C" bool EXPOSEDFUNC SetCurrentDirectory(const char *dName){
  65.    return SetCurrentDirectoryA(dName);
  66. }
  67.  
  68. extern "C" void EXPOSEDFUNC Abort(){
  69.    // User request to unconditionally exit the IDE - save nothing!
  70.    ::ExitProcess(-3);
  71. }
  72.  
  73. extern "C" void EXPOSEDFUNC IDEMessageBeep(int soundType){
  74.    if(soundType != MB_ICONASTERISK && soundType != MB_ICONEXCLAMATION &&
  75.       soundType != MB_ICONHAND && soundType != MB_ICONQUESTION){
  76.       soundType = -1;
  77.    }
  78.    ::MessageBeep(soundType);
  79. }
  80.  
  81. struct FindFirstHelper{
  82.    FindFirstHelper();
  83.    ~FindFirstHelper();
  84.    LPWIN32_FIND_DATA ResetFindData();
  85.    bool FindFirst(const char *);
  86.    bool FindNext();
  87.    const char *FileName();
  88.  
  89.    private:
  90.    LPWIN32_FIND_DATA findData;
  91.    HANDLE findFirstHandle;
  92. };
  93.  
  94. FindFirstHelper::FindFirstHelper() : findData(NULL), findFirstHandle(INVALID_HANDLE_VALUE){
  95. }
  96.  
  97. FindFirstHelper::~FindFirstHelper(){
  98.    if(findData)
  99.       delete findData;
  100.  
  101.    if(findFirstHandle != INVALID_HANDLE_VALUE)
  102.       ::FindClose(findFirstHandle);
  103. }
  104.  
  105. LPWIN32_FIND_DATA FindFirstHelper::ResetFindData(){
  106.    if(findData == NULL){
  107.       findData = new WIN32_FIND_DATA;
  108.    }else{
  109.       ::FindClose(findFirstHandle);
  110.    }
  111.    return findData;
  112. }
  113.  
  114. bool FindFirstHelper::FindFirst(const char *filePattern){
  115.    ResetFindData();
  116.  
  117.    #if 0
  118.    // gmc revist: we should handle UNC filenames here as well
  119.    string UNCAware = "\\\\?\\";
  120.    UNCAware += filePattern;
  121.    findFirstHandle = ::FindFirstFileW(UNCAware.c_str(), findData);
  122.    #else
  123.    string UNCAware = filePattern;
  124.    findFirstHandle = ::FindFirstFileA(UNCAware.c_str(), findData);
  125.    #endif
  126.  
  127.    return (findFirstHandle != INVALID_HANDLE_VALUE);
  128. }
  129.  
  130. bool FindFirstHelper::FindNext(){
  131.    return (findData && ::FindNextFileA(findFirstHandle, findData));
  132. }
  133.  
  134. const char *FindFirstHelper::FileName(){
  135.    return findData->cFileName;
  136. }
  137. static FindFirstHelper ffh;
  138.  
  139. extern "C" const char * EXPOSEDFUNC FindFirstFile(const char * filePattern){
  140.    if(ffh.FindFirst(filePattern))
  141.       StringReturn = ffh.FileName();
  142.    else
  143.       StringReturn = "";
  144.  
  145.    return StringReturn.c_str();
  146. }
  147.  
  148. extern "C" const char * EXPOSEDFUNC FindNextFile(){
  149.    if(ffh.FindNext())
  150.       StringReturn = ffh.FileName();
  151.    else
  152.       StringReturn = "";
  153.  
  154.    return StringReturn.c_str();
  155. }
  156.  
  157. extern "C" const char * EXPOSEDFUNC GetEnvironmentVariable(const char * envVar){
  158.    char tmp[512];
  159.    int cnt = ::GetEnvironmentVariableA(envVar, tmp, sizeof(tmp));
  160.    if(!cnt){
  161.       // gmc revist: Look in the registration database under the heading
  162.       // "Environment" before giving up
  163.       StringReturn = "";
  164.    }else{
  165.       StringReturn = tmp;
  166.    }
  167.  
  168.    return StringReturn.c_str();
  169. }
  170.  
  171. extern "C" void EXPOSEDFUNC AssociateButton(int /*resId*/, const char * /*scriptToExecute*/){
  172.    // need to implement this!
  173. }
  174.  
  175. extern "C" char EXPOSEDFUNC PlaySound(const char *wavFile, int optionsMask){
  176.    return (bool)::sndPlaySoundA(wavFile, optionsMask);
  177. }
  178.  
  179. extern "C" char EXPOSEDFUNC CopyFile(const char *src, const char *dst, bool overWrite){
  180.    BOOL failIfExists = !overWrite;
  181.  
  182.    return (bool)::CopyFileA(src, dst, failIfExists);
  183. }
  184.  
  185. extern "C" char EXPOSEDFUNC MoveFile(const char *src, const char *dst){
  186.    return (bool)::MoveFileA(src, dst);
  187. }
  188.  
  189. extern "C" char EXPOSEDFUNC DeleteFile(const char *src){
  190.    return bool(::DeleteFileA(src));
  191. }
  192.  
  193. extern "C" unsigned EXPOSEDFUNC GetFileAttributes(const char *fileName){
  194.    return GetFileAttributesA(fileName);
  195. }
  196.  
  197. extern "C" char EXPOSEDFUNC SetFileAttributes(const char *fileName, int newAttrs){
  198.    return char(SetFileAttributesA(fileName, newAttrs));
  199. }
  200.  
  201. extern "C" char EXPOSEDFUNC FileExists(char * fileName){
  202.    if(!(*fileName))
  203.       return FALSE;
  204.    OFSTRUCT dummy;
  205.    if(::OpenFile(fileName, &dummy, OF_EXIST) == HFILE_ERROR)
  206.       return FALSE;
  207.    return TRUE;
  208. }
  209.  
  210. extern "C" char EXPOSEDFUNC IsLegalFileName(char * fileName){
  211.    if(fileName == NULL)
  212.       return FALSE;
  213.    if(!(*fileName))
  214.       return FALSE;
  215.    if(strlen (fileName) > MAXPATH)
  216.       return FALSE;
  217.  
  218.    char drive[MAXDRIVE];
  219.    char dir[MAXDIR];
  220.    char name[MAXFILE];
  221.    char ext[MAXEXT];
  222.  
  223.    int rv = fnsplit(fileName, drive, dir, name, ext);
  224.  
  225.    if(rv & WILDCARDS)
  226.       return FALSE;
  227.  
  228.    if(!(rv & FILENAME))
  229.       return FALSE;
  230.  
  231.    // looks like it is okay
  232.    return TRUE;
  233. }
  234.  
  235. extern "C" bool EXPOSEDFUNC Spawn(LPTSTR szCmdLine){
  236.    PROCESS_INFORMATION  piProcInfo;
  237.    STARTUPINFO          siStartInfo;
  238.  
  239.    siStartInfo.cb                = sizeof( STARTUPINFO );
  240.    siStartInfo.lpReserved        = NULL;
  241.    siStartInfo.lpDesktop         = NULL;
  242.    siStartInfo.lpTitle           = NULL;
  243.    //siStartInfo.dwX;
  244.    //siStartInfo.dwY;
  245.    //siStartInfo.dwXSize;
  246.    //siStartInfo.dwYSize;
  247.    //siStartInfo.dwXCountChars;
  248.    //siStartInfo.dwYCountChars;
  249.    //siStartInfo.dwFillAttribute;
  250.    //siStartInfo.dwFlags;
  251.    //siStartInfo.wShowWindow;
  252.    siStartInfo.cbReserved2        = 0;
  253.    siStartInfo.lpReserved2        = NULL;
  254.    //siStartInfo.hStdInput;
  255.    //siStartInfo.hStdOutput;
  256.    //siStartInfo.hStdError;       
  257.  
  258.    return CreateProcess( NULL, szCmdLine, NULL, NULL, FALSE, NULL, NULL,
  259.                          NULL, &siStartInfo, &piProcInfo );
  260. }
  261.  
  262. extern "C" const char * EXPOSEDFUNC GetValueData(HKEY hTopKey,
  263.                                                  const char *szSubKey,
  264.                                                  const char *szValueName){
  265.    char bigTempBuffer[1024];                                                  
  266.    DWORD  dwDataSize = 1;
  267.    StringReturn = "";
  268.    HKEY   hKey;
  269.  
  270.    if (RegOpenKeyEx(hTopKey, szSubKey, 0, KEY_READ, &hKey) == ERROR_SUCCESS){
  271.  
  272.       // Get the size of the value data.
  273.       if (RegQueryValueEx(hKey, szValueName, NULL, NULL, NULL,
  274.                           &dwDataSize) == ERROR_SUCCESS){
  275.  
  276.          // Get the value data.
  277.          RegQueryValueEx(hKey, szValueName, NULL, NULL, bigTempBuffer, &dwDataSize);
  278.          StringReturn = bigTempBuffer;
  279.       }
  280.    }
  281.    RegCloseKey(hKey);
  282.  
  283.    return StringReturn.c_str();;
  284. }
  285.  
  286. extern "C" bool EXPOSEDFUNC SetValueData(HKEY hTopKey,
  287.                                          const char *szSubKey,
  288.                                          const char *szValueName,
  289.                                          const char *szValueData){
  290.  
  291.    HKEY   hKey;
  292.    LONG   lResult;
  293.    BOOL   bSuccess;
  294.    DWORD  disp;
  295.  
  296.    if (RegCreateKeyEx(hTopKey, szSubKey, 0, "", REG_OPTION_NON_VOLATILE, 
  297.        KEY_ALL_ACCESS, NULL, &hKey, &disp) == ERROR_SUCCESS){
  298.       lResult = RegSetValueEx(hKey, szValueName, 0, REG_SZ, (LPBYTE)szValueData,
  299.                               strlen(szValueData) + 1);
  300.       bSuccess = (lResult == ERROR_SUCCESS ? TRUE : FALSE);
  301.    }
  302.    RegCloseKey(hKey);
  303.  
  304.    return bSuccess;
  305. }
  306.  
  307. // The purpose of this routine is to return a string that contains the hotkeys 
  308. // associated with the main BCW menu.  This can be used when writing scripts 
  309. // that perform assignements to determine what keystrokes will implicitly be 
  310. // recognized by the IDE (for example, Alt-F will invoke the file menu).
  311. // Given a main menu with the content:
  312. //  File Edit Search View Project Script Tool Debug Options Window Help
  313. //  -    -    -      -    -        -     -    -     -       -      -
  314. // the result will be "FESVPCTDOWH"
  315. extern "C" const char *EXPOSEDFUNC GetMainMenuHotKeys(){
  316.    StringReturn = "";
  317.  
  318.    HWND curWin = ::GetFocus();
  319.    HWND frameWin;
  320.    do{
  321.       frameWin = curWin;
  322.       curWin = GetParent(curWin);
  323.    }while(curWin);
  324.    
  325.    if(frameWin){
  326.       char outBuf[200];
  327.       int outBufUsed = 0;
  328.  
  329.       #if 0 // this doesn't work under NT 
  330.       MENUITEMINFO mi;
  331.       HMENU menu = GetMenu(frameWin);
  332.       int cnt = GetMenuItemCount(menu);
  333.       for (int i = 0; i < cnt; i++){
  334.          if(GetMenuItemInfo(menu, i, TRUE, &mi)){
  335.             if(mi.fType & MFT_STRING && mi.cch){
  336.                for(int j = 0; j < mi.cch - 1; j++){
  337.                   if(mi.dwTypeData[j] == '&'){
  338.                      outBuf[outBufUsed++] = mi.dwTypeData[j + 1];
  339.                      outBuf[outBufUsed] = '\0';
  340.                      break;
  341.                   }
  342.                }
  343.             }
  344.          }
  345.       }
  346.       #else
  347.       char menuString[200];
  348.       HMENU menu = GetMenu(frameWin);
  349.       int cnt = GetMenuItemCount(menu);
  350.       for (int i = 0; i < cnt; i++){
  351.          int choiceLen = GetMenuString(menu, i, menuString, 
  352.             sizeof(menuString), MF_BYPOSITION);
  353.          if(choiceLen){
  354.             for(int j = 0; j < choiceLen - 1; j++){
  355.                if(menuString[j] == '&'){
  356.                   outBuf[outBufUsed++] = menuString[j + 1];
  357.                   outBuf[outBufUsed] = '\0';
  358.                   break;
  359.                }
  360.             }
  361.          }
  362.       }
  363.       
  364.       #endif
  365.  
  366.       if(outBufUsed)
  367.          StringReturn = outBuf;
  368.    }
  369.    
  370.    return StringReturn.c_str();
  371. }  
  372.  
  373. int WINAPI
  374. DllEntryPoint( HINSTANCE hInst, DWORD fdwReason, LPVOID )
  375. {
  376.     if(fdwReason == DLL_PROCESS_ATTACH){
  377.       DisableThreadLibraryCalls(hInst);
  378.     }
  379.     return TRUE;
  380. }
  381.