IO_stat MCCdata::load(IO_handle stream, MCObject *parent, const char *version) { IO_stat stat; if ((stat = IO_read_uint4(&id, stream)) != IO_NORMAL) return stat; if (parent->gettype() == CT_BUTTON) { uint1 set; stat = IO_read_uint1(&set, stream); data = (void *)(set ? 1 : 0); return stat; } else { if (id & COMPACT_PARAGRAPHS) { char *string; if ((stat = IO_read_string(string, stream, sizeof(uint1))) != IO_NORMAL) return stat; data = string; } else { MCParagraph *paragraphs = NULL; while (True) { uint1 type; if ((stat = IO_read_uint1(&type, stream)) != IO_NORMAL) return stat; switch (type) { // MW-2012-03-04: [[ StackFile5500 ]] Handle either the paragraph or extended // paragraph tag. case OT_PARAGRAPH: case OT_PARAGRAPH_EXT: { MCParagraph *newpar = new MCParagraph; newpar->setparent((MCField *)parent); // MW-2012-03-04: [[ StackFile5500 ]] If the paragraph tab was the extended // variant, then pass the correct is_ext parameter. if ((stat = newpar->load(stream, version, type == OT_PARAGRAPH_EXT)) != IO_NORMAL) { delete newpar; return stat; } newpar->appendto(paragraphs); } break; default: data = paragraphs; MCS_seek_cur(stream, -1); return IO_NORMAL; } } } } return IO_NORMAL; }
IO_stat IO_fgets(char *ptr, uint4 length, IO_handle stream) { uint4 bytes = length; if (MCS_read(ptr, sizeof(uint1), bytes, stream) == IO_ERROR) return IO_ERROR; ptr[bytes - 1] = '\0'; strtok(ptr, "\n"); length = strlen(ptr) + 1; if (length != bytes) if (MCS_seek_cur(stream, length - bytes) != IO_NORMAL) return IO_ERROR; return IO_NORMAL; }
IO_stat MCStyledText::load(IO_handle p_stream, const char *p_version) { IO_stat stat; MCParagraph *paragraphs = NULL; while (True) { uint1 type; if ((stat = IO_read_uint1(&type, p_stream)) != IO_NORMAL) return stat; switch (type) { // MW-2012-03-04: [[ StackFile5500 ]] Handle both the paragraph and extended // paragraph record. case OT_PARAGRAPH: case OT_PARAGRAPH_EXT: { MCParagraph *newpar = new MCParagraph; newpar->setparent((MCField *)parent); // MW-2012-03-04: [[ StackFile5500 ]] If the record is extended then // pass in 'true' for 'is_ext'. if ((stat = newpar->load(p_stream, p_version, type == OT_PARAGRAPH_EXT)) != IO_NORMAL) { delete newpar; return stat; } newpar->appendto(paragraphs); } break; default: m_paragraphs = paragraphs; MCS_seek_cur(p_stream, -1); return IO_NORMAL; } } return IO_NORMAL; }
IO_stat MCCdata::load(IO_handle stream, MCObject *parent, uint32_t version) { IO_stat stat; if ((stat = IO_read_uint4(&id, stream)) != IO_NORMAL) return checkloadstat(stat); if (parent->gettype() == CT_BUTTON) { uint1 set; stat = IO_read_uint1(&set, stream); data = reinterpret_cast<void *>(set ? 1 : 0); return checkloadstat(stat); } else { if (id & COMPACT_PARAGRAPHS) { // MW-2013-11-19: [[ UnicodeFileFormat ]] This flag is never set by newer engines // so is just legacy. char *string; if ((stat = IO_read_cstring_legacy(string, stream, sizeof(uint1))) != IO_NORMAL) return checkloadstat(stat); data = string; } else { MCParagraph *paragraphs = NULL; while (True) { uint1 type; if ((stat = IO_read_uint1(&type, stream)) != IO_NORMAL) return checkloadstat(stat); switch (type) { // MW-2012-03-04: [[ StackFile5500 ]] Handle either the paragraph or extended // paragraph tag. case OT_PARAGRAPH: case OT_PARAGRAPH_EXT: { MCParagraph *newpar = new (nothrow) MCParagraph; newpar->setparent((MCField *)parent); // MW-2012-03-04: [[ StackFile5500 ]] If the paragraph tab was the extended // variant, then pass the correct is_ext parameter. if ((stat = newpar->load(stream, version, type == OT_PARAGRAPH_EXT)) != IO_NORMAL) { delete newpar; return checkloadstat(stat); } newpar->appendto(paragraphs); } break; default: data = paragraphs; MCS_seek_cur(stream, -1); return IO_NORMAL; } } } } return IO_NORMAL; }
// if the image is in a directly supported format return the raw data otherwise decode & return the bitmap bool MCImageImport(IO_handle p_stream, IO_handle p_mask_stream, MCPoint &r_hotspot, char *&r_name, MCImageCompressedBitmap *&r_compressed, MCImageBitmap *&r_bitmap) { bool t_success = true; uindex_t t_width = 0, t_height = 0; uint8_t t_head[8]; uindex_t t_size = 8; uint32_t t_compression = F_RLE; if (t_success) t_success = MCS_read(t_head, sizeof(uint8_t), t_size, p_stream) == IO_NORMAL && t_size == 8 && MCS_seek_cur(p_stream, -8) == IO_NORMAL; if (t_success) { if (memcmp(t_head, "GIF87a", 6) == 0) t_compression = F_GIF; else if (memcmp(t_head, "GIF89a", 6) == 0) t_compression = F_GIF; else if (memcmp(t_head, "\211PNG", 4) == 0) t_compression = F_PNG; else if (memcmp(t_head, "\xff\xd8", 2) == 0) t_compression = F_JPEG; else if (MCImageGetMetafileGeometry(p_stream, t_width, t_height)) t_compression = F_PICT; if (t_compression != F_RLE) { t_success = MCImageCreateCompressedBitmap(t_compression, r_compressed); if (t_success) { if (t_success) t_success = read_all(p_stream, r_compressed->data, r_compressed->size); r_compressed->width = t_width; r_compressed->height = t_height; } } else { MCImageBitmap *t_bitmap = nil; if (memcmp(t_head, "BM", 2) == 0) t_success = MCImageDecodeBMP(p_stream, r_hotspot, t_bitmap); else if (memcmp(t_head, "#define", 7) == 0) t_success = MCImageDecodeXBM(p_stream, r_hotspot, r_name, t_bitmap); else if (memcmp(t_head, "/* XPM", 6) == 0) t_success = MCImageDecodeXPM(p_stream, t_bitmap); else if (t_head[0] == 'P' && (t_head[1] >= '1' && t_head[1] <= '6')) { t_success = MCImageDecodeNetPBM(p_stream, t_bitmap); // may have a mask image if (t_success && p_mask_stream != nil) { MCImageBitmap *t_mask = nil; t_success = MCImageDecodeNetPBM(p_mask_stream, t_mask) && MCImageBitmapApplyMask(t_bitmap, t_mask); MCImageFreeBitmap(t_mask); } } else // if all else fails, assume it's an XWD t_success = MCImageDecodeXWD(p_stream, r_name, t_bitmap); if (t_success) r_bitmap = t_bitmap; else MCImageFreeBitmap(t_bitmap); } } return t_success; }
IO_stat MCParagraph::load(IO_handle stream, const char *version) { IO_stat stat; stat = IO_NORMAL; if (stat == IO_NORMAL) stat = IO_read_uint2(&m_text_size, stream); if (m_text_size == 1) { if (stat == IO_NORMAL) { char t_temp; uint4 t_temp_count; t_temp_count = 1; stat = IO_read(&t_temp, sizeof(uint1), t_temp_count, stream); } if (stat == IO_NORMAL) m_text_size = 0; } else if (m_text_size > 1) { if (stat == IO_NORMAL) { m_text = malloc(m_text_size); if (m_text == NULL) stat = IO_ERROR; } if (stat == IO_NORMAL) { uint4 t_temp_text_size; t_temp_text_size = m_text_size; stat = IO_read(m_text, sizeof(uint1), t_temp_text_size, stream); } if (stat == IO_NORMAL) { if (MCencryptstring != NULL) MCX_passde((char *)m_text, MCencryptstring, m_text_size); m_text_size -= 1; } } while(stat == IO_NORMAL) { uint1 t_type; stat = IO_read_uint1(&t_type, stream); if (stat != IO_NORMAL) break; uint4 t_block_offset, t_block_length, t_block_style; stat = load_block(stream, version, t_block_offset, t_block_length, t_block_style); if (stat != IO_NORMAL) break; // Make sure the block doesn't overrun the text buffer (shouldn't ever be // necessary...) t_block_length = MCU_min(m_text_size - t_block_offset, t_block_length); // Byte-swap the text to native byte-order if its unicode, otherwise translate // Mac<->ISO if necessary. const MCParagraphCharStyle *t_style_info; t_style_info = FetchCharStyle(t_block_style); if (t_style_info -> is_unicode) { uint4 t_length; t_length = t_block_length / 2; uint2 *t_ptr; t_ptr = (uint2 *)((uint1 *)m_text + t_block_offset); for(; t_length > 0; t_length -= 1) swap_uint2(t_ptr++); } else if (MCtranslatechars) { #ifdef _MACOSX IO_iso_to_mac((char *)m_text + t_block_offset, t_block_length); #else IO_mac_to_iso((char *)m_text + t_block_offset, t_block_length); #endif } // Replace the style in the given range with the style ReplaceStyles(t_block_offset, t_block_length, t_block_style); } if (stat == IO_NORMAL) { // If no styles were applied, we need to translate the text if (m_styles_size == 0 && MCtranslatechars && m_text_size > 0) #ifdef _MACOSX IO_iso_to_mac((char *)m_text, m_text_size); #else IO_mac_to_iso((char *)m_text, m_text_size); #endif Compact(); MCS_seek_cur(stream, -1); } return stat; }