// MW-2011-09-13: [[ Masks ]] Updated to store data in an MCWindowMask struct.
MCWindowShape *MCImage::makewindowshape(void)
{
bool t_success = true;
MCWindowShape *t_mask = nil;
CGImageRef t_mask_image = nil;
MCImageBitmap *t_bitmap = nil;
uint8_t *t_alpha = nil;
uindex_t t_alpha_stride = 0;
uindex_t t_width, t_height;
t_success = lockbitmap(t_bitmap, true);
if (t_success)
t_success = MCImageBitmapHasTransparency(t_bitmap);
if (t_success)
{
t_width = t_bitmap->width;
t_height = t_bitmap->height;
t_alpha_stride = (t_width + 3) & ~3;
t_success = MCMemoryAllocate(t_alpha_stride * t_height, t_alpha);
}
if (t_success)
{
surface_extract_alpha(t_bitmap->data, t_bitmap->stride, t_alpha, t_alpha_stride, t_width, t_height);
t_success = MCAlphaToCGImage(t_width, t_height, t_alpha, t_alpha_stride, t_mask_image);
}
if (t_success)
t_success = MCMemoryNew(t_mask);
unlockbitmap(t_bitmap);
if (!t_success)
{
CGImageRelease(t_mask_image);
MCMemoryDeallocate(t_mask);
MCMemoryDeallocate(t_alpha);
return nil;
}
t_mask->width = t_width;
t_mask->height = t_height;
t_mask->is_sharp = false;
t_mask->data = (char*)t_alpha;
t_mask->stride = t_alpha_stride;
t_mask->handle = t_mask_image;
return t_mask;
}
void MCTileCacheSoftwareCompositor_Cleanup(void *p_context)
{
MCTileCacheSoftwareCompositorContext *self;
self = (MCTileCacheSoftwareCompositorContext *)p_context;
MCMemoryDeallocate(self -> tile_row);
MCMemoryDelete(self);
}
int MCR_exec(regexp *prog, MCStringRef string, MCRange p_range)
{
// AL-2014-06-25: [[ Bug 12676 ]] Ensure string is not unnativized by MCR_exec
int status;
int flags = 0;
if (MCStringIsNative(string))
{
uindex_t t_length;
unichar_t *t_string_chars;
t_string_chars = nil;
MCMemoryAllocate(MCStringGetLength(string) * sizeof(unichar_t), t_string_chars);
t_length = MCStringGetChars(string, p_range, t_string_chars);
status = regexec(&prog->rexp, t_string_chars, t_length, NSUBEXP, prog->matchinfo, flags);
MCMemoryDeallocate(t_string_chars);
}
else
status = regexec(&prog->rexp, MCStringGetCharPtr(string) + p_range . offset, p_range . length, NSUBEXP, prog->matchinfo, flags);
if (status != REG_OKAY)
{
if (status == REG_NOMATCH)
{
return (0);
}
//MCValueRelease(regexperror);
regerror(status, NULL, regexperror);
return(0);
}
return (1);
}
MCStreamCache::~MCStreamCache()
{
if (m_cache_file)
MCS_close(m_cache_file);
if (m_cache_buffer)
MCMemoryDeallocate(m_cache_buffer);
}
bool MCServerStopSession()
{
bool t_success = true;
if (s_current_session == NULL)
return true;
char *t_data = NULL;
uint32_t t_data_length = 0;
MCVariable *t_session_var;
t_session_var = MCVariable::lookupglobal_cstring("$_SESSION");
if (t_session_var != NULL)
t_success = t_session_var->getvalue().encode((void*&)t_data, t_data_length);
if (t_success)
{
MCMemoryDeallocate(s_current_session->data);
s_current_session->data = t_data;
s_current_session->data_length = t_data_length;
t_success = MCSessionCommit(s_current_session);
s_current_session = NULL;
}
return t_success;
}
MCReferencedImageRep::~MCReferencedImageRep()
{
MCCStringFree(m_file_name);
MCCStringFree(m_search_key);
MCMemoryDeallocate(m_url_data);
}
MCReferencedImageRep::~MCReferencedImageRep()
{
MCValueRelease(m_file_name);
MCValueRelease(m_search_key);
MCMemoryDeallocate(m_url_data);
}
void MCSessionDisposeSession(MCSession *p_session)
{
if (p_session == NULL)
return;
MCCStringFree(p_session->id);
MCCStringFree(p_session->ip);
MCCStringFree(p_session->filename);
MCMemoryDeallocate(p_session->data);
MCMemoryDelete(p_session);
}
static bool WindowsGetModuleDescription(MCStringRef p_path, MCStringRef& r_description)
{
bool t_success;
t_success = true;
MCAutoStringRefAsWString t_path;
/* UNCHECKED */ t_path.Lock(p_path);
DWORD t_size;
t_size = 0;
if (t_success)
{
t_size = GetFileVersionInfoSizeW(*t_path, nil);
if (t_size == 0)
t_success = false;
}
void *t_data;
t_data = nil;
if (t_success)
t_success = MCMemoryAllocate(t_size, t_data);
if (t_success &&
!GetFileVersionInfoW(*t_path, 0, t_size, t_data))
t_success = false;
UINT t_desc_length;
WCHAR *t_desc;
t_desc_length = 0;
t_desc = nil;
if (t_success &&
!VerQueryValueW(t_data, L"\\StringFileInfo\\040904b0\\FileDescription", (void **)&t_desc, &t_desc_length))
t_success = false;
if (t_success)
t_success = MCStringCreateWithWString(t_desc, r_description);
MCMemoryDeallocate(t_data);
// Make sure a description gets set
if (!t_success)
r_description = MCValueRetain(kMCEmptyString);
return t_success;
}
bool MCTileCacheCoreGraphicsCompositor_AllocateTile(void *p_context, int32_t p_size, const void *p_bits, uint32_t p_stride, void*& r_tile)
{
MCTileCacheCoreGraphicsCompositorContext *self;
self = (MCTileCacheCoreGraphicsCompositorContext *)p_context;
// If the stride is exactly one tile wide, we don't need a copy.
void *t_data;
t_data = nil;
if (p_stride == p_size * sizeof(uint32_t))
t_data = (void *)p_bits;
else if (MCMemoryAllocate(p_size * p_size * sizeof(uint32_t), t_data))
{
// Copy across each scanline of the tile into the buffer.
for(int32_t y = 0; y < p_size; y++)
memcpy((uint8_t *)t_data + y * p_size * sizeof(uint32_t), (uint8_t *)p_bits + p_stride * y, p_size * sizeof(uint32_t));
}
CGImageRef t_tile;
t_tile = nil;
if (t_data != nil)
{
// IM-2013-08-21: [[ RefactorGraphics ]] Refactor CGImage creation code to be pixel-format independent
CGBitmapInfo t_bm_info;
t_bm_info = MCGPixelFormatToCGBitmapInfo(kMCGPixelFormatNative, true);
CGContextRef t_cgcontext;
t_cgcontext = CGBitmapContextCreate((void *)t_data, p_size, p_size, 8, p_size * sizeof(uint32_t), self -> colorspace, t_bm_info);
if (t_cgcontext != nil)
{
t_tile = CGBitmapContextCreateImage(t_cgcontext);
CGContextRelease(t_cgcontext);
}
}
if (t_data != p_bits)
MCMemoryDeallocate(t_data);
if (t_tile == nil)
return false;
r_tile = t_tile;
return true;
}
bool read_binary(MCSystemFileHandle *p_file, void *&r_data, uint32_t &r_length)
{
if (!read_uint32(p_file, r_length))
return false;
uint32_t t_read;
void *t_data = NULL;
if (!MCMemoryAllocate(r_length, t_data))
return false;
if (p_file->Read(t_data, r_length, t_read) && t_read == r_length)
{
r_data = t_data;
return true;
}
else
{
MCMemoryDeallocate(t_data);
return false;
}
}
bool read_all(IO_handle p_stream, uint8_t *&r_data, uindex_t &r_data_size)
{
bool t_success = true;
uint8_t *t_buffer = nil;
uindex_t t_size = 0;
t_size = MCS_fsize(p_stream) - MCS_tell(p_stream);
t_success = MCMemoryAllocate(t_size, t_buffer);
if (t_success)
t_success = IO_NORMAL == MCS_readfixed(t_buffer, t_size, p_stream);
if (t_success)
{
r_data = t_buffer;
r_data_size = t_size;
}
else
MCMemoryDeallocate(t_buffer);
return t_success;
}
bool MCStreamCache::AppendToCache(void *p_buffer, uint32_t p_length, uint32_t &r_written)
{
bool t_success = true;
if (m_cache_length + p_length > m_buffer_limit)
{
if (m_cache_file == NULL)
{
t_success = MCMultiPartCreateTempFile(cgi_get_upload_temp_dir(), m_cache_file, m_cache_filename);
if (t_success && m_cache_buffer != NULL)
t_success = (IO_NORMAL == MCS_write(m_cache_buffer, 1, m_cache_length, m_cache_file));
MCMemoryDeallocate(m_cache_buffer);
m_cache_buffer = NULL;
}
if (t_success)
t_success = (IO_NORMAL == MCS_write(p_buffer, 1, p_length, m_cache_file));
m_cache_length += p_length;
r_written = p_length;
}
else
{
if (m_cache_buffer == NULL)
t_success = MCMemoryAllocate(m_buffer_limit, m_cache_buffer);
if (t_success)
{
MCMemoryCopy((uint8_t*)m_cache_buffer + m_cache_length, p_buffer, p_length);
m_cache_length += p_length;
r_written = p_length;
}
}
return t_success;
}
bool MCTileCacheSoftwareCompositor_BeginFrame(void *p_context, MCStackSurface *p_surface, MCRegionRef p_dirty)
{
MCTileCacheSoftwareCompositorContext *self;
self = (MCTileCacheSoftwareCompositorContext *)p_context;
MCGRaster t_raster;
if (!p_surface -> LockPixels(p_dirty, t_raster))
return false;
self -> bits = t_raster . pixels;
self -> stride = t_raster . stride;
MCMemoryDeallocate(self -> tile_row);
self -> tile_row = nil;
self -> tile_row_color = 0;
self -> tile_size = MCTileCacheGetTileSize(self -> tilecache);
self -> dirty = MCRegionGetBoundingBox(p_dirty);
self -> clip = self -> dirty;
self -> combiner = s_surface_combiners_nda[GXcopy];
self -> opacity = 255;
return true;
}
bool read_cstring(MCSystemFileHandle *p_file, char *&r_string)
{
uint32_t t_strlen;
if (!read_uint32(p_file, t_strlen))
return false;
uint32_t t_read;
char *t_str = NULL;
if (!MCMemoryAllocate(t_strlen + 1, t_str))
return false;
if (p_file->Read(t_str, t_strlen, t_read) && t_read == t_strlen)
{
t_str[t_strlen] = '\0';
r_string = t_str;
return true;
}
else
{
MCMemoryDeallocate(t_str);
return false;
}
}
bool MCStreamCache::Ensure(uint32_t p_offset)
{
if (p_offset <= m_cache_length)
return true;
bool t_success = true;
void *t_buffer;
t_success = MCMemoryAllocate(m_buffer_limit, t_buffer);
while (t_success && p_offset > m_cache_length)
{
uint32_t t_to_read;
uint32_t t_read;
t_to_read = MCMin(p_offset - m_cache_length, m_buffer_limit);
t_success = Read(t_buffer, m_cache_length, t_to_read, t_read) && (t_read == t_to_read);
}
MCMemoryDeallocate(t_buffer);
return t_success;
}
static bool cgi_native_from_encoding(MCSOutputTextEncoding p_encoding, const char *p_text, uint32_t p_text_length, char *&r_native, uint32_t &r_native_length)
{
bool t_success = true;
uint8_t *t_native = NULL;
uint32_t t_native_length = 0;
if (p_encoding == kMCSOutputTextEncodingUTF8)
{
int32_t t_unicode_length;
t_unicode_length = UTF8ToUnicode(p_text, p_text_length, NULL, 0);
uint16_t *t_unicode = NULL;
t_success = MCMemoryAllocate(t_unicode_length, t_unicode);
if (t_success)
{
UTF8ToUnicode(p_text, p_text_length, t_unicode, t_unicode_length);
t_success = MCConvertNativeFromUTF16(t_unicode, t_unicode_length / 2, t_native, t_native_length);
}
MCMemoryDeallocate(t_unicode);
}
else if (p_encoding == kMCSOutputTextEncodingWindows1252)
t_success = MCConvertNativeFromWindows1252((uint8_t*)p_text, p_text_length, t_native, t_native_length);
else if (p_encoding == kMCSOutputTextEncodingMacRoman)
t_success = MCConvertNativeFromMacRoman((uint8_t*)p_text, p_text_length, t_native, t_native_length);
else if (p_encoding == kMCSOutputTextEncodingISO8859_1)
t_success = MCConvertNativeFromISO8859_1((uint8_t*)p_text, p_text_length, t_native, t_native_length);
if (t_success)
{
r_native = (char*)t_native;
r_native_length = t_native_length;
}
return t_success;
}
MCResidentImageRep::~MCResidentImageRep()
{
MCMemoryDeallocate(m_data);
}
void MCTileCacheSoftwareCompositor_DeallocateTile(void *p_context, void *p_tile)
{
MCMemoryDeallocate(p_tile);
}
bool MCCrypt_rsa_op(bool p_encrypt, RSA_KEYTYPE p_key_type, const char *p_message_in, uint32_t p_message_in_length,
const char *p_key, uint32_t p_key_length, const char *p_passphrase,
char *&r_message_out, uint32_t &r_message_out_length, char *&r_result, uint32_t &r_error)
{
bool t_success = true;
EVP_PKEY *t_key = NULL;
RSA *t_rsa = NULL;
int32_t t_rsa_size;
uint8_t *t_output_buffer = NULL;
int32_t t_output_length;
if (!InitSSLCrypt())
{
t_success = false;
MCCStringClone("error: ssl library initialization failed", r_result);
}
if (t_success)
{
if (!load_pem_key(p_key, p_key_length, p_key_type, p_passphrase, t_key))
{
t_success = false;
MCCStringClone("error: invalid key", r_result);
}
}
if (t_success)
{
t_rsa = EVP_PKEY_get1_RSA(t_key);
if (t_rsa == NULL)
{
t_success = false;
MCCStringClone("error: not an RSA key", r_result);
}
}
if (t_success)
{
t_rsa_size = RSA_size(t_rsa);
if (!MCMemoryAllocate(t_rsa_size, t_output_buffer))
{
t_success = false;
r_error = EE_NO_MEMORY;
}
}
int (*t_rsa_func)(int, const unsigned char*, unsigned char*, RSA*, int) = NULL;
if (t_success)
{
if (p_encrypt)
{
if (p_key_type == RSAKEY_PRIVKEY)
t_rsa_func = RSA_private_encrypt;
else
t_rsa_func = RSA_public_encrypt;
if (p_message_in_length >= unsigned(t_rsa_size - 11))
{
t_success = false;
MCCStringClone("error: message too large", r_result);
}
}
else
{
if (p_key_type == RSAKEY_PRIVKEY)
t_rsa_func = RSA_private_decrypt;
else
t_rsa_func = RSA_public_decrypt;
if (p_message_in_length != t_rsa_size)
{
t_success = false;
MCCStringClone("error: invalid message size", r_result);
}
}
}
if (t_success)
{
t_output_length = t_rsa_func(p_message_in_length, (const uint8_t*)p_message_in, t_output_buffer, t_rsa, RSA_PKCS1_PADDING);
if (t_output_length < 0)
{
t_success = false;
MCCStringClone("error: SSL operation failed", r_result);
}
}
if (t_rsa != NULL)
RSA_free(t_rsa);
if (t_key != NULL)
EVP_PKEY_free(t_key);
if (t_success)
{
r_message_out = (char*)t_output_buffer;
r_message_out_length = t_output_length;
}
else
{
uint32_t t_err;
t_err = ERR_get_error();
if (t_err)
{
const char *t_ssl_error = ERR_reason_error_string(t_err);
MCCStringAppendFormat(r_result, " (SSL error: %s)", t_ssl_error);
}
MCMemoryDeallocate(t_output_buffer);
}
return t_success;
}
void __CGDataProviderDeallocate(void *info, const void *data, size_t size)
{
MCMemoryDeallocate(const_cast<void*>(data));
}
bool MCTextLayout(const unichar_t *p_chars, uint32_t p_char_count, MCFontStruct *p_font, MCTextLayoutCallback p_callback, void *p_context)
{
bool t_success;
t_success = true;
// The state structure we use to record the list of runs and the dc we use
// for processing.
MCTextLayoutState self;
MCMemoryClear(&self, sizeof(MCTextLayoutState));
if (t_success)
{
self . dc = CreateCompatibleDC(nil);
if (self . dc == nil)
t_success = false;
}
// Fetch a layout font for the provided HFONT.
if (t_success)
t_success = MCTextLayoutFontFromHFONT(p_font -> fid, self . primary_font);
// First thing we need to do is itemize the input string. The ScriptItemize
// function splits up the chars into runs, each run being potentially
// processed differently by Uniscribe.
// Unfortunately, there is no way to predict for an arbitrary string how
// many items might be generated, nor is the ScriptItemize function
// incremental, thus we must loop with an every increasing buffer until
// we have enough room.
SCRIPT_ITEM *t_items;
uint32_t t_item_limit, t_item_count;
SCRIPT_STATE t_script_state;
SCRIPT_CONTROL t_script_control;
t_items = nil;
t_item_limit = 0;
t_item_count = 0;
MCMemoryClear(&t_script_state, sizeof(SCRIPT_STATE));
MCMemoryClear(&t_script_control, sizeof(SCRIPT_CONTROL));
while(t_success)
{
// Increase the item array by 32 each time
if (t_success)
t_success = MCMemoryResizeArray(t_item_limit + 32, t_items, t_item_limit);
// Attempt to itemize
HRESULT t_result;
if (t_success)
{
t_result = ScriptItemize(p_chars, p_char_count, t_item_limit, &t_script_control, &t_script_state, t_items, (int *)&t_item_count);
if (t_result != S_OK && t_result != E_OUTOFMEMORY)
t_success = false;
}
if (t_success && t_result == S_OK)
break;
}
// Next we loop through the items one by one, processing them as we go, this
// process is slightly recursive - LayoutItem may recurse to fill in any
// 'holes' caused by glyphs not in the primary font.
for(uint32_t i = 0; i < t_item_count && t_success; i++)
t_success = MCTextLayoutStyleItem(
self,
t_items[i] . a,
p_chars + t_items[i] . iCharPos,
t_items[i + 1] . iCharPos - t_items[i] . iCharPos,
self . primary_font);
// At this point we should have an array of runs to render. First though we
// need to compute the visual to logical mapping.
uint8_t *t_levels;
int *t_map;
t_levels = nil;
t_map = nil;
if (t_success)
t_success =
MCMemoryNewArray(self . run_count, t_levels) &&
MCMemoryNewArray(self . run_count, t_map);
// Work out the run mapping, but only if we have runs to map!
if (t_success && self . run_count > 0)
{
for(uint32_t i = 0; i < self . run_count; i++)
t_levels[i] = self . runs[i] . embedding_level;
if (ScriptLayout(self . run_count, t_levels, t_map, nil) != S_OK)
t_success = false;
}
// Now we have the mapping we loop through the runs in the correct order
// dispatching them to the callback.
if (t_success && p_callback != nil)
{
double t_x;
t_x = 0.0;
for(uint32_t i = 0; i < self . run_count && t_success; i++)
{
MCTextLayoutRun *t_run;
t_run = &self . runs[t_map[i]];
// Allocate a temporary array for the glyph structures
MCTextLayoutGlyph *t_glyphs;
t_glyphs = nil;
if (t_success)
t_success = MCMemoryNewArray(t_run -> glyph_count, t_glyphs);
if (t_success)
{
// Compute the position for each glyph, keeping a running
// total of the advance width.
for(uint32_t i = 0; i < t_run -> glyph_count; i++)
{
t_glyphs[i] . index = t_run -> glyphs[i];
t_glyphs[i] . x = t_x + t_run -> goffsets[i] . du;
t_glyphs[i] . y = t_run -> goffsets[i] . dv;
t_x += t_run -> advances[i];
}
// Dispatch the span to the callback.
MCTextLayoutSpan t_span;
t_span . chars = t_run -> chars;
t_span . clusters = t_run -> clusters;
t_span . char_count = t_run -> char_count;
t_span . glyphs = t_glyphs;
t_span . glyph_count = t_run -> glyph_count;
t_span . font = t_run -> font -> handle;
t_success = p_callback(p_context, &t_span);
}
// Free the temporary array.
MCMemoryDeleteArray(t_glyphs);
}
}
// Free all the arrays and other resources that have been allocated.
MCMemoryDeleteArray(t_map);
MCMemoryDeleteArray(t_levels);
for(uint32_t i = 0; i < self . run_count; i++)
{
MCMemoryDeallocate(self . runs[i] . chars);
MCMemoryDeallocate(self . runs[i] . clusters);
MCMemoryDeallocate(self . runs[i] . glyphs);
MCMemoryDeallocate(self . runs[i] . advances);
MCMemoryDeallocate(self . runs[i] . goffsets);
}
MCMemoryDeleteArray(self . runs);
MCMemoryDeleteArray(t_items);
if (self . dc != nil)
DeleteDC(self . dc);
return t_success;
}
bool MCImageEncodePNG(MCImageIndexedBitmap *p_indexed, IO_handle p_stream, uindex_t &r_bytes_written)
{
bool t_success = true;
MCPNGWriteContext t_context;
t_context.stream = p_stream;
t_context.byte_count = 0;
png_structp t_png_ptr = nil;
png_infop t_info_ptr = nil;
png_color *t_png_palette = nil;
png_byte *t_png_transparency = nil;
png_bytep t_data_ptr = nil;
uindex_t t_stride = 0;
/*init png stuff*/
if (t_success)
{
t_success = nil != (t_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, (png_error_ptr)NULL,
(png_error_ptr)NULL));
}
if (t_success)
t_success = nil != (t_info_ptr = png_create_info_struct(t_png_ptr));
/*in case of png error*/
if (setjmp(png_jmpbuf(t_png_ptr)))
t_success = false;
if (t_success)
png_set_write_fn(t_png_ptr,(png_voidp)&t_context,fakewrite,fakeflush);
if (t_success)
{
png_set_IHDR(t_png_ptr, t_info_ptr, p_indexed->width, p_indexed->height, 8,
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_gAMA(t_png_ptr, t_info_ptr, 1/MCgamma);
}
if (t_success)
t_success = MCMemoryNewArray(p_indexed->palette_size, t_png_palette);
/*create palette for 8 bit*/
if (t_success)
{
for (uindex_t i = 0; i < p_indexed->palette_size ; i++)
{
t_png_palette[i].red = p_indexed->palette[i].red >> 8;
t_png_palette[i].green = p_indexed->palette[i].green >> 8;
t_png_palette[i].blue = p_indexed->palette[i].blue >> 8;
}
png_set_PLTE(t_png_ptr, t_info_ptr, t_png_palette, p_indexed->palette_size);
}
if (MCImageIndexedBitmapHasTransparency(p_indexed))
{
if (t_success)
t_success = MCMemoryAllocate(p_indexed->palette_size, t_png_transparency);
if (t_success)
{
memset(t_png_transparency, 0xFF, p_indexed->palette_size);
t_png_transparency[p_indexed->transparent_index] = 0x00;
png_set_tRNS(t_png_ptr, t_info_ptr, t_png_transparency, p_indexed->palette_size, NULL);
}
}
if (t_success)
png_write_info(t_png_ptr, t_info_ptr);
if (t_success)
{
t_data_ptr = (png_bytep)p_indexed->data;
t_stride = p_indexed->stride;
}
if (t_success)
{
for (uindex_t i = 0; i < p_indexed->height; i++)
{
png_write_row(t_png_ptr, t_data_ptr);
t_data_ptr += t_stride;
}
}
if (t_success)
png_write_end(t_png_ptr, t_info_ptr);
if (t_png_ptr != nil)
png_destroy_write_struct(&t_png_ptr, &t_info_ptr);
if (t_png_palette != nil)
MCMemoryDeleteArray(t_png_palette);
if (t_png_transparency != nil)
MCMemoryDeallocate(t_png_transparency);
if (t_success)
r_bytes_written = t_context.byte_count;
return t_success;
}
MCVectorImageRep::~MCVectorImageRep()
{
MCMemoryDeallocate(m_data);
}
bool MCGRasterToCGImage(const MCGRaster &p_raster, MCGRectangle p_src_rect, CGColorSpaceRef p_colorspace, bool p_copy, bool p_invert, CGImageRef &r_image)
{
bool t_success = true;
int32_t t_x, t_y;
uint32_t t_width, t_height;
t_x = p_src_rect.origin.x;
t_y = p_src_rect.origin.y;
t_width = p_src_rect.size.width;
t_height = p_src_rect.size.height;
/* OVERHAUL - REVISIT: pixel formats */
const uint8_t *t_src_ptr = (uint8_t*)p_raster.pixels;
t_src_ptr += t_y * p_raster.stride + t_x * sizeof(uint32_t);
uint32_t t_dst_stride;
if (p_invert)
p_copy = true;
CGImageRef t_image = nil;
CGDataProviderRef t_data_provider = nil;
if (!p_copy)
{
t_dst_stride = p_raster.stride;
t_success = nil != (t_data_provider = CGDataProviderCreateWithData(nil, t_src_ptr, t_height * p_raster.stride, nil));
}
else
{
uint8_t* t_buffer = nil;
t_dst_stride = t_width * sizeof(uint32_t);
uindex_t t_buffer_size = t_height * t_dst_stride;
t_success = MCMemoryAllocate(t_buffer_size, t_buffer);
if (t_success)
{
int32_t t_src_stride;
uint8_t* t_dst_ptr = t_buffer;
if (!p_invert)
{
t_src_stride = p_raster.stride;
}
else
{
t_src_ptr += ((int32_t)t_height - 1) * p_raster.stride;
t_src_stride = -p_raster.stride;
}
for (uindex_t y = 0; y < t_height; y++)
{
MCMemoryCopy(t_dst_ptr, t_src_ptr, t_dst_stride);
t_dst_ptr += t_dst_stride;
t_src_ptr += t_src_stride;
}
}
if (t_success)
t_success = nil != (t_data_provider = CGDataProviderCreateWithData(nil, t_buffer, t_buffer_size, __CGDataProviderDeallocate));
if (!t_success)
MCMemoryDeallocate(t_buffer);
}
// IM-2013-08-21: [[ RefactorGraphics ]] Refactor CGImage creation code to be pixel-format independent
CGBitmapInfo t_bm_info;
t_bm_info = MCGPixelFormatToCGBitmapInfo(kMCGPixelFormatNative, true);
if (t_success)
t_success = nil != (t_image = CGImageCreate(t_width, t_height, 8, 32, t_dst_stride, p_colorspace, t_bm_info, t_data_provider, nil, true, kCGRenderingIntentDefault));
CGDataProviderRelease(t_data_provider);
if (t_success)
r_image = t_image;
return t_success;
}
bool MCFileSystemListEntries(const char *p_folder, uint32_t p_options, MCFileSystemListCallback p_callback, void *p_context)
{
bool t_success;
t_success = true;
char *t_pattern;
t_pattern = nil;
if (t_success)
t_success = MCCStringFormat(t_pattern, "%s%s", p_folder, MCCStringEndsWith(p_folder, "/") ? "*" : "/*");
void *t_native_pattern;
t_native_pattern = nil;
if (t_success)
t_success = MCFileSystemPathToNative(t_pattern, t_native_pattern);
HANDLE t_find_handle;
WIN32_FIND_DATAW t_find_data;
t_find_handle = INVALID_HANDLE_VALUE;
if (t_success)
{
t_find_handle = FindFirstFileW((LPCWSTR)t_native_pattern, &t_find_data);
if (t_find_handle == INVALID_HANDLE_VALUE)
t_success = false;
}
while(t_success)
{
char *t_entry_filename;
if (t_success)
t_success = MCFileSystemPathFromNative(t_find_data . cFileName, t_entry_filename);
MCFileSystemEntry t_entry;
if (t_success)
{
t_entry . type = (t_find_data . dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 ? kMCFileSystemEntryFolder : kMCFileSystemEntryFile;
t_entry . filename = t_entry_filename;
t_success = p_callback(p_context, t_entry);
}
MCCStringFree(t_entry_filename);
////
if (!FindNextFileW(t_find_handle, &t_find_data))
{
if (GetLastError() == ERROR_NO_MORE_FILES)
break;
t_success = false;
}
}
if (t_find_handle != INVALID_HANDLE_VALUE)
FindClose(t_find_handle);
MCMemoryDeallocate(t_native_pattern);
MCCStringFree(t_pattern);
return t_success;
}
bool MCGRasterCreateCGDataProvider(const MCGRaster &p_raster, const MCGIntegerRectangle &p_src_rect, bool p_copy, bool p_invert, CGDataProviderRef &r_data_provider, uint32_t &r_stride)
{
MCAssert(p_src_rect.origin.x >= 0 && p_src_rect.origin.y >= 0);
MCAssert(p_src_rect.origin.x + p_src_rect.size.width <= p_raster.width);
MCAssert(p_src_rect.origin.y + p_src_rect.size.height <= p_raster.height);
bool t_success = true;
int32_t t_x, t_y;
uint32_t t_width, t_height;
t_x = p_src_rect.origin.x;
t_y = p_src_rect.origin.y;
t_width = p_src_rect.size.width;
t_height = p_src_rect.size.height;
uint8_t *t_src_ptr = (uint8_t*)MCGRasterGetPixelPtr(p_raster, t_x, t_y);
uint32_t t_dst_stride;
if (p_invert)
p_copy = true;
CGDataProviderRef t_data_provider = nil;
if (!p_copy)
{
t_dst_stride = p_raster.stride;
t_data_provider = CGDataProviderCreateWithData(nil, t_src_ptr, t_height * p_raster.stride, __CGDataProviderDeallocate);
t_success = t_data_provider != nil;
if (!t_success)
MCMemoryDeallocate(t_src_ptr);
}
else
{
uint8_t* t_buffer = nil;
t_dst_stride = t_width * sizeof(uint32_t);
uindex_t t_buffer_size = t_height * t_dst_stride;
t_success = MCMemoryAllocate(t_buffer_size, t_buffer);
if (t_success)
{
int32_t t_src_stride;
uint8_t* t_dst_ptr = t_buffer;
if (!p_invert)
{
t_src_stride = p_raster.stride;
}
else
{
t_src_ptr += ((int32_t)t_height - 1) * p_raster.stride;
t_src_stride = -p_raster.stride;
}
for (uindex_t y = 0; y < t_height; y++)
{
MCMemoryCopy(t_dst_ptr, t_src_ptr, t_dst_stride);
t_dst_ptr += t_dst_stride;
t_src_ptr += t_src_stride;
}
}
if (t_success)
{
t_data_provider = CGDataProviderCreateWithData(nil, t_buffer, t_buffer_size, __CGDataProviderDeallocate);
t_success = t_data_provider != nil;
}
if (!t_success)
MCMemoryDeallocate(t_buffer);
}
if (t_success)
{
r_data_provider = t_data_provider;
r_stride = t_dst_stride;
}
return t_success;
}
bool MCImageEncodePNG(MCImageBitmap *p_bitmap, IO_handle p_stream, uindex_t &r_bytes_written)
{
bool t_success = true;
MCPNGWriteContext t_context;
t_context.stream = p_stream;
t_context.byte_count = 0;
png_structp t_png_ptr = nil;
png_infop t_info_ptr = nil;
png_color *t_png_palette = nil;
png_byte *t_png_transparency = nil;
png_bytep t_data_ptr = nil;
uindex_t t_stride = 0;
MCImageIndexedBitmap *t_indexed = nil;
if (MCImageConvertBitmapToIndexed(p_bitmap, false, t_indexed))
{
t_success = MCImageEncodePNG(t_indexed, p_stream, r_bytes_written);
MCImageFreeIndexedBitmap(t_indexed);
return t_success;
}
/*init png stuff*/
if (t_success)
{
t_success = nil != (t_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, (png_error_ptr)NULL,
(png_error_ptr)NULL));
}
if (t_success)
t_success = nil != (t_info_ptr = png_create_info_struct(t_png_ptr));
/*in case of png error*/
if (setjmp(png_jmpbuf(t_png_ptr)))
t_success = false;
if (t_success)
png_set_write_fn(t_png_ptr,(png_voidp)&t_context,fakewrite,fakeflush);
bool t_fully_opaque = true;
if (t_success)
{
t_fully_opaque = !MCImageBitmapHasTransparency(p_bitmap);
png_set_IHDR(t_png_ptr, t_info_ptr, p_bitmap->width, p_bitmap->height, 8,
t_fully_opaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_gAMA(t_png_ptr, t_info_ptr, 1/MCgamma);
}
if (t_success)
{
png_write_info(t_png_ptr, t_info_ptr);
//32 bit compensate for byte swapped systems
if (t_fully_opaque)
png_set_filler(t_png_ptr, 0, MCswapbytes ? PNG_FILLER_AFTER : PNG_FILLER_BEFORE);
if (MCswapbytes)
png_set_bgr(t_png_ptr);
else
png_set_swap_alpha(t_png_ptr);
}
if (t_success)
{
t_data_ptr = (png_bytep)p_bitmap->data;
t_stride = p_bitmap->stride;
}
if (t_success)
{
for (uindex_t i = 0; i < p_bitmap->height; i++)
{
png_write_row(t_png_ptr, t_data_ptr);
t_data_ptr += t_stride;
}
}
if (t_success)
png_write_end(t_png_ptr, t_info_ptr);
if (t_png_ptr != nil)
png_destroy_write_struct(&t_png_ptr, &t_info_ptr);
if (t_png_palette != nil)
MCMemoryDeleteArray(t_png_palette);
if (t_png_transparency != nil)
MCMemoryDeallocate(t_png_transparency);
if (t_success)
r_bytes_written = t_context.byte_count;
return t_success;
}
static bool MCRegistryListValues(HKEY p_root, const char *p_key, MCRegistryListValuesCallback p_callback, void *p_context)
{
bool t_success;
t_success = true;
// Attempt to open the given key.
HKEY t_handle;
t_handle = nil;
if (t_success)
if (RegOpenKeyExA(p_root, p_key, 0, KEY_QUERY_VALUE, &t_handle) != ERROR_SUCCESS)
t_success = false;
// Next determine the maximum length of the value names.
DWORD t_max_name_length;
if (t_success)
if (RegQueryInfoKeyA(t_handle, nil, nil, nil, nil, nil, nil, nil, &t_max_name_length, nil, nil, nil) != ERROR_SUCCESS)
t_success = false;
// Allocate a buffer big enough for the name
char *t_name_buffer;
t_name_buffer = nil;
if (t_success)
t_success = MCMemoryNewArray(t_max_name_length + 1, t_name_buffer);
if (t_success)
{
DWORD t_index;
t_index = 0;
while(t_success)
{
DWORD t_name_length, t_value_length;
t_name_length = t_max_name_length + 1;
t_value_length = 0;
LSTATUS t_result;
if (t_success)
{
t_result = RegEnumValueA(t_handle, t_index, t_name_buffer, &t_name_length, nil, nil, nil, &t_value_length);
if (t_result == ERROR_NO_MORE_ITEMS)
break;
if (t_result != ERROR_SUCCESS)
t_success = false;
}
void *t_value_buffer;
t_value_buffer = nil;
if (t_success)
t_success = MCMemoryAllocate(t_value_length, t_value_buffer);
DWORD t_type;
if (t_success)
{
t_name_length = t_max_name_length + 1;
if (RegEnumValueA(t_handle, t_index, t_name_buffer, &t_name_length, nil, &t_type, (LPBYTE)t_value_buffer, &t_value_length) != ERROR_SUCCESS)
t_success = false;
}
if (t_success && p_callback != nil)
p_callback(p_context, t_name_buffer, t_type, t_value_buffer, t_value_length);
MCMemoryDeallocate(t_value_buffer);
t_index++;
}
}
MCMemoryDeleteArray(t_name_buffer);
if (t_handle != nil)
RegCloseKey(t_handle);
return t_success;
}