dalcwdde.c

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

            // hence the DAL returns 0 by default
            lpControllerConfig->lViewPositionX = 0;
            lpControllerConfig->lViewPositionY = 0;
          }

          // return HW Status flag: interlace mode, double scan mode, panel expansion.
          lpControllerConfig->ulHwStatusFlag = 0;

          if (lpController->lpHWED->ulFunctionHooks & GCO_HOOK_GETEXPANSIONSETTING)
          {
            if ((*lpController->lpHWED->pfnGetExpansionSetting)
                                        (lpController->hGCO, 
                                         lpController->ulController, 
                                         (ULONG)DAL_GETEXPANSIONSETTING_HW))
            {
              lpControllerConfig->ulHwStatusFlag |= CWDDEDI_CONTROLLER_HWSTATUS_FLAG_RMXON;
            }
          }

          if (DEVMODEFLAG_INTERLACED & lpController->sModeInfo.ulModeFlags)
          {
            lpControllerConfig->ulHwStatusFlag |= CWDDEDI_CONTROLLER_HWSTATUS_FLAG_INTERLACEMODE;
          }

          if (DEVMODEFLAG_DOUBLESCAN & lpController->sModeInfo.ulModeFlags)
          {
            lpControllerConfig->ulHwStatusFlag |= CWDDEDI_CONTROLLER_HWSTATUS_FLAG_DOUBLESCANMODE;
          }

          if (GCO_OVERLAYTHEATERMODE & lpController->ulFlags)
          {
            lpControllerConfig->ulHwStatusFlag |= CWDDEDI_CONTROLLER_HWSTATUS_FLAG_OVLTHEATERMODE;
          }

          lpControllerConfig->ulControllerConfigflag = 0;

          // 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.

          lpControllerConfig->ulReserved1 = 0;
        }
      }
      *lpInfoSize = sizeof(CONTROLLERCONFIG);
      break;

    case CWDDEDI_ControllerEnumRefresh:
      {
        CONTROLLERENUMREFRESH FAR *lpEnumRefresh;
        OUTPUTULONG FAR           *lpOutputUlong;

        if (ulInputSize < (sizeof(CWDDECMD) + sizeof(CONTROLLERENUMREFRESH)))
        {
          // input size of the buffer is less than the command buffer and
          // enum refresh structure so fail the call.

          ulReturn = CWDDE_ERR_BADINPUTSIZE;
        } else if (ulOutputSize < sizeof(OUTPUTULONG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an OUTPUTULONG structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } 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
        {
          lpEnumRefresh          = (CONTROLLERENUMREFRESH FAR *)(lpCmd + 1);
          lpOutputUlong          = (OUTPUTULONG FAR *) lpOutput;
          lpOutputUlong->ulSize  = sizeof(OUTPUTULONG);
          lpOutputUlong->ulValue = 0;

          if ((lpEnumRefresh->ulEnumIndex == 0) ||
              (lpHDE->sEnumRefresh.ulEnumIndex != lpEnumRefresh->ulEnumIndex) ||
              (lpHDE->sEnumRefresh.ulFilter != lpEnumRefresh->ulDisplayFilter) ||
              (lpHDE->sEnumRefresh.ulController != lpCmd->ulIndex) ||
              (lpHDE->sEnumRefresh.ulDriverID != lpCmd->ulDriverReserved))
          {
            lpHDE->sEnumRefresh.ulEnumIndex = 0;
            lpHDE->sEnumRefresh.ulFilter = lpEnumRefresh->ulDisplayFilter;
            lpHDE->sEnumRefresh.ulController = lpCmd->ulIndex;
            lpHDE->sEnumRefresh.ulDriverID = lpCmd->ulDriverReserved;
            lpHDE->sEnumRefresh.lpDalMode = lpHDE->lpaModes;
          }

          if ((lpEnumRefresh->lViewResolutionCx == 0) ||
              (lpEnumRefresh->lViewResolutionCy == 0))
          {
            lpEnumRefresh->lViewResolutionCx = lpHDE->aControllers[lpCmd->ulIndex].sModeInfo.ulPelsWidth;
            lpEnumRefresh->lViewResolutionCy = lpHDE->aControllers[lpCmd->ulIndex].sModeInfo.ulPelsHeight;
          }

          if (lpEnumRefresh->ulColourDepth == 0)
          {
            lpEnumRefresh->ulColourDepth = lpHDE->aControllers[lpCmd->ulIndex].sModeInfo.ulBitsPerPixel;
          }

          ulReturn = CWDDE_OK;

          while ((lpHDE->sEnumRefresh.ulEnumIndex <= lpEnumRefresh->ulEnumIndex) &&
                 (CWDDE_OK == ulReturn))
          {
            ulReturn = DALCWDDE_ControllerEnumNextRefresh(lpHDE,
                                                          (LPDAL_MODEINFO FAR *)&lpHDE->sEnumRefresh.lpDalMode,
                                                          lpEnumRefresh,
                                                          (ULONG FAR *)&lpOutputUlong->ulValue,
                                                          lpHDE->sEnumRefresh.ulController);
            lpHDE->sEnumRefresh.ulEnumIndex++;
            lpHDE->sEnumRefresh.lpDalMode++;
          }

          // increment the mode past the last mode to ensure the DAL searches from
          // the new mode forward in the next call for the enumeration.

        }
      }
      *lpInfoSize = sizeof(OUTPUTULONG);
      break;

    case CWDDEDI_ControllerSetConfig:
      {
        CONTROLLERCONFIG FAR *lpControllerConfig;
        OUTPUTULONG FAR      *lpOutputUlong;
        ULONG                 ulCount;

        if (ulInputSize < sizeof(CWDDECMD) + sizeof(CONTROLLERCONFIG))
        {
          ulReturn = CWDDE_ERR_BADINPUTSIZE;
        } else if (ulOutputSize < sizeof(OUTPUTULONG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an OUTPUTULONG structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else
        {
          ulCount = (ulInputSize - sizeof(CWDDECMD)) /
                     sizeof(CONTROLLERCONFIG);
          lpControllerConfig = (CONTROLLERCONFIG FAR *) (lpCmd + 1);

          ulReturn = DALCWDDE_ControllerSetConfig(lpHDE,
                                                  lpCmd->ulDriverReserved,
                                                  lpCmd,
                                                  lpControllerConfig,
                                                  ulCount);

          // output the bit vector of controllers to the driver.
          lpOutputUlong          = (OUTPUTULONG FAR *) lpOutput;
          lpOutputUlong->ulSize  = sizeof(OUTPUTULONG);
          lpOutputUlong->ulValue = lpHDE->aControllerMap[lpCmd->ulDriverReserved];
        }
      }
      *lpInfoSize = sizeof(OUTPUTULONG);
      break;

    case CWDDEDI_ControllerValidateConfig:
      {
        CONTROLLERCONFIG FAR *lpControllerConfig;
        ULONG                 ulCount;

        if (ulInputSize < sizeof(CWDDECMD) + sizeof(CONTROLLERCONFIG))
        {
          ulReturn = CWDDE_ERR_BADINPUTSIZE;
        } else
        {
          ulCount = (ulInputSize - sizeof(CWDDECMD)) /
                     sizeof(CONTROLLERCONFIG);
          lpControllerConfig = (CONTROLLERCONFIG FAR *) (lpCmd + 1);

          ulReturn = DALCWDDE_ControllerValidateConfig(lpHDE,
                                                       lpCmd->ulDriverReserved,
                                                       lpCmd,
                                                       lpControllerConfig,
                                                       ulCount);
        }
      }
      *lpInfoSize = 0;
      break;

    case CWDDEDI_ControllerGetGamma:
      {
        CONTROLLERGAMMA FAR *lpControllerGamma;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulOutputSize < sizeof(CONTROLLERGAMMA))
        {
          // cannot return gamma correction values for the controller
          // because the caller has provided insufficient space in the
          // output parameter

          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
        {
          lpControllerGamma = (CONTROLLERGAMMA FAR *) lpOutput;

          DALGetGammaCorrection(hDAL,
                                lpCmd->ulDriverReserved,
                                (LPDEVCLUT)lpControllerGamma->triGamma);
        }
      }
      *lpInfoSize = sizeof(CONTROLLERGAMMA);
      break;

    case CWDDEDI_ControllerSetGamma:
      {
        CONTROLLERGAMMA FAR *lpControllerGamma;
        LPDEVGCO             lpController;
        LPDRIVERDATA         lpDriverData;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulInputSize < (sizeof(CONTROLLERGAMMA) + sizeof(CWDDECMD)))
        {
          // cannot program gamma correction values for the controller
          // because the caller has provided insufficient data in the
          // input parameter

          ulReturn = CWDDE_ERR_BADINPUTSIZE;

        } 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
        {
          lpControllerGamma = (CONTROLLERGAMMA FAR *)
                                  ((LPUCHAR)lpInput + sizeof(CWDDECMD));

          lpController = (LPDEVGCO) &lpHDE->aControllers[lpCmd->ulIndex];

          lpDriverData = (LPDRIVERDATA) &lpHDE->aDriverData[lpCmd->ulDriverReserved];

          // Gamma should be saved only if adjusted via CWDDE interface 
          // flag it dirty here
          lpDriverData->ulFlags |= DRIVERDATA_SAVEGAMMA;

          DALSetGammaCorrection(hDAL,
                                lpCmd->ulDriverReserved,
                                (LPDEVCLUT)lpControllerGamma->triGamma);
        }
      }
      *lpInfoSize = 0;
      break;

      case CWDDEDI_ControllerGetGamma16:
      {
        CONTROLLERGAMMA16 FAR *lpControllerGamma16;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulOutputSize < sizeof(CONTROLLERGAMMA16))
        {
          // cannot return gamma correction values for the controller
          // because the caller has provided insufficient space in the
          // output parameter

          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
        {
          lpControllerGamma16 = (CONTROLLERGAMMA16 FAR *) lpOutput;

          DALGetGamma16Correction(hDAL,
                                  lpCmd->ulDriverReserved,
                                  (LPDEVCLUT16)lpControllerGamma16->triGamma16);
        }
      }
      *lpInfoSize = sizeof(CONTROLLERGAMMA16);
      break;

    case CWDDEDI_ControllerSetGamma16:
      {
        CONTROLLERGAMMA16 FAR *lpControllerGamma16;
        LPDEVGCO               lpController;
        LPDRIVERDATA           lpDriverData;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulInputSize < (sizeof(CONTROLLERGAMMA16) + sizeof(CWDDECMD)))
        {
          // cannot program gamma correction values for the controller
          // because the caller has provided insufficient data in the
          // input parameter

          ulReturn = CWDDE_ERR_BADINPUTSIZE;

        } 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
        {
          lpControllerGamma16 = (CONTROLLERGAMMA16 FAR *)
                                  ((LPUCHAR)lpInput + sizeof(CWDDECMD));

          lpController = (LPDEVGCO) &lpHDE->aControllers[lpCmd->ulIndex];
          lpDriverData = (LPDRIVERDATA) &lpHDE->aDriverData[lpCmd->ulDriverReserved];

          // Gamma should be saved only if adjusted via CWDDE interface 
          // flag it dirty here
          lpDriverData->ulFlags |= DRIVERDATA_SAVEGAMMA;

          DALSetGamma16Correction(hDAL,
                                  lpCmd->ulDriverReserved,
                                  (LPDEVCLUT16)lpControllerGamma16->triGamma16);
        }
      }
      *lpInfoSize = 0;
      break;

    case CWDDEDI_ControllerGetBestView:
      {
        CONTROLLERBESTVIEW FAR  *lpControllerBestView;
        CONTR