cfgmgr32.pas

East make Tray Icon in delphi

  {$EXTERNALSYM PIRQ_RESOURCE}

const
  //
  // Define the size of each range structure
  //
  IRQType_Range = SizeOf(IRQ_RANGE);
  {$EXTERNALSYM IRQType_Range}

  //
  // Flags for resource descriptor APIs indicating the width of certain
  // variable-size resource descriptor structure fields, where applicable.
  //
  CM_RESDES_WIDTH_DEFAULT = $00000000;  // 32 or 64-bit IRQ_RESOURCE / IRQ_DES, based on client
  {$EXTERNALSYM CM_RESDES_WIDTH_DEFAULT}
  CM_RESDES_WIDTH_32      = $00000001;  // 32-bit IRQ_RESOURCE / IRQ_DES
  {$EXTERNALSYM CM_RESDES_WIDTH_32}
  CM_RESDES_WIDTH_64      = $00000002;  // 64-bit IRQ_RESOURCE / IRQ_DES
  {$EXTERNALSYM CM_RESDES_WIDTH_64}
  CM_RESDES_WIDTH_BITS    = $00000003;
  {$EXTERNALSYM CM_RESDES_WIDTH_BITS}

//--------------------------------------------------------------
// Device Private Resource
//--------------------------------------------------------------

type
  //
  // DEVICEPRIVATE_RANGE structure
  //
  PDEVPRIVATE_RANGE = ^DEVPRIVATE_RANGE;
  {$EXTERNALSYM PDEVPRIVATE_RANGE}
  DEVPRIVATE_RANGE = packed record
    PR_Data1: DWORD;     // mask for base alignment
    PR_Data2: DWORD;     // number of bytes
    PR_Data3: DWORD;     // minimum address
  end;
  {$EXTERNALSYM DEVPRIVATE_RANGE}

  //
  // DEVPRIVATE_DES structure
  //
  PDEVPRIVATE_DES = ^DEVPRIVATE_DES;
  {$EXTERNALSYM PDEVPRIVATE_DES}
  DEVPRIVATE_DES = packed record
    PD_Count: DWORD;
    PD_Type: DWORD;
    PD_Data1: DWORD;
    PD_Data2: DWORD;
    PD_Data3: DWORD;
    PD_Flags: DWORD;
  end;
  {$EXTERNALSYM DEVPRIVATE_DES}

  //
  // DEVPRIVATE_RESOURCE
  //
  PDEVPRIVATE_RESOURCE = ^DEVPRIVATE_RESOURCE;
  {$EXTERNALSYM PDEVPRIVATE_RESOURCE}
  DEVPRIVATE_RESOURCE = packed record
    PRV_Header: DEVPRIVATE_DES;
    PRV_Data: array [0..0] of DEVPRIVATE_RANGE;
  end;
  {$EXTERNALSYM DEVPRIVATE_RESOURCE}

const
  //
  // Define the size of each range structure
  //
  PType_Range = SizeOf(DEVPRIVATE_RANGE);
  {$EXTERNALSYM PType_Range}

//--------------------------------------------------------------
// Class-Specific Resource
//--------------------------------------------------------------

type
  PCS_DES = ^CS_DES;
  {$EXTERNALSYM PCS_DES}
  CS_DES = packed record
    CSD_SignatureLength: DWORD;
    CSD_LegacyDataOffset: DWORD;
    CSD_LegacyDataSize: DWORD;
    CSD_Flags: DWORD;
    CSD_ClassGuid: TGUID;
    CSD_Signature: array [0..0] of Byte;
  end;
  {$EXTERNALSYM CS_DES}

  PCS_RESOURCE = ^CS_RESOURCE;
  {$EXTERNALSYM PCS_RESOURCE}
  CS_RESOURCE = packed record
    CS_Header: CS_DES;
  end;
  {$EXTERNALSYM CS_RESOURCE}

//--------------------------------------------------------------
// PC Card Configuration Resource
//--------------------------------------------------------------

const
  //
  // Define the attribute flags for a PC Card configuration resource descriptor.
  // Each bit flag is identified with a constant bitmask.  Following the bitmask
  // definition are the possible values.
  //
  mPCD_IO_8_16        = $1;   // Bitmask, whether I/O is 8 or 16 bits
  {$EXTERNALSYM mPCD_IO_8_16}
  fPCD_IO_8           = $0;   // I/O is 8-bit
  {$EXTERNALSYM fPCD_IO_8}
  fPCD_IO_16          = $1;   // I/O is 16-bit
  {$EXTERNALSYM fPCD_IO_16}
  mPCD_MEM_8_16       = $2;   // Bitmask, whether MEM is 8 or 16 bits
  {$EXTERNALSYM mPCD_MEM_8_16}
  fPCD_MEM_8          = $0;   // MEM is 8-bit
  {$EXTERNALSYM fPCD_MEM_8}
  fPCD_MEM_16         = $2;   // MEM is 16-bit
  {$EXTERNALSYM fPCD_MEM_16}
  mPCD_MEM_A_C        = $C;   // Bitmask, whether MEMx is Attribute or Common
  {$EXTERNALSYM mPCD_MEM_A_C}
  fPCD_MEM1_A         = $4;   // MEM1 is Attribute
  {$EXTERNALSYM fPCD_MEM1_A}
  fPCD_MEM2_A         = $8;   // MEM2 is Attribute
  {$EXTERNALSYM fPCD_MEM2_A}
  fPCD_IO_ZW_8        = $10;  // zero wait on 8 bit I/O
  {$EXTERNALSYM fPCD_IO_ZW_8}
  fPCD_IO_SRC_16      = $20;  // iosrc 16
  {$EXTERNALSYM fPCD_IO_SRC_16}
  fPCD_IO_WS_16       = $40;  // wait states on 16 bit io
  {$EXTERNALSYM fPCD_IO_WS_16}
  mPCD_MEM_WS         = $300; // Bitmask, for additional wait states on memory windows
  {$EXTERNALSYM mPCD_MEM_WS}
  fPCD_MEM_WS_ONE     = $100; // 1 wait state
  {$EXTERNALSYM fPCD_MEM_WS_ONE}
  fPCD_MEM_WS_TWO     = $200; // 2 wait states
  {$EXTERNALSYM fPCD_MEM_WS_TWO}
  fPCD_MEM_WS_THREE   = $300; // 3 wait states
  {$EXTERNALSYM fPCD_MEM_WS_THREE}

  fPCD_MEM_A          = $4;   // MEM is Attribute
  {$EXTERNALSYM fPCD_MEM_A}

  fPCD_ATTRIBUTES_PER_WINDOW = $8000;
  {$EXTERNALSYM fPCD_ATTRIBUTES_PER_WINDOW}

  fPCD_IO1_16         = $00010000;  // I/O window 1 is 16-bit
  {$EXTERNALSYM fPCD_IO1_16}
  fPCD_IO1_ZW_8       = $00020000;  // I/O window 1 zero wait on 8 bit I/O
  {$EXTERNALSYM fPCD_IO1_ZW_8}
  fPCD_IO1_SRC_16     = $00040000;  // I/O window 1 iosrc 16
  {$EXTERNALSYM fPCD_IO1_SRC_16}
  fPCD_IO1_WS_16      = $00080000;  // I/O window 1 wait states on 16 bit io
  {$EXTERNALSYM fPCD_IO1_WS_16}

  fPCD_IO2_16         = $00100000;  // I/O window 2 is 16-bit
  {$EXTERNALSYM fPCD_IO2_16}
  fPCD_IO2_ZW_8       = $00200000;  // I/O window 2 zero wait on 8 bit I/O
  {$EXTERNALSYM fPCD_IO2_ZW_8}
  fPCD_IO2_SRC_16     = $00400000;  // I/O window 2 iosrc 16
  {$EXTERNALSYM fPCD_IO2_SRC_16}
  fPCD_IO2_WS_16      = $00800000;  // I/O window 2 wait states on 16 bit io
  {$EXTERNALSYM fPCD_IO2_WS_16}

  mPCD_MEM1_WS        = $03000000;  // MEM window 1 Bitmask, for additional wait states on memory windows
  {$EXTERNALSYM mPCD_MEM1_WS}
  fPCD_MEM1_WS_ONE    = $01000000;  // MEM window 1, 1 wait state
  {$EXTERNALSYM fPCD_MEM1_WS_ONE}
  fPCD_MEM1_WS_TWO    = $02000000;  // MEM window 1, 2 wait states
  {$EXTERNALSYM fPCD_MEM1_WS_TWO}
  fPCD_MEM1_WS_THREE  = $03000000;  // MEM window 1, 3 wait states
  {$EXTERNALSYM fPCD_MEM1_WS_THREE}
  fPCD_MEM1_16        = $04000000;  // MEM window 1 is 16-bit
  {$EXTERNALSYM fPCD_MEM1_16}

  mPCD_MEM2_WS        = $30000000;  // MEM window 2 Bitmask, for additional wait states on memory windows
  {$EXTERNALSYM mPCD_MEM2_WS}
  fPCD_MEM2_WS_ONE    = $10000000;  // MEM window 2, 1 wait state
  {$EXTERNALSYM fPCD_MEM2_WS_ONE}
  fPCD_MEM2_WS_TWO    = $20000000;  // MEM window 2, 2 wait states
  {$EXTERNALSYM fPCD_MEM2_WS_TWO}
  fPCD_MEM2_WS_THREE  = $30000000;  // MEM window 2, 3 wait states
  {$EXTERNALSYM fPCD_MEM2_WS_THREE}
  fPCD_MEM2_16        = $40000000;  // MEM window 2 is 16-bit
  {$EXTERNALSYM fPCD_MEM2_16}

  PCD_MAX_MEMORY   = 2;
  {$EXTERNALSYM PCD_MAX_MEMORY}
  PCD_MAX_IO       = 2;
  {$EXTERNALSYM PCD_MAX_IO}

type
  PPCCARD_DES = ^PCCARD_DES;
  {$EXTERNALSYM PPCCARD_DES}
  PCCARD_DES = packed record
    PCD_Count: DWORD;
    PCD_Type: DWORD;
    PCD_Flags: DWORD;
    PCD_ConfigIndex: Byte;
    PCD_Reserved: array [0..2] of Byte;
    PCD_MemoryCardBase1: DWORD;
    PCD_MemoryCardBase2: DWORD;
    PCD_MemoryCardBase: array [0..PCD_MAX_MEMORY-1] of DWORD; // will soon be removed
    PCD_MemoryFlags: array [0..PCD_MAX_MEMORY-1] of WORD;     // will soon be removed
    PCD_IoFlags: array [0..PCD_MAX_IO-1] of Byte;             // will soon be removed
  end;
  {$EXTERNALSYM PCCARD_DES}

  PPCCARD_RESOURCE = ^PCCARD_RESOURCE;
  {$EXTERNALSYM PPCCARD_RESOURCE}
  PCCARD_RESOURCE = packed record
    PcCard_Header: PCCARD_DES;
  end;
  {$EXTERNALSYM PCCARD_RESOURCE}

//--------------------------------------------------------------
// MF (multifunction) PCCard Configuration Resource
//--------------------------------------------------------------

const
  mPMF_AUDIO_ENABLE   = $8;   // Bitmask, whether audio is enabled or not
  {$EXTERNALSYM mPMF_AUDIO_ENABLE}
  fPMF_AUDIO_ENABLE   = $8;   // Audio is enabled
  {$EXTERNALSYM fPMF_AUDIO_ENABLE}

type
  PMFCARD_DES = ^MFCARD_DES;
  {$EXTERNALSYM PMFCARD_DES}
  MFCARD_DES = packed record
    PMF_Count: DWORD;
    PMF_Type: DWORD;
    PMF_Flags: DWORD;
    PMF_ConfigOptions: Byte;
    PMF_IoResourceIndex: Byte;
    PMF_Reserved: array [0..1] of Byte;
    PMF_ConfigRegisterBase: DWORD;
  end;
  {$EXTERNALSYM MFCARD_DES}

  PMFCARD_RESOURCE = ^MFCARD_RESOURCE;
  {$EXTERNALSYM PMFCARD_RESOURCE}
  MFCARD_RESOURCE = packed record
    MfCard_Header: MFCARD_DES;
  end;
  {$EXTERNALSYM MFCARD_RESOURCE}

//--------------------------------------------------------------
// Bus Number Resource
//--------------------------------------------------------------

//
// Define the attribute flags for a Bus Number resource descriptor.
// Each bit flag is identified with a constant bitmask.  Following the bitmask
// definition are the possible values.
//
// Currently unused.
//

  //
  // BUSNUMBER_RANGE
  //
  PBUSNUMBER_RANGE = ^BUSNUMBER_RANGE;
  {$EXTERNALSYM PBUSNUMBER_RANGE}
  BUSNUMBER_RANGE = packed record
    BUSR_Min: ULONG;          // minimum Bus Number in the range
    BUSR_Max: ULONG;          // maximum Bus Number in the range
    BUSR_nBusNumbers: ULONG;  // specifies number of buses required
    BUSR_Flags: ULONG;        // flags describing the range (currently unused)
  end;
  {$EXTERNALSYM BUSNUMBER_RANGE}

  //
  // BUSNUMBER_DES structure
  //
  PBUSNUMBER_DES = ^BUSNUMBER_DES;
  {$EXTERNALSYM PBUSNUMBER_DES}
  BUSNUMBER_DES = packed record
    BUSD_Count: DWORD;       // number of BUSNUMBER_RANGE structs in BUSNUMBER_RESOURCE
    BUSD_Type: DWORD;        // size (in bytes) of BUSNUMBER_RANGE (BusNumberType_Range)
    BUSD_Flags: DWORD;       // flags describing the range (currently unused)
    BUSD_Alloc_Base: ULONG;  // specifies the first Bus that was allocated
    BUSD_Alloc_End: ULONG;   // specifies the last Bus number that was allocated
  end;
  {$EXTERNALSYM BUSNUMBER_DES}

  //
  // BUSNUMBER_RESOURCE structure
  //
  PBUSNUMBER_RESOURCE = ^BUSNUMBER_RESOURCE;
  {$EXTERNALSYM PBUSNUMBER_RESOURCE}
  BUSNUMBER_RESOURCE = packed record
    BusNumber_Header: BUSNUMBER_DES;                  // info about Bus Number range list
    BusNumber_Data: array [0..0] of BUSNUMBER_RANGE;  // list of Bus Number ranges
  end;
  {$EXTERNALSYM BUSNUMBER_RESOURCE}

const
  //
  // Define the size of each range structure
  //
  BusNumberType_Range = SizeOf(BUSNUMBER_RANGE);
  {$EXTERNALSYM BusNumberType_Range}

//--------------------------------------------------------------
// Hardware Profile Information
//--------------------------------------------------------------

const
  //
  // Define flags relating to hardware profiles
  //
  CM_HWPI_NOT_DOCKABLE  = $00000000;   // machine is not dockable
  {$EXTERNALSYM CM_HWPI_NOT_DOCKABLE}
  CM_HWPI_UNDOCKED      = $00000001;   // hw profile for docked config
  {$EXTERNALSYM CM_HWPI_UNDOCKED}
  CM_HWPI_DOCKED        = $00000002;   // hw profile for undocked config
  {$EXTERNALSYM CM_HWPI_DOCKED}

type
  //
  // HWPROFILEINFO structure
  //
  PHWPROFILEINFO_A = ^HWPROFILEINFO_A;
  {$EXTERNALSYM PHWPROFILEINFO_A}
  HWPROFILEINFO_A = packed record
    HWPI_ulHWProfile: ULONG;                      // handle of hw profile
    HWPI_szFriendlyName: array [0..MAX_PROFILE_LEN-1] of Char;  // friendly name of hw profile
    HWPI_dwFlags: DWORD;                          // profile flags (CM_HWPI_*)
  end;
  {$EXTERNALSYM HWPROFILEINFO_A}

  PHWPROFILEINFO_W = ^HWPROFILEINFO_W;
  {$EXTERNALSYM PHWPROFILEINFO_W}
  HWPROFILEINFO_W = packed record
    HWPI_ulHWProfile: ULONG;                      // handle of hw profile