{

MCColor *color;

MCColor *backcolor;

// MW-2012-05-04: [[ Values ]] linkText, imageSource and metaData are all

// better represented as uniqued strings, rather than names.

MCStringRef linktext;

MCStringRef imagesource;

MCStringRef metadata;

MCImage *image;

// MW-2012-01-06: [[ Block Changes ]] These are the x, y location of the

// image source (previously unioned with colornames).

int2 x, y;

// MW-2012-02-14: [[ FontRefs ]] The block's textFont attr is now stored as

// a name.

MCNameRef fontname;

uint2 fontsize;

uint2 fontstyle;

int2 shift;

// MW-2006-04-21: [[ Purify ]] Ensure this is initialised to empty

Blockatts(void)

{

memset(this, 0, sizeof(Blockatts));

}

{

MCParagraph *parent;

uint4 flags;

Blockatts *atts;

findex_t m_index, m_size;

coord_t width;

coord_t origin;

uint2 opened;

coord_t tabpos; // Pixel offset to use when calculating tabstops

uint2 visual_index; // Visual ordering index from left to right

uint8_t direction_level;

// Store pointer to containing segment for convenience

MCSegment *segment;

// MW-2012-02-14: [[ FontRefs ]] The concrete font to use for the block.

// (only valid when the block is open).

MCFontRef m_font;

MCBlock();

MCBlock(const MCBlock &bref);

~MCBlock();

bool visit(MCObjectVisitorOptions p_options, uint32_t p_part, MCObjectVisitor* p_visitor);

// MCBlock functions

void copy(MCBlock *bptr);

// IM-2016-07-06: [[ Bug 17690 ]] Test if block sizes or offsets require 32bit

// values to store (stack file format v8.1).

uint32_t getminimumstackfileversion(void);

// MW-2012-03-04: [[ StackFile5500 ]] If 'is_ext' is true then this block has

// an extension style attribute section.

IO_stat load(IO_handle stream, uint32_t version, bool is_ext);

IO_stat save(IO_handle stream, uint4 p_part, uint32_t p_version);

// MW-2012-02-14: [[ FontRefs ]] To open a block, we need the parent's fontref.

void open(MCFontRef parent_font);

void close();

// MW-2012-02-14: [[ FontRefs ]] Compute a concrete font for the block using the given

// parent font.

void mapfont(MCFontRef p_parent_font);

// MW-2012-02-14: [[ FontRefs ]] Free the block's concrete font.

void unmapfont(void);

// MW-2012-02-14: [[ FontRefs ]] Recompute the concrete font for the block using the

// given parent font. Returns 'true' if something changed.

bool recomputefonts(MCFontRef p_parent_font);

// MW-2012-02-06: The 'persistent_only' param determines whether things like

// 'flagged' are excluded from the sameness check (used by styledText).

Boolean sameatts(MCBlock *bptr, bool p_persistent_only);

bool fit(coord_t x, coord_t width, findex_t& r_break_index, bool& r_break_fits);

void split(findex_t p_index);

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

void drawstring(MCDC *dc, coord_t x, coord_t lx, coord_t cx, int2 y, findex_t start, findex_t length, Boolean image, uint32_t style);

// MW-2012-02-27: [[ Bug 2939 ]] The 'flags' parameter indicates whether the left and/or

// right edge of any box or 3d-box should be rendered.

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

void draw(MCDC *dc, coord_t x, coord_t p_left_cell, coord_t cx, int2 y, findex_t si, findex_t ei, MCStringRef p_text, uint2 pstyle, uint32_t flags);

// MW-2012-02-17: [[ SplitTextAttrs ]] Returns the effective font attrs of the block.

// If 'base_attrs' is non-nil, it uses that to derive the attrs.

void getfontattrs(MCObjectFontAttrs *base_attrs, MCNameRef& fname, uint2& fsize, uint2& fstyle);

// MW-2012-02-17: [[ SplitTextAttrs ]] Fetches the textFont property of the block, or returns

// false if none is set.

bool gettextfont(MCNameRef& r_textfont) const;

// MW-2012-02-17: [[ SplitTextAttrs ]] Fetches the textFont property of the block, or returns

// false if none is set.

bool gettextfont(const char*& r_textfont) const;

// MW-2012-02-17: [[ SplitTextAttrs ]] Fetches the textSize property of the block, or returns

// false if none is set.

bool gettextsize(uint2& r_textsize) const;

// MW-2012-02-17: [[ SplitTextAttrs ]] Fetches the textStyle property of the block, or returns

// false if none is set.

bool gettextstyle(uint2& r_textstyle) const;

// MW-2012-02-17: [[ SplitTextAttrs ]] Returns true if the block has any font attrs set, or

// false otherwise.

bool hasfontattrs(void) const;

// MW-2012-02-21: [[ FieldExport ]] Update the fields in the field style export struct to

// reflect changes made by this block.

void exportattrs(MCFieldCharacterStyle& x_syle);

// MW-2012-03-04: [[ FieldImport ]] Set the attributes of the block to those described by

// the style.

void importattrs(const MCFieldCharacterStyle& x_style);

// MW-2012-03-04: [[ StackFile5500 ]] Measure the size of the serialized attributes.

uint32_t measureattrs(uint32_t p_version);

Boolean getshift(int2 &out);

void setshift(int2 in);

Boolean getcolor(const MCColor *&color);

Boolean getbackcolor(const MCColor *&color);

void setcolor(const MCColor *color);

void setbackcolor(const MCColor *color);

MCParagraph *getparent()

{

return parent;

}

void setparent(MCParagraph *pgptr)

{

parent = pgptr;

}

coord_t getsubwidth(MCDC *dc, coord_t x, findex_t i, findex_t l);

coord_t getwidth(MCDC *dc, coord_t x);

void reset();

coord_t GetAscent() const;

coord_t GetDescent() const;

coord_t GetLeading() const;

void freeatts();

void freerefs();

void openimage();

void closeimage();

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

// strings.

MCStringRef getlinktext();

MCStringRef getimagesource();

MCStringRef getmetadata(void);

void sethilite(Boolean on);

// MW-2012-01-26: [[ FlaggedField ]] Returns whether the given block has the

// 'flagged' status set.

bool getflagged(void) const

{

return (flags & F_FLAGGED) != 0;

}

Boolean gethilite() const

{

return (flags & F_HILITED) != 0;

}

Boolean getvisited() const

{

return (flags & F_VISITED) != 0;

}

void setvisited()

{

flags |= F_VISITED;

}

void clearvisited()

{

flags &= ~F_VISITED;

}

Boolean islink() const

{

// MW-2012-02-17: [[ SplitTextAttrs ]] We are a link if we have a font

// style and the FA_LINK attr is set.

return flags & F_HAS_FSTYLE

&& atts != NULL && (atts->fontstyle & FA_LINK) != 0;

}

bool hasatts() const

{

// MW-2012-02-17: [[ SplitTextAttrs ]] We have atts if one of the flags is

// set.

return (flags & F_HAS_ATTS) != 0;

}

void cleanatts()

{

// MW-2012-02-17: [[ SplitTextAttrs ]] If we no longer have any atts, delete the struct.

if ((flags & F_HAS_ATTS) == 0)

{

delete atts;

atts = nil;

}

}

bool getflag(unsigned int f) const

{

return (flags & f) != 0;

}

MCBlock *next()

{

return (MCBlock *)MCDLlist::next();

}

MCBlock *prev()

{

return (MCBlock *)MCDLlist::prev();

}

void totop(MCBlock *&list)

{

MCDLlist::totop((MCDLlist *&)list);

}

void insertto(MCBlock *&list)

{

MCDLlist::insertto((MCDLlist *&)list);

}

void appendto(MCBlock *&list)

{

MCDLlist::appendto((MCDLlist *&)list);

}

void append(MCBlock *node)

{

MCDLlist::append((MCDLlist *)node);

}

void splitat(MCBlock *node)

{

MCDLlist::splitat((MCDLlist *)node) ;

}

MCBlock *remove(MCBlock *&list)

{

return (MCBlock *)MCDLlist::remove((MCDLlist *&)list);

}

bool imagechanged(MCImage *p_image, bool p_deleting);

////////// BIDIRECTIONAL SUPPORT

coord_t getorigin() const

{

return origin;

}

void setorigin(coord_t o)

{

origin = o;

}

uint2 GetVisualIndex() const

{

return visual_index;

}

void SetVisualIndex(uint2 i)

{

visual_index = i;

}

uint2 GetDirectionLevel() const

{

return direction_level;

}

void SetDirectionLevel(uint8_t l)

{

direction_level = l;

}

bool is_rtl() const

{

// If odd, text is right-to-left, otherwise left-to-right

return GetDirectionLevel() & 1;

}

coord_t getwidth(MCDC *dc = NULL)

{

if (is_rtl())

return getwidth(dc, origin - width);

else

return getwidth(dc, origin);

}

void settabpos(coord_t offset)

{

tabpos = offset;

}

// Returns the next/previous block in visual order (or nil if none)

MCBlock *GetNextBlockVisualOrder();

MCBlock *GetPrevBlockVisualOrder();

void SetSegment(MCSegment *p_segment)

{

segment = p_segment;

}

MCSegment *GetSegment(void)

{

return segment;

}

////////////////////

// Returns only the "index" component of the range

findex_t GetOffset();

// Returns only the "length" component of the range

findex_t GetLength();

// Returns the range of text covered by the block

void GetRange(findex_t &r_index, findex_t &r_length);

// Sets the indices correctly using the parent paragraph's stringref

void SetRange(findex_t t_index, findex_t t_length);

// Moves the index by the specified number of character positions

void MoveRange(findex_t t_index_offset, findex_t t_length_offset);

// Translates from a pixel position to a cursor index

findex_t GetCursorIndex(coord_t x, Boolean chunk, Boolean last, bool moving_forward);

// Returns the x coordinate of the cursor

coord_t GetCursorX(findex_t fi);

// Moves the index forwards by one codepoint, possibly changing block

MCBlock *AdvanceIndex(findex_t &x_index);

// Moves the index backwards by one codepoint, possibly changing block

MCBlock *RetreatIndex(findex_t &x_index);

// Returns the codepoint at the given index into the block

codepoint_t GetCodepointAtIndex(findex_t p_index) const;

// Finds the first linebreak character in the block

bool GetFirstLineBreak(findex_t &r_index);

// Returns true if the block's text was stored in Unicode format (required

// when reading the existing (non-Unicode) stack file format)

bool IsSavedAsUnicode() const

{

return flags & F_HAS_UNICODE;

}

// Returns true if the block has a trailing tab character.

bool HasTrailingTab(void) const

{

return m_size != 0 && GetCodepointAtIndex(m_size - 1) == '\t';

}

//////////

void GetLinkText(MCExecContext& ctxt, MCStringRef& r_linktext);

void SetLinktext(MCExecContext& ctxt, MCStringRef p_linktext);

void GetMetadata(MCExecContext& ctxt, MCStringRef& r_metadata);

void SetMetadata(MCExecContext& ctxt, MCStringRef p_metadata);

void GetImageSource(MCExecContext& ctxt, MCStringRef &r_image_source);

void SetImageSource(MCExecContext& ctxt, MCStringRef p_image_source);

void GetVisited(MCExecContext& ctxt, bool& r_value);

// PM-2015-07-06: [[ Bug 15577 ]] "visited" property should be RW

void SetVisited(MCExecContext& ctxt, bool p_value);

void GetFlagged(MCExecContext& ctxt, bool &r_value);

void SetFlagged(MCExecContext& ctxt, bool p_value);

void GetTextFont(MCExecContext& ctxt, MCStringRef &r_fontname);

void SetTextFont(MCExecContext& ctxt, MCStringRef p_fontname);

void GetTextStyle(MCExecContext& ctxt, MCInterfaceTextStyle &r_style);

void SetTextStyle(MCExecContext& ctxt, const MCInterfaceTextStyle& p_style);

void GetTextSize(MCExecContext& ctxt, uinteger_t*& r_size);

void SetTextSize(MCExecContext& ctxt, uinteger_t* p_size);

void GetTextShift(MCExecContext& ctxt, integer_t*& r_shift);

void GetEffectiveTextShift(MCExecContext& ctxt, integer_t& r_shift);

void SetTextShift(MCExecContext& ctxt, integer_t* p_shift);

void GetForeColor(MCExecContext& ctxt, MCInterfaceNamedColor &r_color);

void GetEffectiveForeColor(MCExecContext& ctxt, MCInterfaceNamedColor &r_color);

void SetForeColor(MCExecContext& ctxt, const MCInterfaceNamedColor &p_color);

void GetBackColor(MCExecContext& ctxt, MCInterfaceNamedColor &r_color);

void SetBackColor(MCExecContext& ctxt, const MCInterfaceNamedColor &p_color);

void GetTextStyleElement(MCExecContext& ctxt, MCNameRef p_index, bool*& r_value);

void SetTextStyleElement(MCExecContext& ctxt, MCNameRef p_index, bool p_value);

//////////

// FG-2014-11-11: [[ Better theming ]]

// Sets up the colours on the DC for the given type of drawing

void setcolorfornormaltext(MCDC*, MCColor*);

void setcolorforhilite(MCDC*);

void setcolorforselectedtext(MCDC*, MCColor*);