* phpage is an array which contains nPages pieces of _PROPSHEETPAGEW

0:012> dt comctl32!_PROPSHEETPAGEW
   +0x000 dwSize           : Uint4B
   +0x004 dwFlags          : Uint4B
   +0x008 hInstance        : Ptr32 HINSTANCE__   <<<<< base address of module
   +0x00c pszTemplate      : Ptr32 Uint2B   <<<<< resource Id
   +0x00c pResource        : Ptr32 DLGTEMPLATE   <<<<< resource Id - kernel32!FindResourceW
   +0x010 hIcon            : Ptr32 HICON__
   +0x010 pszIcon          : Ptr32 Uint2B
   +0x014 pszTitle         : Ptr32 Uint2B
   +0x018 pfnDlgProc       : Ptr32   
   +0x01c lParam           : Int4B
   +0x020 pfnCallback      : Ptr32   
   +0x024 pcRefParent      : Ptr32 Uint4B
   +0x028 pszHeaderTitle   : Ptr32 Uint2B
   +0x02c pszHeaderSubTitle : Ptr32 Uint2B
   +0x030 hActCtx          : Ptr32 Void

https://msdn2.microsoft.com/en-us/library/aa815151.aspx
 

Thank you for giving me these wonderful days darling.

Celebrate for two years from wedding in Zhengzhou, Celebrate for my 24th birthday, Celebrate for first time to know Tiffany, Celebrate for have a new target in the following years :)
 

If we forget to release it by calling free, delete, sysfreestring, we experiences the memory leak.

There are several ways to avoid the leaking.

1. Use MS built-in detection API

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF )

2. Mark the memory

#define HEAPLEAK(k) k = 0xCACF0000 + __LINE__ // CACF: check allocated check free + line number

3. Hook into the allocate and free functions

_CrtSetAllocHook(pfnHook)

hook to: calloc, malloc, realloc, free, memcpy, strcpy ...

4. Hook from the system level - what NuMega have done before...

However, I done it :)

1. It builds a table strlen(s1)*strlen(s2)
2. Compare the s1 and s2 and fill the equaled bit in the table
3. Find out the longest connected lines in that table
4. Re-build the string with the line's offset

Not sure if it is the best algorithm to do that :)

However it only spend 47ms to compare and find out the duplicate string ("pro") of "programming" and "professional" in 10000 times.

"abbazyabcyzabcegz" and ""xabcyzabcdegabbazyabh" for 10,000 times
Milliseconds: 109 

Cool? 

//////

StrNode* GetDupStr(__notnull LPCWSTR lpszP1, __notnull LPCWSTR lpszP2)
{
    // 0. valid parameters, if SAL does not work
    if (lpszP1==NULL || lpszP2==NULL || wcslen(lpszP1)==0 || wcslen(lpszP2)==0)
        return NULL;
    //
    // 1. build the table
    //
    // calculate the size
    int nLen1 = (int)wcslen(lpszP1);
    int nLen2 = (int)wcslen(lpszP2);
    int nMapLen = sizeof(bool)*nLen1*nLen2;
    // allocate the memory @allocate abMap
    bool* abMap;
    abMap = (bool*)malloc(nMapLen);
    //ZeroMemory
    memset(abMap, 0x0, nMapLen);

    //
    // 2. compare and fill the table
    //
    for(int i=0; i<nLen1; i++)
    //rows
    {
        WCHAR cRow = lpszP1[i];
        //check if there is duplicated char in previous chars, if so, memcpy directly
        for(int k=0; k<i; k++)
        {
            if (lpszP1[k]==cRow)
            {
                memcpy(&abMap[i*nLen2], &abMap[k*nLen2], nLen2);
                DEBUG("Dup: %c\n", cRow);
            }
        }
        //loop cols
        for(int j=0; j<nLen2; j++)
        //cols
        {
            //check equality
            if (cRow==lpszP2[j])
            {
                //MarkEqual(abMap, CalPos(nLen2, i, j));
                MarkBit(abMap, CalcBitPos(nLen2, i, j));
            }
        }
    }

    //
    // 3. print out the table
    //
#ifdef _DUPSTR_DEBUG_
    PrintTable(abMap, lpszP1, lpszP2);
    DEBUG("\n", NULL);
#endif

    //
    // 4. search table, find out the connected points
    //
    // get minimun strlen of two strings
    int nMinLen = nLen1 < nLen2 ? nLen1 : nLen2;
    // build maxNode var @allocate pMaxNode
    BNode *pMaxNode = NULL;
    //
    // loop the cols and rows from longest to shortest, and compare the maxlength with current nLen
    // jump out if maxLen > nLen
    //
    //loop for cols
    for(int i=0; i<nLen2; i++)
    {
        //current len
        int nLen = nMinLen < nLen2-i ? nMinLen : nLen2-i;
        if ( pMaxNode==NULL || pMaxNode->len<nLen)
        {
            //get pNodes
            BNode *pNode = CheckPoints(&abMap[CalcBitPos(nLen2, 0, i)], nLen, nLen2+1);
            //rebuild
            RebuildMaxNodes(&pMaxNode, &pNode);
        }
    }
    //then loop for rows
    for(int i=1; i<nLen1; i++)
    {
        int nLen = nMinLen < nLen1-i ? nMinLen : nLen1-i;
        if ( pMaxNode==NULL || pMaxNode->len<nLen)
        {
            BNode *pNode = CheckPoints(&abMap[CalcBitPos(nLen2, i, 0)], nLen, nLen2+1);
            /* @refactor RebuildMaxNodes
            if (pNode!=NULL)
            {
                if (pMaxNode==NULL)
                {
                    DEBUG("leave null\n", NULL);
                    pMaxNode = pNode;
                }
                else if (pMaxNode->len < pNode->len)
                {
                    DEBUG("got new length: %d\n", pNode->len);
                    //free previous pMaxNode
                    ReleaseNode(pMaxNode);
                    pMaxNode = pNode;
                }
                else if (pMaxNode->len == pNode->len)
                {
                    DEBUG("get duplicated\n", NULL);
                    pMaxNode->next = pNode;
                }
                else
                {
                    ReleaseNode(pNode);
                }
            }
            */
            RebuildMaxNodes(&pMaxNode, &pNode);
        }
    }

    //
    // 5. print out pMaxNodes
    //
    StrNode* pstrNode = NULL;
    //
    BNode* pn = pMaxNode;
    //foreach pMaxNode
    while(pn!=NULL)
    {
        //calculate the string offset
        int nStrOffset = (int)((pn->pbStart - abMap) % nLen2);
        //allocate new string @allocate lpszOutput
        LPWSTR lpszOutput = new WCHAR[pn->len+1];
        memset(lpszOutput, 0x0, (pn->len+1)*sizeof(WCHAR));
        memcpy(lpszOutput, lpszP2+nStrOffset, pn->len * sizeof(WCHAR));

        DEBUG("%x => ", pn->pbStart);
        DEBUG("%d => ", pn->len);
        DEBUG("%s\n", lpszOutput);
        //DEBUG("%x => %d => %s\n", pn->pbStart, pn->len, lpszOutput);

        //attach string to return structure
        if (pstrNode==NULL)
        {
            //build the node
            pstrNode = BuildStrNode(lpszP2+nStrOffset, pn->len, lpszOutput);
            HEAPLEAK(pstrNode->magic, 0xCACF0169);
        }
        else
        {
            //build the node
            /* @refactor BuildStrNode
            StrNode* psn = new StrNode;
            memset(psn, 0x0, sizeof(StrNode));
            psn->lpSrc = lpszP2+nStrOffset;
            psn->len = pn->len;
            psn->str = lpszOutput;
            psn->next = NULL;
            pstrNode->next = psn;
            */
            StrNode* psn = pstrNode;
            while(psn->next!=NULL)
            {
                psn = psn->next;
            }
            psn->next = BuildStrNode(lpszP2+nStrOffset, pn->len, lpszOutput);
            HEAPLEAK(psn->next->magic, 0xCACF0189);
        }

        pn = pn->next;
    }
    //@release pMaxNode
    ReleaseBNode(pMaxNode);
    //@release abMap
    delete abMap;

    return pstrNode;
}

Attached full code files.
 

MaxDuplicatedString.7z

1. ASPX vs JSP
2. Code Behind C# vs Servlet
3. Web Controls vs TagLib
4. Master/Content Page vs Tiles
5. Validation vs Validation in Java
6. ViewState vs FormBean
7. ASP.NET vs Struts

I was frustrated why my company published this Struts-like framework at the very beginning, but after a while, I know the reason:

1. ASP is too old and may worse than PHP
2. ASP.NET intend to bring a new easy-to-use platform to developer and reduce the coding tasks for developers. That's the major target of this framework.
3. ASP.NET is a framework, such as Struts, Spring, Velocity, but not a platform, C# is the platform

So, we should compare the C# enterprise platform and J2EE platform, make sense?

Will do that later.

Why TDD? First we need to know why Unit Test.

Unit Test intend to bring us a assumption and we need and only need to implement all the functionalities which defined in the Test. And the test will cover all kinds of possible calls from outside caller. The Test treats the function as a black-box and just make the guess to call it.

It is a very good and accurate technology to test the robust of the code and reduce the bug. But we are human being, once we developed the function, it is more easier for us to write the "Success assumption" Test instead of "Failure assumption" one.

TDD is the best practice to force us develop the functions from perspective of Tester and function caller. It will prevent to develop the functions that never ever will be called. Also it could avoid to waste our time to develop the never been called functions and codes.

Recommend book: Test Driven Development - Example - Kent Beck.

Here is the best example from that book to explain what is TDD:

1. Write the Test

AssertEquals( functionName(1,2), 3);

2. Develop the function

function functionName(int a, int b)
{
return a + b;
}

3. Enhance the Test

AssertEquals( functionName(-1, -2), 3);

4. Enhance the function

function functionName(int a, int b)
{
return Math.abs(a + b);
}

5. Repeat steps 3,4 until all the features of this function satisfied you :)

Best Practice
=================================
1. Write the Test, then write the code
2. Assume Fails, not success - the way of thinking
3. Code should satisfy your Unit Test, not yourself
4. Do not forget good code standard and comments, XP is extreme programming, term extreme forces on the methodology, programming forces on the standards
5. Do not conflict with the Design, if something wrong, review your design and think about that
6. Pay attention to your Test code, refactor it if necessary.
7. Refactor the code after all functions have been implemented

 

I am thinking of the general framework of the period of my software development. Here is my conclusion:

1. Software Design - UML - To design the class and functions
2. Design Inspection - Team Review
3. Unit Test - TDD
4. Implement the functionality - Pairs programming if possible
5. Go back 3, until FULL green
6. Code Inspection - Peer Review, Team Review

I will try to find some best practices and summarize it of each phrase. 

How to enumerate the windows
===============================
    HWND hClarifyWnd;
    EnumWindows(EnumClarifyProc, (LPARAM)&hClarifyWnd);

BOOL CALLBACK EnumClarifyProc(HWND hWnd, LPARAM lParam)
{
    if( IsWindowVisible(hWnd) ) {
        HWND* phCwnd = (HWND*)lParam;
        int nLen = GetWindowTextLength(hWnd);
        LPSTR lpszTitle = new CHAR[nLen + 1];
        GetWindowText(hWnd, lpszTitle, nLen+1);
        if(strstr(lpszTitle, CLARIFY_TITLE)){
            //assign window handle
            *phCwnd = hWnd;
            delete lpszTitle;
            return TRUE;
        }
        delete lpszTitle;
    }
    return TRUE;
}

How to control the controls in another window/process
====================================
bool SendMessageWrapper(HWND hWnd, HANDLE hProcess, HTREEITEM hItem, int TVM_FLAG, TV_ITEM *tvItemParam, char* item)
{
    TV_ITEM tvItm,*tvItem;
    if (tvItemParam!=NULL)
        tvItem = tvItemParam;
    else
        tvItem = &tvItm;

    TV_ITEM *ptvItem;
    ptvItem = (TV_ITEM*) VirtualAllocEx(hProcess, NULL, sizeof(TV_ITEM), MEM_COMMIT, PAGE_READWRITE);

    char *pItem;
    pItem = (char*) VirtualAllocEx(hProcess, NULL, MAX_CHAR_LEN, MEM_COMMIT, PAGE_READWRITE);

    if (ptvItem==NULL || pItem==NULL)
        return false;

    (*tvItem).hItem = hItem;
    (*tvItem).mask = TVIF_TEXT | TVIF_CHILDREN;
    (*tvItem).pszText = pItem;
    (*tvItem).cchTextMax = MAX_CHAR_LEN;

    WriteProcessMemory(hProcess, ptvItem, tvItem, sizeof(TVITEMEX), NULL);

    SendMessage(hWnd, TVM_FLAG, 0, (LPARAM)ptvItem);

    ReadProcessMemory(hProcess, pItem, item, MAX_CHAR_LEN, NULL);
    ReadProcessMemory(hProcess, ptvItem, tvItem, sizeof(TVITEMEX), NULL);

    // free
    VirtualFreeEx(hProcess, ptvItem, 0, MEM_RELEASE);
    VirtualFreeEx(hProcess, pItem, 0, MEM_RELEASE);

    return true;
}
 

ClarifyHelperMsg.cpp

<><><>

J2EE: very complex platform, you can do anything you want to do on this platform, it contains so many great ideas and concept, and the performance is quite amazing in the server side. but lots of people have the misunderstanding and intend to use other platforms... it is not very popular even though it should be.
====================================
JSP: one good way to separate the Page and Logical, and it will be converted to Servlet (java code) at the runtime. Good concept. (asp)
TagLib: great thing, it is a way to separate the Page and Logical in JSP. (asp.net/web controls)
Servlet: Historic things. Good controller. provided Filter mechanism, it is a extreme good concept and it influences all the web-app frameworks.
JDO: Very cool concept, and with several nice implementation, such as Kodo JDO, OpenAccess JDO, Apache JDO...
Hibernate: good concept and implementation which was inherited from JDO but become more and more stronger and popular in Open Source community recently.
EJB2: Good concept but too complicated implementation and bad performance.
EJB3: Steal several good points from JDO, good implementation.
... others ...

Although I am not a J2EE specialist as I work for Microsoft, but I really love this tech :)

ASP.NET: good platform, but sometimes it does not do the simple things in the simple way, and there is just few good practice in the Internet and lots of newbies use this tech, so... the live ASP.NET applications always contain strange issues. low performance, not security... actually it is not the truth.
====================================
Page Events: good concept, but a little bit complex... maybe MS intend to migrate the win32 developer to .net platform and web-based app environment more smoothly, but it is really different as the win32 platform, the network latency and server performance is the big problem of ASP.NET applications if there are too many Page Events.
View State: good idea to generate and maintain it automatically. Actually it could be saved in server-side :)
Lots of web controls: good implementation, concept is inherited from J2EE Taglib.
ADO.NET: old wine in new bottle.
Data Binding: Good concept and inherits from win32 age.

It is a easy to use platform for developer. 

 
AJAX + Server-side App: GWT from Google, YUI from Yahoo, they all intend to build a big client-side AJAX platform to reduce the dependency of server and client platform. That is a good idea and right way, but it will effect to all the platform provider... so, from the marketing perspective, not sure how many developers will follow this alliance.
=====================================
JavaScript to build the rich client:
Web Service (SOAP call) or JSON call for communication:
Server-side application:

it is a good idea but need the good framework to support it.

 
PHP & Mod_Perl: my lovely Perl, my cute PHP, time is fast... who knows what will happen to them...