45 Day Series: CodeProject VC++ Forum Q&A - V

MFC

WINDOW32

GENERAL

FUNNY

Answer

MFC

    CStringA strFormat;
    // For Integer

    strFormat.Format("%d",10);
    // For Float

    strFormat.Format("%f",10.05);
   

    CStringW strFormat;
    // For Integer
    strFormat.Format(L"%d",10);
    // For Float

    strFormat.Format(L"%f",10.05);
    

 CFont *m_Font1 = new CFont();
CStatic *staticCtl =(CStatic *) GetDlgItem(IDC_STATIC1);
m_Font1->CreatePointFont(100,_T("Arial")); 
staticCtl->SetFont(m_Font1);

COleDateTime dt("9/24/2008");
CString dayNameLong = dt.Format("%A");
CString dayNameShort = dt.Format("%a"); 

Because MFC was designed that way. The one object wraps all the app instance info that Windows apps have only one of, like the HINSTANCE, and the commandline params passed. It also holds any other application-wide stuff of which there can only be one. That makes it a nice place to hide app-wide variables that in the old days would be global.

because it the base class for the application class. It is needless to have more than one application class for one application. The implementation has dependency on the global object obtained from AfxGetApp(), which is used by the AfxWinMain from winMain. Then it is similar to ask why only one main function for an application.

"The main application class in MFC encapsulates the initialization, running, and termination of an application for the Windows operating system. An application built on the framework must have one and only one object of a class derived from CWinApp." from msdn.

(m_pic.GetDC())->SetBkMode(TRANSPARANT);
(m_pic.GetDC())->TextOut(0,0,"hello");

    CTimeSpan sPan(0,0,0, 86400 );// 1 day 
   CTime CurTime = CTime::GetCurrentTime(); 
   CurTime +=sPan; 
   CString csTime = CurTime.Format(_T("%A, %B %d, %Y")); 
    
   AfxMessageBox(csTime );
    

WINDOW32

    TCHAR tcPath[MAX_PATH];
    GetEnvironmentVariable( _T("PUBLIC"), tcPath, MAX_PATH );

    extern "C" {
    __declspec(dllexport) int MyFunc ( int A ) { return(A*2); }
    }
    
    and in .def (in EXPORTS):
    MyFunc @3
    
    'DumpBin /exports mydll.lib' will report '_MyFunc' as the name.
    
    If, we used:
    extern "C" {
    __declspec(dllexport) int __stdcall MyFunc ( int A ) { return(A*2); }
    }
    

#include <windows.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "CodeBlocksWindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Code::Blocks Template Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}



// frees you from using the GDI function, which requires a region
void GradientFillRect(HDC hdc, LPRECT rcGradient, COLORREF start, COLORREF end, BOOL isVertical)
{
	BYTE startRed = GetRValue(start);
	BYTE startGreen = GetGValue(start);
	BYTE startBlue = GetBValue(start);

	BYTE endRed = GetRValue(end);
	BYTE endGreen = GetGValue(end);
	BYTE endBlue = GetBValue(end);

	HBRUSH endColor = CreateSolidBrush(end);
	FillRect(hdc, rcGradient, endColor);
	DeleteObject(endColor);

	//Gradient line width/height
	int dy = 1;

	int length = (isVertical ? rcGradient->bottom - rcGradient->top : rcGradient->right - rcGradient->left) - dy;

	for (int dn = 0; dn >= length; dn += dy)
	{
		BYTE currentRed = (BYTE)MulDiv(endRed-startRed, dn, length) + startRed;
		BYTE currentGreen = (BYTE)MulDiv(endGreen-startGreen, dn, length) + startGreen;
		BYTE currentBlue = (BYTE)MulDiv(endBlue-startBlue, dn, length) + startBlue;

		RECT currentRect = {0};
		if (isVertical)
		{
			currentRect.left = rcGradient->left;
			currentRect.top = rcGradient->top + dn;
			currentRect.right = currentRect.left + rcGradient->right - rcGradient->left;
			currentRect.bottom = currentRect.top + dy;
		}
		else
		{
			currentRect.left = rcGradient->left + dn;
			currentRect.top = rcGradient->top;
			currentRect.right = currentRect.left + dy;
			currentRect.bottom = currentRect.top + rcGradient->bottom - rcGradient->top;
		}

		HBRUSH currentColor = CreateSolidBrush(RGB(currentRed, currentGreen, currentBlue));
		FillRect(hdc, &currentRect, currentColor);
		DeleteObject(currentColor);
	}
}


/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT myRect;
    COLORREF startCol = RGB(71,71,71), endCol = RGB(200,200,200);

    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        case WM_ERASEBKGND:
            GetClientRect(hwnd, &myRect);
            GradientFillRect(HDC (wParam), &myRect, startCol, endCol, false);
            return 1;                           // indicate that WM_ERASEBKGND was handled

        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }
    return 0;
}

  CString CStr = ...; 
  LPTSTR pTCharStr = new  TCHAR[CStr.GetLength() + 1];
 
  _tcscpy_s(pTCharStr, CStr.GetLength() + 1, CStr); 

     #include <string>... 
     CString CStr = ...;
     #if defined(_UNICODE) 
            wstring stdstr = CStr;
      #else 
            string stdstr = CStr;
      #endif 
    

HKEY hKey = NULL; 
string MyChoiceVariable; 
if (ERROR_SUCCESS != RegOpenKeyEx(
    HKEY_LOCAL_MACHINE, 
    "SOFTWARE\\..", 
    0,
    KEY_QUERY_VALUE,
    &hKey ))
 { 
  MyChoiceVariable = "KEY DOES NOT EXIST"; 
  
  cout << MyChoiceVariable << endl; 
 } 
 
 if (ERROR_SUCCESS == RegOpenKeyEx( 
    HKEY_LOCAL_MACHINE, 
    "SOFTWARE\\..", 
    0,
    KEY_QUERY_VALUE,
    &hKey ))
    { 
      MyChoiceVariable = "KEY EXISTS"; 
      cout << MyChoiceVariable << endl;
    } 
    

Use GetScrollInfo, add amount scrolled(lpsi->nPos) to retrieved client co-ordinates. Hope this helps!

The scroll window has no actual relationship to window it is attached to. Take notepad for example. Every time you click on the up arrow on the scroll bar, the text moves by one line of text. So the amount of pixels will vary depending on the font size. Which won;t really be available to some external program. When a program uses scroll bars, and is asked to paint a window, it gets the scroll pos, and interprets that however it likes. And how they do it will be app dependent...

To exploit the rundll32.exe your exported function must follow some rules, for instance the prototype must be like the following :-

CALLBACK MsgBoxW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow); then a working sample (at least, on XP it works...) will be

void CALLBACK MsgBoxW(HWND hwnd, HINSTANCE hinst, LPWSTR lpszCmdLine, int nCmdShow)
{ 
    MessageBox(hwnd, lpszCmdLine, L"MyMessageBox", MB_OK);
}

GetSystemDefaultLangID() returns the system locale. This is used to determine which code page is used for non-Unicode (aka "ANSI") text on a system. It can be changed (on XP) from the advanced tab on the "regional and language options" in Control Panel (probably needs to be rebooted before the change takes effect) GetUserDefaultUILanguage() returns the current UI language which can be set by a user if MUI pack is installed.

 Try GetProcessMemoryInfo()

GENERAL

• http://www.codeproject.com/KB/COM/jscalls.aspx[^]
• http://www.digitalmars.com/d/archives/digitalmars/DMDScript/169.html[^]
• http://www.google.com/search?num=30&hl=en&safe=off&q=call+js+%28function+OR+method%29+from+C%2B%2B&btnG=Search[^]

1. Add the InitCommonControls() call at the very beggining of your program.
2. On the stdafx.h file, add this line: #include "commctrl.h" On the properties of your project:
3. On Linker/Manifest File make sure the generate manifest entry is set to "Yes"
4. On Linker/Command Line add "comctl32.lib" (without the cuotes).
5. On Manifest Tool/Input and Output, set the "Aditional Manifest File" to $(IntDir)\XPCommonControls.manifest

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestversion="1.0">
     <dependency>
          <dependentassembly>
               <assemblyidentity>
                    type="win32"
                    name="Microsoft.Windows.Common-Controls"
                    version="6.0.0.0"
                    processorArchitecture="X86"
                    publicKeyToken="6595b64144ccf1df"
                    language="*"/>

    FILE * fpin = fopen("MyBinaryFile.foo","rb");
    FILE * fpout = fopen("MytextFile.txt","w");
    int c;
    int count = 0;
    while ( (c=getc(fpin)) != EOF )
    {
     fprintf(fpout, "%02x ", c);
      if (count % 16 == 15) fprintf(fpout, "\n"); 
      
     count++;
    }
    
    fclose(fpin);
    fclose(fpout);
    

1. choose a place to store a date (registry, a file, etc)
2. when the app starts, check that place for the date
3. if you don't find a date, store the current date there
4. if you do find a date, subtract the current date from the stored date.
5. compare the difference to your time limit. there's a huge obvious vulnerability in schemes like this (find the date and erase it to reset the trial). but, they do work.

Pls tell me how this program works... I set a pointer to class to Zero, but still I can access an instance member as far as I don't access any instance variable.

       #include "stdafx.h" 
       #include <stdio.h>
       
       class A 
       { 
       public: 
        int i; 
        void PrintMe(); 
       };
        void A::PrintMe() 
        {
         printf("Hello World\n");
        } 
        
        void main() 
        { 
            A* p = 0; 
            p->PrintMe(); 
        }
    

The A::PrintMe function doesn't access class members and isn't virtual so the this pointer isn't used. This is perfectly legal.

Calling a method on p doesn't actually dereference p, it just sets this to the value of p. If PrintMe() dereferenced this, for example accessing non-static data members, then the code would crash.

__declspec(dllexport) int g_iYourVariable;

__declspec(dllimport) int g_iYourVariable;

     char cArr[] = { '1', '2', '\0', '3', '\0', '4', 
    '5', '\0' }; 
    
    BSTR MyBstr = ::SysAllocStringByteLen(cArr, sizeof(cArr));
    _bstr_t  bstrSend(MyBstr, true);
    

1. Get the value of project name from the project property if you are using VS2005, vsproperty->c/c++->preprocessor->preprocessor definitions: PROJECT_NAME=$(ProjectName)
2. Now use the PROJECT_NAME Macro from above in your code,

        #define STRINGIZE(_x) #_x
        #define STRINGIZEVALUE(_x) STRINGIZE(_x)
        
        char projectName[]= STRINGIZEVALUE(PROJECT_NAME);
       

// IsOnStack.cpp : Defines the entry point for the console application.//

        #include "stdafx.h"
        #include <iostream>
        #include <windows.h>
        using namespace std; 
        
        bool IsOnStack(const void *pData)
        { 
            DWORD StackBase; 
            DWORD StackLimit; 
            __asm { 
                    MOV EAX, DWORD PTR FS:[0x04] 
                    MOV StackBase, EAX 
                    MOV EAX, DWORD PTR FS:[0x08] 
                    MOV StackLimit, EAX 
                   } 
            
            DWORD Address = reinterpret_cast<DWORD>(pData); 
            return   (Address >= StackLimit) && (Address < StackBase);
        } 
        
        const char* PrintStack(const void *pData)
        { 
            return IsOnStack(pData) ? ": Stack" : ": Not on Stack";
        } 
        
        int main(int argc, char* argv[])
        { 
             const char *pString1 = "String1"; 
             cout << pString1<< 
             
             PrintStack(pString1) << endl; 
             char String2[] = "String2"; 
             cout << String2 << 
             PrintStack(String2) << endl; 
             return 0;
         }
        

Output is:
String1: Not on Stack
String2: Stack

The phrase 'NFS mount' implies a device driver. It is generally not recommended to develop Microsoft Windows device drivers in C++ however it can be done. Microsoft supplies the IFS Kit[ http://www.microsoft.com/whdc/DevTools/IFSKit/default.mspx[^]] for developing file systems and file system filters.

If you however simply want to use something already available (or have some common sense) then perhaps you can use Microsoft Windows Services for UNIX[ http://technet.microsoft.com/en-us/interopmigration/bb380242.aspx[^]] This link will give you a head-start.
http://www.openfree.org/pet/index.php/Mount_an_NFS_share_from_Windows[^]

#pragma once directive specifies that the file will be included only once by the compiler when compiling a source code file. This can reduce build times as the compiler will not open and read the file after the first #include of the module.

Application can use different proxy settings for InternetOpen instance

    (HINTERNET) using InternetSetOption. [ BOOL InternetSetOption( __in HINTERNET 
    hInternet, __in DWORD dwOption, __in LPVOID lpBuffer, __in DWORD dwBufferLength 
    ); ^]
    

• http://gaskell.org/the-requested-operation-requires-elevation-in-windows-vista/[^]
• http://windowshelp.microsoft.com/windows/en-us/help/f941cb45-b2cd-4b39-ab87-cb9ea959f44e1033.mspx[^]

FUNNY

1. the message box when your application is still running.
2. Press down the Print Screen key on the keyboard.
3. Close your application.
4. Open MS Paint.
5. Paste the image ( CTRL + V ).
6. Enjoy you Message Box

On lighter side About Polymorphism :-

Teacher object calls the LearnPolymorphism() method on two instances of Pupil. The first one one,
say cleverPupil, that is really an instance of CleverPupil, calls readBook(goodOOPBook) to fulfill task.
On the other hand, the second Pupil instance, say lazyPupil, instance of LazyPupil, implements the method
in his own way, with a call to startAsking(hereAndThere)...

Both CleverPupil and LazyPupil inherit from Pupil hence Teacher is able to call virtual Pupil method
LearnPolymorphism() on them. But, due to Polymorphism, Teacher obtains two quite distinct results from them.

• Rajesh R Subramanian
• Roger Stoltz
• cmk
• CPallini
• Michael Schubert
• PJ Arends
• ThatsAlok
• DavidCrow
• Naveen
• Michael Dunn
• cofi++
• Moak
• Mike O'Neill
• SandipG
• Mark Salsbery
•  Alain Rist
• J_E_D_I
• Maxwell Chen
• Iain Clarke
• Nibu babu thomas
• Rajkumar R
• Stephen Hewitt
• led mike