seamlessrdp/ClientDLL/clipper.cpp

//
// Copyright (C) 2004-2005 Martin Wickett
//

#define TSDLL

#include "clipper.h"

BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
    UNREFERENCED_PARAMETER( lpvReserved );
    UNREFERENCED_PARAMETER( hinstDLL );
    
    switch ( fdwReason ) {
        case DLL_PROCESS_ATTACH:
        break;
        
        case DLL_THREAD_ATTACH:
        break;
        
        case DLL_THREAD_DETACH:
        break;
        
        case DLL_PROCESS_DETACH:
        break;
        
        default:
        break;
    }
    return TRUE;
}

void WINAPI VirtualChannelOpenEvent( DWORD openHandle, UINT event,
                                     LPVOID pdata, UINT32 dataLength,
                                     UINT32 totalLength, UINT32 dataFlags )
{
    LPDWORD pdwControlCode = ( LPDWORD ) pdata;
    CHAR ourData[ 1600 ];
    UINT ui = 0;
    
    UNREFERENCED_PARAMETER( openHandle );
    UNREFERENCED_PARAMETER( dataFlags );
    
    ZeroMemory( ourData, sizeof( ourData ) );
    
    //copy the send string (with the same lenth of the data)
    strncpy( ourData, ( LPSTR ) pdata, dataLength / sizeof( char ) );
    
    if ( OUTPUT_DEBUG_INFO == 1 ) {
        OutputDebugString
        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Virtual channel data received" );
        OutputDebugString( ourData );
    }
    
    if ( dataLength == totalLength ) {
        switch ( event ) {
            case CHANNEL_EVENT_DATA_RECEIVED: {
                CTokenizer tok( _T( ( LPSTR ) ourData ), _T( ";" ) );
                CStdString cs;
                
                CWindowData *wid = new CWindowData( "" );
                CStdString messageType;
                int mixMaxType = 0;
                
                while ( tok.Next( cs ) ) {
                    CStdString msg;
                    CTokenizer msgTok( cs, _T( "=" ) );
                    
                    msgTok.Next( msg );
                    
                    if ( strcmp( msg, "MSG" ) == 0 ) {
                        msgTok.Next( msg );
                        messageType = msg;
                    }
                    
                    if ( strcmp( msg, "ID" ) == 0 ) {
                        msgTok.Next( msg );
                        wid->SetId( msg );
                    } else if ( strcmp( msg, "TITLE" ) == 0 ) {
                        msgTok.Next( msg );
                        wid->SetTitle( msg );
                    } else if ( strcmp( msg, "POS" ) == 0 ) {
                        msgTok.Next( msg );
                        
                        CStdString pos;
                        CTokenizer posTok( msg, _T( "~" ) );
                        
                        posTok.Next( pos );
                        
                        
                        // check bounds, coords can be negative if window top left point is moved off the screen.
                        // we don't care about that since the window can't be see so just use zero.
                        
                        if ( strchr( pos, '-' ) == NULL ) {
                            wid->SetX1( atoi( pos ) );
                        } else {
                            wid->SetX1( 0 );
                        }
                        
                        posTok.Next( pos );
                        
                        if ( strchr( pos, '-' ) == NULL ) {
                            wid->SetY1( atoi( pos ) );
                        } else {
                            wid->SetY1( 0 );
                        }
                        
                        posTok.Next( pos );
                        
                        if ( strchr( pos, '-' ) == NULL ) {
                            wid->SetX2( atoi( pos ) );
                        } else {
                            wid->SetX2( 0 );
                        }
                        
                        posTok.Next( pos );
                        
                        if ( strchr( pos, '-' ) == NULL ) {
                            wid->SetY2( atoi( pos ) );
                        } else {
                            wid->SetY2( 0 );
                        }
                    } else if ( strcmp( msg, "TYPE" ) == 0 ) {
                        msgTok.Next( msg );
                        mixMaxType = atoi( msg );
                    }
                }
                
                if ( strcmp( messageType, "HSHELL_WINDOWCREATED" ) == 0 ) {
                    if ( OUTPUT_DEBUG_INFO == 1 ) {
                        OutputDebugString
                        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HSHELL_WINDOWCREATED window title is:" );
                        OutputDebugString( wid->GetTitle() );
                    }
                    
                    CStdString s = wid->GetId();
                    char *ptr;
                    int length = s.GetLength();
                    ptr = s.GetBufferSetLength( length );
                    
                    hash_insert( ptr, wid, &m_ht );
                    
                    CreateAndShowWindow( wid );
                    
                    DoClipping( 1 );
                } else if ( strcmp( messageType, "HSHELL_WINDOWDESTROYED" ) == 0 ) {
                    if ( OUTPUT_DEBUG_INFO == 1 ) {
                        OutputDebugString
                        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HSHELL_WINDOWDISTROYED window title is:" );
                        OutputDebugString( wid->GetTitle() );
                    }
                    
                    CStdString s = wid->GetId();
                    char *ptr;
                    int length = s.GetLength();
                    ptr = s.GetBufferSetLength( length );
                    
                    CWindowData *oldWinData =
                        ( CWindowData * ) hash_del( ptr, &m_ht );
                        
                    DestroyTaskbarWindow( oldWinData );
                    
                    delete oldWinData;
                    
                    DoClipping( 1 );
                } else if ( strcmp( messageType, "HCBT_MINMAX" ) == 0 ) {
                    if ( OUTPUT_DEBUG_INFO == 1 ) {
                        OutputDebugString
                        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HCBT_MINMAX" );
                    }
                    
                    
                    //TODO
                    
                } else if ( strcmp( messageType, "HCBT_MOVESIZE" ) == 0 ) {
                    if ( OUTPUT_DEBUG_INFO == 1 ) {
                        OutputDebugString
                        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HCBT_MOVESIZE window title is:" );
                        OutputDebugString( wid->GetTitle() );
                    }
                    
                    CStdString s = wid->GetId();
                    char *ptr;
                    int length = s.GetLength();
                    ptr = s.GetBufferSetLength( length );
                    
                    CWindowData *movedWinData =
                        ( CWindowData * ) hash_lookup( ptr, &m_ht );
                        
                    if ( movedWinData != NULL ) {
                        movedWinData->SetX1( wid->GetX1() );
                        movedWinData->SetX2( wid->GetX2() );
                        movedWinData->SetY1( wid->GetY1() );
                        movedWinData->SetY2( wid->GetY2() );
                        
                        DoClipping( 1 );
                    }
                    
                    delete wid;
                } else if ( strcmp( messageType, "CALLWNDPROC_WM_MOVING" ) == 0 ) {
                    if ( OUTPUT_DEBUG_INFO == 1 ) {
                        OutputDebugString
                        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type CALLWNDPROC_WM_MOVING window title is:" );
                        OutputDebugString( wid->GetTitle() );
                    }
                    
                    CStdString s = wid->GetId();
                    char *ptr;
                    int length = s.GetLength();
                    ptr = s.GetBufferSetLength( length );
                    
                    CWindowData *movedWinData =
                        ( CWindowData * ) hash_lookup( ptr, &m_ht );
                        
                    if ( movedWinData != NULL ) {
                        movedWinData->SetX1( wid->GetX1() );
                        movedWinData->SetX2( wid->GetX2() );
                        movedWinData->SetY1( wid->GetY1() );
                        movedWinData->SetY2( wid->GetY2() );
                        
                        ////might be too much of an overhead forcing the redraw here. Might be better to do 'DoClipping(0)' instead?
                        DoClipping( 1 );
                    }
                    
                    delete wid;
                }
            }
            break;
            
            case CHANNEL_EVENT_WRITE_COMPLETE: {}
            break;
            
            case CHANNEL_EVENT_WRITE_CANCELLED: {}
            break;
            
            default: {}
            break;
        }
    } else {}
}


VOID VCAPITYPE VirtualChannelInitEventProc( LPVOID pInitHandle, UINT event,
        LPVOID pData, UINT dataLength )
{
    UINT ui;
    
    UNREFERENCED_PARAMETER( pInitHandle );
    UNREFERENCED_PARAMETER( dataLength );
    
    switch ( event ) {
        case CHANNEL_EVENT_INITIALIZED: {}
        break;
        
        case CHANNEL_EVENT_CONNECTED: {
            //
            // open channel
            //
            ui = gpEntryPoints->pVirtualChannelOpen( gphChannel,
                    &gdwOpenChannel,
                    CHANNELNAME,
                    ( PCHANNEL_OPEN_EVENT_FN )
                    VirtualChannelOpenEvent );
                    
            if ( ui == CHANNEL_RC_OK ) {}
            else {
                MessageBox( NULL, TEXT( "Open of RDP virtual channel failed" ),
                            TEXT( "TS Window Clipper" ), MB_OK );
            }
            
            if ( ui != CHANNEL_RC_OK ) {
                return ;
            }
        }
        break;
        
        case CHANNEL_EVENT_V1_CONNECTED: {
            MessageBox( NULL,
                        TEXT
                        ( "Connecting to a non Windows 2000 Terminal Server" ),
                        TEXT( "TS Window Clipper" ), MB_OK );
        }
        break;
        
        case CHANNEL_EVENT_DISCONNECTED: {}
        break;
        
        case CHANNEL_EVENT_TERMINATED: {
            //
            // free the entry points table
            //
            LocalFree( ( HLOCAL ) gpEntryPoints );
        }
        break;
        
        default: {}
        break;
    }
}

BOOL VCAPITYPE VirtualChannelEntry( PCHANNEL_ENTRY_POINTS pEntryPoints )
{
    CHANNEL_DEF cd;
    UINT uRet;
    
    size_t s = 10;
    hash_construct_table( &m_ht, s );
    
    //
    // allocate memory
    //
    gpEntryPoints =
        ( PCHANNEL_ENTRY_POINTS ) LocalAlloc( LPTR, pEntryPoints->cbSize );
        
    memcpy( gpEntryPoints, pEntryPoints, pEntryPoints->cbSize );
    
    //
    // initialize CHANNEL_DEF structure
    //
    ZeroMemory( &cd, sizeof( CHANNEL_DEF ) );
    strcpy( cd.name, CHANNELNAME );       // ANSI ONLY
    
    //
    // register channel
    //
    uRet =
        gpEntryPoints->pVirtualChannelInit( ( LPVOID * ) & gphChannel,
                                            ( PCHANNEL_DEF ) & cd, 1,
                                            VIRTUAL_CHANNEL_VERSION_WIN2000,
                                            ( PCHANNEL_INIT_EVENT_FN )
                                            VirtualChannelInitEventProc );
                                            
    if ( uRet == CHANNEL_RC_OK ) {
        if ( ALWAYS__CLIP ) {
            DoClipping( 1 );
        }
    } else {
        MessageBox( NULL, TEXT( "RDP Virtual channel Init Failed" ),
                    TEXT( "TS Window Clipper" ), MB_OK );
    }
    
    if ( uRet != CHANNEL_RC_OK ) {
        return FALSE;
    }
    
    //
    // make sure channel was initialized
    //
    if ( cd.options != CHANNEL_OPTION_INITIALIZED ) {
        return FALSE;
    }
    
    return TRUE;
}


// data structure to transfer informations
typedef struct _WindowFromProcessOrThreadID
{
    union
    {
        DWORD procId;
        DWORD threadId;
    };
    HWND hWnd;
}
Wnd4PTID;

// Callback procedure
BOOL CALLBACK PrivateEnumWindowsProc( HWND hwnd, LPARAM lParam )
{
    DWORD procId;
    DWORD threadId;
    Wnd4PTID *tmp = ( Wnd4PTID * ) lParam;
    // get the process/thread id of current window
    threadId = GetWindowThreadProcessId( hwnd, &procId );
    // check if the process/thread id equal to the one passed by lParam?
    if ( threadId == tmp->threadId || procId == tmp->procId ) {
        // check if the window is a main window
        // because there lots of windows belong to the same process/thread
        LONG dwStyle = GetWindowLong( hwnd, GWL_STYLE );
        if ( dwStyle & WS_SYSMENU ) {
            tmp->hWnd = hwnd;
            return FALSE;       // break the enumeration
        }
    }
    return TRUE;                // continue the enumeration
}

// Enumarate all the MainWindow of the system
HWND FindProcessMainWindow( DWORD procId )
{
    Wnd4PTID tempWnd4ID;
    tempWnd4ID.procId = procId;
    if ( !EnumWindows
            ( ( WNDENUMPROC ) PrivateEnumWindowsProc, ( LPARAM ) & tempWnd4ID ) ) {
            
        if ( OUTPUT_DEBUG_INFO == 1 ) {
            OutputDebugString
            ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Found main process window" );
        }
        
        return tempWnd4ID.hWnd;
    }
    
    
    if ( OUTPUT_DEBUG_INFO == 1 ) {
        OutputDebugString
        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Could not find main process window" );
    }
    
    return NULL;
}


void DoClipping( int forceRedraw )
{
    //if main window handle is null, try to get it
    if ( m_mainWindowHandle == NULL ) {
        m_mainWindowHandle = FindProcessMainWindow( GetCurrentProcessId() );
        
        //hide the window from taskbar and put at the back of the z order
        if ( HIDE_TSAC_WINDOW == 1 ) {
            ShowWindow( m_mainWindowHandle, SW_HIDE );
            SetWindowLongPtr( m_mainWindowHandle, GWL_EXSTYLE,
                              GetWindowLong( m_mainWindowHandle,
                                             GWL_EXSTYLE ) | WS_EX_TOOLWINDOW );
            ShowWindow( m_mainWindowHandle, SW_SHOW );
        }
        
        SetWindowPos( m_mainWindowHandle, HWND_NOTOPMOST, 0, 0, 0, 0,
                      SWP_NOMOVE | SWP_NOSIZE );
    }
    
    //if we have the handle, lets use it for the clipping
    if ( m_mainWindowHandle != NULL ) {
        RECT wRect;
        GetWindowRect( m_mainWindowHandle, &wRect );
        
        if ( OUTPUT_DEBUG_INFO == 1 ) {
            OutputDebugString
            ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Restarting clipping..." );
        }
        
        m_regionResult = NULL;
        
        if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
            OutputDebugString
            ( "-----------------------------------------------------------------------------" );
            OutputDebugString
            ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> starting printing of window table" );
        }
        
        //enumerate though hashtable
        if ( &m_ht != NULL ) {
            hash_enumerate( &m_ht, CreateRegionFromWindowData );
        }
        
        if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
            OutputDebugString
            ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> finished printing of window table" );
            OutputDebugString
            ( "-----------------------------------------------------------------------------" );
        }
        
        if ( m_regionResult == NULL ) {
            if ( ALWAYS__CLIP ) {
                m_regionResult = CreateRectRgn( 0, 0, 0, 0 );
            } else {
                m_regionResult =
                    CreateRectRgn( 0, 0, wRect.right, wRect.bottom );
            }
        }
        
        SetWindowRgn( m_mainWindowHandle, ( HRGN__ * ) m_regionResult, TRUE );
        
        if ( forceRedraw == 1 ) {
            // invalidate the window and force it to redraw
            RedrawWindow( m_mainWindowHandle, NULL, NULL,
                          RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN );
        }
    } else {
        if ( OUTPUT_DEBUG_INFO == 1 ) {
            OutputDebugString
            ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Coulf not find window to clip" );
        }
    }
}

void CreateRegionFromWindowData( char *key, void *value )
{
    CWindowData * wd;
    wd = ( CWindowData * ) value;
    int x1 = 0, x2 = 0, y1 = 0, y2 = 0;
    
    char strB[ 5 ];
    char strT[ 5 ];
    char strL[ 5 ];
    char strR[ 5 ];
    
    if ( m_regionResult == NULL ) {
        m_regionResult = CreateRectRgn( 0, 0, 0, 0 );
    }
    
    if ( OUTPUT_DEBUG_INFO == 1 && OUTPUT_WINDOW_TABLE_DEBUG_INFO != 1 ) {
        OutputDebugString
        ( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Adding this window to cliping region" );
        OutputDebugString( wd->GetTitle() );
    }
    if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
        ltoa( wd->GetY2(), strB, 10 );
        ltoa( wd->GetY1(), strT, 10 );
        ltoa( wd->GetX2(), strR, 10 );
        ltoa( wd->GetX1(), strL, 10 );
        
        OutputDebugString( "This window is in the table:" );
        OutputDebugString( wd->GetTitle() );
        OutputDebugString( wd->GetId() );
        OutputDebugString( strL );
        OutputDebugString( strT );
        OutputDebugString( strR );
        OutputDebugString( strB );
        OutputDebugString( "*******************" );
    }
    
    HRGN newRegion =
        CreateRectRgn( wd->GetX1(), wd->GetY1(), wd->GetX2(), wd->GetY2() );
        
    CombineRgn( m_regionResult, newRegion, m_regionResult, RGN_OR );
}

/*
   Dummy procedure to catch when window is being maximised.
 
   Need to tell the window on the server to do the same.
 */
LRESULT CALLBACK DummyWindowCallbackProc( HWND hwnd, UINT uMsg, WPARAM wParam,
        LPARAM lParam )
{
    //TODO
    
    return DefWindowProc( hwnd, uMsg, wParam, lParam );
}

void CreateAndShowWindow( CWindowData * wd )
{
    if ( classAlreadyRegistered == 0 ) {
        static const char * szWndName = "WTSWinClipperDummy";
        WNDCLASS wc;
        
        wc.style = 0;
        wc.lpfnWndProc = DummyWindowCallbackProc;
        wc.cbClsExtra = 0;
        wc.cbWndExtra = 0;
        wc.hInstance = 0;
        wc.hIcon = 0;
        wc.hCursor = 0;
        wc.hbrBackground = 0;
        wc.lpszMenuName = 0;
        wc.lpszClassName = szWndName;
        
        if ( RegisterClass( &wc ) ) {
            classAlreadyRegistered = 1;
        }
    }
    
    if ( classAlreadyRegistered = 1 ) {
        HWND hWnd =
            CreateWindow( TEXT( "WTSWinClipperDummy" ), wd->GetTitle(), WS_POPUP,
                          0, 0, 0, 0, 0, 0, 0, 0 );
        ShowWindow( hWnd, 3 );
        SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOREDRAW );
        wd->TaskbarWindowHandle = hWnd;
        SetFocus( m_mainWindowHandle );
    }
}

void DestroyTaskbarWindow( CWindowData * wd )
{
    if ( wd->TaskbarWindowHandle != NULL ) {
        DestroyWindow( wd->TaskbarWindowHandle );
    }
}
1	astrand	930	//
2	astrand	938	// Copyright (C) 2004-2005 Martin Wickett
3	astrand	930	//
4
5			#define TSDLL
6
7			#include "clipper.h"
8
9	astrand	992	BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
10	astrand	930	{
11	astrand	992	UNREFERENCED_PARAMETER( lpvReserved );
12			UNREFERENCED_PARAMETER( hinstDLL );
13
14			switch ( fdwReason ) {
15			case DLL_PROCESS_ATTACH:
16	astrand	933	break;
17	astrand	992
18			case DLL_THREAD_ATTACH:
19	astrand	933	break;
20	astrand	992
21			case DLL_THREAD_DETACH:
22	astrand	933	break;
23	astrand	992
24			case DLL_PROCESS_DETACH:
25	astrand	933	break;
26	astrand	992
27			default:
28	astrand	933	break;
29	astrand	930	}
30			return TRUE;
31			}
32
33	astrand	992	void WINAPI VirtualChannelOpenEvent( DWORD openHandle, UINT event,
34			LPVOID pdata, UINT32 dataLength,
35			UINT32 totalLength, UINT32 dataFlags )
36	astrand	930	{
37	astrand	992	LPDWORD pdwControlCode = ( LPDWORD ) pdata;
38			CHAR ourData[ 1600 ];
39	astrand	933	UINT ui = 0;
40	astrand	992
41			UNREFERENCED_PARAMETER( openHandle );
42			UNREFERENCED_PARAMETER( dataFlags );
43
44			ZeroMemory( ourData, sizeof( ourData ) );
45
46	astrand	930	//copy the send string (with the same lenth of the data)
47	astrand	992	strncpy( ourData, ( LPSTR ) pdata, dataLength / sizeof( char ) );
48
49			if ( OUTPUT_DEBUG_INFO == 1 ) {
50	astrand	933	OutputDebugString
51	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Virtual channel data received" );
52			OutputDebugString( ourData );
53	astrand	933	}
54	astrand	992
55			if ( dataLength == totalLength ) {
56			switch ( event ) {
57			case CHANNEL_EVENT_DATA_RECEIVED: {
58			CTokenizer tok( _T( ( LPSTR ) ourData ), _T( ";" ) );
59	astrand	933	CStdString cs;
60	astrand	992
61			CWindowData *wid = new CWindowData( "" );
62	astrand	933	CStdString messageType;
63			int mixMaxType = 0;
64	astrand	992
65			while ( tok.Next( cs ) ) {
66	astrand	933	CStdString msg;
67	astrand	992	CTokenizer msgTok( cs, _T( "=" ) );
68
69			msgTok.Next( msg );
70
71			if ( strcmp( msg, "MSG" ) == 0 ) {
72			msgTok.Next( msg );
73	astrand	933	messageType = msg;
74			}
75	astrand	992
76			if ( strcmp( msg, "ID" ) == 0 ) {
77			msgTok.Next( msg );
78			wid->SetId( msg );
79			} else if ( strcmp( msg, "TITLE" ) == 0 ) {
80			msgTok.Next( msg );
81			wid->SetTitle( msg );
82			} else if ( strcmp( msg, "POS" ) == 0 ) {
83			msgTok.Next( msg );
84
85	astrand	933	CStdString pos;
86	astrand	992	CTokenizer posTok( msg, _T( "~" ) );
87
88			posTok.Next( pos );
89
90
91	astrand	933	// check bounds, coords can be negative if window top left point is moved off the screen.
92			// we don't care about that since the window can't be see so just use zero.
93	astrand	992
94			if ( strchr( pos, '-' ) == NULL ) {
95			wid->SetX1( atoi( pos ) );
96	astrand	937	} else {
97	astrand	992	wid->SetX1( 0 );
98	astrand	933	}
99	astrand	992
100			posTok.Next( pos );
101
102			if ( strchr( pos, '-' ) == NULL ) {
103			wid->SetY1( atoi( pos ) );
104	astrand	937	} else {
105	astrand	992	wid->SetY1( 0 );
106	astrand	933	}
107	astrand	992
108			posTok.Next( pos );
109
110			if ( strchr( pos, '-' ) == NULL ) {
111			wid->SetX2( atoi( pos ) );
112	astrand	937	} else {
113	astrand	992	wid->SetX2( 0 );
114	astrand	933	}
115	astrand	992
116			posTok.Next( pos );
117
118			if ( strchr( pos, '-' ) == NULL ) {
119			wid->SetY2( atoi( pos ) );
120	astrand	937	} else {
121	astrand	992	wid->SetY2( 0 );
122	astrand	933	}
123	astrand	992	} else if ( strcmp( msg, "TYPE" ) == 0 ) {
124			msgTok.Next( msg );
125			mixMaxType = atoi( msg );
126	astrand	933	}
127			}
128	astrand	992
129			if ( strcmp( messageType, "HSHELL_WINDOWCREATED" ) == 0 ) {
130			if ( OUTPUT_DEBUG_INFO == 1 ) {
131	astrand	933	OutputDebugString
132	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HSHELL_WINDOWCREATED window title is:" );
133			OutputDebugString( wid->GetTitle() );
134	astrand	933	}
135	astrand	992
136	astrand	933	CStdString s = wid->GetId();
137			char *ptr;
138			int length = s.GetLength();
139	astrand	992	ptr = s.GetBufferSetLength( length );
140
141			hash_insert( ptr, wid, &m_ht );
142
143			CreateAndShowWindow( wid );
144
145			DoClipping( 1 );
146			} else if ( strcmp( messageType, "HSHELL_WINDOWDESTROYED" ) == 0 ) {
147			if ( OUTPUT_DEBUG_INFO == 1 ) {
148	astrand	933	OutputDebugString
149	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HSHELL_WINDOWDISTROYED window title is:" );
150			OutputDebugString( wid->GetTitle() );
151	astrand	933	}
152	astrand	992
153	astrand	933	CStdString s = wid->GetId();
154			char *ptr;
155			int length = s.GetLength();
156	astrand	992	ptr = s.GetBufferSetLength( length );
157
158	astrand	933	CWindowData *oldWinData =
159	astrand	992	( CWindowData * ) hash_del( ptr, &m_ht );
160
161			DestroyTaskbarWindow( oldWinData );
162
163	astrand	933	delete oldWinData;
164	astrand	992
165			DoClipping( 1 );
166			} else if ( strcmp( messageType, "HCBT_MINMAX" ) == 0 ) {
167			if ( OUTPUT_DEBUG_INFO == 1 ) {
168	astrand	933	OutputDebugString
169	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HCBT_MINMAX" );
170	astrand	933	}
171	astrand	992
172
173	astrand	933	//TODO
174	astrand	992
175			} else if ( strcmp( messageType, "HCBT_MOVESIZE" ) == 0 ) {
176			if ( OUTPUT_DEBUG_INFO == 1 ) {
177	astrand	933	OutputDebugString
178	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type HCBT_MOVESIZE window title is:" );
179			OutputDebugString( wid->GetTitle() );
180	astrand	933	}
181	astrand	992
182	astrand	933	CStdString s = wid->GetId();
183			char *ptr;
184			int length = s.GetLength();
185	astrand	992	ptr = s.GetBufferSetLength( length );
186
187	astrand	933	CWindowData *movedWinData =
188	astrand	992	( CWindowData * ) hash_lookup( ptr, &m_ht );
189
190			if ( movedWinData != NULL ) {
191			movedWinData->SetX1( wid->GetX1() );
192			movedWinData->SetX2( wid->GetX2() );
193			movedWinData->SetY1( wid->GetY1() );
194			movedWinData->SetY2( wid->GetY2() );
195
196			DoClipping( 1 );
197	astrand	933	}
198	astrand	992
199	astrand	933	delete wid;
200	astrand	992	} else if ( strcmp( messageType, "CALLWNDPROC_WM_MOVING" ) == 0 ) {
201			if ( OUTPUT_DEBUG_INFO == 1 ) {
202	astrand	933	OutputDebugString
203	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Message was of type CALLWNDPROC_WM_MOVING window title is:" );
204			OutputDebugString( wid->GetTitle() );
205	astrand	933	}
206	astrand	992
207	astrand	933	CStdString s = wid->GetId();
208			char *ptr;
209			int length = s.GetLength();
210	astrand	992	ptr = s.GetBufferSetLength( length );
211
212	astrand	933	CWindowData *movedWinData =
213	astrand	992	( CWindowData * ) hash_lookup( ptr, &m_ht );
214
215			if ( movedWinData != NULL ) {
216			movedWinData->SetX1( wid->GetX1() );
217			movedWinData->SetX2( wid->GetX2() );
218			movedWinData->SetY1( wid->GetY1() );
219			movedWinData->SetY2( wid->GetY2() );
220
221	astrand	933	////might be too much of an overhead forcing the redraw here. Might be better to do 'DoClipping(0)' instead?
222	astrand	992	DoClipping( 1 );
223	astrand	933	}
224	astrand	992
225	astrand	933	delete wid;
226			}
227	astrand	930	}
228			break;
229	astrand	992
230			case CHANNEL_EVENT_WRITE_COMPLETE: {}
231	astrand	930	break;
232	astrand	992
233			case CHANNEL_EVENT_WRITE_CANCELLED: {}
234	astrand	930	break;
235	astrand	992
236			default: {}
237	astrand	930	break;
238			}
239	astrand	937	} else {}
240	astrand	930	}
241
242
243	astrand	992	VOID VCAPITYPE VirtualChannelInitEventProc( LPVOID pInitHandle, UINT event,
244			LPVOID pData, UINT dataLength )
245	astrand	930	{
246	astrand	933	UINT ui;
247	astrand	992
248			UNREFERENCED_PARAMETER( pInitHandle );
249			UNREFERENCED_PARAMETER( dataLength );
250
251			switch ( event ) {
252			case CHANNEL_EVENT_INITIALIZED: {}
253	astrand	930	break;
254	astrand	992
255			case CHANNEL_EVENT_CONNECTED: {
256	astrand	930	//
257			// open channel
258			//
259	astrand	992	ui = gpEntryPoints->pVirtualChannelOpen( gphChannel,
260			&gdwOpenChannel,
261			CHANNELNAME,
262			( PCHANNEL_OPEN_EVENT_FN )
263			VirtualChannelOpenEvent );
264
265			if ( ui == CHANNEL_RC_OK ) {}
266	astrand	933	else {
267	astrand	992	MessageBox( NULL, TEXT( "Open of RDP virtual channel failed" ),
268			TEXT( "TS Window Clipper" ), MB_OK );
269	astrand	933	}
270	astrand	992
271			if ( ui != CHANNEL_RC_OK ) {
272			return ;
273	astrand	933	}
274	astrand	930	}
275			break;
276	astrand	992
277			case CHANNEL_EVENT_V1_CONNECTED: {
278			MessageBox( NULL,
279			TEXT
280			( "Connecting to a non Windows 2000 Terminal Server" ),
281			TEXT( "TS Window Clipper" ), MB_OK );
282	astrand	930	}
283			break;
284	astrand	992
285			case CHANNEL_EVENT_DISCONNECTED: {}
286	astrand	930	break;
287	astrand	992
288			case CHANNEL_EVENT_TERMINATED: {
289	astrand	930	//
290			// free the entry points table
291			//
292	astrand	992	LocalFree( ( HLOCAL ) gpEntryPoints );
293	astrand	930	}
294			break;
295	astrand	992
296			default: {}
297	astrand	930	break;
298			}
299			}
300
301	astrand	992	BOOL VCAPITYPE VirtualChannelEntry( PCHANNEL_ENTRY_POINTS pEntryPoints )
302	astrand	930	{
303			CHANNEL_DEF cd;
304	astrand	933	UINT uRet;
305	astrand	992
306	astrand	933	size_t s = 10;
307	astrand	992	hash_construct_table( &m_ht, s );
308
309	astrand	930	//
310			// allocate memory
311			//
312	astrand	933	gpEntryPoints =
313	astrand	992	( PCHANNEL_ENTRY_POINTS ) LocalAlloc( LPTR, pEntryPoints->cbSize );
314
315			memcpy( gpEntryPoints, pEntryPoints, pEntryPoints->cbSize );
316
317	astrand	930	//
318			// initialize CHANNEL_DEF structure
319			//
320	astrand	992	ZeroMemory( &cd, sizeof( CHANNEL_DEF ) );
321			strcpy( cd.name, CHANNELNAME ); // ANSI ONLY
322
323	astrand	930	//
324			// register channel
325			//
326	astrand	933	uRet =
327	astrand	992	gpEntryPoints->pVirtualChannelInit( ( LPVOID * ) & gphChannel,
328			( PCHANNEL_DEF ) & cd, 1,
329			VIRTUAL_CHANNEL_VERSION_WIN2000,
330			( PCHANNEL_INIT_EVENT_FN )
331			VirtualChannelInitEventProc );
332
333			if ( uRet == CHANNEL_RC_OK ) {
334			if ( ALWAYS__CLIP ) {
335			DoClipping( 1 );
336	astrand	933	}
337	astrand	937	} else {
338	astrand	992	MessageBox( NULL, TEXT( "RDP Virtual channel Init Failed" ),
339			TEXT( "TS Window Clipper" ), MB_OK );
340	astrand	930	}
341	astrand	992
342			if ( uRet != CHANNEL_RC_OK ) {
343	astrand	930	return FALSE;
344	astrand	933	}
345	astrand	992
346	astrand	930	//
347			// make sure channel was initialized
348			//
349	astrand	992	if ( cd.options != CHANNEL_OPTION_INITIALIZED ) {
350	astrand	930	return FALSE;
351	astrand	933	}
352	astrand	992
353	astrand	930	return TRUE;
354			}
355
356
357			// data structure to transfer informations
358			typedef struct _WindowFromProcessOrThreadID
359			{
360	astrand	933	union
361			{
362			DWORD procId;
363			DWORD threadId;
364			};
365			HWND hWnd;
366	astrand	937	}
367			Wnd4PTID;
368	astrand	930
369			// Callback procedure
370	astrand	992	BOOL CALLBACK PrivateEnumWindowsProc( HWND hwnd, LPARAM lParam )
371	astrand	930	{
372	astrand	933	DWORD procId;
373			DWORD threadId;
374	astrand	992	Wnd4PTID tmp = ( Wnd4PTID ) lParam;
375	astrand	933	// get the process/thread id of current window
376	astrand	992	threadId = GetWindowThreadProcessId( hwnd, &procId );
377	astrand	933	// check if the process/thread id equal to the one passed by lParam?
378	astrand	992	if ( threadId == tmp->threadId \|\| procId == tmp->procId ) {
379	astrand	933	// check if the window is a main window
380			// because there lots of windows belong to the same process/thread
381	astrand	992	LONG dwStyle = GetWindowLong( hwnd, GWL_STYLE );
382			if ( dwStyle & WS_SYSMENU ) {
383	astrand	933	tmp->hWnd = hwnd;
384			return FALSE; // break the enumeration
385			}
386			}
387			return TRUE; // continue the enumeration
388	astrand	930	}
389
390			// Enumarate all the MainWindow of the system
391	astrand	992	HWND FindProcessMainWindow( DWORD procId )
392	astrand	930	{
393	astrand	933	Wnd4PTID tempWnd4ID;
394			tempWnd4ID.procId = procId;
395	astrand	992	if ( !EnumWindows
396			( ( WNDENUMPROC ) PrivateEnumWindowsProc, ( LPARAM ) & tempWnd4ID ) ) {
397
398			if ( OUTPUT_DEBUG_INFO == 1 ) {
399	astrand	933	OutputDebugString
400	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Found main process window" );
401	astrand	933	}
402	astrand	992
403	astrand	933	return tempWnd4ID.hWnd;
404			}
405	astrand	992
406
407			if ( OUTPUT_DEBUG_INFO == 1 ) {
408	astrand	933	OutputDebugString
409	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Could not find main process window" );
410	astrand	933	}
411	astrand	992
412	astrand	933	return NULL;
413	astrand	930	}
414
415
416	astrand	992	void DoClipping( int forceRedraw )
417	astrand	930	{
418	astrand	933	//if main window handle is null, try to get it
419	astrand	992	if ( m_mainWindowHandle == NULL ) {
420			m_mainWindowHandle = FindProcessMainWindow( GetCurrentProcessId() );
421
422	astrand	933	//hide the window from taskbar and put at the back of the z order
423	astrand	992	if ( HIDE_TSAC_WINDOW == 1 ) {
424			ShowWindow( m_mainWindowHandle, SW_HIDE );
425			SetWindowLongPtr( m_mainWindowHandle, GWL_EXSTYLE,
426			GetWindowLong( m_mainWindowHandle,
427			GWL_EXSTYLE ) \| WS_EX_TOOLWINDOW );
428			ShowWindow( m_mainWindowHandle, SW_SHOW );
429	astrand	933	}
430	astrand	992
431			SetWindowPos( m_mainWindowHandle, HWND_NOTOPMOST, 0, 0, 0, 0,
432			SWP_NOMOVE \| SWP_NOSIZE );
433	astrand	933	}
434	astrand	992
435	astrand	933	//if we have the handle, lets use it for the clipping
436	astrand	992	if ( m_mainWindowHandle != NULL ) {
437	astrand	933	RECT wRect;
438	astrand	992	GetWindowRect( m_mainWindowHandle, &wRect );
439
440			if ( OUTPUT_DEBUG_INFO == 1 ) {
441	astrand	933	OutputDebugString
442	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Restarting clipping..." );
443	astrand	933	}
444	astrand	992
445	astrand	933	m_regionResult = NULL;
446	astrand	992
447			if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
448	astrand	933	OutputDebugString
449	astrand	992	( "-----------------------------------------------------------------------------" );
450	astrand	933	OutputDebugString
451	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> starting printing of window table" );
452	astrand	933	}
453	astrand	992
454	astrand	933	//enumerate though hashtable
455	astrand	992	if ( &m_ht != NULL ) {
456			hash_enumerate( &m_ht, CreateRegionFromWindowData );
457	astrand	933	}
458	astrand	992
459			if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
460	astrand	933	OutputDebugString
461	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> finished printing of window table" );
462	astrand	933	OutputDebugString
463	astrand	992	( "-----------------------------------------------------------------------------" );
464	astrand	933	}
465	astrand	992
466			if ( m_regionResult == NULL ) {
467			if ( ALWAYS__CLIP ) {
468			m_regionResult = CreateRectRgn( 0, 0, 0, 0 );
469	astrand	937	} else {
470	astrand	933	m_regionResult =
471	astrand	992	CreateRectRgn( 0, 0, wRect.right, wRect.bottom );
472	astrand	933	}
473			}
474	astrand	992
475			SetWindowRgn( m_mainWindowHandle, ( HRGN__ * ) m_regionResult, TRUE );
476
477			if ( forceRedraw == 1 ) {
478	astrand	933	// invalidate the window and force it to redraw
479	astrand	992	RedrawWindow( m_mainWindowHandle, NULL, NULL,
480			RDW_INVALIDATE \| RDW_UPDATENOW \| RDW_ALLCHILDREN );
481	astrand	933	}
482	astrand	937	} else {
483	astrand	992	if ( OUTPUT_DEBUG_INFO == 1 ) {
484	astrand	933	OutputDebugString
485	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Coulf not find window to clip" );
486	astrand	933	}
487			}
488	astrand	930	}
489
490	astrand	992	void CreateRegionFromWindowData( char key, void value )
491	astrand	930	{
492	astrand	992	CWindowData * wd;
493			wd = ( CWindowData * ) value;
494	astrand	933	int x1 = 0, x2 = 0, y1 = 0, y2 = 0;
495	astrand	992
496			char strB[ 5 ];
497			char strT[ 5 ];
498			char strL[ 5 ];
499			char strR[ 5 ];
500
501			if ( m_regionResult == NULL ) {
502			m_regionResult = CreateRectRgn( 0, 0, 0, 0 );
503	astrand	933	}
504	astrand	992
505			if ( OUTPUT_DEBUG_INFO == 1 && OUTPUT_WINDOW_TABLE_DEBUG_INFO != 1 ) {
506	astrand	933	OutputDebugString
507	astrand	992	( "TS WINDOW CLIPPER :: CLIENT DLL :: Info --> Adding this window to cliping region" );
508			OutputDebugString( wd->GetTitle() );
509	astrand	933	}
510	astrand	992	if ( OUTPUT_WINDOW_TABLE_DEBUG_INFO == 1 ) {
511			ltoa( wd->GetY2(), strB, 10 );
512			ltoa( wd->GetY1(), strT, 10 );
513			ltoa( wd->GetX2(), strR, 10 );
514			ltoa( wd->GetX1(), strL, 10 );
515
516			OutputDebugString( "This window is in the table:" );
517			OutputDebugString( wd->GetTitle() );
518			OutputDebugString( wd->GetId() );
519			OutputDebugString( strL );
520			OutputDebugString( strT );
521			OutputDebugString( strR );
522			OutputDebugString( strB );
523			OutputDebugString( "*******************" );
524	astrand	933	}
525	astrand	992
526	astrand	933	HRGN newRegion =
527	astrand	992	CreateRectRgn( wd->GetX1(), wd->GetY1(), wd->GetX2(), wd->GetY2() );
528
529			CombineRgn( m_regionResult, newRegion, m_regionResult, RGN_OR );
530	astrand	930	}
531
532			/*
533			Dummy procedure to catch when window is being maximised.
534	astrand	937
535	astrand	930	Need to tell the window on the server to do the same.
536			*/
537	astrand	992	LRESULT CALLBACK DummyWindowCallbackProc( HWND hwnd, UINT uMsg, WPARAM wParam,
538			LPARAM lParam )
539	astrand	930	{
540	astrand	933	//TODO
541	astrand	992
542			return DefWindowProc( hwnd, uMsg, wParam, lParam );
543	astrand	930	}
544
545	astrand	992	void CreateAndShowWindow( CWindowData * wd )
546	astrand	930	{
547	astrand	992	if ( classAlreadyRegistered == 0 ) {
548			static const char * szWndName = "WTSWinClipperDummy";
549	astrand	933	WNDCLASS wc;
550	astrand	992
551	astrand	933	wc.style = 0;
552			wc.lpfnWndProc = DummyWindowCallbackProc;
553			wc.cbClsExtra = 0;
554			wc.cbWndExtra = 0;
555			wc.hInstance = 0;
556			wc.hIcon = 0;
557			wc.hCursor = 0;
558			wc.hbrBackground = 0;
559			wc.lpszMenuName = 0;
560			wc.lpszClassName = szWndName;
561	astrand	992
562			if ( RegisterClass( &wc ) ) {
563	astrand	933	classAlreadyRegistered = 1;
564			}
565			}
566	astrand	992
567			if ( classAlreadyRegistered = 1 ) {
568	astrand	933	HWND hWnd =
569	astrand	992	CreateWindow( TEXT( "WTSWinClipperDummy" ), wd->GetTitle(), WS_POPUP,
570			0, 0, 0, 0, 0, 0, 0, 0 );
571			ShowWindow( hWnd, 3 );
572			SetWindowPos( hWnd, 0, 0, 0, 0, 0, SWP_NOREDRAW );
573	astrand	933	wd->TaskbarWindowHandle = hWnd;
574	astrand	992	SetFocus( m_mainWindowHandle );
575	astrand	933	}
576	astrand	930	}
577
578	astrand	992	void DestroyTaskbarWindow( CWindowData * wd )
579	astrand	930	{
580	astrand	992	if ( wd->TaskbarWindowHandle != NULL ) {
581			DestroyWindow( wd->TaskbarWindowHandle );
582	astrand	933	}
583			}