size_t wxChmInputStream::OnSysRead(void *buffer, size_t bufsize)
{
if ( m_pos >= m_size )
{
m_lasterror = wxSTREAM_EOF;
return 0;
}
m_lasterror = wxSTREAM_NO_ERROR;
// If the rest to read from the stream is less
// than the buffer size, then only read the rest
if ( m_pos + bufsize > m_size )
bufsize = m_size - m_pos;
if (m_contentStream->SeekI(m_pos) == wxInvalidOffset)
{
m_lasterror = wxSTREAM_EOF;
return 0;
}
size_t read = m_contentStream->Read(buffer, bufsize).LastRead();
m_pos += read;
if (m_contentStream->SeekI(m_pos) == wxInvalidOffset)
{
m_lasterror = wxSTREAM_READ_ERROR;
return 0;
}
if (read != bufsize)
m_lasterror = m_contentStream->GetLastError();
return read;
}
void Synch() {
if (m_pStream)
m_lasterror = m_pStream->GetLastError();
else
m_lasterror = wxSTREAM_READ_ERROR;
}
bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
{
UnRef();
char anim_type[12];
switch (type)
{
case wxANIMATION_TYPE_GIF:
strcpy(anim_type, "gif");
break;
case wxANIMATION_TYPE_ANI:
strcpy(anim_type, "ani");
break;
default:
anim_type[0] = '\0';
break;
}
// create a GdkPixbufLoader
GError *error = NULL;
GdkPixbufLoader *loader;
if (type != wxANIMATION_TYPE_INVALID && type != wxANIMATION_TYPE_ANY)
loader = gdk_pixbuf_loader_new_with_type(anim_type, &error);
else
loader = gdk_pixbuf_loader_new();
if (!loader ||
error != NULL) // even if the loader was allocated, an error could have happened
{
wxLogDebug(wxT("Could not create the loader for '%s' animation type: %s"),
anim_type, error->message);
return false;
}
// connect to loader signals
g_signal_connect(loader, "area-updated", G_CALLBACK(gdk_pixbuf_area_updated), this);
guchar buf[2048];
bool data_written = false;
while (stream.IsOk())
{
// read a chunk of data
if (!stream.Read(buf, sizeof(buf)) &&
stream.GetLastError() != wxSTREAM_EOF) // EOF is OK for now
{
// gdk_pixbuf_loader_close wants the GError == NULL
gdk_pixbuf_loader_close(loader, NULL);
return false;
}
// fetch all data into the loader
if (!gdk_pixbuf_loader_write(loader, buf, stream.LastRead(), &error))
{
wxLogDebug(wxT("Could not write to the loader: %s"), error->message);
// gdk_pixbuf_loader_close wants the GError == NULL
gdk_pixbuf_loader_close(loader, NULL);
return false;
}
data_written = true;
}
if (!data_written)
{
wxLogDebug("Could not read data from the stream...");
return false;
}
// load complete: gdk_pixbuf_loader_close will now check if the data we
// wrote inside the pixbuf loader does make sense and will give an error
// if it doesn't (because of a truncated file, corrupted data or whatelse)
if (!gdk_pixbuf_loader_close(loader, &error))
{
wxLogDebug(wxT("Could not close the loader: %s"), error->message);
return false;
}
// wait until we get the last area_updated signal
return data_written;
}
wxStreamError wxBackingFileImpl::ReadAt(wxFileOffset pos,
void *buffer,
size_t *size)
{
size_t reqestedSize = *size;
*size = 0;
// size1 is the number of bytes it will read directly from the backing
// file. size2 is any remaining bytes not yet backed, these are returned
// from the buffer or read from the parent stream.
size_t size1, size2;
if (pos + reqestedSize <= m_filelen + size_t(0)) {
size1 = reqestedSize;
size2 = 0;
} else if (pos < m_filelen) {
size1 = size_t(m_filelen - pos);
size2 = reqestedSize - size1;
} else {
size1 = 0;
size2 = reqestedSize;
}
if (pos < 0)
return wxSTREAM_READ_ERROR;
// read the backing file
if (size1) {
if (m_file.Seek(pos) == wxBadSeek)
return wxSTREAM_READ_ERROR;
ssize_t n = m_file.Read(buffer, size1);
if (n > 0) {
*size = n;
pos += n;
}
if (*size < size1)
return wxSTREAM_READ_ERROR;
}
// read from the buffer or parent stream
if (size2)
{
while (*size < reqestedSize)
{
// if pos is further ahead than the parent has been read so far,
// then read forward in the parent stream
while (pos - m_filelen + size_t(0) >= m_buflen)
{
// if the parent is small enough, don't use a backing file
// just the buffer memory
if (!m_stream && m_filelen == 0)
return m_parenterror;
// before refilling the buffer write out the current buffer
// to the backing file if there is anything in it
if (m_buflen)
{
if (!m_file.IsOpened())
if (!wxCreateTempFile(m_prefix, &m_file, &m_filename))
return wxSTREAM_READ_ERROR;
if (m_file.Seek(m_filelen) == wxBadSeek)
return wxSTREAM_READ_ERROR;
size_t count = m_file.Write(m_buf, m_buflen);
m_filelen += count;
if (count < m_buflen) {
wxDELETE(m_stream);
if (count > 0) {
wxDELETEA(m_buf);
m_buflen = 0;
}
m_parenterror = wxSTREAM_READ_ERROR;
return m_parenterror;
}
m_buflen = 0;
if (!m_stream) {
wxDELETEA(m_buf);
}
}
if (!m_stream)
return m_parenterror;
// refill buffer
m_buflen = m_stream->Read(m_buf, m_bufsize).LastRead();
if (m_buflen < m_bufsize) {
m_parenterror = m_stream->GetLastError();
if (m_parenterror == wxSTREAM_NO_ERROR)
m_parenterror = wxSTREAM_EOF;
wxDELETE(m_stream);
}
}
// copy to the user's buffer
size_t start = size_t(pos - m_filelen);
size_t len = wxMin(m_buflen - start, reqestedSize - *size);
memcpy((char*)buffer + *size, m_buf + start, len);
*size += len;
pos += len;
}
}
return wxSTREAM_NO_ERROR;
}
/**
* Calculates the checksums from the given stream.
*
* @param in Input stream from which the data will be extracted to
* compute the checksum. The data are extracted until the end
* of the stream is reached.
* @param checksums Array of checksums to calculate.
* @param sumValues The calculated values of the checksums from the input
* stream. The array is erased first before adding results.
* On success <CODE>ArrayChecksum.GetCount() == sumValues.GetCount()</CODE>,
* on failure, <CODE>sumValues</CODE> should be empty.
* @return <UL>
* <LI><CODE>Ok</CODE> if the checksum has been successfully calculated.</Li>
* <LI><CODE>ReadError</CODE> if a read error has occured.</LI>
* <LI><CODE>Canceled</CODE> if the user has canceled the calculation.</LI>
* </UL>
*/
ChecksumCalculator::State ChecksumCalculator::calculate(wxInputStream& in,
const ArrayChecksum& checksums,
wxArrayString& sumValues)
{
// Check if the input stream is valid.
if (!in.IsOk())
return ReadError;
// Check if at least a checksum instance is OK.
bool aInstanceOK = false;
size_t i = 0;
size_t s = checksums.GetCount();
while (!aInstanceOK && i < s)
if (checksums[i] != NULL)
aInstanceOK = true;
else
i++;
if (!aInstanceOK)
return ReadError;
// Initializes the buffer.
const size_t bufSize = getBufferSize();
wxByte* buff = new wxByte[bufSize];
// Calculating the checksum.
ChecksumProgress* p = getChecksumProgress();
bool canceled = false;
size_t read;
wxStreamError lastError = wxSTREAM_NO_ERROR;
s = checksums.GetCount();
for (i = 0; i < s; i++)
if (checksums[i] != NULL)
checksums[i]->reset();
while (!canceled && !in.Eof() && lastError == wxSTREAM_NO_ERROR)
{
in.Read(buff, bufSize);
read = in.LastRead();
if (read > 0 && read <= bufSize)
{
for (i = 0; i < s; i++)
if (checksums[i] != NULL)
checksums[i]->update(buff, read);
if (p != NULL)
p->update(read, canceled);
}
lastError = in.GetLastError();
}
// Cleans-up the memory
delete[] buff;
if (canceled)
return CanceledByUser;
if (lastError != wxSTREAM_NO_ERROR && lastError != wxSTREAM_EOF)
return ReadError;
sumValues.Empty();
for (i = 0; i < s; i++)
if (checksums[i] != NULL)
sumValues.Add(checksums[i]->getValue());
else
sumValues.Add(wxEmptyString);
return Ok;
}