/[rdesktop]/sourceforge.net/trunk/seamlessrdp/ServerExe/HookDll/hookdll.cpp
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/seamlessrdp/ServerExe/HookDll/hookdll.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 930 by astrand, Thu Jun 30 14:14:56 2005 UTC revision 999 by astrand, Tue Aug 30 09:18:53 2005 UTC
# Line 1  Line 1 
 //*********************************************************************************  
1  //  //
2  //Title: Terminal Services Window Clipper  // Copyright (C) 2004-2005 Martin Wickett
3  //  //
 //Author: Martin Wickett  
 //  
 //Date: 2004  
 //  
 //*********************************************************************************  
4    
5  #include "hookdll.h"  #include "hookdll.h"
6  #include <windows.h>  #include <windows.h>
7  #include <winuser.h>  #include <winuser.h>
8    #include <stdio.h>
9    #include <stdarg.h>
10    
11  #include "wtsapi32.h"  #include "wtsapi32.h"
12  #include "Cchannel.h"  #include "Cchannel.h"
13    
14  #define DLL_EXPORT extern "C" __declspec(dllexport)  #define DLL_EXPORT extern "C" __declspec(dllexport)
15    
16  // Shared DATA  // Shared DATA
17  #pragma data_seg ( "SHAREDDATA" )  #pragma data_seg ( "SHAREDDATA" )
18    
19          // this is the total number of processes this dll is currently attached to  // this is the total number of processes this dll is currently attached to
20          int                             iInstanceCount          = 0;  int iInstanceCount = 0;
21          HWND                    hWnd                            = 0;  HWND hWnd = 0;
22    
23  #pragma data_seg ()  #pragma data_seg ()
24    
25  #pragma comment(linker, "/section:SHAREDDATA,rws")  #pragma comment(linker, "/section:SHAREDDATA,rws")
26    
27  bool                    bHooked        = false;  #define snprintf _snprintf
28  bool                    bHooked2       = false;  
29  bool                    bHooked3       = false;  bool bHooked = false;
30  HHOOK                   hhook          = 0;//cbt  bool bHooked2 = false;
31  HHOOK                   hhook2         = 0;//shell  bool bHooked3 = false;
32  HHOOK                   hhook3             = 0;//wnd proc  HHOOK hhook = 0; //cbt
33  HINSTANCE               hInst          = 0;  HHOOK hhook2 = 0; //shell
34  HANDLE                  m_vcHandle         = 0;  HHOOK hhook3 = 0; //wnd proc
35    HINSTANCE hInst = 0;
36  BOOL APIENTRY DllMain( HINSTANCE hinstDLL, DWORD  ul_reason_for_call, LPVOID lpReserved )  HANDLE m_vcHandle = 0;
37  {  
38      switch (ul_reason_for_call)  
39          {  void SendDebug( char *format, ... )
40                  case DLL_PROCESS_ATTACH:  {
41                          {      va_list argp;
42                                  // remember our instance handle      char buf [ 256 ];
43                                  hInst = hinstDLL;      
44                                  ++iInstanceCount;      va_start( argp, format );
45                                  OpenVirtualChannel();      vsprintf( buf, format, argp );
46                                   break;      va_end( argp );
47                          }      
48        if ( ChannelIsOpen() ) {
49                  case DLL_THREAD_ATTACH:          WriteToChannel( "DEBUG1," );
50                                  break;          WriteToChannel( buf );
51                  case DLL_THREAD_DETACH:          WriteToChannel( "\n" );
                         break;  
                 case DLL_PROCESS_DETACH:  
                         {  
                                 --iInstanceCount;  
                                 CloseVirtualChannel();  
                         }  
                         break;  
52      }      }
53    }
54    
55    
56    
57    BOOL APIENTRY DllMain( HINSTANCE hinstDLL, DWORD ul_reason_for_call, LPVOID lpReserved )
58    {
59        switch ( ul_reason_for_call ) {
60            case DLL_PROCESS_ATTACH: {
61                // remember our instance handle
62                hInst = hinstDLL;
63                ++iInstanceCount;
64                OpenVirtualChannel();
65                break;
66            }
67            
68            case DLL_THREAD_ATTACH:
69            break;
70            case DLL_THREAD_DETACH:
71            break;
72            case DLL_PROCESS_DETACH: {
73                --iInstanceCount;
74                CloseVirtualChannel();
75            }
76            break;
77        }
78        
79      return TRUE;      return TRUE;
80  }  }
81    
82  LRESULT CALLBACK CallWndProc(int nCode, WPARAM wParam, LPARAM lParam )  LRESULT CALLBACK CallWndProc( int nCode, WPARAM wParam, LPARAM lParam )
83    {
84        if ( nCode < 0 ) {
85            return CallNextHookEx( hhook3, nCode, wParam, lParam );
86        }
87        
88        PCHAR buffer = NULL;
89        char windowTitle[ 150 ] = { ""
90                                  };
91        HWND windowHandle = NULL;
92        HWND windowHandle2 = NULL;
93        char result[ 255 ] = { ""
94                             };
95        char strWindowId[ 25 ];
96        char type[ 25 ];
97        
98        LONG b, t, l, r;
99        char strX[ 5 ];
100        char strY[ 5 ];
101        char strW[ 5 ];
102        char strH[ 5 ];
103        
104        CWPSTRUCT *details = ( CWPSTRUCT * ) lParam;
105        CREATESTRUCT *cs = ( CREATESTRUCT * ) details->lParam;
106        LONG dwStyle = GetWindowLong( details->hwnd, GWL_STYLE );
107        WINDOWPOS *wp = ( WINDOWPOS * ) details->lParam;
108        RECT *rect = ( RECT * ) details->lParam;
109        
110        switch ( details->message ) {
111        
112            case WM_SIZING:
113            case WM_MOVING:
114            snprintf( result, sizeof( result ),
115                      "POSITION1,0x%x,%d,%d,%d,%d,0x%x",
116                      ( int ) details->hwnd,
117                      rect->left, rect->top,
118                      rect->right - rect->left,
119                      rect->bottom - rect->top,
120                      0 );
121            result[ sizeof( result ) - 1 ] = '\0';
122            buffer = result;
123            
124            break;
125            
126            /* Note: WM_WINDOWPOSCHANGING/WM_WINDOWPOSCHANGED are
127            strange. Sometimes, for example when bringing up the
128            Notepad About dialog, only an WM_WINDOWPOSCHANGING is
129            sent. In some other cases, for exmaple when opening
130            Format->Text in Notepad, both events are sent. Also, for
131            some reason, when closing the Notepad About dialog, an
132            WM_WINDOWPOSCHANGING event is sent which looks just like
133            the event that was sent when the About dialog was opened...  */
134            case WM_WINDOWPOSCHANGING:
135            
136            if ( !( dwStyle & WS_VISIBLE ) )
137                break;
138                
139            if ( !( dwStyle & WS_DLGFRAME ) )
140                break;
141                
142            if ( !( wp->flags & SWP_NOZORDER ) ) {
143                snprintf( result, sizeof( result ),
144                          "ZCHANGE1,0x%x,0x%x,0x%x\n",
145                          details->hwnd,
146                          wp->flags & SWP_NOACTIVATE ? wp->hwndInsertAfter : 0,
147                          0 );
148                result[ sizeof( result ) - 1 ] = '\0';
149            }
150            buffer = result;
151            
152            break;
153            
154            
155            case WM_CREATE:
156            if ( cs->style & WS_DLGFRAME ) {
157                sprintf( result, "DEBUG:WM_CREATE:%dx%d at %d,%d, title=%s, menu=%p, window=%p, WS_BORDER=%d, WS_DLGFRAME=%d, WS_POPUP=%d",
158                         cs->cx, cs->cy, cs->x, cs->y, cs->lpszName, cs->hMenu, details->hwnd,
159                         cs->style & WS_BORDER, cs->style & WS_DLGFRAME,
160                         cs->style & WS_POPUP );
161                buffer = result;
162            }
163            
164            break;
165            
166            
167            case WM_DESTROY:
168            if ( dwStyle & WS_DLGFRAME ) {
169                sprintf( result, "WM_DESTROY:%p", details->hwnd );
170                buffer = result;
171            }
172            
173            break;
174            
175            default:
176            break;
177        }
178        
179        if ( ChannelIsOpen() ) {
180            if ( buffer != NULL ) {
181                WriteToChannel( buffer );
182            }
183        }
184        
185        return CallNextHookEx( hhook3, nCode, wParam, lParam );
186    }
187    
188    LRESULT CALLBACK CbtProc( int nCode, WPARAM wParam, LPARAM lParam )
189    {
190        if ( nCode < 0 ) {
191            return CallNextHookEx( hhook, nCode, wParam, lParam );
192        }
193        
194        
195        PCHAR buffer = NULL;
196        
197        
198        char windowTitle[ 150 ] = { ""
199                                  };
200        HWND windowHandle = NULL;
201        char result[ 255 ] = { ""
202                             };
203        char strWindowId[ 25 ];
204        char type[ 25 ];
205        
206        
207        LONG b, t, l, r;
208        char strW[ 5 ];
209        char strY[ 5 ];
210        char strX[ 5 ];
211        char strH[ 5 ];
212        RECT rect;
213        
214        int i = 0; //tmp
215        
216        switch ( nCode ) {
217            case HCBT_MINMAX:
218            
219            windowHandle = ( HWND ) wParam;
220            //get win name
221            GetWindowText( windowHandle, windowTitle, 150 );
222            
223            //get an id for it
224            itoa( ( int ) windowHandle, strWindowId, 10 );
225            
226            //get operation type(min,max). if max, do not clip at all,if min use window's previous coords
227            //codes are:
228            
229            // SW_HIDE= 0  SW_SHOWNORMAL=1  SW_NORMAL=1  SW_SHOWMINIMIZED=2  SW_SHOWMAXIMIZED=3  SW_MAXIMIZE=3
230            // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9
231            // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11
232            
233            itoa( ( int ) lParam, type, 10 );
234            
235            //get coords
236            GetWindowRect( windowHandle, &rect );
237            b = rect.bottom;
238            t = rect.top;
239            l = rect.left;
240            r = rect.right;
241            ltoa( b - t, strW, 10 );
242            ltoa( t, strY, 10 );
243            ltoa( r - l, strH, 10 );
244            ltoa( l, strX, 10 );
245            
246            //get name
247            GetWindowText( windowHandle, windowTitle, 150 );
248            
249            ////setup return string
250            strcat( result, "MSG=HCBT_MINMAX;OP=4;" );
251            
252            // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9
253            // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11
254            strcat( result, "ID=" );
255            strcat( result, strWindowId );
256            strcat( result, ";" );
257            strcat( result, "TITLE=" );
258            strcat( result, windowTitle );
259            strcat( result, ";" );
260            strcat( result, "X=" );
261            strcat( result, strX );
262            strcat( result, ";" );
263            strcat( result, "Y=" );
264            strcat( result, strY );
265            strcat( result, ";" );
266            strcat( result, "H=" );
267            strcat( result, strH );
268            strcat( result, ";" );
269            strcat( result, "W=" );
270            strcat( result, strW );
271            strcat( result, ";" );
272            strcat( result, "TYPE=" );
273            strcat( result, type );
274            strcat( result, "." );
275            
276            //-------------------------------------------------------------------------------------------------
277            // code to prevent minimising windows (can be removed once minimise has been implemented)
278            //i = (int)lParam;
279            //if (i==0 || i==2 || i==6 || i==7 || i==8 || i==11)
280            //if ( i==2 || i==6 )
281            //{
282            // MessageBox(0,"Minimising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);
283            // return 1;
284            //}
285            //-----------------------------------------------------------------------------------------
286            
287            //-------------------------------------------------------------------------------------------------
288            // code to prevent maximising windows (can be removed once maximise has been implemented)
289            //i = (int)lParam;
290            //if (i==3 || i==9 || i==11)
291            //if (i==3 || i==11)
292            //{
293            // MessageBox(0,"Maximising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);
294            // return 1;
295            //}
296            //-----------------------------------------------------------------------------------------
297            
298            buffer = result;
299            
300            break;
301            
302            default:
303            break;
304        }
305        
306        if ( ChannelIsOpen() ) {
307            if ( buffer != NULL ) {
308                WriteToChannel( buffer );
309            }
310        }
311        
312        return CallNextHookEx( hhook, nCode, wParam, lParam );
313    }
314    
315    
316    LRESULT CALLBACK ShellProc( int nCode, WPARAM wParam, LPARAM lParam )
317    {
318        if ( nCode < 0 ) {
319            return CallNextHookEx( hhook, nCode, wParam, lParam );
320        }
321        
322        if ( ChannelIsOpen() ) {
323            PCHAR buffer = NULL;
324            
325            char windowTitle[ 150 ] = { ""
326                                      };
327            HWND windowHandle = NULL;
328            char result[ 255 ] = { ""
329                                 };
330            char strWindowId[ 25 ];
331            LONG b, t, l, r;
332            char strW[ 5 ];
333            char strY[ 5 ];
334            char strX[ 5 ];
335            char strH[ 5 ];
336            RECT rect;
337            
338            switch ( nCode ) {
339                case HSHELL_WINDOWCREATED:
340                
341                //get window id
342                windowHandle = ( HWND ) wParam;
343                itoa( ( int ) windowHandle, strWindowId, 10 );
344                
345                //get coords
346                GetWindowRect( windowHandle, &rect );
347                b = rect.bottom;
348                t = rect.top;
349                l = rect.left;
350                r = rect.right;
351                ltoa( b - t, strH, 10 );
352                ltoa( t, strY, 10 );
353                ltoa( r - l, strW, 10 );
354                ltoa( l, strX, 10 );
355                
356                //get name
357                GetWindowText( windowHandle, windowTitle, 150 );
358                
359                ////setup return string
360                strcat( result, "MSG=HSHELL_WINDOWCREATED;OP=0;" );
361                strcat( result, "ID=" );
362                strcat( result, strWindowId );
363                strcat( result, ";" );
364                strcat( result, "TITLE=" );
365                strcat( result, windowTitle );
366                strcat( result, ";" );
367                strcat( result, "X=" );
368                strcat( result, strX );
369                strcat( result, ";" );
370                strcat( result, "Y=" );
371                strcat( result, strY );
372                strcat( result, ";" );
373                strcat( result, "H=" );
374                strcat( result, strH );
375                strcat( result, ";" );
376                strcat( result, "W=" );
377                strcat( result, strW );
378                strcat( result, "." );
379                
380                buffer = result;
381                
382                break;
383                
384                case HSHELL_WINDOWDESTROYED:
385                
386                //get window id
387                windowHandle = ( HWND ) wParam;
388                itoa( ( int ) windowHandle, strWindowId, 10 );
389                
390                //get coords
391                GetWindowRect( windowHandle, &rect );
392                b = rect.bottom;
393                t = rect.top;
394                l = rect.left;
395                r = rect.right;
396                ltoa( b - t, strH, 10 );
397                ltoa( t, strY, 10 );
398                ltoa( r - l, strW, 10 );
399                ltoa( l, strX, 10 );
400                
401                //get name
402                GetWindowText( windowHandle, windowTitle, 150 );
403                
404                ////setup return string
405                strcat( result, "MSG=HSHELL_WINDOWDESTROYED;OP=1;" );
406                strcat( result, "ID=" );
407                strcat( result, strWindowId );
408                strcat( result, ";" );
409                strcat( result, "TITLE=" );
410                strcat( result, windowTitle );
411                strcat( result, ";" );
412                strcat( result, "X=" );
413                strcat( result, strX );
414                strcat( result, ";" );
415                strcat( result, "Y=" );
416                strcat( result, strY );
417                strcat( result, ";" );
418                strcat( result, "H=" );
419                strcat( result, strH );
420                strcat( result, ";" );
421                strcat( result, "W=" );
422                strcat( result, strW );
423                strcat( result, "." );
424                
425                buffer = result;
426                
427                break;
428                default:
429                break;
430            }
431            
432            if ( buffer != NULL ) {
433                WriteToChannel( buffer );
434            }
435        }
436        
437        return CallNextHookEx( hhook, nCode, wParam, lParam );
438    }
439    
440    DLL_EXPORT void SetCbtHook( void )
441  {  {
442          if (nCode<0)      if ( !bHooked ) {
443          {          hhook = SetWindowsHookEx( WH_CBT, ( HOOKPROC ) CbtProc, hInst, ( DWORD ) NULL );
444                  return CallNextHookEx(hhook3, nCode, wParam, lParam);          bHooked = true;
445          }      }
446        
447          PCHAR buffer          = NULL;      if ( !bHooked2 ) {
448          char windowTitle[150] = {""};          hhook2 = SetWindowsHookEx( WH_SHELL, ( HOOKPROC ) ShellProc, hInst, ( DWORD ) NULL );
449          HWND windowHandle     = NULL;          bHooked2 = true;
450          char result[255]      = {""};      }
451          char strWindowId[25];      
452          char type[25];      if ( !bHooked3 ) {
453            hhook3 = SetWindowsHookEx( WH_CALLWNDPROC, ( HOOKPROC ) CallWndProc, hInst, ( DWORD ) NULL );
454          LONG b,t,l,r;          bHooked3 = true;
455      char strB[5];      }
456          char strT[5];  }
457          char strL[5];  
458      char strR[5];  DLL_EXPORT void RemoveCbtHook( void )
459          RECT rect;  {
460        if ( bHooked ) {
461          CWPSTRUCT* details = (CWPSTRUCT*) lParam;          UnhookWindowsHookEx( hhook );
462            bHooked = false;
463          switch( details->message )      }
464          {            
465                  case WM_SIZING:      if ( bHooked2 ) {
466                  case WM_MOVING:          UnhookWindowsHookEx( hhook2 );
467                                    bHooked2 = false;
468                          windowHandle = details->hwnd;      }
469                          //get win name      
470                          GetWindowText(windowHandle,windowTitle,150);      if ( bHooked3 ) {
471                                    UnhookWindowsHookEx( hhook3 );
472                          //get an id for it          bHooked3 = false;
473                          itoa((int)windowHandle, strWindowId, 10);      }
                           
                         //get coords  
                         GetWindowRect(windowHandle,&rect);  
                         b = rect.bottom;  
                         t = rect.top;  
                         l = rect.left;  
                         r = rect.right;  
                         ltoa(b,strB,10);  
                         ltoa(t,strT,10);  
                         ltoa(r,strR,10);  
                         ltoa(l,strL,10);  
   
                         ////setup return string  
                         strcat(result, "MSG=CALLWNDPROC_WM_MOVING;");  
                         strcat( result, "ID=" );  
                         strcat( result, strWindowId );  
                         strcat( result, ";" );  
                         strcat( result, "TITLE=" );  
                         strcat( result, windowTitle);  
                         strcat( result, ";" );  
                         strcat( result, "POS=" );  
                         strcat( result, strL);  
                         strcat( result, "~");  
                         strcat( result, strT);  
                         strcat( result, "~");  
                         strcat( result, strR);  
                         strcat( result, "~");  
                         strcat( result, strB);  
                         strcat( result, ";" );  
                           
                         buffer = result;  
                   
                 break;  
   
                 default:  
                         break;  
         }  
   
         if (ChannelIsOpen())  
         {  
                 if ( buffer != NULL)  
                 {  
                         WriteToChannel(buffer);  
                 }  
         }  
   
         return CallNextHookEx(hhook3, nCode, wParam, lParam);  
 }  
   
 LRESULT CALLBACK CbtProc(int nCode, WPARAM wParam, LPARAM lParam )  
 {  
         if (nCode<0)  
         {  
                 return CallNextHookEx(hhook, nCode, wParam, lParam);  
         }  
   
   
                 PCHAR buffer          = NULL;  
   
   
                 char windowTitle[150] = {""};  
                 HWND windowHandle     = NULL;  
                 char result[255]      = {""};  
                 char strWindowId[25];  
                 char type[25];  
   
   
                 LONG b,t,l,r;  
         char strB[5];  
                 char strT[5];  
             char strL[5];  
         char strR[5];  
                 RECT rect;  
   
                 int i = 0;//tmp  
           
                 switch( nCode )  
                 {  
                         case HCBT_MINMAX:  
   
                                 windowHandle = (HWND)wParam;  
                                 //get win name  
                                 GetWindowText(windowHandle,windowTitle,150);  
                                   
                                 //get an id for it  
                                 itoa((int)windowHandle, strWindowId, 10);  
                                   
                                 //get operation type(min,max). if max, do not clip at all,if min use window's previous coords  
                                 //codes are:  
   
                                 // SW_HIDE= 0  SW_SHOWNORMAL=1  SW_NORMAL=1  SW_SHOWMINIMIZED=2  SW_SHOWMAXIMIZED=3  SW_MAXIMIZE=3  
                                 // SW_SHOWNOACTIVATE=4  SW_SHOW=5  SW_MINIMIZE=6  SW_SHOWMINNOACTIVE=7  SW_SHOWNA=8  SW_RESTORE=9    
                                 // SW_SHOWDEFAULT=10  SW_FORCEMINIMIZE=11  SW_MAX=11      
   
                                 itoa((int)lParam, type, 10);  
   
                                 //get coords  
                                 GetWindowRect(windowHandle,&rect);  
                                 b = rect.bottom;  
                                 t = rect.top;  
                                 l = rect.left;  
                                 r = rect.right;  
                                 ltoa(b,strB,10);  
                                 ltoa(t,strT,10);  
                                 ltoa(r,strR,10);  
                                 ltoa(l,strL,10);  
   
                                 //get name  
                                 GetWindowText(windowHandle,windowTitle,150);  
   
                                 ////setup return string  
                                 strcat(result, "MSG=HCBT_MINMAX;");  
                                 strcat( result, "ID=" );  
                                 strcat( result, strWindowId );  
                                 strcat( result, ";" );  
                                 strcat( result, "TITLE=" );  
                                 strcat( result, windowTitle);  
                                 strcat( result, ";" );  
                                 strcat( result, "POS=" );  
                                 strcat( result, strL);  
                                 strcat( result, "~");  
                                 strcat( result, strT);  
                                 strcat( result, "~");  
                                 strcat( result, strR);  
                                 strcat( result, "~");  
                                 strcat( result, strB);  
                                 strcat( result, ";" );  
                                 strcat( result, "TYPE=" );  
                                 strcat( result, type );  
                                 strcat( result, ";" );  
   
                                 //-------------------------------------------------------------------------------------------------  
                                 // code to prevent minimising windows (can be removed once minimise has been implemented)  
                                 i = (int)lParam;  
                                 //if (i==0 || i==2 || i==6 || i==7 || i==8 || i==11)  
                                 if ( i==2 || i==6 )  
                                 {  
                                         MessageBox(0,"Minimising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);  
                                         return 1;  
                                 }  
                                 //-----------------------------------------------------------------------------------------  
   
                                 //-------------------------------------------------------------------------------------------------  
                                 // code to prevent maximising windows (can be removed once maximise has been implemented)  
                                 i = (int)lParam;  
                                 //if (i==3 || i==9 || i==11)  
                                 if (i==3 || i==11)  
                                 {  
                                         MessageBox(0,"Maximising windows is not allowed in this version. Sorry!","TS Window Clipper", MB_OK);  
                                         return 1;  
                                 }  
                                 //-----------------------------------------------------------------------------------------  
   
                                 buffer = result;  
   
                                 break;  
   
                         case HCBT_MOVESIZE:  
           
                                 windowHandle = (HWND)wParam;  
                                 //get win name  
                                 GetWindowText(windowHandle,windowTitle,150);  
                                   
                                 //get an id for it  
                                 itoa((int)windowHandle, strWindowId, 10);  
   
                                 //get coords  
                                 GetWindowRect(windowHandle,&rect);  
                                 b = rect.bottom;  
                                 t = rect.top;  
                                 l = rect.left;  
                                 r = rect.right;  
                                 ltoa(b,strB,10);  
                                 ltoa(t,strT,10);  
                                 ltoa(r,strR,10);  
                                 ltoa(l,strL,10);  
   
                                 //get name  
                                 GetWindowText(windowHandle,windowTitle,150);  
   
                                 ////setup return string  
                                 strcat(result, "MSG=HCBT_MOVESIZE;");  
                                 strcat( result, "ID=" );  
                                 strcat( result, strWindowId );  
                                 strcat( result, ";" );  
                                 strcat( result, "TITLE=" );  
                                 strcat( result, windowTitle);  
                                 strcat( result, ";" );  
                                 strcat( result, "POS=" );  
                                 strcat( result, strL);  
                                 strcat( result, "~");  
                                 strcat( result, strT);  
                                 strcat( result, "~");  
                                 strcat( result, strR);  
                                 strcat( result, "~");  
                                 strcat( result, strB);  
                                 strcat( result, ";" );  
   
                                 buffer = result;  
   
                                 break;  
                         case HCBT_SETFOCUS:  
                                 //buffer = "HCBT_SETFOCUS";  
                                 //not needed yet  
                         break;  
                         default:  
                                 break;  
                 }  
   
         if (ChannelIsOpen())  
         {  
                 if ( buffer != NULL)  
                 {  
                         WriteToChannel(buffer);  
                 }  
         }  
   
         return CallNextHookEx(hhook, nCode, wParam, lParam);  
 }  
   
   
 LRESULT CALLBACK ShellProc(int nCode, WPARAM wParam, LPARAM lParam )  
 {  
         if (nCode<0)  
         {  
                 return CallNextHookEx(hhook, nCode, wParam, lParam);  
         }  
   
         if (ChannelIsOpen())  
         {  
                 PCHAR buffer          = NULL;  
   
                 char windowTitle[150] = {""};  
                 HWND windowHandle     = NULL;  
                 char result[255]      = {""};  
                 char strWindowId[25];  
                 LONG b,t,l,r;  
         char strB[5];  
                 char strT[5];  
             char strL[5];  
         char strR[5];  
                 RECT rect;  
   
                 switch( nCode )  
                         {  
                                 case HSHELL_WINDOWCREATED:  
                                           
                                         //get window id  
                                         windowHandle = (HWND) wParam;  
                                         itoa((int)windowHandle, strWindowId, 10);  
   
                                         //get coords  
                                         GetWindowRect(windowHandle,&rect);  
                                         b = rect.bottom;  
                                         t = rect.top;  
                                         l = rect.left;  
                                         r = rect.right;  
                                         ltoa(b,strB,10);  
                                         ltoa(t,strT,10);  
                                         ltoa(r,strR,10);  
                                         ltoa(l,strL,10);  
   
                                         //get name  
                                         GetWindowText(windowHandle,windowTitle,150);  
   
                                         ////setup return string  
                                         strcat(result, "MSG=HSHELL_WINDOWCREATED;");  
                                         strcat( result, "ID=" );  
                                         strcat( result, strWindowId );  
                                         strcat( result, ";" );  
                                         strcat( result, "TITLE=" );  
                                         strcat( result, windowTitle);  
                                         strcat( result, ";" );  
                                         strcat( result, "POS=" );  
                                         strcat( result, strL);  
                                         strcat( result, "~");  
                                         strcat( result, strT);  
                                         strcat( result, "~");  
                                         strcat( result, strR);  
                                         strcat( result, "~");  
                                         strcat( result, strB);  
                                         strcat( result, ";" );  
   
                                         buffer = result;  
   
                                         break;  
   
                                 case HSHELL_WINDOWDESTROYED:  
                                   
                                         //get window id  
                                         windowHandle = (HWND) wParam;  
                                         itoa((int)windowHandle, strWindowId, 10);  
                                           
                                         //get name  
                                         GetWindowText(windowHandle,windowTitle,150);  
   
                                         ////setup return string  
                                         strcat(result, "MSG=HSHELL_WINDOWDESTROYED;");  
                                         strcat( result, "ID=" );  
                                         strcat( result, strWindowId );  
                                         strcat( result, ";" );  
                                         strcat( result, "TITLE=" );  
                                         strcat( result, windowTitle);  
                                         strcat( result, ";" );  
   
                                         buffer = result;  
   
                                         break;  
                                 default:  
                                         break;  
                         }  
   
                 if ( buffer != NULL)  
                 {  
                         WriteToChannel(buffer);  
                 }  
         }  
           
         return CallNextHookEx(hhook, nCode, wParam, lParam);  
 }  
   
 DLL_EXPORT void SetCbtHook(void)  
 {  
         if (!bHooked)  
         {  
                 hhook           = SetWindowsHookEx(WH_CBT, (HOOKPROC)CbtProc, hInst, (DWORD)NULL);  
                 bHooked         = true;  
         }  
   
         if (!bHooked2)  
         {  
                 hhook2          = SetWindowsHookEx(WH_SHELL, (HOOKPROC)ShellProc, hInst, (DWORD)NULL);    
                 bHooked2                = true;  
         }  
   
         if (!bHooked3)  
         {  
                 hhook3          = SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)CallWndProc, hInst, (DWORD)NULL);    
                 bHooked3                = true;  
         }  
 }  
   
 DLL_EXPORT      void RemoveCbtHook(void)  
 {  
         if(bHooked)  
         {  
                 UnhookWindowsHookEx(hhook);      
                 bHooked = false;  
         }  
   
         if(bHooked2)  
         {  
                 UnhookWindowsHookEx(hhook2);      
                 bHooked2 = false;  
         }  
   
         if(bHooked3)  
         {  
                 UnhookWindowsHookEx(hhook3);      
                 bHooked3 = false;  
         }  
474  }  }
475    
476  DLL_EXPORT int GetInstanceCount()  DLL_EXPORT int GetInstanceCount()
477  {  {
478          return iInstanceCount;      return iInstanceCount;
479  }  }
480    
481  int OpenVirtualChannel()  int OpenVirtualChannel()
482  {  {
483                  m_vcHandle = WTSVirtualChannelOpen(WTS_CURRENT_SERVER_HANDLE,WTS_CURRENT_SESSION,CHANNELNAME);      m_vcHandle = WTSVirtualChannelOpen( WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, CHANNELNAME );
484                        
485                  if (m_vcHandle==NULL)      if ( m_vcHandle == NULL ) {
486                  {          return 0;
487                          return 0;      } else {
488                  }          return 1;
489                  else      }
                 {  
                         return 1;  
                 }  
490  }  }
491    
492  int CloseVirtualChannel()  int CloseVirtualChannel()
493  {  {
494          BOOL result = WTSVirtualChannelClose(m_vcHandle);      BOOL result = WTSVirtualChannelClose( m_vcHandle );
495          
496           m_vcHandle = NULL;      m_vcHandle = NULL;
497                
498          if (result)      if ( result ) {
499          {          return 1;
500                  return 1;      } else {
501          }          return 0;
502          else      }
         {  
                 return 0;  
         }  
503  }  }
504    
505  int ChannelIsOpen()  int ChannelIsOpen()
506  {  {
507          if (m_vcHandle==NULL)      if ( m_vcHandle == NULL ) {
508          {          return 0;
509                  return 0;      } else {
510          }          return 1;
511          else      }
512          {  }
513                  return 1;  
514          }  int WriteToChannel( PCHAR buffer )
515  }  {
516        PULONG bytesRead = 0;
517  int WriteToChannel(PCHAR buffer)      PULONG pBytesWritten = 0;
518  {      
519      PULONG bytesRead      = 0;      BOOL result = WTSVirtualChannelWrite( m_vcHandle, buffer, ( ULONG ) strlen( buffer ), pBytesWritten );
520          PULONG pBytesWritten  = 0;      
521        if ( result ) {
522          BOOL result = WTSVirtualChannelWrite(m_vcHandle,buffer,(ULONG) strlen(buffer),pBytesWritten);          return 1;
523                } else {
524          if (result)          return 0;
525          {      }
                 return 1;  
         }  
         else  
         {  
                 return 0;  
         }  
526  }  }
Legend:
Removed from v.930  
changed lines
  Added in v.999
  ViewVC Help
Powered by ViewVC 1.1.26