dalcwdde.c

此代码为WCE5.0下显示器的源代码

              case DAL_CONTROLLER_CAPS_HW_ICON:                
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_HW_ICON;
                break;

              case DAL_CONTROLLER_CAPS_OVERLAY_GAMMA:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_OVERLAY_GAMMA;
                break;

              case DAL_CONTROLLER_CAPS_CURSOR_BLINK:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_CURSOR_BLINK_SPEED;
                break;

              case DAL_CONTROLLER_CAPS_EXCLUSIVE_HW_CURSOR_ICON:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_EXCLV_HW_CURSOR_ICON;
                break;

              case DAL_CONTROLLER_CAPS_SWITCHABLE_OVERLAY:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_SWITCHABLE_OVERLAY;
                break;

            }

            i <<= 1;

          };

          // force these values to zero in case the caller is trying to read
          // so information out of these in a future version and we do not
          // support that future version.

          lpControllerCaps->ulReserved1 = 0;
          lpControllerCaps->ulReserved2 = 0;
          lpControllerCaps->ulReserved3 = 0;
        }
      }
      *lpInfoSize = sizeof(CONTROLLERCAPS);
      break;

    case CWDDEDI_ControllerGetInfo:
      {
        CONTROLLERINFO FAR *lpControllerInfo;
        LPDEVGCO            lpController;
        LPDEVGDO            lpDisplay;
        GCO_QUERY_STRUCTURE sQueryGCO;
        ULONG               ulIndex;
     //   ULONG               ulHook;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulOutputSize < sizeof(CONTROLLERINFO))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an CONTROLLERINFO structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else if ((!(lpHDE->aControllerMap[lpCmd->ulDriverReserved] &
                       VECTORFROMINDEX(lpCmd->ulIndex))) &&
                     (lpHDE->aControllers[lpCmd->ulIndex].ulFlags & GCO_MAPPED))
        {
          // calling driver does not own the controller, so fail the call
          ulReturn = CWDDE_ERR_BADINPUT;
        } else
        {
          lpController = (LPDEVGCO) &lpHDE->aControllers[lpCmd->ulIndex];

          lpControllerInfo = (CONTROLLERINFO FAR *)lpOutput;
          lpControllerInfo->ulSize = sizeof(CONTROLLERINFO);

          lpControllerInfo->ulDisplaysCanEnable = 0;

          for(i = 0; i < lpHDE->ulDisplaysCount; i++)
          {
            lpDisplay = (LPDEVGDO) &lpHDE->aDisplays[i];

            // mark each display as mapable, and remove it if some condition
            // exists which will restrict it from mapping to the controller

            lpControllerInfo->ulDisplaysCanEnable |= VECTORFROMINDEX(i);
          }

          // get the pertinent info from the GCO

          ZEROMEMORY((LPGCO_QUERY_STRUCTURE) &sQueryGCO, sizeof(GCO_QUERY_STRUCTURE));
          (*lpController->lpHWED->pfnGetInfo)
                          (lpController->hGCO, lpController->ulController,
                           (LPGCO_QUERY_STRUCTURE) &sQueryGCO);

          lpControllerInfo->ulHorizontalRefresh = (sQueryGCO.ulHorizontalRefreshRate / 1000);

          // overlay brightness should be obsolete here;
          ZEROMEMORY((LPVOID)&lpControllerInfo->OverlayGamma, sizeof(HW_ADJUSTMENT));
          if (DAL_OVLADJUST_SUPPORTED_FLAG & 
               lpHDE->asOvlAdjust[DAL_OVERLAY_ADJUSTTYPE_BRIGHTNESS].ulFlags)
          {
            (*lpController->lpHWED->pfnGetOverlayGammaAdjustment)
                         (lpController->hGCO,
                          (LPHW_ADJUSTMENT)&(lpControllerInfo->OverlayGamma));
            if (!(DAL_CONTROLLER_OVERLAY_RGB & lpController->ulControllerFlags))
            {
              ulIndex = ulGetOverlayPriorityDisplay(lpController->ulDisplayTypes);
              lpControllerInfo->OverlayGamma.lDefault =
                                lpHDE->alOverlayYUVDefaultBrightness[ulIndex];
            }
          }

          // zero initialize the structure so unhooked adjustemnt are initialized to zero
          ZEROMEMORY((LPVOID)&lpControllerInfo->Expansion, sizeof(HW_ADJUSTMENT));
          ZEROMEMORY((LPVOID)&lpControllerInfo->CursorBlinkingSpeed, sizeof(HW_ADJUSTMENT));

          for (ulIndex = 0; ulIndex < DAL_MAX_GCO_ADJUSTMENTS; ulIndex++)
		  {
            // loop through each possible adjustment for the controller, and query
            // the defaults for the adjustment functions hooked by the controller
            if ((lpController->lpHWED->ulFunctionHooks &
                          aGCO_Adjustment[ulIndex].ulHook) &&
                (aGCO_Adjustment[ulIndex].ulHookIndex ==0))
            {
              switch(aGCO_Adjustment[ulIndex].ulHook)
              {
                case GCO_HOOK_TEXT_CURSOR_BLINKING_ADJUSTMENT:
                {           
                  MOVEMEMORY((LPVOID)&lpControllerInfo->CursorBlinkingSpeed,
                             (LPVOID)&lpController->aAdjustment[ulIndex],
                             sizeof(HW_ADJUSTMENT));
                }

                break;

                case GCO_HOOK_RATIOMETRIC_EXPANSION_ADJUSTMENT:
                {
                  // Check specifically if this controller supports
                  // expansion. If not just don't do anything.
                  if (lpController->lpHWED->aControllerCaps[lpController->ulController] 
                       & DAL_CONTROLLER_CAPS_EXPANSION)
                  {
                    MOVEMEMORY((LPVOID)&lpControllerInfo->Expansion,
                               (LPVOID)&lpController->aAdjustment[ulIndex],
                                sizeof(HW_ADJUSTMENT));
                  }
                }

                break;
              }
            }
          }

          // Return Desktop size to the caller. Implemented for direct
          // draw people.
          lpControllerInfo->lDesktopResolutionCx = lpController->siDesktop.cx;
          lpControllerInfo->lDesktopResolutionCy = lpController->siDesktop.cy;

          // force these values to zero in case the caller is trying to read
          // so information out of these in a future version and we do not
          // support that future version.

          lpControllerInfo->ulReserved1 = 0;
        }
      }
      *lpInfoSize = sizeof(CONTROLLERINFO);
      break;

    case CWDDEDI_ControllerGetConfig:
      {
        CONTROLLERCONFIG FAR *lpControllerConfig;
        LPDEVGCO              lpController;
        //LPDEVGDO              lpDisplay;
        GCO_QUERY_STRUCTURE   sQueryGCO;
        ULONG                 ulSpan;
        ULONG                 ulPixel;
       // ULONG                 ulHook;
        ULONG                 ulIndex;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulOutputSize < sizeof(CONTROLLERCONFIG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an CONTROLLERCONFIG structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else if ((!(lpHDE->aControllerMap[lpCmd->ulDriverReserved] &
                      VECTORFROMINDEX(lpCmd->ulIndex))) &&
                     (lpHDE->aControllers[lpCmd->ulIndex].ulFlags & GCO_MAPPED))
        {
          // calling driver does not own the controller, so fail the call
          ulReturn = CWDDE_ERR_BADINPUT;
        } else
        {
          lpController = (LPDEVGCO) &lpHDE->aControllers[lpCmd->ulIndex];

          lpControllerConfig = (CONTROLLERCONFIG FAR *)lpOutput;
          lpControllerConfig->ulSize = sizeof(CONTROLLERCONFIG);

          // CWDDE documentation is unclear here if this need be programmed,
          // but for conveniance the DAL will copy back the index anyways
          lpControllerConfig->ulControllerIndex = lpCmd->ulIndex;

          // Fetch the screen resolution for the caller
          lpControllerConfig->lViewResolutionCx = (LONG)
                      lpController->sModeInfo.ulPelsWidth;
          lpControllerConfig->lViewResolutionCy = (LONG)
                      lpController->sModeInfo.ulPelsHeight;
          lpControllerConfig->ulVerticalRefresh = (ULONG)
                      lpController->sModeInfo.ulDisplayFrequency;

          if (lpController->ulFlags & GCO_PANLOCKED)
          {
            // controller is pan locked, hence program back the pan locking
            // rectnagle to the caller

            lpControllerConfig->lPanViewLockTop    = lpController->rtPanLock.top;
            lpControllerConfig->lPanViewLockLeft   = lpController->rtPanLock.left;
            lpControllerConfig->lPanViewLockBottom = lpController->rtPanLock.bottom;
            lpControllerConfig->lPanViewLockRight  = lpController->rtPanLock.right;

          } else
          {
            // controller is not pan locked, hence pass back a pan locking
            // rectnagle of all zeros to indicate no pan locking in place

            lpControllerConfig->lPanViewLockTop    = 0;
            lpControllerConfig->lPanViewLockLeft   = 0;
            lpControllerConfig->lPanViewLockBottom = 0;
            lpControllerConfig->lPanViewLockRight  = 0;
          }

          if (lpController->ulFlags & GCO_VIEWSIZELOCKED)
          {
            lpControllerConfig->ulLockSmartView = TRUE;
          } else
          {
            lpControllerConfig->ulLockSmartView = FALSE;
          }

          lpControllerConfig->lCursorBlinkSpeed = 0;
          lpControllerConfig->lOverlayGamma = 0;
          lpControllerConfig->lExpansion = 0;

          // overlay brightness should be obsolete here;
          if (DAL_OVLADJUST_SUPPORTED_FLAG & 
               lpHDE->asOvlAdjust[DAL_OVERLAY_ADJUSTTYPE_BRIGHTNESS].ulFlags)
          {
            ulIndex = lpController->ulDisplayTypes & HW_DISPLAY_TYPES_MASK;
            lpControllerConfig->lOverlayGamma = lpHDE->asOvlAdjust
                       [DAL_OVERLAY_ADJUSTTYPE_BRIGHTNESS].lpAdjusts[ulIndex];
          }

          // expansion is treated as an adjustment, so thunk the adjustment
          // into the DAL's internal flags

          for (ulIndex = 0; ulIndex < DAL_MAX_GCO_ADJUSTMENTS; ulIndex++)
          {
            // loop through each possible adjustment for the controller, and
            // set the adjustment state for adjustements that
            // are hooked by the Controller
            if ((lpController->lpHWED->ulFunctionHooks &
                          aGCO_Adjustment[ulIndex].ulHook) &&
                (aGCO_Adjustment[ulIndex].ulHookIndex ==0))
            {
              switch(aGCO_Adjustment[ulIndex].ulHook)
              {
                case GCO_HOOK_TEXT_CURSOR_BLINKING_ADJUSTMENT:
                {           
                  lpControllerConfig->lCursorBlinkSpeed = lpController->alAdjustments[ulIndex];
                }

                break;

                case GCO_HOOK_RATIOMETRIC_EXPANSION_ADJUSTMENT:
                {
                  // Check specifically if this controller supports
                  // expansion. If not just don't do anything.
                  if (lpController->lpHWED->aControllerCaps[lpController->ulController] 
                       & DAL_CONTROLLER_CAPS_EXPANSION)
                  {
                    if (lpController->ulFlags & GCO_EXPANSION)
                    {
                      lpControllerConfig->lExpansion = 1;
                    }
                  }
                }

                break;
              }
            }
          }

          lpControllerConfig->ulEnabledDisplays = lpController->ulDisplays;

          if ((lpController->ulFlags & GCO_ACTIVE)
             &&(!(lpHDE->aDriverData[lpCmd->ulDriverReserved].ulFlags &DRIVERDATA_DDEXCLUSIVEMODE)))
          {
            if (GCO_HOOK2_GETDISPLAYXYPOS & lpController->lpHWED->ulFunctionHooks2)
            {
              (*lpController->lpHWED->pfnGCOGetDisplayXYPos)(lpController->hGCO,
                                                             lpController->ulController,
                                                             (LPULONG)&lpControllerConfig->lViewPositionX,
                                                             (LPULONG)&lpControllerConfig->lViewPositionY);
            }
            else
            {
              // get the pertinent info from the GCO
              ZEROMEMORY((LPGCO_QUERY_STRUCTURE) &sQueryGCO, sizeof(GCO_QUERY_STRUCTURE));
              (*lpController->lpHWED->pfnGetInfo)
                              (lpController->hGCO, lpController->ulController,
                               (LPGCO_QUERY_STRUCTURE) &sQueryGCO);

              sQueryGCO.ulDisplayOffset -= lpController->ulOffset;
                        
              if (sQueryGCO.ulFlags & GCO_QUERY_STRUCTURE_FLAGS_TILEENABLED) 
              {
                vCalculateTiledCoordinatesFromOffset(sQueryGCO.ulDisplayOffset ,
                                                     (lpController->sModeInfo.ulBitsPerPixel >> 3),
                                                      sQueryGCO.ulTileWidthBytes,
                                                      lpController->ulPitch, 
                                                      sQueryGCO.ulTileHeightLines,
                                                      (LPULONG)&lpControllerConfig->lViewPositionX,
                                                      (LPULONG)&lpControllerConfig->lViewPositionY);
              }
              else
              {
                sQueryGCO.ulDisplayOffset /= (lpController->sModeInfo.ulBitsPerPixel >> 3);

                // these divides are a killer if they are not initialized

                ulSpan = sQueryGCO.ulDisplayOffset / lpController->ulPitch;
                ulPixel = sQueryGCO.ulDisplayOffset - (ulSpan * lpController->ulPitch);
   
                lpControllerConfig->lViewPositionX = ulPixel;
                lpControllerConfig->lViewPositionY = ulSpan;
              }
            }

            lpController->rtView.left   = lpControllerConfig->lViewPositionX;
            lpController->rtView.top    = lpControllerConfig->lViewPositionY;
            lpController->rtView.right  = lpControllerConfig->lViewResolutionCx + 
                                          lpControllerConfig->lViewPositionX;
            lpController->rtView.bottom = lpControllerConfig->lViewResolutionCy + 
                                          lpControllerConfig->lViewPositionY;

          } else
          {
            // controller is not active, so these settings have no meaning,