C / C++ / MFC

Danny Nowlan wrote:

These techniques work like a charm on my projects that I programmed using Visual C++ v6.0.

TCHAR szAppData[MAX_PATH];
...
hr = SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, szAppData);
PathAppend(szAppData, "Company\Product\File.txt")

• CSIDL_APPDATA - Per user, roaming [user profile]\Application data
  
• CSIDL_LOCAL_APPDATA - Per user, non-roaming [user profile]\Local Settings\Application data
  
• CSIDL_COMMON_APPDATA - Hidden folder for normal users. Per machine (non-user specific & non- roaming) All Users\Application data
  
• CSIDL_COMMON_DOCUMENTS - Visible folder for normal users. Default files in this folder is readonly for other users than the creator, the application must change the security permissions on its application-folder to change this behavior. Per machine (non-user specific & non- roaming) All Users\Documents
  

Shaheen.India wrote:

'GetPathName()' returns just a single charecter. When i use '_MBCS' it returns full file path.

Shaheen.India wrote:

I want unicode standard with full file path when i open a file using "CFileDialog".

Shaheen.India wrote:

When i open a file, if it belongs like "e:\MyData\aa.txt", it returns just "e" as string

Shaheen.India wrote:

openFilePath = fileOpen.GetPathName();//Here is a break point. at this stage //value of openFilePath display like {"e"} only.

akshay1741 wrote:

any ideas or suggestions will help. like how do i go about creating sets of colours in c++ so when the user types in the text i can match the colour from his text to my set and send it up to the sql database?

akshay1741 wrote:

cleverly extract the key words

Covean wrote:

Have you control about the subprocess?
If so why not use named events?

HANDLE hEvent = CreateEvent(NULL, true, false, "some_silly_name_you_can_refer_to_in_your_processes");

#pragma once
#define WINVER 0x0501
#define _WIN32_WINNT 0x0501
#define _WIN32_WINDOWS 0x0410 
#define _WIN32_IE 0x0600
#define WIN32_LEAN_AND_MEAN

#include <windows.h>

////////////////////////////////////////////////////////////////////////////////////
// Konstanten //////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

TCHAR szEventName[]=TEXT("FDInteropDllFaceDetectionStatusChanged");
TCHAR szMapFileName[]=TEXT("FDInterOpDLLFaceDetectionMapFile");

////////////////////////////////////////////////////////////////////////////////////
// Strukturen //////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

// FaceDetectionStatus Hauptobjekt
typedef struct _fdsObject
{
     DWORD     dwTimeStamp;
     BOOL     bFaceDetected;
     INT          nX1;
     INT          nY1;
     INT          nX2;
     INT          nY2;
} FDS_OBJECT, *PFDS_OBJECT, NEAR *NPFDS_OBJECT, FAR *LPFDS_OBJECT;

////////////////////////////////////////////////////////////////////////////////////
// exportierte Funktionen //////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////

// Gibt das Handle auf das systemweite, benannte Event zurück, welches ausgelöst wird, wenn mit
// SetFaceDetectionStatus neue Daten an den "wartenden" Prozess geschickt werden.
HANDLE _declspec(dllexport) __stdcall GetFaceDetectionStatusChangedEventHandle();

// Gibt das Event, dass mit GetFaceDetectionStatusChangedEventHandle geöffnet wurde, wieder frei.
void _declspec(dllexport) __stdcall CloseFaceDetectionStatusChangedEventHandle(HANDLE hFaceDetectionStatusChangedEventHandle);

// Gibt eine Handle auf einen prozessübergreifenden gemeinsamen Speicherbereich zurück.
HANDLE _declspec(dllexport) __stdcall CreateFaceDetectionStatusMapFile();

// Dekrementiert den Zähler, der angibt wieviele Prozesse derzeit auf den prozessübergreifenden gemeinsamen Speicherbereich zugreifen.
// Wird der Zähler auf 0 dekrementiert, so wird auch der Speicherbereich freigegeben.
void _declspec(dllexport) __stdcall CloseFaceDetectionStatusMapFile(HANDLE hFaceDetectionStatusMapFile);

// Versucht die aktuellen Werte der Gesichtserkennung aus dem prozessübergreifenden gemeinsamen Speicherbereich auszulesen
// und kopiert bei Erfolg die Werte in den Buffer pFDSObject.
// Sollte hFaceDetectionStatusMapFile oder pFDSObject NULL sein gibt die Funktion auf jeden Fall FALSE zurück.
BOOL _declspec(dllexport) __stdcall GetCurrentFaceDetectionStatus(HANDLE hFaceDetectionStatusMapFile, LPFDS_OBJECT pFDSObject);

// Setzt den aktuellen Status der Gesichtserkennung.
// Wird für bFaceDetected der Wert 0 angegeben, so bedeutet dies, daß zur Zeit kein Gesicht erkannt wird, jeder andere Wert entspricht einem
// erkannten Gesicht.
// Die Werte X1, Y1, X2, Y2 stellen die Koordinaten des Rechtecks dar in dem die Gesichtserkennung vermutlich ein Gesicht erkannt hat.
void _declspec(dllexport) __stdcall SetFaceDetectionStatus(INT bFaceDetected, INT nX1, INT nY1, INT nX2, INT nY2);

#include "fdinterop.h"

/////////////////////////////////////////////////////////////////////////////////////
//// DLL Hauptfunktion //////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

BOOL __stdcall DllMain(HANDLE hModule, DWORD dwReasonForCall, LPVOID lpReserved)
{
     switch(dwReasonForCall)
     {
          case DLL_PROCESS_ATTACH:
          case DLL_THREAD_ATTACH:
          case DLL_THREAD_DETACH:
          case DLL_PROCESS_DETACH:
               break;
     }
     return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////////
//// GetFaceDetectionStatusChangedEventHandle ///////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

HANDLE __stdcall GetFaceDetectionStatusChangedEventHandle()
{
     return CreateEvent(NULL, TRUE, FALSE, szEventName);
}

/////////////////////////////////////////////////////////////////////////////////////
//// CloseFaceDetectionStatusChangedEventHandle /////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

void __stdcall CloseFaceDetectionStatusChangedEventHandle(HANDLE hFaceDetectionStatusChangedEventHandle)
{
     CloseHandle(hFaceDetectionStatusChangedEventHandle);
}

/////////////////////////////////////////////////////////////////////////////////////
//// CreateFaceDetectionStatusMapFile ///////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

HANDLE __stdcall CreateFaceDetectionStatusMapFile()
{
     return CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(FDS_OBJECT), szMapFileName);
}

/////////////////////////////////////////////////////////////////////////////////////
//// CloseFaceDetectionStatusMapFile ///////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

void __stdcall CloseFaceDetectionStatusMapFile(HANDLE hFaceDetectionStatusMapFile)
{
     CloseHandle(hFaceDetectionStatusMapFile);
}

/////////////////////////////////////////////////////////////////////////////////////
//// GetCurrentFaceDetectionStatus //////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

BOOL __stdcall GetCurrentFaceDetectionStatus(HANDLE hFaceDetectionStatusMapFile, LPFDS_OBJECT pFDSObject)
{     
     LPFDS_OBJECT pFDSBuffer = NULL;
     
     if((hFaceDetectionStatusMapFile == NULL) || (pFDSObject == NULL))
          return FALSE;

     pFDSBuffer = (LPFDS_OBJECT)MapViewOfFile(hFaceDetectionStatusMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(FDS_OBJECT));
     if(pFDSBuffer == NULL)
          return   FALSE;

     memcpy(pFDSObject, pFDSBuffer, sizeof(FDS_OBJECT));
     UnmapViewOfFile(pFDSBuffer);
     return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////////
//// SetFaceDetectionStatus /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

void __stdcall SetFaceDetectionStatus(INT bFaceDetected, INT nX1, INT nY1, INT nX2, INT nY2)
{
     FDS_OBJECT fdsObject;
     LPFDS_OBJECT pFDSObject;
     HANDLE hFaceDetectionStatusMapFile = NULL;
     HANDLE hFaceDetectionStatusChangedEvent = NULL;

     fdsObject.dwTimeStamp = GetTickCount();
     fdsObject.bFaceDetected = (bFaceDetected==0) ? FALSE : TRUE;
     fdsObject.nX1 = nX1;
     fdsObject.nY1 = nY1;
     fdsObject.nX2 = nX2;
     fdsObject.nY2 = nY2;

     // ToDo: Speicherzugriffe synchronisieren (bzw. muß man das mit diesen Funktionen hier überhaupt?)
     hFaceDetectionStatusMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, szMapFileName);
     if (hFaceDetectionStatusMapFile != NULL) 
     {
          pFDSObject = MapViewOfFile(hFaceDetectionStatusMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(FDS_OBJECT));                            
          if(pFDSObject != NULL)
          {
               memcpy(pFDSObject, &fdsObject, sizeof(FDS_OBJECT));
               UnmapViewOfFile(pFDSObject);
               CloseHandle(hFaceDetectionStatusMapFile);
          }
     }

     hFaceDetectionStatusChangedEvent = GetFaceDetectionStatusChangedEventHandle();
     SetEvent(hFaceDetectionStatusChangedEvent);
     CloseFaceDetectionStatusChangedEventHandle(hFaceDetectionStatusChangedEvent);
}