pfgcondmgre.pas

delphi编写与Palm数据交换管道连接程序。

{/// Registry Restore Function }

  CmRestoreHotSyncSettings: function(bToDefaults: Bool): Integer; stdcall;


{/// general Palm information storage calls }

  PiSetValueDword: function(const pFolder: PChar;
                            const pKey: PChar;
                            dwValue: LongInt): LongInt; stdcall;

  PiGetValueDword: function(const pFolder: PChar;
                            const pKey: PChar;
                            var pdwValue: LongInt;
                            dwDefault: LongInt): LongInt; stdcall;

  PiSetValueString: function(const pFolder: PChar;
                             const pKey: PChar;
                             const pValue: PChar): LongInt; stdcall;

  PiGetValueString: function(const pFolder: PChar;
                             const pKey: PChar;
                             pValue: PChar;
                             var piLen: Integer;
                             const pDefault: PChar): LongInt; stdcall;

  PiSetHotsyncValueDword: function(const pFolder: PChar;
                                   const pKey: PChar;
                                   dwValue: LongInt): LongInt; stdcall;

  PiGetHotsyncValueDword: function(const pFolder: PChar;
                                   const pKey: PChar;
                                   var pdwValue: LongInt;
                                   dwDefault: LongInt): LongInt; stdcall;

  PiSetHotsyncValueString: function(const pFolder: PChar;
                                    const pKey: PChar;
                                    const pValue: PChar): LongInt; stdcall;

  PiGetHotsyncValueString: function(const pFolder: PChar;
                                    const pKey: PChar;
                                    pValue: PChar;
                                    var piLen: Integer;
                                    const pDefault: PChar): LongInt; stdcall;

{/// Install Conduit API }

  ImRegister: function(const sFIT: FILEINSTALLTYPE): Integer; stdcall;

  ImRegisterID: function(dwCreatorID: LongInt): Integer; stdcall;

  ImUnregisterID: function(dwCreatorID: LongInt): Integer; stdcall;

  ImSetDirectory: function(dwID: LongInt;
                           const pDirectory: PTCHAR): Integer; stdcall;

  ImSetExtension: function(dwID: LongInt;
                           const pExtension: PTCHAR): Integer; stdcall;

  ImSetMask: function(dwID: LongInt;
                      dwMask: LongInt): Integer; stdcall;

  ImSetModule: function(dwID: LongInt;
                        const pModule: PTCHAR): Integer; stdcall;

  ImSetName: function(dwID: LongInt;
                      const pConduitName: PTCHAR): Integer; stdcall;

  ImSetDWord: function(dwID: LongInt;
                       const pValue: PTCHAR;
                       dwValue: LongInt): Integer; stdcall;

  ImSetString: function(dwID: LongInt;
                        const pValue: PTCHAR;
                        pString: PTCHAR): Integer; stdcall;

  ImGetDirectory: function(dwID: LongInt;
                           pDirectory: PTCHAR;
                           var piSize: Integer): Integer; stdcall;

  ImGetExtension: function(dwID: LongInt; 
                           pExtension: PTCHAR; 
                           var piSize: Integer): Integer; stdcall; 

  ImGetMask: function(dwID: LongInt;
                      var pdwMask: LongInt): Integer; stdcall;

  ImGetModule: function(dwID: LongInt;
                        pModule: PTCHAR;
                        var piSize: Integer): Integer; stdcall;

  ImGetName: function(dwID: LongInt;
                      pConduitName: PTCHAR;
                      var piSize: Integer): Integer; stdcall;

  ImGetDWord: function(dwID: LongInt;
                       const pValue: PTCHAR;
                       var pdwMask: LongInt;
                       dwDefault: LongInt): Integer; stdcall;

  ImGetString: function(dwID: LongInt;
                        const pValue: PTCHAR;
                        pString: PTCHAR;
                        var piSize: Integer;
                        const pDefault: PTCHAR): Integer; stdcall;

{///Install Notifier Manager API }

  NmRegister: function(const pNotifierPath: PTCHAR): Integer; stdcall;

  NmUnregister: function(const pNotifierPath: PTCHAR): Integer; stdcall;

  NmGetCount: function(var pdwCount: LongInt): Integer; stdcall;

  NmFind: function(const pNotifier: PTCHAR): Integer; stdcall;

  NmGetByIndex: function(iIndex: Integer;
                         pNotifier: PTCHAR;
                         var piSize: Integer): Integer; stdcall;

  NmRenameByIndex: function(iIndex: Integer;
                            const pNotifier: PTCHAR): Integer; stdcall;



implementation

uses Dialogs, pfgUserData;

var
  DllHandle : THandle;
  DllLoaded : Boolean;


procedure LoadDLL;
begin
  if DLLLoaded then Exit;

  DLLHandle := LoadLibrary(PChar(PalmPath + 'CONDMGR.DLL'));
  DLLLoaded := DLLHandle >= 32;
  if DLLLoaded then
  begin
    @CmGetLibVersion := GetProcAddress(DLLHandle,'CmGetLibVersion');
    Assert(@CmGetLibVersion <> nil);
    @CmConvertCreatorIDToString := GetProcAddress(DLLHandle,'CmConvertCreatorIDToString');
    Assert(@CmConvertCreatorIDToString <> nil);
    @CmConvertStringToCreatorID := GetProcAddress(DLLHandle,'CmConvertStringToCreatorID');
    Assert(@CmConvertStringToCreatorID <> nil);
    @CmGetConduitCount := GetProcAddress(DLLHandle,'CmGetConduitCount');
    Assert(@CmGetConduitCount <> nil);
    @CmGetCreatorIDList := GetProcAddress(DLLHandle,'CmGetCreatorIDList');
    Assert(@CmGetCreatorIDList <> nil);
    @CmGetConduitCreatorID := GetProcAddress(DLLHandle,'CmGetConduitCreatorID');
    Assert(@CmGetConduitCreatorID <> nil);
    @CmGetConduitByCreator := GetProcAddress(DLLHandle,'CmGetConduitByCreator');
    Assert(@CmGetConduitByCreator <> nil);
    @CmInstallConduit := GetProcAddress(DLLHandle,'CmInstallConduit');
    Assert(@CmInstallConduit <> nil);
    @CmInstallCreator := GetProcAddress(DLLHandle,'CmInstallCreator');
    Assert(@CmInstallCreator <> nil);
    @CmRemoveConduitByCreatorID := GetProcAddress(DLLHandle,'CmRemoveConduitByCreatorID');
    Assert(@CmRemoveConduitByCreatorID <> nil);
    @CmSetCreatorPriority := GetProcAddress(DLLHandle,'CmSetCreatorPriority');
    Assert(@CmSetCreatorPriority <> nil);
    @CmGetCreatorPriority := GetProcAddress(DLLHandle,'CmGetCreatorPriority');
    Assert(@CmGetCreatorPriority <> nil);
    @CmSetCreatorName := GetProcAddress(DLLHandle,'CmSetCreatorName');
    Assert(@CmSetCreatorName <> nil);
    @CmGetCreatorName := GetProcAddress(DLLHandle,'CmGetCreatorName');
    Assert(@CmGetCreatorName <> nil);
    @CmSetCreatorDirectory := GetProcAddress(DLLHandle,'CmSetCreatorDirectory');
    Assert(@CmSetCreatorDirectory <> nil);
    @CmGetCreatorDirectory := GetProcAddress(DLLHandle,'CmGetCreatorDirectory');
    Assert(@CmGetCreatorDirectory <> nil);
    @CmSetCreatorRemote := GetProcAddress(DLLHandle,'CmSetCreatorRemote');
    Assert(@CmSetCreatorRemote <> nil);
    @CmGetCreatorRemote := GetProcAddress(DLLHandle,'CmGetCreatorRemote');
    Assert(@CmGetCreatorRemote <> nil);
    @CmSetCreatorUser := GetProcAddress(DLLHandle,'CmSetCreatorUser');
    Assert(@CmSetCreatorUser <> nil);
    @CmGetCreatorUser := GetProcAddress(DLLHandle,'CmGetCreatorUser');
    Assert(@CmGetCreatorUser <> nil);
    @CmSetCreatorTitle := GetProcAddress(DLLHandle,'CmSetCreatorTitle');
    Assert(@CmSetCreatorTitle <> nil);
    @CmGetCreatorTitle := GetProcAddress(DLLHandle,'CmGetCreatorTitle');
    Assert(@CmGetCreatorTitle <> nil);
    @CmSetCreatorInfo := GetProcAddress(DLLHandle,'CmSetCreatorInfo');
    Assert(@CmSetCreatorInfo <> nil);
    @CmGetCreatorInfo := GetProcAddress(DLLHandle,'CmGetCreatorInfo');
    Assert(@CmGetCreatorInfo <> nil);
    @CmSetCreatorFile := GetProcAddress(DLLHandle,'CmSetCreatorFile');
    Assert(@CmSetCreatorFile <> nil);
    @CmGetCreatorFile := GetProcAddress(DLLHandle,'CmGetCreatorFile');
    Assert(@CmGetCreatorFile <> nil);
    @CmGetCreatorType := GetProcAddress(DLLHandle,'CmGetCreatorType');
    Assert(@CmGetCreatorType <> nil);
    @CmSetCreatorIntegrate := GetProcAddress(DLLHandle,'CmSetCreatorIntegrate');
    Assert(@CmSetCreatorIntegrate <> nil);
    @CmGetCreatorIntegrate := GetProcAddress(DLLHandle,'CmGetCreatorIntegrate');
    Assert(@CmGetCreatorIntegrate <> nil);
    @CmSetCreatorModule := GetProcAddress(DLLHandle,'CmSetCreatorModule');
    Assert(@CmSetCreatorModule <> nil);
    @CmGetCreatorModule := GetProcAddress(DLLHandle,'CmGetCreatorModule');
    Assert(@CmGetCreatorModule <> nil);
    @CmSetCreatorArgument := GetProcAddress(DLLHandle,'CmSetCreatorArgument');
    Assert(@CmSetCreatorArgument <> nil);
    @CmGetCreatorArgument := GetProcAddress(DLLHandle,'CmGetCreatorArgument');
    Assert(@CmGetCreatorArgument <> nil);
    @CmSetComPort := GetProcAddress(DLLHandle,'CmSetComPort');
    Assert(@CmSetComPort <> nil);
    @CmGetComPort := GetProcAddress(DLLHandle,'CmGetComPort');
    Assert(@CmGetComPort <> nil);
    @CmSetBackupConduit := GetProcAddress(DLLHandle,'CmSetBackupConduit');
    Assert(@CmSetBackupConduit <> nil);
    @CmGetBackupConduit := GetProcAddress(DLLHandle,'CmGetBackupConduit');
    Assert(@CmGetBackupConduit <> nil);
    @CmSetNotifierDll := GetProcAddress(DLLHandle,'CmSetNotifierDll');
    Assert(@CmSetNotifierDll <> nil);
    @CmGetNotifierDll := GetProcAddress(DLLHandle,'CmGetNotifierDll');
    Assert(@CmGetNotifierDll <> nil);
    @CmSetPCIdentifier := GetProcAddress(DLLHandle,'CmSetPCIdentifier');
    Assert(@CmSetPCIdentifier <> nil);
    @CmGetPCIdentifier := GetProcAddress(DLLHandle,'CmGetPCIdentifier');
    Assert(@CmGetPCIdentifier <> nil);
    @CmGetCorePath := GetProcAddress(DLLHandle,'CmGetCorePath');
    Assert(@CmGetCorePath <> nil);
    @CmSetCorePath := GetProcAddress(DLLHandle,'CmSetCorePath');
    Assert(@CmSetCorePath <> nil);
    @CmGetHotSyncExecPath := GetProcAddress(DLLHandle,'CmGetHotSyncExecPath');
    Assert(@CmGetHotSyncExecPath <> nil);
    @CmSetHotSyncExecPath := GetProcAddress(DLLHandle,'CmSetHotSyncExecPath');
    Assert(@CmSetHotSyncExecPath <> nil);
    @CmSetCreatorValueDword := GetProcAddress(DLLHandle,'CmSetCreatorValueDword');
    Assert(@CmSetCreatorValueDword <> nil);
    @CmGetCreatorValueDword := GetProcAddress(DLLHandle,'CmGetCreatorValueDword');
    Assert(@CmGetCreatorValueDword <> nil);
    @CmSetCreatorValueString := GetProcAddress(DLLHandle,'CmSetCreatorValueString');
    Assert(@CmSetCreatorValueString <> nil);
    @CmGetCreatorValueString := GetProcAddress(DLLHandle,'CmGetCreatorValueString');
    Assert(@CmGetCreatorValueString <> nil);
    @CmRestoreHotSyncSettings := GetProcAddress(DLLHandle,'CmRestoreHotSyncSettings');
    Assert(@CmRestoreHotSyncSettings <> nil);
    @PiSetValueDword := GetProcAddress(DLLHandle,'PiSetValueDword');
    Assert(@PiSetValueDword <> nil);
    @PiGetValueDword := GetProcAddress(DLLHandle,'PiGetValueDword');
    Assert(@PiGetValueDword <> nil);
    @PiSetValueString := GetProcAddress(DLLHandle,'PiSetValueString');
    Assert(@PiSetValueString <> nil);
    @PiGetValueString := GetProcAddress(DLLHandle,'PiGetValueString');
    Assert(@PiGetValueString <> nil);
    @PiSetHotsyncValueDword := GetProcAddress(DLLHandle,'PiSetHotsyncValueDword');
    Assert(@PiSetHotsyncValueDword <> nil);
    @PiGetHotsyncValueDword := GetProcAddress(DLLHandle,'PiGetHotsyncValueDword');
    Assert(@PiGetHotsyncValueDword <> nil);
    @PiSetHotsyncValueString := GetProcAddress(DLLHandle,'PiSetHotsyncValueString');
    Assert(@PiSetHotsyncValueString <> nil);
    @PiGetHotsyncValueString := GetProcAddress(DLLHandle,'PiGetHotsyncValueString');
    Assert(@PiGetHotsyncValueString <> nil);
    @ImRegister := GetProcAddress(DLLHandle,'ImRegister');
    //Assert(@ImRegister <> nil);
    @ImRegisterID := GetProcAddress(DLLHandle,'ImRegisterID');
    //Assert(@ImRegisterID <> nil);
    @ImUnregisterID := GetProcAddress(DLLHandle,'ImUnregisterID');
    //Assert(@ImUnregisterID <> nil);
    @ImSetDirectory := GetProcAddress(DLLHandle,'ImSetDirectory');
    //Assert(@ImSetDirectory <> nil);
    @ImSetExtension := GetProcAddress(DLLHandle,'ImSetExtension');
    //Assert(@ImSetExtension <> nil);
    @ImSetMask := GetProcAddress(DLLHandle,'ImSetMask');
    //Assert(@ImSetMask <> nil);
    @ImSetModule := GetProcAddress(DLLHandle,'ImSetModule');
    //Assert(@ImSetModule <> nil);
    @ImSetName := GetProcAddress(DLLHandle,'ImSetName');
    //Assert(@ImSetName <> nil);
    @ImSetDWord := GetProcAddress(DLLHandle,'ImSetDWord');
    //Assert(@ImSetDWord <> nil);
    @ImSetString := GetProcAddress(DLLHandle,'ImSetString');
    //Assert(@ImSetString <> nil);
    @ImGetDirectory := GetProcAddress(DLLHandle,'ImGetDirectory');
    //Assert(@ImGetDirectory <> nil);
    @ImGetExtension := GetProcAddress(DLLHandle,'ImGetExtension');
    //Assert(@ImGetExtension <> nil);
    @ImGetMask := GetProcAddress(DLLHandle,'ImGetMask');
    //Assert(@ImGetMask <> nil);
    @ImGetModule := GetProcAddress(DLLHandle,'ImGetModule');
    //Assert(@ImGetModule <> nil);
    @ImGetName := GetProcAddress(DLLHandle,'ImGetName');
    //Assert(@ImGetName <> nil);
    @ImGetDWord := GetProcAddress(DLLHandle,'ImGetDWord');
    //Assert(@ImGetDWord <> nil);
    @ImGetString := GetProcAddress(DLLHandle,'ImGetString');
    //Assert(@ImGetString <> nil);
    @NmRegister := GetProcAddress(DLLHandle,'NmRegister');
    //Assert(@NmRegister <> nil);
    @NmUnregister := GetProcAddress(DLLHandle,'NmUnregister');
    //Assert(@NmUnregister <> nil);
    @NmGetCount := GetProcAddress(DLLHandle,'NmGetCount');
    //Assert(@NmGetCount <> nil);
    @NmFind := GetProcAddress(DLLHandle,'NmFind');
    //Assert(@NmFind <> nil);
    @NmGetByIndex := GetProcAddress(DLLHandle,'NmGetByIndex');
    //Assert(@NmGetByIndex <> nil);
    @NmRenameByIndex := GetProcAddress(DLLHandle,'NmRenameByIndex');
    //Assert(@NmRenameByIndex <> nil);
  end;
end;

initialization
  DLLLoaded := False;
  LoadDLL;

  if (not DllLoaded) then
  begin
    MessageDlg('pfgCondMgre: Unable to load condmgr.dll',mtError,[mbOk],0);
    Abort;
  end;

finalization
  if DLLLoaded then FreeLibrary(DLLHandle);
end.