programs/oleview/oleview.c

   1 /*
   2  * OleView (oleview.c)
   3  *
   4  * Copyright 2006 Piotr Caban
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "main.h"
  22
  23 GLOBALS globals;
  24 static WCHAR wszRegEdit[] = { 'r','e','g','e','d','i','t','.','e','x','e','\0' };
  25
  26 INT_PTR CALLBACK CreateInstOnProc(HWND hDlgWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  27 {
  28     HWND hEdit;
  29
  30     switch(uMsg)
  31     {
  32         case WM_COMMAND:
  33             switch(LOWORD(wParam)) {
  34             case IDOK:
  35                 memset(globals.wszMachineName, 0, sizeof(WCHAR[MAX_LOAD_STRING]));
  36                 hEdit = GetDlgItem(hDlgWnd, IDC_MACHINE);
  37
  38                 if (GetWindowTextLength(hEdit)>0)
  39                     GetWindowText(hEdit, globals.wszMachineName, MAX_LOAD_STRING);
  40
  41                 EndDialog(hDlgWnd, IDOK);
  42                 return TRUE;
  43             case IDCANCEL:
  44                 EndDialog(hDlgWnd, IDCANCEL);
  45                 return TRUE;
  46             }
  47     }
  48
  49     return FALSE;
  50 }
  51
  52 void ResizeChild(void)
  53 {
  54     RECT client, stat, tool;
  55
  56     MoveWindow(globals.hStatusBar, 0, 0, 0, 0, TRUE);
  57     MoveWindow(globals.hToolBar, 0, 0, 0, 0, TRUE);
  58
  59     if(IsWindowVisible(globals.hStatusBar))
  60         GetClientRect(globals.hStatusBar, &stat);
  61     else stat.bottom = 0;
  62
  63     if(IsWindowVisible(globals.hToolBar))
  64     {
  65         GetClientRect(globals.hToolBar, &tool);
  66         tool.bottom += 2;
  67     }
  68     else tool.bottom = 0;
  69
  70     GetClientRect(globals.hMainWnd, &client);
  71     MoveWindow(globals.hPaneWnd, 0, tool.bottom,
  72             client.right, client.bottom-tool.bottom-stat.bottom, TRUE);
  73 }
  74
  75 void RefreshMenu(HTREEITEM item)
  76 {
  77     TVITEM tvi;
  78     HTREEITEM parent;
  79     HMENU hMenu = GetMenu(globals.hMainWnd);
  80
  81     memset(&tvi, 0, sizeof(TVITEM));
  82     tvi.hItem = item;
  83     SendMessage(globals.hTree, TVM_GETITEM, 0, (LPARAM)&tvi);
  84
  85     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_CREATEINST, FALSE);
  86     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_RELEASEINST, FALSE);
  87     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_VIEW, FALSE);
  88
  89     if(tvi.lParam && ((ITEM_INFO *)tvi.lParam)->cFlag&SHOWALL)
  90     {
  91         EnableMenuItem(hMenu, IDM_COPYCLSID, MF_ENABLED);
  92         EnableMenuItem(hMenu, IDM_HTMLTAG, MF_ENABLED);
  93         EnableMenuItem(hMenu, IDM_VIEW, MF_GRAYED);
  94
  95         if(!((ITEM_INFO *)tvi.lParam)->loaded)
  96         {
  97             EnableMenuItem(hMenu, IDM_CREATEINST, MF_ENABLED);
  98             EnableMenuItem(hMenu, IDM_CREATEINSTON, MF_ENABLED);
  99             EnableMenuItem(hMenu, IDM_RELEASEINST, MF_GRAYED);
 100             SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_CREATEINST, TRUE);
 101         }
 102         else
 103         {
 104             EnableMenuItem(hMenu, IDM_CREATEINST, MF_GRAYED);
 105             EnableMenuItem(hMenu, IDM_CREATEINSTON, MF_GRAYED);
 106             EnableMenuItem(hMenu, IDM_RELEASEINST, MF_ENABLED);
 107             SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_RELEASEINST, TRUE);
 108         }
 109     }
 110     else if(tvi.lParam && ((ITEM_INFO *)tvi.lParam)->cFlag&INTERFACE)
 111     {
 112         EnableMenuItem(hMenu, IDM_TYPEINFO, MF_GRAYED);
 113         EnableMenuItem(hMenu, IDM_CREATEINST, MF_GRAYED);
 114         EnableMenuItem(hMenu, IDM_CREATEINSTON, MF_GRAYED);
 115         EnableMenuItem(hMenu, IDM_RELEASEINST, MF_GRAYED);
 116         EnableMenuItem(hMenu, IDM_COPYCLSID, MF_ENABLED);
 117         EnableMenuItem(hMenu, IDM_HTMLTAG, MF_GRAYED);
 118         EnableMenuItem(hMenu, IDM_VIEW, MF_ENABLED);
 119         SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_VIEW, TRUE);
 120     }
 121     else
 122     {
 123         EnableMenuItem(hMenu, IDM_TYPEINFO, MF_GRAYED);
 124         EnableMenuItem(hMenu, IDM_CREATEINST, MF_GRAYED);
 125         EnableMenuItem(hMenu, IDM_CREATEINSTON, MF_GRAYED);
 126         EnableMenuItem(hMenu, IDM_RELEASEINST, MF_GRAYED);
 127         EnableMenuItem(hMenu, IDM_COPYCLSID, MF_GRAYED);
 128         EnableMenuItem(hMenu, IDM_HTMLTAG, MF_GRAYED);
 129         EnableMenuItem(hMenu, IDM_VIEW, MF_GRAYED);
 130     }
 131     parent = TreeView_GetParent(globals.hTree, item);
 132     if(parent==tree.hAID || parent==tree.hGBCC)
 133         EnableMenuItem(hMenu, IDM_COPYCLSID, MF_ENABLED);
 134 }
 135
 136 int MenuCommand(WPARAM wParam, HWND hWnd)
 137 {
 138     BOOL vis;
 139     HTREEITEM hSelect;
 140     WCHAR wszAbout[MAX_LOAD_STRING];
 141     WCHAR wszAboutVer[MAX_LOAD_STRING];
 142
 143     switch(wParam)
 144     {
 145         case IDM_ABOUT:
 146             LoadString(globals.hMainInst, IDS_ABOUT, wszAbout,
 147                     sizeof(WCHAR[MAX_LOAD_STRING]));
 148             LoadString(globals.hMainInst, IDS_ABOUTVER, wszAboutVer,
 149                     sizeof(WCHAR[MAX_LOAD_STRING]));
 150             ShellAbout(hWnd, wszAbout, wszAboutVer, NULL);
 151             break;
 152         case IDM_CREATEINST:
 153             hSelect = TreeView_GetSelection(globals.hTree);
 154             CreateInst(hSelect, NULL);
 155             SendMessage(globals.hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)hSelect);
 156             break;
 157         case IDM_CREATEINSTON:
 158             if(DialogBox(0, MAKEINTRESOURCE(DLG_CREATEINSTON),
 159                         hWnd, CreateInstOnProc) == IDCANCEL) break;
 160             hSelect = TreeView_GetSelection(globals.hTree);
 161             CreateInst(hSelect, globals.wszMachineName);
 162             SendMessage(globals.hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)hSelect);
 163             break;
 164         case IDM_RELEASEINST:
 165             hSelect = TreeView_GetSelection(globals.hTree);
 166             ReleaseInst(hSelect);
 167             RefreshMenu(hSelect);
 168             RefreshDetails(hSelect);
 169             break;
 170         case IDM_EXPERT:
 171             globals.bExpert = !globals.bExpert;
 172             CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 173                     globals.bExpert ? MF_CHECKED : MF_UNCHECKED);
 174             EmptyTree();
 175             if(globals.bExpert) AddTreeEx();
 176             else AddTree();
 177             hSelect = TreeView_GetChild(globals.hTree, TVI_ROOT);
 178             SendMessage(globals.hTree, TVM_SELECTITEM, 0, (LPARAM)hSelect);
 179             RefreshMenu(hSelect);
 180             break;
 181         case IDM_FLAG_INSERV:
 182             vis = globals.dwClsCtx&CLSCTX_INPROC_SERVER;
 183             globals.dwClsCtx = globals.dwClsCtx&(~CLSCTX_INPROC_SERVER);
 184             globals.dwClsCtx = globals.dwClsCtx|((~vis)&CLSCTX_INPROC_SERVER);
 185             if(!globals.dwClsCtx) globals.dwClsCtx = vis;
 186             else CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 187                     vis ? MF_UNCHECKED : MF_CHECKED);
 188             break;
 189         case IDM_FLAG_INHANDL:
 190             vis = globals.dwClsCtx&CLSCTX_INPROC_HANDLER;
 191             globals.dwClsCtx = globals.dwClsCtx&(~CLSCTX_INPROC_HANDLER);
 192             globals.dwClsCtx = globals.dwClsCtx|((~vis)&CLSCTX_INPROC_HANDLER);
 193             if(!globals.dwClsCtx) globals.dwClsCtx = vis;
 194             else CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 195                     vis ? MF_UNCHECKED : MF_CHECKED);
 196             break;
 197         case IDM_FLAG_LOCSERV:
 198             vis = globals.dwClsCtx&CLSCTX_LOCAL_SERVER;
 199             globals.dwClsCtx = globals.dwClsCtx&(~CLSCTX_LOCAL_SERVER);
 200             globals.dwClsCtx = globals.dwClsCtx|((~vis)&CLSCTX_LOCAL_SERVER);
 201             if(!globals.dwClsCtx) globals.dwClsCtx = vis;
 202             else CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 203                     vis ? MF_UNCHECKED : MF_CHECKED);
 204             break;
 205         case IDM_FLAG_REMSERV:
 206             vis = globals.dwClsCtx&CLSCTX_REMOTE_SERVER;
 207             globals.dwClsCtx = globals.dwClsCtx&(~CLSCTX_REMOTE_SERVER);
 208             globals.dwClsCtx = globals.dwClsCtx|((~vis)&CLSCTX_REMOTE_SERVER);
 209             if(!globals.dwClsCtx) globals.dwClsCtx = vis;
 210             else CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 211                     vis ? MF_UNCHECKED : MF_CHECKED);
 212             break;
 213         case IDM_REFRESH:
 214             EmptyTree();
 215             if(globals.bExpert) AddTreeEx();
 216             else AddTree();
 217             hSelect = TreeView_GetChild(globals.hTree, TVI_ROOT);
 218             SendMessage(globals.hTree, TVM_SELECTITEM, 0, (LPARAM)hSelect);
 219             RefreshMenu(hSelect);
 220             break;
 221         case IDM_REGEDIT:
 222         {
 223             STARTUPINFO si;
 224             PROCESS_INFORMATION pi;
 225
 226             memset(&si, 0, sizeof(si));
 227             si.cb = sizeof(si);
 228             CreateProcess(NULL, wszRegEdit, NULL, NULL, FALSE, 0,\
 229                     NULL, NULL, &si, &pi);
 230             CloseHandle(pi.hProcess);
 231             CloseHandle(pi.hThread);
 232             break;
 233         }
 234         case IDM_STATUSBAR:
 235             vis = IsWindowVisible(globals.hStatusBar);
 236             ShowWindow(globals.hStatusBar, vis ? SW_HIDE : SW_SHOW);
 237             CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 238                     vis ? MF_UNCHECKED : MF_CHECKED);
 239             ResizeChild();
 240             break;
 241         case IDM_TOOLBAR:
 242             vis = IsWindowVisible(globals.hToolBar);
 243             ShowWindow(globals.hToolBar, vis ? SW_HIDE : SW_SHOW);
 244             CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 245                     vis ? MF_UNCHECKED : MF_CHECKED);
 246             ResizeChild();
 247             break;
 248         case IDM_EXIT:
 249             DestroyWindow(hWnd);
 250             break;
 251     }
 252     return 0;
 253 }
 254
 255 void UpdateStatusBar(int itemID)
 256 {
 257     WCHAR info[MAX_LOAD_STRING];
 258
 259     if(!LoadString(globals.hMainInst, itemID, info, sizeof(WCHAR[MAX_LOAD_STRING])))
 260         LoadString(globals.hMainInst, IDS_READY, info, sizeof(WCHAR[MAX_LOAD_STRING]));
 261
 262     SendMessage(globals.hStatusBar, SB_SETTEXT, 0, (LPARAM)info);
 263 }
 264
 265 LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg,
 266         WPARAM wParam, LPARAM lParam)
 267 {
 268     switch(uMsg)
 269     {
 270         case WM_CREATE:
 271             OleInitialize(NULL);
 272             if(!CreatePanedWindow(hWnd, &globals.hPaneWnd, globals.hMainInst))
 273                 PostQuitMessage(0);
 274             SetLeft(globals.hPaneWnd, CreateTreeWindow(globals.hMainInst));
 275             SetRight(globals.hPaneWnd, CreateDetailsWindow(globals.hMainInst));
 276             SetFocus(globals.hTree);
 277             break;
 278         case WM_COMMAND:
 279             MenuCommand(LOWORD(wParam), hWnd);
 280             break;
 281         case WM_DESTROY:
 282             OleUninitialize();
 283             EmptyTree();
 284             PostQuitMessage(0);
 285             break;
 286         case WM_MENUSELECT:
 287             UpdateStatusBar(LOWORD(wParam));
 288             break;
 289         case WM_SETFOCUS:
 290             SetFocus(globals.hTree);
 291             break;
 292         case WM_SIZE:
 293             if(wParam == SIZE_MINIMIZED) break;
 294             ResizeChild();
 295             break;
 296         default:
 297             return DefWindowProc(hWnd, uMsg, wParam, lParam);
 298     }
 299     return 0;
 300 }
 301
 302 BOOL InitApplication(HINSTANCE hInst)
 303 {
 304     WNDCLASS wc;
 305     WCHAR wszAppName[MAX_LOAD_STRING];
 306
 307     LoadString(hInst, IDS_APPNAME, wszAppName, sizeof(WCHAR[MAX_LOAD_STRING]));
 308
 309     memset(&wc, 0, sizeof(WNDCLASS));
 310     wc.lpfnWndProc = WndProc;
 311     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 312     wc.lpszMenuName = MAKEINTRESOURCE(IDM_MENU);
 313     wc.lpszClassName = wszAppName;
 314
 315     if(!RegisterClass(&wc))
 316         return FALSE;
 317
 318     return TRUE;
 319 }
 320
 321 BOOL InitInstance(HINSTANCE hInst, int nCmdShow)
 322 {
 323     HWND hWnd;
 324     WCHAR wszAppName[MAX_LOAD_STRING];
 325     WCHAR wszTitle[MAX_LOAD_STRING];
 326     TBBUTTON tB[] = {
 327         {0, 0, 0, BTNS_SEP, {0, 0}, 0, 0},
 328         {0, IDM_BIND, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
 329         {1, IDM_TYPELIB, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
 330         {0, 0, 0, BTNS_SEP, {0, 0}, 0, 0},
 331         {2, IDM_REGEDIT, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
 332         {0, 0, 0, BTNS_SEP, {0, 0}, 0, 0},
 333         {3, IDM_CREATEINST, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
 334         {4, IDM_RELEASEINST, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0},
 335         {0, 0, 0, BTNS_SEP, {0, 0}, 0, 0},
 336         {5, IDM_VIEW, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0}
 337     };
 338
 339     LoadString(hInst, IDS_APPNAME, wszAppName, sizeof(WCHAR[MAX_LOAD_STRING]));
 340     LoadString(hInst, IDS_APPTITLE, wszTitle, sizeof(WCHAR[MAX_LOAD_STRING]));
 341
 342     hWnd = CreateWindow(wszAppName, wszTitle, WS_OVERLAPPEDWINDOW,
 343             CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInst, NULL);
 344     if(!hWnd) return FALSE;
 345
 346     globals.hStatusBar = CreateStatusWindow(WS_VISIBLE|WS_CHILD,
 347             (LPWSTR)wszTitle, hWnd, 0);
 348
 349     globals.hToolBar = CreateToolbarEx(hWnd, WS_CHILD|WS_VISIBLE, 0, 1, hInst,
 350             IDB_TOOLBAR, tB, 10, 16, 16, 16, 16, sizeof(TBBUTTON));
 351     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_CREATEINST, FALSE);
 352     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_RELEASEINST, FALSE);
 353     SendMessage(globals.hToolBar, TB_ENABLEBUTTON, IDM_VIEW, FALSE);
 354
 355     globals.hMainWnd = hWnd;
 356     globals.hMainInst = hInst;
 357     globals.bExpert = TRUE;
 358     globals.dwClsCtx = CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER;
 359
 360     ShowWindow(hWnd, nCmdShow);
 361     UpdateWindow(hWnd);
 362
 363     return TRUE;
 364 }
 365
 366 int APIENTRY wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst,
 367                 LPWSTR lpCmdLine, int nCmdShow)
 368 {
 369     MSG msg;
 370     HANDLE hAccelTable;
 371
 372     if(!hPrevInst)
 373     {
 374         if(!InitApplication(hInst))
 375             return FALSE;
 376     }
 377
 378     if(!InitInstance(hInst, nCmdShow))
 379         return FALSE;
 380
 381     hAccelTable = LoadAccelerators(hInst, MAKEINTRESOURCE(IDA_OLEVIEW));
 382
 383     while(GetMessage(&msg, NULL, 0, 0))
 384     {
 385         if(TranslateAccelerator(globals.hMainWnd, hAccelTable, &msg)) continue;
 386
 387         TranslateMessage(&msg);
 388         DispatchMessage(&msg);
 389     }
 390
 391     return msg.wParam;
 392 }