home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / msj / msjv4_1 / sleuth / macsl / mpmquery.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-10-04  |  13.0 KB  |  487 lines
  1. /*-----------------------------------------------------------------*/
  2. /* MpmQuery.c                                                      */
  3. /* Information gathering functions                                 */
  4. /*-----------------------------------------------------------------*/
  5.  
  6. #include "MacPM.h"
  7.  
  8. /*-----------------------------------------------------------------*/
  9. /* Stuff pahwndKids with the child window handles of hwndParent    */
  10. /* from idMin to idMax.                                            */
  11. /*-----------------------------------------------------------------*/
  12.  
  13. SHORT APIENTRY WinMultWindowFromIDs( hwndParent, pahwndKids,
  14.                                     idMin, idMax )
  15.     HWND        hwndParent;
  16.     PHWND       pahwndKids;
  17.     USHORT      idMin, idMax;
  18. {
  19.     HWND        hwnd;
  20.     USHORT      id;
  21.     SHORT       sFound;
  22.  
  23.     memset( pahwndKids, 0, (idMax - idMin + 1) * sizeof(HWND) );
  24.  
  25.     if( ! MpmValidateWindow(hwndParent) )
  26.       return 0;
  27.  
  28.     if( ISDESKTOPWINDOW(hwndParent) )
  29.       return 0;  /* could handle this case... */
  30.  
  31.     sFound = 0;
  32.  
  33.     for( hwnd = MYWNDOF(hwndParent).hwndTopChild;
  34.          hwnd;
  35.          hwnd = MYWNDOF(hwnd).hwndNextSibling )
  36.     {
  37.       id = MYWNDOF(hwnd).id;
  38.       if( id >= idMin  &&  id <= idMax )
  39.       {
  40.         pahwndKids[ id - idMin ] = hwnd;
  41.         sFound++;
  42.       }
  43.     }
  44.     
  45.     return sFound;
  46. }
  47.  
  48. /*-----------------------------------------------------------------*/
  49. /* Return the active window handle.  We ignore fLock.              */
  50. /*-----------------------------------------------------------------*/
  51.  
  52. HWND APIENTRY WinQueryActiveWindow( hwndDesktop, fLock )
  53.     HWND        hwndDesktop;
  54.     BOOL        fLock;
  55. {
  56.     ASSERT( ! hwndDesktop  ||
  57.             hwndDesktop == HWND_DESKTOP  ||
  58.             hwndDesktop == _hwndDesktop,
  59.             "WinQueryActiveWindow: bad hwndDesktop" );
  60.  
  61.     return _hwndActive;
  62. }
  63.  
  64. /*-----------------------------------------------------------------*/
  65. /* Fill pszName (max len sNameMax) with hwnd's window class name.  */
  66. /*-----------------------------------------------------------------*/
  67.  
  68. SHORT APIENTRY WinQueryClassName( hwnd, sNameMax, pszName )
  69.     HWND        hwnd;
  70.     SHORT       sNameMax;
  71.     PSZ         pszName;
  72. {
  73.     SHORT       sNameLen;
  74.  
  75.     pszName[0] = '\0';
  76.  
  77.     if( ! MpmValidateWindow(hwnd) )
  78.       return 0;
  79.  
  80.     if( ! sNameMax )
  81.       return 0;
  82.  
  83.     sNameLen = strlen( MYCLASSOF(hwnd).szName );
  84.     if( sNameLen > sNameMax-1 )
  85.       sNameLen = sNameMax - 1;
  86.  
  87.     memcpy( pszName, MYCLASSOF(hwnd).szName, sNameLen );
  88.     pszName[sNameLen] = '\0';
  89.  
  90.     return sNameLen;
  91. }
  92.  
  93. /*-----------------------------------------------------------------*/
  94. /* Return the desktop window handle.                               */
  95. /*-----------------------------------------------------------------*/
  96.  
  97. HWND APIENTRY WinQueryDesktopWindow( hab, hdc )
  98.     HAB         hab;
  99.     HDC         hdc;
  100. {
  101.     ASSERT( ! hdc,
  102.             "WinQueryDesktopWindow: hdc must be NULL" );
  103.  
  104.     /* ignore hab */
  105.  
  106.     return _hwndDesktop;
  107. }
  108.  
  109. /*-----------------------------------------------------------------*/
  110. /* Return the object window handle.                                */
  111. /*-----------------------------------------------------------------*/
  112.  
  113. HWND APIENTRY WinQueryObjectWindow( hwndDesktop )
  114.     HWND        hwndDesktop;
  115. {
  116.     ASSERT( ! hwndDesktop  ||
  117.             hwndDesktop == HWND_DESKTOP  ||
  118.             hwndDesktop == _hwndDesktop,
  119.             "WinQueryObjectWindow: bad hwndDesktop" );
  120.  
  121.     return _hwndObject;
  122. }
  123.  
  124. /*-----------------------------------------------------------------*/
  125. /* Return one of the SV_ system values.                            */
  126. /*-----------------------------------------------------------------*/
  127.  
  128. LONG APIENTRY WinQuerySysValue( hwndDesktop, iSysValue )
  129.     HWND        hwndDesktop;
  130.     SHORT       iSysValue;
  131. {
  132.     if( iSysValue < 0 || iSysValue >= SV_CSYSVALUES )
  133.       return 0;
  134.  
  135.     return _alSysVal[iSysValue];
  136. }
  137.  
  138. /*-----------------------------------------------------------------*/
  139. /* Return one of hwnd's relatives as determined by cmd.            */
  140. /* This is done differently depending on hwnd's WK_ window kind,   */
  141. /* since we use the Mac's window information for WK_MAIN windows,  */
  142. /* and our own fields for child windows.                           */
  143. /* We ignore fLock.                                                */
  144. /*-----------------------------------------------------------------*/
  145.  
  146. HWND APIENTRY WinQueryWindow( hwnd, cmd, fLock )
  147.     HWND        hwnd;
  148.     SHORT       cmd;
  149.     BOOL        fLock;
  150. {
  151.     UCHAR       ucKind;
  152.     WindowPeek  pwin;
  153.  
  154.     if( ! MpmValidateWindow(hwnd) )
  155.       return FALSE;
  156.  
  157.     ucKind = MYWNDOF(hwnd).ucKind;
  158.  
  159. top:
  160.     switch( cmd )
  161.     {
  162.       case QW_NEXT:
  163.         switch( ucKind )
  164.         {
  165.           case WK_DESKTOP:
  166.           case WK_OBJECT:
  167.             return NULL;
  168.           case WK_MAIN:
  169.             pwin = PWINOFHWND(hwnd)->nextWindow;
  170.             return pwin ? HWNDOFPWIN(pwin) : NULL;
  171.           case WK_CHILD:
  172.             return MYWNDOF(hwnd).hwndNextSibling;
  173.         }
  174.         break;
  175.  
  176.       case QW_PREV:
  177.         switch( ucKind )
  178.         {
  179.           case WK_DESKTOP:
  180.           case WK_OBJECT:
  181.             return NULL;
  182.           case WK_MAIN:
  183.             return NULL;  /* later take care of this... */
  184.           case WK_CHILD:
  185.             return MYWNDOF(hwnd).hwndPrevSibling;
  186.         }
  187.         break;
  188.  
  189.       case QW_TOP:
  190.         switch( ucKind )
  191.         {
  192.           case WK_DESKTOP:
  193.             return HWNDOFPWIN( WindowList );
  194.           case WK_OBJECT:
  195.           case WK_MAIN:
  196.           case WK_CHILD:
  197.             return MYWNDOF(hwnd).hwndTopChild;
  198.         }
  199.         break;
  200.  
  201.       case QW_BOTTOM:
  202.         switch( ucKind )
  203.         {
  204.           case WK_DESKTOP:
  205.             return NULL;  /* later... */
  206.           case WK_OBJECT:
  207.           case WK_MAIN:
  208.           case WK_CHILD:
  209.             return MYWNDOF(hwnd).hwndBottomChild;
  210.         }
  211.         break;
  212.  
  213.       case QW_OWNER:
  214.         return MYWNDOF(hwnd).hwndOwner;
  215.  
  216.       case QW_PARENT:
  217.         switch( ucKind )
  218.         {
  219.           case WK_DESKTOP:
  220.           case WK_OBJECT:
  221.           case WK_MAIN:
  222.             return NULL;
  223.           case WK_CHILD:
  224.             return MYWNDOF(hwnd).hwndParent;
  225.         }
  226.         break;
  227.  
  228.       case QW_NEXTTOP:
  229.         switch( ucKind )
  230.         {
  231.           case WK_DESKTOP:
  232.           case WK_OBJECT:
  233.             return NULL;
  234.           case WK_MAIN:
  235.             cmd = QW_NEXT;
  236.             goto top;
  237.           case WK_CHILD:
  238.             while( ISCHILDWINDOW(hwnd) )
  239.               hwnd = MYWNDOF(hwnd).hwndParent;
  240.             return hwnd;
  241.         }
  242.         break;
  243.  
  244.       case QW_PREVTOP:
  245.         switch( ucKind )
  246.         {
  247.           case WK_DESKTOP:
  248.           case WK_OBJECT:
  249.             return NULL;
  250.           case WK_MAIN:
  251.             cmd = QW_PREV;
  252.             goto top;
  253.           case WK_CHILD:
  254.             cmd = QW_NEXTTOP;
  255.             goto top;
  256.         }
  257.         break;
  258.     }
  259.  
  260.     return NULL;
  261. }
  262.  
  263. /*-----------------------------------------------------------------*/
  264. /* Return the lock count for a window.  Always 0 in MacPM!         */
  265. /*-----------------------------------------------------------------*/
  266.  
  267. SHORT APIENTRY WinQueryWindowLockCount( hwnd )
  268.     HWND        hwnd;
  269. {
  270.     MpmValidateWindow( hwnd );
  271.  
  272.     return 0;
  273. }
  274.  
  275. /*-----------------------------------------------------------------*/
  276. /* Fill *pswp with the position and size of hwnd.                  */
  277. /*-----------------------------------------------------------------*/
  278.  
  279. BOOL APIENTRY WinQueryWindowPos( hwnd, pswp )
  280.     HWND        hwnd;
  281.     PSWP        pswp;
  282. {
  283.     PMYWND      pwnd;
  284.  
  285.     if( ! MpmValidateWindow(hwnd) )
  286.       return FALSE;
  287.  
  288.     pwnd = PMYWNDOF(hwnd);
  289.     pswp->fs = SWP_MOVE | SWP_SIZE;
  290.     if( pwnd->ucKind == WK_MAIN )
  291.     {
  292.       if( pwnd->pwin == (WindowPeek)FrontWindow() )
  293.         pswp->fs |= SWP_ACTIVATE;
  294.       else
  295.         pswp->fs |= SWP_DEACTIVATE;
  296.     }
  297.     pswp->x  = pwnd->x;
  298.     pswp->y  = pwnd->y;
  299.     pswp->cx = pwnd->cx;
  300.     pswp->cy = pwnd->cy;
  301.     pswp->hwnd = hwnd;
  302.     pswp->hwndInsertBehind = NULL;
  303.  
  304.     return TRUE;
  305. }
  306.  
  307. /*-----------------------------------------------------------------*/
  308. /* Fill *ppid and *ptid with the process and task ID's for hwnd.   */
  309. /* In MacPM, these are fake values.                                */
  310. /*-----------------------------------------------------------------*/
  311.  
  312. BOOL APIENTRY WinQueryWindowProcess( hwnd, ppid, ptid )
  313.     HWND        hwnd;
  314.     PPID        ppid;
  315.     PTID        ptid;
  316. {
  317.     if( ! MpmValidateWindow(hwnd) )
  318.       return FALSE;
  319.  
  320.     *ppid = MY_PID;
  321.     *ptid = MY_PID;
  322.  
  323.     return TRUE;
  324. }
  325.  
  326. /*-----------------------------------------------------------------*/
  327. /* Fill *prcl with the window rectangle for hwnd.                  */
  328. /*-----------------------------------------------------------------*/
  329.  
  330. BOOL APIENTRY WinQueryWindowRect( hwnd, prcl )
  331.     HWND        hwnd;
  332.     PRECTL      prcl;
  333. {
  334.     PMYWND      pwnd;
  335.  
  336.     if( ! MpmValidateWindow(hwnd) )
  337.       return FALSE;
  338.  
  339.     pwnd = PMYWNDOF(hwnd);
  340.  
  341.     prcl->xLeft   = 0;
  342.     prcl->yBottom = 0;
  343.     prcl->xRight  = pwnd->cx;
  344.     prcl->yTop    = pwnd->cy;
  345.  
  346.     return TRUE;
  347. }
  348.  
  349. /*-----------------------------------------------------------------*/
  350. /* Fill *pszText with hwnd's window text, by sending hwnd a        */
  351. /* WM_QUERYWINDOWPARAMS message.                                   */
  352. /*-----------------------------------------------------------------*/
  353.  
  354. SHORT APIENTRY WinQueryWindowText( hwnd, sMax, pszText )
  355.     HWND        hwnd;
  356.     SHORT       sMax;
  357.     PSZ         pszText;
  358. {
  359.     WNDPARAMS   wprm;
  360.  
  361.     pszText[0] = '\0';
  362.  
  363.     memzero( &wprm );
  364.  
  365.     wprm.fsStatus = WPM_TEXT | WPM_CCHTEXT;
  366.     wprm.pszText = pszText;
  367.     wprm.cchText = sMax;
  368.  
  369.     if( WinSendMsg( hwnd, WM_QUERYWINDOWPARAMS, MPFROMP(&wprm), 0 ) )
  370.       return wprm.cchText;
  371.     else
  372.       return 0;
  373. }
  374.  
  375. /*-----------------------------------------------------------------*/
  376. /* Return hwnd's window text length, by sending hwnd a             */
  377. /* WM_QUERYWINDOWPARAMS message.                                   */
  378. /*-----------------------------------------------------------------*/
  379.  
  380. SHORT APIENTRY WinQueryWindowTextLength( hwnd )
  381.     HWND        hwnd;
  382. {
  383.     WNDPARAMS   wprm;
  384.  
  385.     memzero( &wprm );
  386.  
  387.     wprm.fsStatus = WPM_CCHTEXT;
  388.  
  389.     if( WinSendMsg( hwnd, WM_QUERYWINDOWPARAMS, MPFROMP(&wprm), 0 ) )
  390.       return wprm.cchText;
  391.     else
  392.       return 0;
  393. }
  394.  
  395. /*-----------------------------------------------------------------*/
  396. /* Return one of hwnd's long values, as determined by index.       */
  397. /*-----------------------------------------------------------------*/
  398.  
  399. ULONG APIENTRY WinQueryWindowULong( hwnd, index )
  400.     HWND        hwnd;
  401.     SHORT       index;
  402. {
  403.     if( ! MpmValidateWindow(hwnd) )
  404.       return FALSE;
  405.  
  406.     if( index >= QWL_USER )
  407.       return *(PULONG)&MYWNDOF(hwnd).bExtra[index];
  408.  
  409.     switch( index )
  410.     {
  411.       case QWL_STYLE:
  412.         return MYWNDOF(hwnd).flStyle;
  413.  
  414.       case QWP_PFNWP:
  415.         return (ULONG)MYWNDOF(hwnd).pfnwp;
  416.  
  417.       case QWL_HMQ:
  418.         return (ULONG)(HMQ)1;
  419.     }
  420.  
  421.     return 0L;
  422. }
  423.  
  424. /*-----------------------------------------------------------------*/
  425. /* Return one of hwnd's short values, as determined by index.      */
  426. /*-----------------------------------------------------------------*/
  427.  
  428. USHORT APIENTRY WinQueryWindowUShort( hwnd, index )
  429.     HWND        hwnd;
  430.     SHORT       index;
  431. {
  432.     if( ! MpmValidateWindow(hwnd) )
  433.       return FALSE;
  434.  
  435.     if( index >= QWL_USER )
  436.       return *(PUSHORT)&MYWNDOF(hwnd).bExtra[index];
  437.  
  438.     switch( index )
  439.     {
  440.       case QWS_ID:
  441.         return MYWNDOF(hwnd).id;
  442.     }
  443.  
  444.     return 0;
  445. }
  446.  
  447. /*-----------------------------------------------------------------*/
  448. /* Return the child of hwndParent with the specified window ID.    */
  449. /*-----------------------------------------------------------------*/
  450.  
  451. HWND APIENTRY WinWindowFromID( hwndParent, id )
  452.     HWND        hwndParent;
  453.     USHORT      id;
  454. {
  455.     HWND        hwnd;
  456.  
  457.     if( ! MpmValidateWindow(hwndParent) )
  458.       return NULL;
  459.  
  460.     if( ISDESKTOPWINDOW(hwndParent) )
  461.       return NULL;  /* could handle this case... */
  462.  
  463.     for( hwnd = MYWNDOF(hwndParent).hwndTopChild;
  464.          hwnd;
  465.          hwnd = MYWNDOF(hwnd).hwndNextSibling )
  466.       if( MYWNDOF(hwnd).id == id )
  467.         return hwnd;
  468.  
  469.     return NULL;
  470. }
  471.  
  472. /*-----------------------------------------------------------------*/
  473. /* Fill *prect with the Mac rectangle for hwnd.                    */
  474. /*-----------------------------------------------------------------*/
  475.  
  476. LOCAL VOID MpmQueryMacRect( hwnd, prect )
  477.     HWND        hwnd;
  478.     Rect*       prect;
  479. {
  480.     RECTL       rcl;
  481.  
  482.     WinQueryWindowRect( hwnd, &rcl );
  483.     MpmMapMacOfRcl( hwnd, prect, &rcl );
  484. }
  485.  
  486. /*-----------------------------------------------------------------*/
  487.