/* Copyright (C) 2003-2013 Runtime Revolution Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "prefix.h"

#include "globdefs.h"

#include "filedefs.h"

#include "parsedef.h"

#include "objdefs.h"

#include "mcio.h"

#include "globals.h"

#include "stack.h"

#include "field.h"

#include "image.h"

#include "paragraf.h"

#include "line.h"

#include "MCBlock.h"

#include "util.h"

#include "context.h"

#include "mctheme.h"

#include "font.h"

#include "path.h"

#include "segment.h"

#include "exec-interface.h"

// Default MCBlock constructor - makes a block with everything initialized

// to zero.

MCBlock::MCBlock(void)

{

parent = NULL;

flags = F_CLEAR|F_HAS_UNICODE;

atts = NULL;

m_index = m_size = 0;

width = 0;

opened = 0;

origin = 0;

tabpos = 0;

direction_level = 0;

// MW-2012-02-14: [[ FontRefs ]] The font for the block starts off nil.

m_font = nil;

}

// MCBlock copy constructor - copy an existing block.

// Note that this copies everything except the linkage and opened state.

MCBlock::MCBlock(const MCBlock &bref) : MCDLlist(bref)

{

parent = bref.parent;

flags = bref.flags;

if (flags & F_HAS_ATTS)

{

atts = new Blockatts;

if (flags & F_HAS_COLOR)

{

atts->color = new MCColor;

*atts->color = *bref.atts->color;

}

if (flags & F_HAS_BACK_COLOR)

{

atts->backcolor = new MCColor;

*atts->backcolor = *bref.atts->backcolor;

}

// MW-2012-02-17: [[ SplitTextAttrs ]] Copy across the font attrs the other

// block has.

if ((flags & F_HAS_FNAME) != 0)

/* UNCHECKED */ MCNameClone(bref.atts->fontname, atts -> fontname);

if ((flags & F_HAS_FSIZE) != 0)

atts -> fontsize = bref . atts -> fontsize;

if ((flags & F_HAS_FSTYLE) != 0)

atts -> fontstyle = bref . atts -> fontstyle;

atts->shift = bref.atts->shift;

// MW-2012-05-04: [[ Values ]] linkText / imageSource / metaData are now uniqued

// strings.

if (flags & F_HAS_LINK)

atts -> linktext = MCValueRetain(bref . atts -> linktext);

if (flags & F_HAS_IMAGE)

atts -> imagesource = MCValueRetain(bref . atts -> imagesource);

if (flags & F_HAS_METADATA)

atts -> metadata = MCValueRetain(bref . atts -> metadata);

}

else

atts = NULL;

m_index = bref.m_index;

m_size = bref.m_size;

width = 0;

opened = 0;

origin = 0;

tabpos = 0;

direction_level = bref.direction_level;

// MW-2012-02-14: [[ FontRefs ]] The font for the block starts off nil.

m_font = nil;

}

// MCBlock deconstructor - frees all associated data structures.

MCBlock::~MCBlock()

{

while (opened)

close();

if (atts != NULL)

freeatts();

}

bool MCBlock::visit(MCVisitStyle p_style, uint32_t p_part, MCObjectVisitor *p_visitor)

{

return p_visitor -> OnBlock(this);

}

// MW-2012-03-04: [[ StackFile5500 ]] If 'is_ext' is true then the record is an extended

// record.

IO_stat MCBlock::load(IO_handle stream, uint32_t version, bool is_ext)

{

IO_stat stat;

// MW-2012-03-04: [[ StackFile5500 ]] If this is an extended block, then work out

// where to skip to when all the attrs currently recognized have been read.

int64_t t_attr_end;

if (is_ext)

{

// Read the size.

uint32_t t_size;

if ((stat = IO_read_uint2or4(&t_size, stream)) != IO_NORMAL)

return stat;

// The end is the current stream position + the size of the attrs.

t_attr_end = MCS_tell(stream) + t_size;

}

if ((stat = IO_read_uint4(&flags, stream)) != IO_NORMAL)

return stat;

// MW-2012-03-04: [[ StackFile5500 ]] If this isn't an extended block, then strip the

// metadata flag.

if (!is_ext)

flags &= ~F_HAS_METADATA;

// MW-2012-01-26: [[ FlaggedField ]] Make sure we ignore the setting of FLAGGED flag.

flags &= ~F_FLAGGED;

if (atts == NULL)

atts = new Blockatts;

// MW-2012-02-17: [[ SplitTextAttrs ]] If the font flag is present, it means there

// is a font record to read.

if (flags & F_FONT)

{

if (version > 1300)

{

uint2 t_font_index;

if ((stat = IO_read_uint2(&t_font_index, stream)) != IO_NORMAL)

return stat;

// MW-2012-02-17: [[ LogFonts ]] Map the font index we have to the font attrs.

// Note that we ignore the 'unicode' tag since that is encoded in flags.

MCNameRef t_fontname;

uint2 t_fontstyle, t_fontsize;

bool t_is_unicode;

MCLogicalFontTableLookup(t_font_index, t_fontname, t_fontstyle, t_fontsize, t_is_unicode);

// MW-2012-02-17: [[ SplitTextAttrs ]] Only set the font attrs if they are

// not inherited.

if (!getflag(F_INHERIT_FNAME))

MCNameClone(t_fontname, atts -> fontname);

if (!getflag(F_INHERIT_FSIZE))

atts -> fontsize = t_fontsize;

if (!getflag(F_INHERIT_FSTYLE))

atts -> fontstyle = t_fontstyle;

}

else

{

// MW-2012-02-17: [[ LogFonts ]] Read a nameref directly.

// MW-2013-11-19: [[ UnicodeFileFormat ]] This path only happens sfv < 1300

// so is legacy.

if ((stat = IO_read_nameref_legacy(atts->fontname, stream, false)) != IO_NORMAL)

return stat;

if ((stat = IO_read_uint2(&atts->fontsize, stream)) != IO_NORMAL)

return stat;

if ((stat = IO_read_uint2(&atts->fontstyle, stream)) != IO_NORMAL)

return stat;

// MW-2012-02-17; [[ SplitTextAttrs ]] All the font attrs are set.

flags |= F_FATTR_MASK;

}

}

if (flags & F_HAS_COLOR)

{

atts->color = new MCColor;

if ((stat = IO_read_mccolor(*atts->color, stream)) != IO_NORMAL)

return stat;

if (flags & F_HAS_COLOR_NAME)

{

// MW-2012-01-06: [[ Block Changes ]] We no longer use the color name

// so load, delete and unset the flag.

// MW-2013-11-19: [[ UnicodeFileFormat ]] The storage of this is ignored,

// so is legacy,

char *colorname;

if ((stat = IO_read_cstring_legacy(colorname, stream, 2)) != IO_NORMAL)

return stat;

delete colorname;

flags &= ~F_HAS_COLOR_NAME;

}

}

if (flags & F_HAS_BACK_COLOR)

{

atts->backcolor = new MCColor;

if ((stat = IO_read_mccolor(*atts->backcolor, stream)) != IO_NORMAL)

return stat;

if (version < 2000 || flags & F_HAS_BACK_COLOR_NAME)

{

// MW-2012-01-06: [[ Block Changes ]] We no longer use the backcolor name

// so load, delete and unset the flag.

// MW-2013-11-19: [[ UnicodeFileFormat ]] The storage of this is ignored,

// so is legacy,

char *backcolorname;

if ((stat = IO_read_cstring_legacy(backcolorname, stream, 2)) != IO_NORMAL)

return stat;

delete backcolorname;

flags &= ~F_HAS_BACK_COLOR_NAME;

}

}

if (flags & F_HAS_SHIFT)

if ((stat = IO_read_int2(&atts->shift, stream)) != IO_NORMAL)

return stat;

// MW-2012-05-04: [[ Values ]] linkText / imageSource / metaData are now uniqued

// strings.

if (flags & F_HAS_LINK)

{

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if ((stat = IO_read_stringref_new(atts->linktext, stream, version >= 7000)) != IO_NORMAL)

return stat;

/* UNCHECKED */ MCValueInterAndRelease(atts -> linktext, atts -> linktext);

}

if (flags & F_HAS_IMAGE)

{

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if ((stat = IO_read_stringref_new(atts->imagesource, stream, version >= 7000)) != IO_NORMAL)

return stat;

/* UNCHECKED */ MCValueInterAndRelease(atts -> imagesource, atts -> imagesource);

}

// MW-2012-03-04: [[ StackFile5500 ]] If there is a metadata attr then read

// it in.

if (flags & F_HAS_METADATA)

{

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if ((stat = IO_read_stringref_new(atts->metadata, stream, version >= 7000)) != IO_NORMAL)

return stat;

/* UNCHECKED */ MCValueInterAndRelease(atts -> metadata, atts -> metadata);

}

// MW-2012-03-04: [[ StackFile5500 ]] If this is an extended block, then skip

// to the end of the attrs record.

if (is_ext)

if ((stat = MCS_seek_set(stream, t_attr_end)) != IO_NORMAL)

return stat;

// ***** IMPORTANT *****

// The "index" and "size" values loaded below are byte indices into the

// parent paragraph's text buffer and are almost certainly wrong if the

// paragraph contains any Unicode text.

//

// Things are this way to maintain file format compatibility with engines

// that do not support the full Unicode refactor.

//

// Helpfully, the paragraph loading code makes a SetRanges call to inform

// the block of the correct offsets as soon as it knows them.

uint2 index, size;

if ((stat = IO_read_uint2(&index, stream)) != IO_NORMAL)

return stat;

if ((stat = IO_read_uint2(&size, stream)) != IO_NORMAL)

return stat;

m_index = index;

m_size = size;

// MW-2012-02-17: [[ SplitTextAttrs ]] Adjust the flags to their in-memory

// representation. We ditch F_FONT because it is superceeded by the HAS_F*

// flags.

if (getflag(F_FONT))

{

flags &= ~F_FONT;

flags = (flags & ~F_FATTR_MASK) | (~(flags & F_FATTR_MASK) & F_FATTR_MASK);

}

else

flags &= ~F_FATTR_MASK;

// MW-2012-02-17: [[ SplitTextAttrs ]] If the block has no atts flags set

// then clear the atts struct.

if ((flags & F_HAS_ATTS) == 0)

{

delete atts;

atts = nil;

}

return IO_NORMAL;

}

IO_stat MCBlock::save(IO_handle stream, uint4 p_part)

{

IO_stat stat;

// MW-2012-03-04: [[ StackFile5500 ]] If the block has metadata and 5.5 stackfile

// format has been requested then this is an extended block.

bool t_is_ext;

if (MCstackfileversion >= 5500 && getflag(F_HAS_METADATA))

t_is_ext = true;

else

t_is_ext = false;

// MW-2012-03-04: [[ StackFile5500 ]] If this is an extended block then use the EXT

// tag.

if ((stat = IO_write_uint1(t_is_ext ? OT_BLOCK_EXT : OT_BLOCK, stream)) != IO_NORMAL)

return stat;

// MW-2012-03-04: [[ StackFile5500 ]] If this is an extended block then write out

// the length of the attrs.

if (t_is_ext)

if ((stat = IO_write_uint2or4(measureattrs(), stream)) != IO_NORMAL)

return stat;

uint4 oldflags = flags;

// MW-2012-01-06: [[ StackFile5500 ]] If this isn't an extended block, then remove

// the metadata flag.

if (!t_is_ext)

flags &= ~F_HAS_METADATA;

flags &= ~F_VISITED;

// MW-2012-01-26: [[ FlaggedField ]] Make sure we don't save the flagged flag.

flags &= ~F_FLAGGED;

// The "has unicode" flag depends on whether the paragraph is native

bool t_is_unicode;

if (MCstackfileversion < 7000 && MCStringIsNative(parent->GetInternalStringRef()))

{

t_is_unicode = false;

flags &= ~F_HAS_UNICODE;

}

else

{

t_is_unicode = true;

flags |= F_HAS_UNICODE;

}

// MW-2012-02-17: [[ SplitTextAttrs ]] If we have unicode, or one of the font attr are

// set then we must serialize a font.

bool t_need_font;

if ((flags & (F_FATTR_MASK | F_HAS_UNICODE)) != 0)

{

// Add in the font record flag.

flags |= F_FONT;

// Invert the font attr flags (from has to inherit).

flags = (flags & ~F_FATTR_MASK) | (~(flags & F_FATTR_MASK) & F_FATTR_MASK);

t_need_font = true;

}

else

t_need_font = false;

if ((stat = IO_write_uint4(flags, stream)) != IO_NORMAL)

return stat;

flags = oldflags;

// MW-2012-02-17: [[ SplitTextAttrs ]] If any one of the font attrs are set, or we

// are unicode we must serialize a font.

if (t_need_font)

{

// MW-2012-02-17: [[ SplitTextAttrs ]] Compute the attrs to write out.

MCNameRef t_fontname;

uint2 t_fontstyle, t_fontsize;

getfontattrs(nil, t_fontname, t_fontsize, t_fontstyle);

// MW-2012-02-17: [[ LogFonts ]] Map the font attrs to the appropriate font

// index and write.

uint2 t_font_index;

t_font_index = MCLogicalFontTableMap(t_fontname, t_fontstyle, t_fontsize, true);

if ((stat = IO_write_uint2(t_font_index, stream)) != IO_NORMAL)

return stat;

}

if (flags & F_HAS_COLOR)

if ((stat = IO_write_mccolor(*atts->color, stream)) != IO_NORMAL)

return stat;

if (flags & F_HAS_BACK_COLOR)

if ((stat = IO_write_mccolor(*atts->backcolor, stream)) != IO_NORMAL)

return stat;

if (flags & F_HAS_SHIFT)

if ((stat = IO_write_int2(atts->shift, stream)) != IO_NORMAL)

return stat;

// MW-2012-05-04: [[ Values ]] linkText / imageSource / metaData are now uniqued

// strings.

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if (flags & F_HAS_LINK)

if ((stat = IO_write_stringref_new(atts->linktext, stream, MCstackfileversion >= 7000)) != IO_NORMAL)

return stat;

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if (flags & F_HAS_IMAGE)

if ((stat = IO_write_stringref_new(atts->imagesource, stream, MCstackfileversion >= 7000)) != IO_NORMAL)

return stat;

// MW-2012-03-04: [[ StackFile5500 ]] If this is an extended block then emit the

// new attributes.

if (t_is_ext)

{

// MW-2013-11-19: [[ UnicodeFileFormat ]] If sfv >= 7000, use unicode.

if (flags & F_HAS_METADATA)

if ((stat = IO_write_stringref_new(atts -> metadata, stream, MCstackfileversion >= 7000)) != IO_NORMAL)

return stat;

}

uint32_t t_index_size;

t_index_size = t_is_unicode ? sizeof(unichar_t) : sizeof(char_t);

if ((stat = IO_write_uint2(m_index * t_index_size, stream)) != IO_NORMAL)

return stat;

if ((stat = IO_write_uint2(m_size * t_index_size, stream)) != IO_NORMAL)

return stat;

return IO_NORMAL;

}

void MCBlock::open(MCFontRef p_parent_font)

{

if (opened++ != 0)

return;

// MW-2012-02-14: [[ FontRefs ]] Map the font for the block.

mapfont(p_parent_font);

if (flags & F_HAS_COLOR)

MCscreen->alloccolor(*atts->color);

if (flags & F_HAS_BACK_COLOR)

MCscreen->alloccolor(*atts->backcolor);

openimage();

width = 0;

}

void MCBlock::close()

{

if (opened == 0 || --opened != 0)

return;

closeimage();

// MW-2012-02-14: [[ FontRefs ]] Unmap the font for the block.

unmapfont();

}

// MW-2012-02-14: [[ FontRefs ]] This method computes the fontref for the block.

void MCBlock::mapfont(MCFontRef p_parent_font)

{

// If we have no font attrs set, then we just copy the parent font.

if (!hasfontattrs())

{

m_font = MCFontRetain(p_parent_font);

return;

}

// MW-2012-02-17: [[ SplitTextAttrs ]] Compute the attrs to write out. If we don't

// have all of the attrs, fetch the inherited ones.

MCNameRef t_textfont;

uint2 t_textstyle, t_textsize;

getfontattrs(nil, t_textfont, t_textsize, t_textstyle);

// Compute the font style from the text style.

MCFontStyle t_font_style;

t_font_style = MCFontStyleFromTextStyle(t_textstyle);

// If the parent font had printer metrics, then make sure we have them too.

if (MCFontHasPrinterMetrics(p_parent_font))

t_font_style |= kMCFontStylePrinterMetrics;

// Create the fontref.

/* UNCHECKED */ MCFontCreate(t_textfont, t_font_style, t_textsize, m_font);

}

// MW-2012-02-14: [[ FontRefs ]] This method delete the fontref associated with the block.

void MCBlock::unmapfont(void)

{

MCFontRelease(m_font);

m_font = nil;

}

// MW-2012-02-14: [[ FontRefs ]] This method updates the current fontref associated with the

// block, returning 'true' if it has changed.

bool MCBlock::recomputefonts(MCFontRef p_parent_font)

{

// If there are no font attributes, then we are updating to the parent font.

if (!hasfontattrs())

{

// If the font is the same as the parent font already then there is nothing to do.

if (m_font == p_parent_font)

return false;

// Otherwise change the current fontref for a copy of the parent fontref.

MCFontRelease(m_font);

m_font = MCFontRetain(p_parent_font);

width = 0;

// As we changed fontref, return 'true'.

return true;

}

// Take a copy of the current font.

MCFontRef t_current_font;

t_current_font = MCFontRetain(m_font);

// Unmap the current fontref, then map again.

unmapfont();

mapfont(p_parent_font);

// We've only changed if the new font is different from the old fontref.

bool t_changed;

t_changed = m_font != t_current_font;

// Get rid of the temporary copy of the old font we took.

MCFontRelease(t_current_font);

if (t_changed)

width = 0;

// Return the result of the operation.

return t_changed;

}

// MW-2012-02-06: [[ Bug ]] The 'flagged' property was causing multiple (identical)

// runs in the styledText format. To rectify this, the 'persistent_only' param

// indicates whether the comparison is for persistence (styledText) or for in-

// memory processing (defrag).

Boolean MCBlock::sameatts(MCBlock *bptr, bool p_persistent_only)

{

// Check to see if a subset of the flags are the same, if they aren't the

// blocks are not the same. Notice that in 'persistent' mode (used by

// styledText generation) we exclude the transient flags. We need to keep

// the latter in the case of 'defrag()' as technically they are different

// runs from that point of view.

// MW-2012-02-13: [[ Block Unicode ]] Make sure both blocks have the same

// 'unicode' flag.

// MW-2012-02-17: [[ SplitTextAttrs ]] Check for all the fattr rather than

// font.

uint32_t t_flags;

t_flags = F_HAS_ALL_FATTR | F_HAS_COLOR | F_HAS_METADATA | F_HAS_SHIFT | F_HAS_BACK_COLOR | F_HAS_LINK | F_HAS_UNICODE;

if (!p_persistent_only)

t_flags |= F_HILITED | F_FLAGGED | F_VISITED;

// If the flags don't match, we can't be the same.

if ((flags & t_flags) != (bptr -> flags & t_flags))

return False;

// If either block has an image, we treat them as different blocks.

if (flags & F_HAS_IMAGE || bptr->flags & F_HAS_IMAGE)

return False;

// MW-2012-02-17: [[ SplitTextAttrs ]] CHeck to see if all the font attrs

// match in turn.

if ((flags & F_HAS_FNAME) != 0 && (atts -> fontname != bptr -> atts -> fontname))

return False;

if ((flags & F_HAS_FSTYLE) != 0 && (atts -> fontstyle != bptr -> atts -> fontstyle))

return False;

if ((flags & F_HAS_FSIZE) != 0 && (atts -> fontsize != bptr -> atts -> fontsize))

return False;

// If the linkTexts are not the same, the blocks are different. Notice that

// we do a pointer comparison - these are 'Names' and as such are identical

// iff they are the same pointer.

if (getlinktext() != bptr -> getlinktext())

return False;

// If the metadatas are not the same, the blocks are different. Notice that

// we do a pointer comparison - the metadata fields are unique values so this

// is sufficient to check for equality.

if (getmetadata() != bptr -> getmetadata())

return False;

// If we have a color set, then make sure it matches the other block.

if ((flags & F_HAS_COLOR) != 0 &&

(bptr->atts->color->red != atts->color->red ||

bptr->atts->color->green != atts->color->green ||

bptr->atts->color->blue != atts->color->blue))

return False;

// If we have a backColor set, then make sure it matches the other block.

if ((flags & F_HAS_BACK_COLOR) != 0 &&

(bptr->atts->backcolor->red != atts->backcolor->red ||

bptr->atts->backcolor->green != atts->backcolor->green ||

bptr->atts->backcolor->blue != atts->backcolor->blue))

return False;

// If we have a shift set, then make sure it matches the other block.

if ((flags & F_HAS_SHIFT) != 0 &&

(bptr -> atts -> shift != atts -> shift))

return False;

// Ensure that the direction level matches

if (direction_level != bptr -> direction_level)

return False;

// Everything matches, so these two blocks must be the same.

return True;

}

static bool MCUnicodeCanBreakBetween(uint2 x, uint2 y)

{

// MW-2013-12-19: [[ Bug 11606 ]] We only check for breaks between chars and spaces

// where the space follows the char. This is because a break will consume all space

// chars after it thus we want to measure up to but not including the spaces.

bool t_x_isspace, t_y_isspace;

// AL-2014-09-03: [[ Bug 13332 ]] Don't break before a non-breaking space

t_x_isspace = MCUnicodeIsWhitespace(x);

t_y_isspace = y != 0x00A0 && MCUnicodeIsWhitespace(y);

if (t_x_isspace && t_y_isspace)

return false;

if (t_y_isspace)

return true;

bool t_xid;

t_xid = MCUnicodeCodepointIsIdeographic(x);

bool t_yid;

t_yid = MCUnicodeCodepointIsIdeographic(y);

if (!t_xid && !t_yid)

return false;

bool t_prohibit_break_after_x;

t_prohibit_break_after_x = (MCUnicodeCodepointGetBreakClass(x) & 2) != 0;

bool t_prohibit_break_before_y;

t_prohibit_break_before_y = (MCUnicodeCodepointGetBreakClass(y) & 1) != 0;

return !t_prohibit_break_after_x && !t_prohibit_break_before_y;

}

bool MCBlock::fit(coord_t x, coord_t maxwidth, findex_t& r_break_index, bool& r_break_fits)

{

// If the block of zero length, then it can't be broken and must be kept with previous blocks.

if (m_size == 0)

{

if (next() != parent -> getblocks())

r_break_fits = false;

else

r_break_fits = true;

r_break_index = m_index;

return true;

}

if ((flags & F_HAS_IMAGE) && atts -> image != NULL)

{

r_break_index = m_index + m_size;

r_break_fits = getwidth(NULL, x) <= maxwidth;

return r_break_fits;

}

// Fetch the first character of the next block

codepoint_t t_next_block_char;

MCBlock *t_next_block;

t_next_block = next();

if (t_next_block != parent -> getblocks())

{

if (t_next_block -> GetLength() == 0)

t_next_block_char = -2;

else

t_next_block_char = parent->GetCodepointAtIndex(t_next_block -> m_index);

}

else

t_next_block_char = -1;

// FG-2013-10-21 [[ Field speedups ]]

// Previously, we used to calculate the length of the entire block here in order

// to determine if splitting was required. Unfortunately, this tends to bypass

// the text layout cache resulting in very slow laying out now that the "proper"

// Unicode text layout APIs are in use.

//

// Now, all text is laid out word-at-a-time.

// We don't completely fit within maxwidth, so compute the last break point in

// the block by measuring

// MW-2013-12-19: [[ Bug 11606 ]] Track the width of the text within the block as a float

// but use the integer width to break. This ensures measure(a & b) == measure(a) + measure(b)

// (otherwise you get drift as the accumulated width the block calculates is different

// from the width of the text that is drawn).

coord_t t_width_float;

t_width_float = 0;

// MW-2009-04-23: [[ Bug ]] For printing, we measure complete runs of text otherwise we get

// positioning issues.

coord_t t_last_break_width;

t_last_break_width = 0;

uint2 t_last_break_i;

t_last_break_i = m_index;

findex_t i;

i = m_index;

codepoint_t t_next_char;

t_next_char = parent->GetCodepointAtIndex(i);

findex_t t_break_index;

t_break_index = m_index;

bool t_can_fit;

t_can_fit = false;

// MW-2013-08-01: [[ Bug 10932 ]] Optimized loop only measuring between potential break

// points, rather than char by char.

bool t_whole_block;

t_whole_block = false;

while(i < m_index + m_size)

{

findex_t initial_i;

initial_i = i;

bool t_can_break;

t_can_break = false;

codepoint_t t_this_char;

bool t_end_of_block;

t_end_of_block = false;

while(i < m_index + m_size)

{

t_this_char = t_next_char;

i = parent->IncrementIndex(i);

if (i < m_index + m_size)

t_next_char = parent->GetCodepointAtIndex(i);

else

{

t_next_char = t_next_block_char;

t_end_of_block = true;

}

if (t_this_char == '\t' ||

t_next_char == -1 ||

MCUnicodeCanBreakBetween(t_this_char, t_next_char))

{

t_can_break = true;

break;

}

}

// MW-2013-11-07: [[ Bug 11393 ]] Previous per-platform implementations all fold into the optimized

// case now (previously iOS / Windows printer were measuring break by break, which is what we do

// generally now).

// FG-2014-04-30: [[ TabAlignments ]] Blocks no longer contain tabs

/*if (t_this_char == '\t')

{

twidth += gettabwidth(x + twidth, initial_i);

twidth_float = (MCGFloat)twidth;

t_last_break_width = twidth;

t_last_break_i = i;

}

else*/

{

MCRange t_range;

t_range = MCRangeMake(initial_i, i - initial_i);

// MM-2014-04-16: [[ Bug 11964 ]] Pass through the transform of the stack to make sure the measurment is correct for scaled text.

t_width_float += MCFontMeasureTextSubstringFloat(m_font, parent->GetInternalStringRef(), t_range, parent -> getparent() -> getstack() -> getdevicetransform());

}

if (t_can_fit && t_width_float > maxwidth)

break;

if (t_can_break)

t_break_index = i;

if (t_width_float <= maxwidth)

{

t_can_fit = true;

t_whole_block = t_end_of_block;

}

if (t_width_float >= maxwidth)

break;

}

// We now have a suitable break point in t_break_index. This could be index if

// there are none in the block. We now loop forward until we get to the end of

// any suitable run of spaces.

while(t_break_index < m_index + m_size && parent->TextIsWordBreak(parent->GetCodepointAtIndex(t_break_index)))

t_break_index = parent->IncrementIndex(t_break_index);

r_break_fits = t_can_fit;

r_break_index = t_break_index;

// If we found a break, was it before the end of the block?

return t_whole_block;

}

void MCBlock::split(findex_t p_index)

{

MCBlock *bptr = new MCBlock(*this);

findex_t newlength = m_size - (p_index - m_index);

bptr->SetRange(p_index, newlength);

m_size -= newlength;

width = 0;

// MW-2012-02-13: [[ Block Unicode ]] Only open the new block if the original

// was already open.

// MW-2012-02-14: [[ FontRefs ]] Pass in the parent fontref so the block can

// compute its fontref.

if (opened)

bptr->open(parent -> getparent() -> getfontref());

append(bptr);

}

// Compute the distance between x and the next tab stop position.

// FG-2014-04-30: [[ TabAlignments ]] Blocks no longer contain tabs

/*coord_t MCBlock::gettabwidth(coord_t x, findex_t i)

{

uint2 *tabs;

uint2 ntabs;

Boolean fixed;

// MW-2012-01-25: [[ ParaStyles ]] Fetch the tab-stops from the owning paragraph.

parent->gettabs(tabs, ntabs, fixed);

// The tabs are 'fixed' if VGRID is set - I presume this also prevents wrapping

// but who can really say!

if (fixed)

{

findex_t ctab = 0;

findex_t cindex = 0;

// Count the number of preceeding tabs in the paragraph.

MCBlock *t_block;

t_block = parent -> getblocks();

findex_t j;

j = 0;

while(j < i)

{

if (t_block -> getflag(F_HAS_TAB))

{

findex_t k;

k = t_block -> GetOffset() + t_block -> GetLength();

while(j < k && j < i)

{

if (parent->GetCodepointAtIndex(j) == '\t')

ctab++;

j = parent->IncrementIndex(j);

}

}

else

j = t_block -> GetOffset() + t_block -> GetLength();

t_block = t_block -> next();

}

// At this point 'ctab' contains the number of tab characters before

// the one gettabwidth was called with - i.e. the 0-based index

// of the tab we started with.

int2 newloc;

if (ctab < ntabs)

{

// The tab array stores absolute positions of each tab from the

// left of the field.

newloc = tabs[ctab];

}

else

{

// We have requested a tab beyond the end of the tab array, so

// we use the length of the last tab as the length of every successive

// tab.

uint2 diff;

if (ntabs == 1)

diff = tabs[0];

else

diff = tabs[ntabs - 1] - tabs[ntabs - 2];

newloc = tabs[ntabs - 1] + diff * (ctab - ntabs + 1);

}

// If the position of the current tab co-incides with the last x position then

// adjust upward by one to ensure we don't overwrite anything (legacy behavior).

if (newloc == x)

return 1;

// The width of the tab is absolute position of the tab minus the x position of

// the left hand-side of the passed in tab character.

return newloc - x;

}

else

{

int2 lasttab = 0;

uint2 i = 0;

// Loop through the tab array and find the first tab to the right of x.

while (i < ntabs && x >= lasttab)

{

lasttab = tabs[i];

i++;

}

if (x >= lasttab && ntabs != 0)

{

// If x is further right than (or is at) the last tab then the tab position

// is the first multiple of the last difference after the last tab which is

// beyond x.

uint2 diff;

if (ntabs == 1)

diff = tabs[0];

else

diff = tabs[ntabs - 1] - tabs[ntabs - 2];

// MW-2012-09-19: [[ Bug 10239 ]] The tab difference can now be zero, in

// the non-vGrid case, if this is the case then just take lasttab to be

// x.

// MW-2014-07-29: [[ Bug 12944 ] Make sure we round x to an int, otherwise the

// rounding up to nearest tab code becomes a little bit broken.

if (diff != 0)

lasttab = tabs[ntabs - 1] + diff * (((int)ceilf(x) - tabs[ntabs - 1]) / diff + 1);

else

lasttab = x;

}

// Adjust by 1 if the last tab is x

if (lasttab == x)

return 1;

// Return the difference between x and the last tab.

return lasttab - x;

}

}*/

// SN-2014-08-13: [[ Bug 13016 ]] Added a parameter for the left of the cell

void MCBlock::drawstring(MCDC *dc, coord_t x, coord_t p_cell_left, coord_t p_cell_right, int2 y, findex_t start, findex_t length, Boolean image, uint32_t style)

{

// MW-2012-02-16: [[ FontRefs ]] Fetch the font metrics we need to draw.

int32_t t_ascent, t_descent;

t_ascent = MCFontGetAscent(m_font);

t_descent = MCFontGetDescent(m_font);

// MW-2012-01-25: [[ ParaStyles ]] Fetch the vGrid setting from the owning paragraph.

if (parent -> getvgrid())

{

// MW-2012-02-09: [[ ParaStyles ]] Fetch the padding setting from the owning paragraph.

// MW-2012-03-19: [[ Bug 10069 ]] Use the horiztonal padding value here.

int32_t t_padding;

t_padding = parent -> gethpadding();

MCRectangle t_cell_clip;

t_cell_clip = dc->getclip();

dc -> save();

findex_t t_index;

t_index = start;

while(t_index < start + length)

{

uindex_t t_next_tab;

// FG-2014-04-30: [[ TabAlignments ]] Blocks no longer contain tabs

/*if (MCStringFirstIndexOfChar(parent->GetInternalStringRef(), '\t', t_index, kMCStringOptionCompareExact, t_next_tab))

{

if (t_next_tab >= m_index + m_size)

t_next_tab = -1;

}

else*/

t_next_tab = -1;

findex_t t_next_index;

if (t_next_tab == -1)

t_next_index = start + length;

else

t_next_index = t_next_tab;

//int2 t_tab_width;

//t_tab_width = 64; //gettabwidth(0, t_index);

// MM-2014-04-16: [[ Bug 11964 ]] Pass through the transform of the stack to make sure the measurment is correct for scaled text.

// FG-2014-07-16: [[ Bug 12539 ]] Make sure not to draw tab characters

coord_t t_width;

MCRange t_range;

t_range = MCRangeMake(t_index, t_next_index - t_index);

if (length > 0 && parent->GetCodepointAtIndex(t_next_index - 1) == '\t')

t_range.length--;

t_width = MCFontMeasureTextSubstringFloat(m_font, parent->GetInternalStringRef(), t_range, parent -> getparent() -> getstack() -> getdevicetransform());