--- product: Chilkat product_version: 11.7.0 language: delphidll language_label: Delphi DLL class: ZipEntry license: bundle deprecated: false reference_html: https://www.chilkatsoft.com/refdoc/dd_CkZipEntryRef.html --- # Chilkat ZipEntry — Delphi DLL — v11.7.0 > Chilkat 11.7.0 · language=delphidll · class=ZipEntry > Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0//classes/ZipEntry.md`. > Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/guide.md`. ## Purpose **Inspect, extract, update, and iterate individual entries inside a ZIP archive.** `Chilkat.ZipEntry` represents a single item associated with a `Chilkat.Zip` archive. An entry may be a file already stored in an opened ZIP, a referenced filesystem file waiting to be compressed, an in-memory text or binary entry, or a directory entry. It provides access to entry-level metadata, compressed and uncompressed data, timestamps, attributes, CRC values, encryption information, and extraction or replacement operations for that specific ZIP item. **Entry metadata** Inspect filenames, stored ZIP paths, comments, timestamps, CRC values, attributes, sizes, compression method, and compression level. **Entry type and state** Use `EntryType` to understand whether the entry comes from an existing ZIP, a filesystem reference, memory data, or a directory. **Extract one entry** Extract a selected file entry to disk, inflate its contents into memory, or read the uncompressed data into Chilkat objects. **Read compressed data** Access the raw compressed entry data when an application needs ZIP-level control rather than only the inflated contents. **Replace or append data** Update an entry's contents from strings, byte data, files, or in-memory data sources before writing the ZIP archive. **Iterate archive entries** Walk through entries returned from `Chilkat.Zip` methods to inspect, filter, extract, or modify ZIP contents one item at a time. **Common pattern:** Open or create a `Chilkat.Zip` object, obtain a `ZipEntry` using methods such as `EntryAt`, `EntryOf`, `EntryMatching`, or `FirstEntry`, then inspect metadata, extract contents, update the entry, or continue iterating through the archive. Use `Chilkat.Zip` for whole-archive operations and `ZipEntry` for operations on one specific archive item. For an extended overview, see [ZipEntry Overview](https://www.chilkatsoft.com/zipEntry_overview.asp). ## Object creation, unlocking and error handling **Create/Dispose** ```pascal var myObject: HCkZipEntry; begin myObject := CkZipEntry_Create(); // ... CkZipEntry_Dispose(myObject); end; ``` `function CkZipEntry_Create: HCkZipEntry; stdcall;` Creates an instance of the HCkZipEntry object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page. `procedure CkZipEntry_Dispose(handle: HCkZipEntry); stdcall;` Objects created by calling CkZipEntry_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Delphi DLL. ## Members common to every Chilkat class Documented once per language in `common-members.md`; listed here so this page is self-contained. | Property | Signature | Access | Meaning | |---|---|---|---| | `DebugLogFilePath` | `procedure CkZipEntry_getDebugLogFilePath(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putDebugLogFilePath(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__debugLogFilePath(objHandle: HCkZipEntry): PWideChar; stdcall;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. | | `LastErrorHtml` | `procedure CkZipEntry_getLastErrorHtml(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__lastErrorHtml(objHandle: HCkZipEntry): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. | | `LastErrorText` | `procedure CkZipEntry_getLastErrorText(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__lastErrorText(objHandle: HCkZipEntry): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. | | `LastErrorXml` | `procedure CkZipEntry_getLastErrorXml(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__lastErrorXml(objHandle: HCkZipEntry): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. | | `LastMethodSuccess` | `function CkZipEntry_getLastMethodSuccess(objHandle: HCkZipEntry): wordbool; stdcall; procedure CkZipEntry_putLastMethodSuccess(objHandle: HCkZipEntry; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. | | `VerboseLogging` | `function CkZipEntry_getVerboseLogging(objHandle: HCkZipEntry): wordbool; stdcall; procedure CkZipEntry_putVerboseLogging(objHandle: HCkZipEntry; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. | | `Version` | `procedure CkZipEntry_getVersion(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__version(objHandle: HCkZipEntry): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" | ## Member index | Member | Kind | Signature | |---|---|---| | `Comment` | property, read/write | `procedure CkZipEntry_getComment(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putComment(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__comment(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `CompressedLength` | property, read-only | `function CkZipEntry_getCompressedLength(objHandle: HCkZipEntry): LongWord; stdcall;` | | `CompressedLength64` | property, read-only | `function CkZipEntry_getCompressedLength64(objHandle: HCkZipEntry): Int64; stdcall;` | | `CompressedLengthStr` | property, read-only | `procedure CkZipEntry_getCompressedLengthStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__compressedLengthStr(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `CompressionLevel` | property, read/write | `function CkZipEntry_getCompressionLevel(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putCompressionLevel(objHandle: HCkZipEntry; newPropVal: Integer); stdcall;` | | `CompressionMethod` | property, read/write | `function CkZipEntry_getCompressionMethod(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putCompressionMethod(objHandle: HCkZipEntry; newPropVal: Integer); stdcall;` | | `Crc` | property, read-only | `function CkZipEntry_getCrc(objHandle: HCkZipEntry): Integer; stdcall;` | | `EncryptionKeyLen` | property, read-only | `function CkZipEntry_getEncryptionKeyLen(objHandle: HCkZipEntry): Integer; stdcall;` | | `EntryID` | property, read-only | `function CkZipEntry_getEntryID(objHandle: HCkZipEntry): Integer; stdcall;` | | `EntryType` | property, read-only | `function CkZipEntry_getEntryType(objHandle: HCkZipEntry): Integer; stdcall;` | | `FileDateTimeStr` | property, read/write | `procedure CkZipEntry_getFileDateTimeStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putFileDateTimeStr(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__fileDateTimeStr(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `FileName` | property, read/write | `procedure CkZipEntry_getFileName(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putFileName(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__fileName(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `FileNameHex` | property, read-only | `procedure CkZipEntry_getFileNameHex(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__fileNameHex(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `HeartbeatMs` | property, read/write | `function CkZipEntry_getHeartbeatMs(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putHeartbeatMs(objHandle: HCkZipEntry; newPropVal: Integer); stdcall;` | | `IsAesEncrypted` | property, read-only | `function CkZipEntry_getIsAesEncrypted(objHandle: HCkZipEntry): wordbool; stdcall;` | | `IsDirectory` | property, read-only | `function CkZipEntry_getIsDirectory(objHandle: HCkZipEntry): wordbool; stdcall;` | | `TextFlag` | property, read/write | `function CkZipEntry_getTextFlag(objHandle: HCkZipEntry): wordbool; stdcall; procedure CkZipEntry_putTextFlag(objHandle: HCkZipEntry; newPropVal: wordbool); stdcall;` | | `UncompressedLength` | property, read-only | `function CkZipEntry_getUncompressedLength(objHandle: HCkZipEntry): LongWord; stdcall;` | | `UncompressedLength64` | property, read-only | `function CkZipEntry_getUncompressedLength64(objHandle: HCkZipEntry): Int64; stdcall;` | | `UncompressedLengthStr` | property, read-only | `procedure CkZipEntry_getUncompressedLengthStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__uncompressedLengthStr(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `AppendString` | method | `function CkZipEntry_AppendString(objHandle: HCkZipEntry;     strContent: PWideChar;     charset: PWideChar): wordbool; stdcall;` | | `CopyToBase64` | method | `function CkZipEntry_CopyToBase64(objHandle: HCkZipEntry;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__copyToBase64(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `CopyToHex` | method | `function CkZipEntry_CopyToHex(objHandle: HCkZipEntry;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__copyToHex(objHandle: HCkZipEntry): PWideChar; stdcall;` | | `Extract` | method | `function CkZipEntry_Extract(objHandle: HCkZipEntry;     dirPath: PWideChar): wordbool; stdcall;` | | `ExtractInto` | method | `function CkZipEntry_ExtractInto(objHandle: HCkZipEntry;     dirPath: PWideChar): wordbool; stdcall;` | | `GetNext` | method | `function CkZipEntry_GetNext(objHandle: HCkZipEntry): wordbool; stdcall;` | | `GetNextMatch` | method | `function CkZipEntry_GetNextMatch(objHandle: HCkZipEntry;     pattern: PWideChar): wordbool; stdcall;` | | `LoadTaskCaller` | method | `function CkZipEntry_LoadTaskCaller(objHandle: HCkZipEntry;     task: HCkTask): wordbool; stdcall;` | | `ReplaceString` | method | `function CkZipEntry_ReplaceString(objHandle: HCkZipEntry;     strContent: PWideChar;     charset: PWideChar): wordbool; stdcall;` | | `SetDt` | method | `procedure CkZipEntry_SetDt(objHandle: HCkZipEntry;     dt: HCkDateTime) stdcall;` | | `UnzipToBd` | method | `function CkZipEntry_UnzipToBd(objHandle: HCkZipEntry;     binData: HCkBinData): wordbool; stdcall;` | | `UnzipToSb` | method | `function CkZipEntry_UnzipToSb(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar;     sb: HCkStringBuilder): wordbool; stdcall;` | | `UnzipToStream` | method | `function CkZipEntry_UnzipToStream(objHandle: HCkZipEntry;     toStream: HCkStream): wordbool; stdcall;` | | `UnzipToString` | method | `function CkZipEntry_UnzipToString(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__unzipToString(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar): PWideChar; stdcall;` | Deprecated members are listed at the end of this file with their replacements; do not use them in new code. ## Properties ### ZipEntry.Comment `Chilkat 11.7.0 · delphidll · ZipEntry · Comment · property · read/write` ```pascal procedure CkZipEntry_getComment(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putComment(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__comment(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Gets or sets the comment stored in the ZIP archive for this entry. ### ZipEntry.CompressedLength `Chilkat 11.7.0 · delphidll · ZipEntry · CompressedLength · property · read-only` ```pascal function CkZipEntry_getCompressedLength(objHandle: HCkZipEntry): LongWord; stdcall; ``` The compressed size of this entry, in bytes. For mapped entries (entries already contained within an opened ZIP archive), this property contains the actual compressed size stored within the ZIP. For file entries or data entries that have not yet been written to a ZIP archive, compression has not yet occurred. In these cases, this property contains: - The current uncompressed data size for data entries. - The cached filesystem file size for referenced file entries. After the ZIP archive is written, the entries become mapped entries, and this property then reflects the actual compressed size stored in the ZIP archive. ### ZipEntry.CompressedLength64 `Chilkat 11.7.0 · delphidll · ZipEntry · CompressedLength64 · property · read-only` ```pascal function CkZipEntry_getCompressedLength64(objHandle: HCkZipEntry): Int64; stdcall; ``` The compressed size of this entry, in bytes, as a 64-bit integer. For mapped entries (entries already contained within an opened ZIP archive), this property contains the actual compressed size stored within the ZIP. For file entries or data entries that have not yet been written to a ZIP archive, compression has not yet occurred. In these cases, this property contains: - The current uncompressed data size for data entries. - The cached filesystem file size for referenced file entries. After the ZIP archive is written, the entries become mapped entries, and this property then reflects the actual compressed size stored in the ZIP archive. Use this property when sizes may exceed the range of a 32-bit integer. ### ZipEntry.CompressedLengthStr `Chilkat 11.7.0 · delphidll · ZipEntry · CompressedLengthStr · property · read-only` ```pascal procedure CkZipEntry_getCompressedLengthStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__compressedLengthStr(objHandle: HCkZipEntry): PWideChar; stdcall; ``` The compressed size of this entry as a decimal string. For mapped entries (entries already contained within an opened ZIP archive), this property contains the actual compressed size stored within the ZIP. For file entries or data entries that have not yet been written to a ZIP archive, compression has not yet occurred. In these cases, this property contains: - The current uncompressed data size for data entries. - The cached filesystem file size for referenced file entries. After the ZIP archive is written, the entries become mapped entries, and this property then reflects the actual compressed size stored in the ZIP archive. This property is useful when sizes may exceed the range of a 32-bit integer. ### ZipEntry.CompressionLevel `Chilkat 11.7.0 · delphidll · ZipEntry · CompressionLevel · property · read/write` ```pascal function CkZipEntry_getCompressionLevel(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putCompressionLevel(objHandle: HCkZipEntry; newPropVal: Integer); stdcall; ``` Gets or sets the compression level for this entry. A value of `0` means no compression, and a value of `9` means maximum compression. The default value is `6`. ### ZipEntry.CompressionMethod `Chilkat 11.7.0 · delphidll · ZipEntry · CompressionMethod · property · read/write` ```pascal function CkZipEntry_getCompressionMethod(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putCompressionMethod(objHandle: HCkZipEntry; newPropVal: Integer); stdcall; ``` Gets or sets the compression method used for this entry. - `0` means no compression. - `8` means Deflate compression. Deflate is the standard compression algorithm used by common ZIP utilities such as WinZip. ### ZipEntry.Crc `Chilkat 11.7.0 · delphidll · ZipEntry · Crc · property · read-only` ```pascal function CkZipEntry_getCrc(objHandle: HCkZipEntry): Integer; stdcall; ``` The CRC value for this ZIP entry. For AES-encrypted entries, the CRC value is `0`. ### ZipEntry.EncryptionKeyLen `Chilkat 11.7.0 · delphidll · ZipEntry · EncryptionKeyLen · property · read-only · since 9.5.0.69` ```pascal function CkZipEntry_getEncryptionKeyLen(objHandle: HCkZipEntry): Integer; stdcall; ``` The AES encryption key length for this entry. If this entry is AES encrypted, the value is `128`, `192`, or `256`. If this entry is not AES encrypted, the value is `0`. ### ZipEntry.EntryID `Chilkat 11.7.0 · delphidll · ZipEntry · EntryID · property · read-only` ```pascal function CkZipEntry_getEntryID(objHandle: HCkZipEntry): Integer; stdcall; ``` A unique identifier assigned to this entry while the ZIP object is instantiated in memory. This ID can be used to retrieve the same entry later with `Zip.EntryById`. ### ZipEntry.EntryType `Chilkat 11.7.0 · delphidll · ZipEntry · EntryType · property · read-only` ```pascal function CkZipEntry_getEntryType(objHandle: HCkZipEntry): Integer; stdcall; ``` Indicates the origin and current state of this ZIP entry. - `0` — Mapped Entry: an entry that already exists in an open ZIP file. - `1` — File Entry: a file in the local filesystem that has been referenced, but not yet read or compressed. - `2` — Data Entry: an entry containing uncompressed data already held in memory. - `3` — Null Entry: an entry that no longer exists in the ZIP archive. - `4` — New Directory Entry: a directory entry added to the ZIP object. When the ZIP archive is written by calling `WriteZip` or `WriteToMemory`, entries are transformed into mapped entries. In other words, after writing, they point to compressed data contained in the newly created or rewritten ZIP archive. ### ZipEntry.FileDateTimeStr `Chilkat 11.7.0 · delphidll · ZipEntry · FileDateTimeStr · property · read/write` ```pascal procedure CkZipEntry_getFileDateTimeStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putFileDateTimeStr(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__fileDateTimeStr(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Gets or sets the local last-modified date/time for this ZIP entry in RFC 822 string format. Example RFC 822 date/time strings: > `Tue, 15 Nov 1994 12:45:26 GMT Fri, 05 Jan 2024 18:30:00 -0500` The timezone may be specified either as a named timezone such as `GMT`, or as a numeric UTC offset such as `-0500`. ### ZipEntry.FileName `Chilkat 11.7.0 · delphidll · ZipEntry · FileName · property · read/write` ```pascal procedure CkZipEntry_getFileName(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; procedure CkZipEntry_putFileName(objHandle: HCkZipEntry; newPropVal: PWideChar); stdcall; function CkZipEntry__fileName(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Gets or sets the filename, including any relative path, stored for this entry inside the ZIP archive. Changing this property changes the path/name that will appear in the ZIP archive. It does not rename a source file in the local filesystem. ### ZipEntry.FileNameHex `Chilkat 11.7.0 · delphidll · ZipEntry · FileNameHex · property · read-only` ```pascal procedure CkZipEntry_getFileNameHex(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__fileNameHex(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Returns the raw filename bytes found in the ZIP entry, encoded as a hexadecimal string. This can be useful for diagnosing filename encoding issues. ### ZipEntry.HeartbeatMs `Chilkat 11.7.0 · delphidll · ZipEntry · HeartbeatMs · property · read/write` ```pascal function CkZipEntry_getHeartbeatMs(objHandle: HCkZipEntry): Integer; stdcall; procedure CkZipEntry_putHeartbeatMs(objHandle: HCkZipEntry; newPropVal: Integer); stdcall; ``` **Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md) The interval in milliseconds between each `AbortCheck` event callback, which enables an application to abort certain method calls before they complete. **By default, HeartbeatMs is set to** `0`**, meaning no AbortCheck event callbacks will trigger.** ### ZipEntry.IsAesEncrypted `Chilkat 11.7.0 · delphidll · ZipEntry · IsAesEncrypted · property · read-only · since 9.5.0.69` ```pascal function CkZipEntry_getIsAesEncrypted(objHandle: HCkZipEntry): wordbool; stdcall; ``` Indicates whether this ZIP entry is AES encrypted. This property can be `True` only for entries already contained in a ZIP archive, such as entries obtained after calling `OpenZip`, `OpenBd`, or `OpenFromMemory`. If the entry is not AES encrypted, the property is `False`. ### ZipEntry.IsDirectory `Chilkat 11.7.0 · delphidll · ZipEntry · IsDirectory · property · read-only` ```pascal function CkZipEntry_getIsDirectory(objHandle: HCkZipEntry): wordbool; stdcall; ``` Indicates whether this ZIP entry is a directory entry. The value is `True` if the entry represents a directory, and `False` if it represents a file. ### ZipEntry.TextFlag `Chilkat 11.7.0 · delphidll · ZipEntry · TextFlag · property · read/write` ```pascal function CkZipEntry_getTextFlag(objHandle: HCkZipEntry): wordbool; stdcall; procedure CkZipEntry_putTextFlag(objHandle: HCkZipEntry; newPropVal: wordbool); stdcall; ``` Gets or sets the text flag in the internal file attributes for this ZIP entry. This flag indicates whether the entry contents should be considered text rather than binary data. The flag is informational and does not need to be accurate for normal ZIP processing. It is provided for compatibility with applications that may be sensitive to this attribute. ### ZipEntry.UncompressedLength `Chilkat 11.7.0 · delphidll · ZipEntry · UncompressedLength · property · read-only` ```pascal function CkZipEntry_getUncompressedLength(objHandle: HCkZipEntry): LongWord; stdcall; ``` The uncompressed size of this entry, in bytes. ### ZipEntry.UncompressedLength64 `Chilkat 11.7.0 · delphidll · ZipEntry · UncompressedLength64 · property · read-only` ```pascal function CkZipEntry_getUncompressedLength64(objHandle: HCkZipEntry): Int64; stdcall; ``` The uncompressed size of this entry, in bytes, as a 64-bit integer. Use this property when the uncompressed size may exceed the range of a 32-bit integer. ### ZipEntry.UncompressedLengthStr `Chilkat 11.7.0 · delphidll · ZipEntry · UncompressedLengthStr · property · read-only` ```pascal procedure CkZipEntry_getUncompressedLengthStr(objHandle: HCkZipEntry; outPropVal: HCkString); stdcall; function CkZipEntry__uncompressedLengthStr(objHandle: HCkZipEntry): PWideChar; stdcall; ``` The uncompressed size of this ZIP entry as a decimal string. This is useful when the uncompressed size may be larger than what can safely be represented by a 32-bit integer. ## Methods ### ZipEntry.AppendString `Chilkat 11.7.0 · delphidll · ZipEntry · AppendString · method` ```pascal function CkZipEntry_AppendString(objHandle: HCkZipEntry;     strContent: PWideChar;     charset: PWideChar): wordbool; stdcall; ``` Appends text data to this ZIP entry's file contents. The text is converted to bytes using the character encoding specified by `charset`, such as `utf-8`, `utf-16`, or `ansi`. If this entry is already a Data Entry (`EntryType = 2`), then the encoded bytes are appended directly to the existing uncompressed in-memory data. If this entry is not already a Data Entry, then the entry is first converted into a Data Entry before the new text data is appended. - If the entry is a mapped entry (`EntryType = 0`), the compressed ZIP entry data is first inflated into memory. The new text data is then appended, and the entry becomes a Data Entry containing the combined uncompressed data. - If the entry is a file entry (`EntryType = 1`), the referenced filesystem file is first loaded into memory. The new text data is then appended, and the entry becomes a Data Entry containing the combined data. After this method is called, the entry contents exist entirely as uncompressed in-memory data associated with the ZipEntry object. Returns True for success, False for failure. Async variant: `AppendStringAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.CopyToBase64 `Chilkat 11.7.0 · delphidll · ZipEntry · CopyToBase64 · method` ```pascal function CkZipEntry_CopyToBase64(objHandle: HCkZipEntry;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__copyToBase64(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Returns the compressed data for this ZIP entry as a Base64-encoded string. This method can only be used when the entry already contains compressed data, meaning the entry is a mapped entry. This is possible for entries from a ZIP archive that has already been opened, or after writing a ZIP archive while it remains open. Returns True for success, False for failure. See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp). ### ZipEntry.CopyToHex `Chilkat 11.7.0 · delphidll · ZipEntry · CopyToHex · method` ```pascal function CkZipEntry_CopyToHex(objHandle: HCkZipEntry;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__copyToHex(objHandle: HCkZipEntry): PWideChar; stdcall; ``` Returns the compressed data for this ZIP entry as a hexadecimal encoded string. This method can only be used when the entry already contains compressed data, meaning the entry is a mapped entry. This is possible for entries from a ZIP archive that has already been opened, or after writing a ZIP archive while it remains open. Returns True for success, False for failure. See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp). ### ZipEntry.Extract `Chilkat 11.7.0 · delphidll · ZipEntry · Extract · method` ```pascal function CkZipEntry_Extract(objHandle: HCkZipEntry;     dirPath: PWideChar): wordbool; stdcall; ``` Extracts this ZIP entry beneath the specified base directory. The entry is extracted according to the relative path stored in the ZIP archive. For example, if the entry filename is `docs/readme.txt` and `dirPath` is `c:/temp/output`, the file is extracted to `c:/temp/output/docs/readme.txt`. Use `ExtractInto` instead if the file should be extracted directly into a specific directory regardless of the path stored in the ZIP archive. Returns True for success, False for failure. Async variant: `ExtractAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.ExtractInto `Chilkat 11.7.0 · delphidll · ZipEntry · ExtractInto · method` ```pascal function CkZipEntry_ExtractInto(objHandle: HCkZipEntry;     dirPath: PWideChar): wordbool; stdcall; ``` Extracts this entry directly into the specified directory, ignoring any path information stored in the ZIP entry. For example, if the entry filename is `docs/readme.txt` and `dirPath` is `c:/temp/output`, the file is extracted to `c:/temp/output/readme.txt`. If this entry is a directory entry, nothing is extracted. To create the directory represented by a directory entry, use `Extract` instead. Returns True for success, False for failure. Async variant: `ExtractIntoAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.GetNext `Chilkat 11.7.0 · delphidll · ZipEntry · GetNext · method · since 11.0.0` ```pascal function CkZipEntry_GetNext(objHandle: HCkZipEntry): wordbool; stdcall; ``` Updates this `ZipEntry` object so that it represents the next entry in the same ZIP archive. The next entry may be either a file entry or a directory entry. Returns `True` if the object was advanced to the next entry. Returns `False` if there are no more entries. ### ZipEntry.GetNextMatch `Chilkat 11.7.0 · delphidll · ZipEntry · GetNextMatch · method · since 11.0.0` ```pascal function CkZipEntry_GetNextMatch(objHandle: HCkZipEntry;     pattern: PWideChar): wordbool; stdcall; ``` Updates this `ZipEntry` object so that it represents the next entry in the ZIP archive matching the specified wildcard pattern. The wildcard character `*` matches zero or more characters. Matching is performed against the full stored filename, including any relative path. The matching entry may be either a file entry or a directory entry. Returns `True` if a matching entry is found. Returns `False` if no further matching entry exists. ### ZipEntry.LoadTaskCaller `Chilkat 11.7.0 · delphidll · ZipEntry · LoadTaskCaller · method · since 9.5.0.80` ```pascal function CkZipEntry_LoadTaskCaller(objHandle: HCkZipEntry;     task: HCkTask): wordbool; stdcall; ``` Loads the caller of the task's async method. Returns True for success, False for failure. ### ZipEntry.ReplaceString `Chilkat 11.7.0 · delphidll · ZipEntry · ReplaceString · method` ```pascal function CkZipEntry_ReplaceString(objHandle: HCkZipEntry;     strContent: PWideChar;     charset: PWideChar): wordbool; stdcall; ``` Replaces this ZIP entry's existing contents with new text data. The text is converted to bytes using the character encoding specified by `charset`, such as `utf-8` or `ansi`. The resulting bytes become the complete contents of the entry. Returns True for success, False for failure. ### ZipEntry.SetDt `Chilkat 11.7.0 · delphidll · ZipEntry · SetDt · method` ```pascal procedure CkZipEntry_SetDt(objHandle: HCkZipEntry;     dt: HCkDateTime) stdcall; ``` Sets the last-modified date/time for this ZIP entry. The `dt` argument is a `CkDateTime` object containing the date/time to store for the entry. ### ZipEntry.UnzipToBd `Chilkat 11.7.0 · delphidll · ZipEntry · UnzipToBd · method · since 9.5.0.67` ```pascal function CkZipEntry_UnzipToBd(objHandle: HCkZipEntry;     binData: HCkBinData): wordbool; stdcall; ``` Unzips this entry directly into a `BinData` object. The uncompressed bytes are written to `binData`. Returns True for success, False for failure. Async variant: `UnzipToBdAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.UnzipToSb `Chilkat 11.7.0 · delphidll · ZipEntry · UnzipToSb · method · since 9.5.0.67` ```pascal function CkZipEntry_UnzipToSb(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar;     sb: HCkStringBuilder): wordbool; stdcall; ``` Unzips this entry as text and appends the result to a `StringBuilder`. The `srcCharset` argument specifies how the uncompressed bytes should be interpreted, such as `utf-8`, `utf-16`, or `windows-1252`. The `lineEndingBehavior` argument controls line-ending conversion: - `0` — leave line endings unchanged. - `1` — convert all line endings to bare LF. - `2` — convert all line endings to CRLF. Returns True for success, False for failure. Async variant: `UnzipToSbAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.UnzipToStream `Chilkat 11.7.0 · delphidll · ZipEntry · UnzipToStream · method · since 9.5.0.67` ```pascal function CkZipEntry_UnzipToStream(objHandle: HCkZipEntry;     toStream: HCkStream): wordbool; stdcall; ``` Unzips this entry to a stream. If called synchronously, the `toStream` must have a sink, such as a file or another stream object. If called asynchronously, the foreground thread can read from the stream while the unzip operation writes to it. Returns True for success, False for failure. Async variant: `UnzipToStreamAsync` — same arguments, returns a `Task` (see Async variants below). ### ZipEntry.UnzipToString `Chilkat 11.7.0 · delphidll · ZipEntry · UnzipToString · method` ```pascal function CkZipEntry_UnzipToString(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkZipEntry__unzipToString(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar): PWideChar; stdcall; ``` Inflates this entry and returns the uncompressed data as a string. The `srcCharset` argument specifies how the uncompressed bytes should be interpreted, such as `utf-8`, `utf-16`, or `windows-1252`. The `lineEndingBehavior` argument controls line-ending conversion: - `0` — leave line endings unchanged. - `1` — convert all line endings to bare LF. - `2` — convert all line endings to CRLF. Returns True for success, False for failure. See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp). Async variant: `UnzipToStringAsync` — same arguments, returns a `Task` (see Async variants below). ## Events and callbacks ### ZipEntry.AbortCheck (event) `Chilkat 11.7.0 · delphidll · ZipEntry · AbortCheck · event` ```pascal function MyAbortCheck(): Integer; cdecl; ``` Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the `HeartbeatMs` property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second. Return `True` to abort; return `False` to continue (not abort) ### ZipEntry.PercentDone (event) `Chilkat 11.7.0 · delphidll · ZipEntry · PercentDone · event` ```pascal function MyPercentDone(pctDone: Integer): Integer; cdecl; ``` This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The `pctDone` argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have `pctDone` equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100). The PercentDone callback also acts as an `AbortCheck` event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination. Return `True` to abort; return `False` to continue (not abort) ### ZipEntry.ProgressInfo (event) `Chilkat 11.7.0 · delphidll · ZipEntry · ProgressInfo · event` ```pascal procedure MyProgressInfo(name: PWideChar; value: PWideChar) cdecl; ``` This event callback provides `tag name`/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory. Note: Some Chilkat methods don't fire any ProgressInfo events. ### ZipEntry.TaskCompleted (event) `Chilkat 11.7.0 · delphidll · ZipEntry · TaskCompleted · event` ```pascal procedure MyTaskCompleted(task: HCkTask) cdecl; ``` Called from the background thread when an asynchronous task completes. ## Async variants Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on. ```pascal function CkZipEntry_AppendStringAsync(objHandle: HCkZipEntry;     strContent: PWideChar;     charset: PWideChar): HCkTask; stdcall; function CkZipEntry_ExtractAsync(objHandle: HCkZipEntry;     dirPath: PWideChar): HCkTask; stdcall; function CkZipEntry_ExtractIntoAsync(objHandle: HCkZipEntry;     dirPath: PWideChar): HCkTask; stdcall; function CkZipEntry_UnzipToBdAsync(objHandle: HCkZipEntry;     binData: HCkBinData): HCkTask; stdcall; function CkZipEntry_UnzipToSbAsync(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar;     sb: HCkStringBuilder): HCkTask; stdcall; function CkZipEntry_UnzipToStreamAsync(objHandle: HCkZipEntry;     toStream: HCkStream): HCkTask; stdcall; function CkZipEntry_UnzipToStringAsync(objHandle: HCkZipEntry;     lineEndingBehavior: Integer;     srcCharset: PWideChar): HCkTask; stdcall; ``` ## Deprecated members — do not use in new code | Member | Kind | Deprecated in | Use instead | |---|---|---|---| | `AppendData` | method | before 11.6.1 | — | | `Copy` | method | before 11.6.1 | — | | `GetDt` | method | before 11.6.1 | — | | `Inflate` | method | before 11.6.1 | — | | `NextEntry` | method | before 11.6.1 | `GetNext` | | `NextMatchingEntry` | method | before 11.6.1 | `GetNextMatch` | | `ReplaceData` | method | before 11.6.1 | — | ## Related classes [`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/BinData.md), [`CkDateTime`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/CkDateTime.md), [`Stream`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Stream.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/StringBuilder.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Task.md)