/* Copyright (C) 2003-2015 LiveCode 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/>.  */

#ifndef	BLOCK_H
#define	BLOCK_H

#include "dllst.h"
#include "field.h"

class MCParagraph;
class MCField;
class MCLine;
class MCSegment;
struct MCFieldCharacterStyle;

typedef struct Blockatts
{
	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));
	}
}
Blockatts;

class MCBlock : public MCDLlist
{

protected:
	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;
public:
	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*);
};
#endif