(*
Copyright (c) 1998-2014 by Carlotta Calandra. All rights reserved.
Copyright (c) 2011-2014 by Xequte software.

This software comes without express or implied warranty.
In no case shall the author be liable for any damage or unwanted behavior of any
computer hardware and/or software.

Author grants you the right to include the component
in your application, whether COMMERCIAL, SHAREWARE, or FREEWARE.

ImageEn, IEvolution and ImageEn ActiveX may not be included in any
commercial, shareware or freeware libraries or components.

www.ImageEn.com
*)

(*
File version 1008
*)

unit iexDCIM;
// NPC: 15/11/11

{$R-}
{$Q-}

{$I ie.inc}

interface


uses
  Windows, Classes, Sysutils, Graphics,
  {$ifdef IEHASUITYPES} System.UITypes, {$endif}
  comctrls, hyieutils, hyiedefs;


{$IFDEF IEINCLUDEIEXACQUIRE}


type

{!!
<FS>TIEDcimAcquire

<FM>Description<FN>
TIEDcimAcquire class is used by <A TIEAcquireParams> to retrieve images from digital camera cards and connected camera devices (which appear as USB drives).

<FM>Properties<FN>  
<TABLE2>
<R> <C_IMG_PROPERTY> <C><A TIEDcimAcquire.AcquireFormats></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEDcimAcquire.Aborting></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEDcimAcquire.SelectedSource></C> </R>
</TABLE>

<FM>Methods<FN>
<TABLE2>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.Create></C> </R>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.Destroy></C> </R>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.Acquire></C> </R>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.CopyImages></C> </R>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.GetListOfDcimSources></C> </R>
<R> <C_IMG_METHOD> <C><A TIEDcimAcquire.SetSelectedSource></C> </R>
</TABLE>
!!}


  TIEDcimAcquire = class
  private
    fOwner: TComponent;
    fAcquireFormats : string;
    fAborting : Boolean;
    fSelectedSource : string;
  public

{!!
<FS>TIEDcimAcquire.Create

<FM>Declaration<FC>
}
    constructor Create(Owner: TComponent);
{!!}


{!!
<FS>TIEDcimAcquire.Destroy

<FM>Declaration<FC>
}
    destructor Destroy; override;
{!!}

{!!
<FS>TIEDcimAcquire.AcquireFormats

<FM>Declaration<FC>
property AcquireFormats : String; (Read/Write)

<FM>Description<FN>
A list of extensions for file types that TIEDcimAcquire will retrieve when calling <A TIEDcimAcquire.Acquire> or <A TIEDcimAcquire.CopyImages>, e.g. '*.jpg;*.jpeg;*.bmp;' or '*.*'

If AcquireFormats is '' then all supported files types (including video types) are retrieved.
!!}         
    property AcquireFormats : string read fAcquireFormats write fAcquireFormats;

{!!
<FS>TIEDcimAcquire.Aborting

<FM>Declaration<FC>
property Aborting : Boolean; (Read/Write)

<FM>Description<FN>
Set to false to cancel the acquisition of images (e.g. during the OnProgress event)
!!}
    property Aborting : Boolean read fAborting write fAborting;

    function GetListOfDcimSources(ssDest : TStrings; bPathsOnly : Boolean) : Integer;

    // Single Image Acquisition
    function Acquire(DestBitmap : TIEBitmap; DestIOParamsVals: TObject = nil) : boolean; overload;

    // Muliple Image Acquisition
    function Acquire(OnGetImage: TIEMultiCallBack; OnProgress: TIEProgressEvent = nil) : boolean; overload;

    // Internal usage only
    function AcquireEx(bMultiple  : Boolean;
                       DestBitmap : TIEBitmap;
                       DestIOParamVals : TObject;
                       OnGetImage  : TIEMultiCallBack;
                       const sDestPath : string;
                       bDeleteFromSource : Boolean;
                       OnProgress: TIEProgressEvent) : Boolean;

    // Special Usage
    function CopyImages(const sDestPath : string; OnProgress: TIEProgressEvent = nil; bDeleteFromSource : Boolean = False) : boolean;

{!!
<FS>TIEDcimAcquire.SelectedSource

<FM>Declaration<FC>
property SelectedSource : string; (Read only)

<FM>Description<FN>
Return the path of the selected DCIM folder which will be used for subsequent calls to <A TIEDcimAcquire.Acquire> or <A TIEDcimAcquire.CopyImages>.

<FM>See Also<FN>
- <A TIEDcimAcquire.SetSelectedSource>
!!}
    property SelectedSource : string read fSelectedSource;

    function SetSelectedSource(sLocation : string) : boolean;

    function IsValidDcimLocation(sLocation : string) : boolean;
  end;


implementation

uses
  ImageEnIO, Dialogs, iexAcquire, IEMIO, iesettings;
  
const
  Digital_Camera_Folder_Name = 'DCIM';

constructor TIEDcimAcquire.Create(Owner: TComponent);
begin
  inherited Create;
  fOwner := Owner;
  fAborting := False;
end;

destructor TIEDcimAcquire.Destroy;
begin
  //
  inherited;
end;

          
{!!
<FS>TIEDcimAcquire.GetListOfDcimSources

<FM>Declaration<FC>
function GetListOfDcimSources(ssDest : TStrings; bPathsOnly : Boolean) : Integer;

<FM>Description<FN>
Locate all drives (camera cards or connected camera devices which appear as USB drives) containing DCIM folders and add them to ssDest.

if bPathsOnly is true then only the DCIM folders are added to the list, e.g. G:\DCIM, H:\DCIM, etc.

Otherwise a raw string is used which provides full device details in the format:

Device Name||Index of Location||API||Device Type

E.g. My Cool Scanner||3||TWN||SCN

The raw string can be decoded using <A StrToAcquireSource>.

Note: ssDest is NOT cleared before the fill!
!!}
function TIEDcimAcquire.GetListOfDcimSources(ssDest : TStrings; bPathsOnly : Boolean) : Integer;
var
  Drives : Array [0..MAX_PATH] of char;
  ADrive : PChar;   
  ErrorMode: word;
  sPath: string;
begin
    { turn off critical errors }
    ErrorMode := SetErrorMode(SEM_FailCriticalErrors);
  try 
    if (fSelectedSource <> '') and (IEDirectoryExists(fSelectedSource) = False) then
      fSelectedSource := '';

    GetLogicalDriveStrings(MAX_PATH, @Drives[0]);
    ADrive := @Drives[0];
    while lstrlen(ADrive) <> 0 do
    begin
      ADrive[2] := #0;
      sPath := IncludeTrailingBackslash(string(ADrive) + '\' + Digital_Camera_Folder_Name);              
      if (ADrive <> 'A:') and (ADrive <> 'B:') and (GetDriveType(PChar(ADrive)) = DRIVE_REMOVABLE) and IEDirectoryExists(sPath) then
      begin
        If fSelectedSource = '' then
          fSelectedSource := sPath;
        if bPathsOnly then
          ssDest.add(sPath)
        else
          ssDest.add(AcquireSourceToStr(IEAcquireSource(ieaDCIM,
                                                        sPath,
                                                        AnsiString(format('Device on %s:\', [uppercase(ADrive[0])])),
                                                        ieadDrive)));
      end;

      // Move ahead to next drive (lstrlen + 2 because we've added a zero byte)
      ADrive := ADrive + lstrlen(ADrive) + 2;
    end;

    Result := ssDest.Count;
  finally
    { restore old error mode }
    SetErrorMode(ErrorMode);
  end;
end;



procedure RetrieveFileList(ssDest : TStrings; const sFolder, sExtensions : string; bIncludeSubFolders : boolean = True);

  function _ValidFile(dwFileAttributes : DWord): boolean;
  const
    INCLUDE_HIDDEN_FILES = False;
    INCLUDE_SYSTEM_FILES = False;
  begin
    result := (dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY= 0) and
             (INCLUDE_HIDDEN_FILES or (dwFileAttributes and FILE_ATTRIBUTE_HIDDEN= 0)) and
             (INCLUDE_SYSTEM_FILES or (dwFileAttributes and FILE_ATTRIBUTE_SYSTEM= 0));
  end;

  procedure _ProcessFolder(sPath : string);
  const
    Period = '.';
    ALL_FILES_SPEC = '*.*';
  var
    ErrorMode  : word;
    FindData   : TWin32FindData;
    FindHandle : THandle;
    Done       : Boolean;
    NewDir     : array[0..MAX_PATH] of Char;
    ADir       : array[0..MAX_PATH] of Char;
    FileName   : array[0..MAX_PATH] of char;
    ScanDir    : array[0..MAX_PATH] of char;
  begin
    { turn off critical errors }
    ErrorMode := SetErrorMode(SEM_FailCriticalErrors);
    try
      // Add backslash  to the currently scanned dir '\'
      lstrcpy(ADir, PChar(IncludeTrailingBackslash(sPath)));
      lstrcpy(ScanDir, ADir);
      lstrcat(ScanDir, ALL_FILES_SPEC);

      // Scan for files this in the current directory
      FindHandle := Windows.FindFirstFile(ScanDir, FindData);
      try
        Done := (FindHandle = INVALID_HANDLE_VALUE);
        while not Done do
        begin
          // FOLDER
          if (FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY <> 0) and
             (FindData.cFileName[0] <> Period) and (bIncludeSubFolders) then
          begin
            lstrcpy(NewDir, ADir);
            lstrcat(NewDir, FindData.CFileName);
            _ProcessFolder(NewDir);
          end
          else
          // FILE
          if _ValidFile(FindData.dwFileAttributes) then
          begin
            lstrcpy(FileName, ADir);
            lstrcat(FileName, FindData.CFileName);
            if IEFilenameInExtensions(Filename, sExtensions) then
              ssDest.Add(Filename);
          end;
          Done := not Windows.FindNextFile(FindHandle, FindData);
        end;

      finally
        Windows.FindClose(FindHandle);
      end;

    finally
      SetErrorMode(ErrorMode);
    end;
  end;

begin
  ssDest.clear;
  _ProcessFolder(sFolder);
end;


 // result is true if an image was retrieved
function TIEDcimAcquire.AcquireEx(bMultiple  : Boolean;
                                  DestBitmap : TIEBitmap;
                                  DestIOParamVals : TObject;
                                  OnGetImage  : TIEMultiCallBack;
                                  const sDestPath : string;    
                                  bDeleteFromSource : Boolean;
                                  OnProgress: TIEProgressEvent) : Boolean;

  procedure ShowProgress(iPercent : Integer);
  begin
    if bMultiple and assigned(OnProgress) then
      OnProgress(Self, iPercent);
  end;

  function ProcessImage(const sFilename : string): boolean;
  var
    TempParams : TIOParamsVals;
  begin
    Result := False;        
    TempParams := TIOParamsVals.Create(nil);
    try
      if assigned(DestBitmap) then
      begin
        DestBitmap.Read(sFilename, TempParams);

        if Assigned(DestIOParamVals) and (DestIOParamVals is TIOParamsVals) then
          TIOParamsVals(DestIOParamVals).Assign(TempParams);
        if assigned(OnGetImage) then
          OnGetImage(DestBitmap, DestIOParamVals, TempParams.DpiX, TempParams.DpiY);
      end;

      if sDestPath <> '' then
      begin
        if Windows.CopyFile(Pchar(sFilename), pChar(IncludeTrailingBackslash(sDestPath) + ExtractFileName(sFilename)), FALSE) = False then
          raise Exception.Create('Unable to copy: ' + sFilename);
        if bDeleteFromSource then
          Windows.DeleteFile(Pchar(sFilename));
      end;
      result := true;
    finally
      FreeAndNil(TempParams);
    end;
  end;

var
  bImageFound: Boolean;
  ssFileList: TStringList;
  i: Integer;
  sAcquireFormats: string;
  bNeedCreateBitmap: Boolean;
begin
  result := False;
  bNeedCreateBitmap := (Assigned(DestBitmap) = False) and Assigned(OnGetImage);
  fAborting := False;
  bImageFound := False;
  ssFileList := TStringList.create;
  if bNeedCreateBitmap then
    DestBitmap := TIEBitmap.create;
  try
    try
      ShowProgress(0);

      // Get file types to retrieve
      sAcquireFormats := fAcquireFormats;
      if sAcquireFormats = '' then
        sAcquireFormats := GetAllSupportedFileExtensions(True, True);

      // Retrieve list of images
      RetrieveFileList(ssFileList, fSelectedSource, sAcquireFormats);
      if ssFileList.count = 0 then
      begin
        MessageDlg('No images were found on the specified device.', mtError, [mbok], 0);
        exit;
      end;

      for i := 0 to ssFileList.count - 1 do
      begin      
        ShowProgress(MulDiv(i, 100, ssFileList.count));
        if ProcessImage(ssFileList[i]) then
          bImageFound := True;
        if (bMultiple = False) and bImageFound then
          Break;
        if fAborting then
          Break;
      end;
      result := bImageFound;
    except
      on E:Exception do
      begin
        MessageDlg('Error encountered retrieving your images: ' + e.message, mtError, [mbok], 0);
        Result := False;
      end;
    end;
  finally
    ssFileList.free;   
    if bNeedCreateBitmap then
      DestBitmap.Free;
  end;
end;

{!!
<FS>TIEDcimAcquire.Acquire

<FM>Declaration<FC>
function Acquire(DestBitmap : <A TIEBitmap>; DestIOParamsVals: TObject = nil) : boolean; overload;
function Acquire(OnGetImage: <A TIEMultiCallBack>; OnProgress: <A TIEProgressEvent>  = nil) : boolean; overload;

<FM>Description<FN>
Retrieve files of the formats specified in <A TIEDcimAcquire.AcquireFormats> that are located in the folder specified by <A TIEDcimAcquire.SelectedSource> (and all sub-folders).

<FB>** Generally you should NOT call this method directly. Use <A TImageEnIO.Acquire> or <A TImageEnMIO.Acquire> Instead **<FN>

Acquiring a single image:   
function Acquire(DestBitmap : <A TIEBitmap>; DestIOParamsVals: TObject = nil) : boolean;
<TABLE>
<R> <H>Parameter</H> <H>Description</H> </R>
<R> <C>DestBitmap</C> <C>The <A TIEBitmap> which will be filled with the acquired image</C> </R>
<R> <C>DestIOParamVals</C> <C>A <A TIOParamsVals> object which will be filled with the parameters of the acquired image (optional)</C> </R>
</TABLE>

Acquiring multiple images:
function Acquire(OnGetImage: <A TIEMultiCallBack>; OnProgress: <A TIEProgressEvent>  = nil) : boolean;
<TABLE>
<R> <H>Parameter</H> <H>Description</H> </R>
<R> <C>ImageAcquireCallBack</C> <C>Event to call for every acquired image</C> </R>
<R> <C>OnProgress</C> <C>Event to display acquisition progress and allow <L TIEDcimAcquire.Aborting>aborting</L> (optional)</C> </R>
</TABLE>

<FM>Example<FC>
// Retrieve the first image from the first connected camera card
ssDcimDevices := TStringList.create;
GetListOfDcimSources(ssDcimDevices, False);
if ssDcimDevices.count > 0 then
begin
  SetSelectedSource(StrToAcquireSource(ssDcimDevices[0]));
  Acquire(ImageEnView1.IEBitmap);
  ImageEnView1.Update;
end;
ssDcimDevices.Free;

// Retrieve all images from the first connected camera card
// Assumes you have created an OnGetImage event that does something with the retrieved images
ssDcimDevices := TStringList.create;
GetListOfDcimSources(ssDcimDevices, False);
if ssDcimDevices.count > 0 then
begin
  SetSelectedSource(StrToAcquireSource(ssDcimDevices[0]));
  Acquire(OnGetImage);
end;
ssDcimDevices.Free;
!!}

// Single Image Acquisition
function TIEDcimAcquire.Acquire(DestBitmap : TIEBitmap; DestIOParamsVals: TObject = nil) : boolean;
begin
  Result := AcquireEx(False, DestBitmap, DestIOParamsVals, nil, '', False, nil);
end;

// Muliple Image Acquisition
function TIEDcimAcquire.Acquire(OnGetImage: TIEMultiCallBack; OnProgress: TIEProgressEvent = nil) : boolean;
var
  ABitmap : TIEBitmap;
begin
  ABitmap := TIEBitmap.Create;
  try
    Result := AcquireEx(True, ABitmap, nil, OnGetImage, '', False, OnProgress);
  finally
    FreeAndNil(ABitmap);
  end;
end;


{!!
<FS>TIEDcimAcquire.CopyImages

<FM>Declaration<FC>
function CopyImages(const sDestPath : string; OnProgress: TIEProgressEvent = nil) : boolean;

<FM>Description<FN>
Copy all files of the formats specified in <A TIEDcimAcquire.AcquireFormats> that are located in the folder specified by sDCIMPath (and all sub-folders) to the path, sDestPath.
If an OnProgress event is passed then a progress dialog can be displayed to the user and retrieval cancelled by setting <A TIEDcimAcquire.Aborting> to True.
If bDeleteFromSource is true then the images will be removed from the source after retrieval

<FB>Warning: Ensure sDestPath points to a valid path.  You should create a new folder for the retrieval as this procedure will OVERWRITE ALL EXISTING FILES WITHOUT WARNING<FN>

<FM>Example<FC>
// Copy all images from the first connected camera card
ssDcimDevices := TStringList.create;
GetListOfDcimSources(ssDcimDevices, False);
if ssDcimDevices.count > 0 then
begin
  CheckCreateNewFolder(sNewFolder);
  SetSelectedSource(StrToAcquireSource(ssDcimDevices[0]));
  Acquire(sNewFolder);
end;
ssDcimDevices.Free;
!!}
function TIEDcimAcquire.CopyImages(const sDestPath : string; OnProgress: TIEProgressEvent = nil; bDeleteFromSource : Boolean = False) : boolean;
var
  ABitmap : TIEBitmap;
begin
  ABitmap := TIEBitmap.Create;
  try
    Result := AcquireEx(True, ABitmap, nil, nil, sDestPath, bDeleteFromSource, OnProgress);
  finally
    FreeAndNil(ABitmap);
  end;
end;


{!!
<FS>TIEDcimAcquire.SetSelectedSource

<FM>Declaration<FC>
function SetSelectedSource(sLocation : string) : boolean;

<FM>Description<FN>
Set the selected DCIM folder which will be used for subsequent calls to <A TIEDcimAcquire.Acquire> or <A TIEDcimAcquire.CopyImages>.  Result is true if the folder exists.

sLocation can be one of the following:
<TABLE>
<R> <H>Value</H> <H>Description</H> </R>
<R> <C>Blank</C> <C>The default device will be selected</C> </R>
<R> <C>Path</C> <C>The path of a DCIM folder, e.g. 'I:\DCIM\'</C> </R>
<R> <C>Drive Letter</C> <C>The letter of a connected camera card or device containing a DCIM folder, e.g. 'I'</C> </R>
<R> <C>Raw device string</C> <C>A string describing a device as returned by <A TIEDcimAcquire.GetListOfDcimSources></C> </R>
</TABLE>
        
<FM>See Also<FN>
- <A TIEDcimAcquire.SelectedSource>

<FM>Example<FC>
// Retrieve all images from the first connected camera card
if SetSelectedSource('') then
  Acquire(OnGetImage);

// Acquire from the camera card on H drive
if SetAcquireSource(ieaDCIM, 'H') then
  Acquire(OnGetImage);
!!}
function TIEDcimAcquire.SetSelectedSource(sLocation : string) : boolean;

  function _SetToDefaultSource : Boolean;
  var
    ssTemp: TStringList;
  begin
    fSelectedSource := '';
    ssTemp := TStringList.create;
    try
      // during fill of list fSelectedSource will bet set if items are found
      GetListOfDcimSources(ssTemp, True);
    finally
      sstemp.free;
    end;
    Result := fSelectedSource <> '';
  end;

  function _SetToPath(const sPath : string) : Boolean;
  var
    ErrorMode  : word;
  begin
    Result := False;
    try
      { turn off critical errors }
      ErrorMode := SetErrorMode(SEM_FailCriticalErrors);
      try
        if IEDirectoryExists(sPath) then
        begin
          Result := True;
          fSelectedSource := sPath;
        end;
      finally
        SetErrorMode(ErrorMode);
      end;
    except
      // UNEXPECTED ERROR
    end;
  end;

begin
  if sLocation = '' then
  begin
    // Default Path
    Result := _SetToDefaultSource;
  end
  else
  if IsAcquireSourceStr(sLocation) then
  begin
    // Raw Device string
    Result := _SetToPath(StrToAcquireSource(sLocation).Location);
  end
  else
  if Length(sLocation) <= 3 then
  begin
    // Drive letter
    Result := _SetToPath(sLocation[1] + ':\' + Digital_Camera_Folder_Name);
  end
  else
  begin
    // Normal path  
    Result := _SetToPath(sLocation);
  end;

  // Make DCIM the API for subsequent calls to Acquire
  {$IFDEF IEINCLUDEMULTIVIEW}
  If Result and (fOwner is TImageEnMIO) then
    (fOwner as TImageEnMIO).AcquireParams.fSelectedSourceAPI := ieaDCIM
  else
  {$ENDIF}
  If Result and (fOwner is TImageEnIO) then
    (fOwner as TImageEnIO).AcquireParams.fSelectedSourceAPI := ieaDCIM
end;



function TIEDcimAcquire.IsValidDcimLocation(sLocation : string) : boolean;    
var
  Handle: THandle;
  FindData: TWin32FindData;
begin
  Result := False;

  If Pos(Uppercase(Digital_Camera_Folder_Name), Uppercase(sLocation)) > 0 then
  begin
    Handle := FindFirstFile(PChar(ExcludeTrailingBackSlash(sLocation)), FindData);
    if Handle <> INVALID_HANDLE_VALUE then
    begin
      Windows.FindClose(Handle);
      Result := (FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY) > 0;
    end;
  end;
end;

{$ELSE} // IEINCLUDEIEXACQUIRE
implementation
{$ENDIF}

end.