home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Multimedia Jumpstart 1.1a / CD_ROM.BIN / develpmt / source / hotspot / viewer / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-07  |  8.1 KB  |  303 lines
  1. /**************************************************************************
  2.  *
  3.  *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4.  *  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5.  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6.  *  PURPOSE.
  7.  *
  8.  *  Copyright (c) 1993  Microsoft Corporation.  All Rights Reserved.
  9.  * 
  10.  **************************************************************************/
  11. /*
  12.     main.c:
  13.         HotspotWP -- WindowProc for viewer pane
  14.         LibMain -- called when DLL is loaded
  15.         LDLLHandler -- gets module-related messages from Viewer
  16.         WEP -- called when DLL is unloaded
  17. */
  18. #include <windows.h>
  19. #include <windowsx.h>
  20. #include <mmsystem.h>
  21. #include <digitalv.h>
  22. #include <viewer.h>
  23. #include "hotspot.h"
  24.  
  25. extern char szMovieInfo[];
  26.  
  27. LPSTR szHotspotClassName = "Hotspot";
  28. HANDLE hModule;
  29.  
  30. /*
  31.     HotspotWP -- this is the WindowProc for the viewer pane.
  32.         Answers the WM_CREATE and EWM_QUERYSIZE messages -- see
  33.         comments next to the messages.
  34. */
  35. LONG CALLBACK HotspotWP(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  36. {
  37.     LPEWDATA lpew;
  38.     LPCREATESTRUCT lpCreate;
  39.     LPSTR szAviFile, szIniFile;
  40.  
  41.     switch (msg)
  42.     {
  43.     /* WM_CREATE -- filenames to use were handed in on the
  44.         LPCREATESTRUCT, so we have to unpack them.  That's what
  45.         all this string stuff does.  Once we have the filenames,
  46.         we just hand them to hspPlayAVI, which handles all the
  47.         subclassing and stuff for us.
  48.     */
  49.     case WM_CREATE:
  50.         lpCreate = (LPCREATESTRUCT)lParam;
  51.         lpew = (LPEWDATA)lpCreate->lpCreateParams;
  52.  
  53.         szIniFile = lpew->szAuthorData;
  54.         while (*szIniFile != ',') szIniFile++;
  55.         *szIniFile = '\0';
  56.         szIniFile++;
  57.         szAviFile = lpew->szAuthorData;
  58.         if ((*szAviFile == '\140') || *szAviFile == '\042' );
  59.             szAviFile++; 
  60.         if ((szIniFile[lstrlen(szIniFile)-1] == '\047') ||
  61.             (szIniFile[lstrlen(szIniFile)-1] == '\042') )
  62.             szIniFile[lstrlen(szIniFile)-1] = '\0';
  63.         hspPlayAVI(hwnd, szAviFile,szIniFile,NULL);
  64.         //{
  65.             //PMOVIEINFO pMovieInfo;
  66.             //HANDLE hglb;
  67.             
  68.             //hglb = GetProp(hwnd, (LPSTR)szMovieInfo);
  69.             //if (hglb)
  70.             //{
  71.                 //pMovieInfo = (PMOVIEINFO)GlobalLock(hglb);
  72.                  //if (pMovieInfo && pMovieInfo->fMovieOpen) 
  73.                 //{
  74.                     //MCI_DGV_SETVIDEO_PARMS    dgv;
  75.                     //UINT                    uDevice;
  76.                     //dgv.dwValue = (DWORD)NULL;//ICAVIDrawProc;
  77.                         ////MakeProcInstance((FARPROC) ICAVIDrawProc,hInstApp);
  78.                     //dgv.dwItem = MCI_AVI_SETVIDEO_DRAW_PROCEDURE;
  79.                     //uDevice = pMovieInfo->wMCIDeviceID;
  80.                     //if (uDevice)
  81.                     //{
  82.                         //DWORD dw;
  83.                                 
  84.                         //dw = mciSendCommand(uDevice,
  85.                         //MCI_SETVIDEO,
  86.                         //MCI_DGV_SETVIDEO_ITEM | MCI_DGV_SETVIDEO_VALUE,
  87.                         //(DWORD) (MCI_DGV_SETVIDEO_PARMS FAR *)&dgv);
  88.                         //OutputDebugString("set draw proc!\n");
  89.                         //if (dw != 0)
  90.                         //{
  91.                             //MessageBox(GetFocus(),
  92.                                 //"The currently installed MCIAVI does not "
  93.                                 //"support the MCI_AVI_SETVIDEO_DRAW_PROCEDURE "
  94.                                 //"command during play.","MCI Problem",
  95.                                 //MB_OK | MB_ICONHAND);
  96.                         //}
  97.                     //}
  98.                     //else
  99.                     //{
  100.                         //MessageBox(GetFocus(),"movie info has no device id",
  101.                             //"real bummer",MB_OK);
  102.                     //}
  103.                     //playMovie(pMovieInfo, 1);
  104.                 //}
  105.                 //else
  106.                 //{
  107.                     //OutputDebugString(
  108.                         //"no pMovieInfo && pMovieInfo->fMovieOpen\n");
  109.                 //}
  110.             //}
  111.             //else
  112.             //{
  113.                 //OutputDebugString("NO WINDOW PROPERTY!!\n");
  114.             //}
  115.         //}
  116.         return 0;
  117.     /* EWM_QUERYSIZE -- the viewer wants to know the pane size.
  118.         hspPlayAVI already glued a handle to the movieinfo structure
  119.         onto this window with SetProp. So, we use GetProp to get the
  120.         movieinfo, which has a deviceID we can then use to ask
  121.         MCI for the size numbers.(with the MCI_WHERE) command.
  122.      */
  123.     case EWM_QUERYSIZE:
  124.         dbg("HotspotWP EWM_QUERYSIZE");
  125.     {
  126.         LPPOINT lpPoint = (LPPOINT) lParam;
  127.         HANDLE hglb;
  128.         PMOVIEINFO pMovieInfo;
  129.         MCI_DGV_RECT_PARMS   mciRect;
  130.     
  131.         hglb = GetProp(hwnd, (LPSTR)szMovieInfo);
  132.         if (!hglb)
  133.         {
  134.             return FALSE;
  135.         }
  136.         pMovieInfo = (PMOVIEINFO)GlobalLock(hglb);
  137.          if (!pMovieInfo->fMovieOpen) 
  138.         {
  139.             GlobalUnlock(hglb);
  140.             return FALSE;
  141.         }
  142.         mciSendCommand(pMovieInfo->wMCIDeviceID, MCI_WHERE, 
  143.                   (DWORD)(MCI_DGV_WHERE_SOURCE), 
  144.                   (DWORD)(LPMCI_DGV_RECT_PARMS)&mciRect);
  145.         lpPoint->x = mciRect.rc.right - mciRect.rc.left; 
  146.         lpPoint->y = mciRect.rc.bottom - mciRect.rc.top; 
  147.         GlobalUnlock(hglb);
  148.         return TRUE;
  149.     }
  150.     /* now we just refuse a few viewer questions... */
  151.     case EWM_ASKPALETTE:
  152.         return NULL;
  153.     case EWM_RENDER:
  154.         return NULL;
  155.     case EWM_COPY:
  156.         return NULL;
  157.     case EWM_PRINT:
  158.         return FALSE;
  159.     case WM_PARENTNOTIFY:
  160.         OutputDebugString("WM_PARENTNOTIFY !!!!!\n");
  161.         if (wParam == WM_LBUTTONDOWN)
  162.         {
  163.             OutputDebugString("WM_LBUTTONDOWN even !!!!!\n");
  164.         }
  165.         else
  166.         {
  167.             {char x[256]; wsprintf(x,"value %X\n",wParam);
  168.                 OutputDebugString(x);   }
  169.             //if (wParam == 1)
  170.             //{
  171.                 //PMOVIEINFO pMovieInfo;
  172.                 //HANDLE hglb;
  173.             
  174.                 //hglb = GetProp(hwnd, (LPSTR)szMovieInfo);
  175.                 //if (hglb)
  176.                 //{
  177.                     //pMovieInfo = (PMOVIEINFO)GlobalLock(hglb);
  178.                      //if (pMovieInfo && pMovieInfo->fMovieOpen) 
  179.                     //{
  180.                         //MCI_DGV_SETVIDEO_PARMS    dgv;
  181.                         //UINT                    uDevice;
  182.                         //dgv.dwValue = (DWORD)ICAVIDrawProc;
  183.                             ////MakeProcInstance((FARPROC) ICAVIDrawProc,hInstApp);
  184.                         //dgv.dwItem = MCI_AVI_SETVIDEO_DRAW_PROCEDURE;
  185.                         //uDevice = pMovieInfo->wMCIDeviceID;
  186.                         //if (uDevice)
  187.                         //{
  188.                             //DWORD dw;
  189.                                 
  190.                             //dw = mciSendCommand(uDevice,
  191.                             //MCI_SETVIDEO,
  192.                             //MCI_DGV_SETVIDEO_ITEM | MCI_DGV_SETVIDEO_VALUE,
  193.                             //(DWORD) (MCI_DGV_SETVIDEO_PARMS FAR *)&dgv);
  194.                             //OutputDebugString("set draw proc!\n");
  195.                             //if (dw != 0)
  196.                             //{
  197.                                 //MessageBox(GetFocus(),
  198.                                     //"The currently installed MCIAVI does not "
  199.                                     //"support the MCI_AVI_SETVIDEO_DRAW_PROCEDURE "
  200.                                     //"command during play.","MCI Problem",
  201.                                     //MB_OK | MB_ICONHAND);
  202.                             //}
  203.                         //}
  204.                         //else
  205.                         //{
  206.                             //MessageBox(GetFocus(),"movie info has no device id",
  207.                                 //"real bummer",MB_OK);
  208.                         //}
  209.                     //}
  210.                     //else
  211.                     //{
  212.                         //OutputDebugString(
  213.                             //"no pMovieInfo && pMovieInfo->fMovieOpen\n");
  214.                     //}
  215.                 //}
  216.                 //else
  217.                 //{
  218.                     //OutputDebugString("NO WINDOW PROPERTY!!\n");
  219.                 //}
  220.             //}
  221.             break;
  222.         //case MCIWNDM_NOTIFYSIZE:
  223.             //OutputDebugString("MCIWNDM_NOTIFYMEDIA\n");
  224.             //if (hwndMCI == 0)
  225.             //{
  226.                 //hwndMCI = (HWND) wParam;
  227.             //}
  228.             //GetWindowRect(hwndMCI, &rc);
  229.             //AdjustWindowRect(&rc, GetWindowLong(hwnd, GWL_STYLE), TRUE);
  230.             //SetWindowPos(hwnd, NULL, 0, 0, rc.right - rc.left,
  231.                 //rc.bottom - rc.top,
  232.                 //SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
  233.             //break;
  234.         }
  235.         break;
  236.     default:
  237.         return DefWindowProc(hwnd, msg, wParam, lParam);
  238.     }
  239.     return FALSE;
  240. }
  241.  
  242. /*
  243.     LibMain -- sets global hModule variable, and registers the
  244.         window class for our viewer pane so Windows can get a pointer
  245.         to our windowproc (i.e. hotspotWP above).  We also call
  246.         initAVI.
  247. */
  248. BOOL CALLBACK LibMain(HANDLE hLibrary, int cbHeap, LPSTR szCmdLine)
  249. {
  250.     WNDCLASS wc;
  251.  
  252.     hModule = hLibrary;
  253.     initAVI();
  254.     wc.lpszClassName = szHotspotClassName;
  255.     wc.style = CS_GLOBALCLASS;
  256.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  257.     wc.hIcon = NULL;
  258.     wc.lpszMenuName = NULL;
  259.     wc.hbrBackground = COLOR_WINDOW + 1;
  260.     wc.hInstance = hModule;
  261.     wc.lpfnWndProc = HotspotWP;
  262.     wc.cbClsExtra = 0;
  263.     wc.cbWndExtra = NULL;
  264.  
  265.     return RegisterClass(&wc);
  266. }
  267.  
  268. /*
  269.     LDLLHandler -- a message handler that talks to viewer on behalf
  270.         of our whole DLL (rather than one window of it)
  271.         
  272.         handles DW_WHATMSG, DW_INIT, DW_TERM. 
  273. */
  274. LONG CALLBACK LDLLHandler(UINT msg, LONG lParam1, LONG lParam2)
  275. {
  276.     switch (msg)
  277.     {
  278.     
  279.     case DW_WHATMSG:        
  280.         return DC_INITTERM;
  281.         
  282.     case DW_INIT:    
  283.  
  284.         return TRUE; 
  285.         
  286.     case DW_TERM:
  287.         return 0;
  288.     }
  289.     return 0;
  290. }
  291.  
  292.  
  293. /*
  294.     WEP -- windows exit procedure
  295.         Calls termAVI to close AVI device drivers
  296. */
  297. int CALLBACK WEP(int nExitType)
  298. {
  299.     termAVI();    
  300.     
  301.     return (TRUE);
  302. }    
  303.