/*-*- c++ -*-********************************************************
- * wxFTCanvas: a canvas for editing formatted text *
+ * wxllist: wxLayoutList, a layout engine for text and graphics *
* *
- * (C) 1998 by Karsten Ballüder (Ballueder@usa.net) *
+ * (C) 1998-1999 by Karsten Ballüder (Ballueder@usa.net) *
* *
* $Id$
*******************************************************************/
/*
- - each Object knows its size and how to draw itself
- - the list is responsible for calculating positions
- - the draw coordinates for each object are the top left corner
- - coordinates only get calculated when things get redrawn
- - during redraw each line gets iterated over twice, first just
- calculating baselines and positions, second to actually draw it
- - the cursor position is the position before an object, i.e. if the
- buffer starts with a text-object, cursor 0,0 is just before the
- first character
-
- - the cursor position and size must be decided at layout/draw time
- or the fonts will be wrong
-*/
-/*
- Known wxGTK bugs:
- - MaxX()/MaxY() don't get set
-*/
+ */
-
#ifdef __GNUG__
-#pragma implementation "wxllist.h"
+ #pragma implementation "wxllist.h"
#endif
-//#include "Mpch.h"
+#include <wx/wxprec.h>
+
+#ifdef __BORLANDC__
+# pragma hdrstop
+#endif
+
+#include "Mpch.h"
+
#ifdef M_BASEDIR
# include "gui/wxllist.h"
+# include "gui/wxlparser.h"
+# define SHOW_SELECTIONS 1
#else
# include "wxllist.h"
+# include "wxlparser.h"
+# define SHOW_SELECTIONS 1
#endif
#ifndef USE_PCH
-# include "iostream.h"
-# include <wx/dc.h>
-# include <wx/postscrp.h>
-# include <wx/print.h>
-# include <wx/log.h>
+# include <iostream.h>
+
+# include <wx/dc.h>
+# include <wx/dcps.h>
+# include <wx/print.h>
+# include <wx/log.h>
+# include <wx/filefn.h>
#endif
-#define BASELINESTRETCH 12
+#ifdef WXLAYOUT_USE_CARET
+# include <wx/caret.h>
+#endif // WXLAYOUT_USE_CARET
+
+#include <ctype.h>
-// This should never really get created
+/// This should never really get created
#define WXLLIST_TEMPFILE "__wxllist.tmp"
#ifdef WXLAYOUT_DEBUG
-static const char *g_aTypeStrings[] =
-{
- "invalid", "text", "cmd", "icon", "linebreak"
-};
-
-# define wxLayoutDebug wxLogDebug
-# define WXL_VAR(x) cerr << #x " = " << x << endl;
-# define WXL_DBG_POINT(p) wxLogDebug(#p ": (%d, %d)", p.x, p.y)
-# define WXL_TRACE(f) wxLogDebug(#f ": ")
-# define TypeString(t) g_aTypeStrings[t]
-void
-wxLayoutObjectBase::Debug(void)
+# define TypeString(t) g_aTypeStrings[t]
+# define WXLO_DEBUG(x) wxLogDebug x
+
+ static const char *g_aTypeStrings[] =
+ {
+ "invalid", "text", "cmd", "icon"
+ };
+ void
+ wxLayoutObject::Debug(void)
+ {
+ WXLO_DEBUG(("%s",g_aTypeStrings[GetType()]));
+ }
+#else
+# define TypeString(t) ""
+# define WXLO_DEBUG(x)
+#endif
+
+// FIXME under MSW, this constant is needed to make the thing properly redraw
+// itself - I don't know where the size calculation error is and I can't
+// waste time looking for it right now. Search for occurences of
+// MSW_CORRECTION to find all the places where I did it.
+#ifdef __WXMSW__
+ static const int MSW_CORRECTION = 10;
+#else
+ static const int MSW_CORRECTION = 0;
+#endif
+
+/// Cursors smaller than this disappear in XOR drawing mode
+#define WXLO_MINIMUM_CURSOR_WIDTH 4
+
+/// Use this character to estimate a cursor size when none is available.
+#define WXLO_CURSORCHAR "E"
+/** @name Helper functions */
+//@{
+/// allows me to compare to wxPoints
+bool operator <=(wxPoint const &p1, wxPoint const &p2)
{
- CoordType bl = 0;
- wxLogDebug("%s: size = %dx%d, bl = %d",
- TypeString(GetType()), GetSize(&bl).x, GetSize(&bl).y, bl);
+ return p1.y < p2.y || (p1.y == p2.y && p1.x <= p2.x);
}
-#else
-# define WXL_VAR(x)
-# define WXL_DBG_POINT(p)
-# define WXL_TRACE(f)
-# define ShowCurrentObject()
-# define TypeString(t) ""
-inline void wxLayoutDebug(const char *, ...) { }
+/// grows a wxRect so that it includes the given point
+
+static
+void GrowRect(wxRect &r, CoordType x, CoordType y)
+{
+ if(r.x > x)
+ r.x = x;
+ else if(r.x + r.width < x)
+ r.width = x - r.x;
+
+ if(r.y > y)
+ r.y = y;
+ else if(r.y + r.height < y)
+ r.height = y - r.y;
+}
+
+#if 0
+// unused
+/// returns true if the point is in the rectangle
+static
+bool Contains(const wxRect &r, const wxPoint &p)
+{
+ return r.x <= p.x && r.y <= p.y && (r.x+r.width) >= p.x && (r.y + r.height) >= p.y;
+}
#endif
-//-------------------------- wxLayoutObjectText
+//@}
+
-wxLayoutObjectText::wxLayoutObjectText(const String &txt)
+void ReadString(wxString &to, wxString &from)
+{
+ to = "";
+ const char *cptr = from.c_str();
+ while(*cptr && *cptr != '\n')
+ to += *cptr++;
+ if(*cptr) cptr++;
+ from = cptr;
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ wxLayoutObject
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* static */
+wxLayoutObject *
+wxLayoutObject::Read(wxString &istr)
+{
+ wxString tmp;
+ ReadString(tmp, istr);
+ int type = -1;
+ sscanf(tmp.c_str(),"%d", &type);
+
+ switch(type)
+ {
+ case WXLO_TYPE_TEXT:
+ return wxLayoutObjectText::Read(istr);
+ case WXLO_TYPE_CMD:
+ return wxLayoutObjectCmd::Read(istr);
+ case WXLO_TYPE_ICON:
+ return wxLayoutObjectIcon::Read(istr);
+ default:
+ return NULL;
+ }
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ wxLayoutObjectText
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+wxLayoutObjectText::wxLayoutObjectText(const wxString &txt)
{
m_Text = txt;
m_Width = 0;
m_Height = 0;
- m_Position = wxPoint(-1,-1);
+ m_Top = 0;
+ m_Bottom = 0;
+}
+
+wxLayoutObject *
+wxLayoutObjectText::Copy(void)
+{
+ wxLayoutObjectText *obj = new wxLayoutObjectText(m_Text);
+ obj->m_Width = m_Width;
+ obj->m_Height = m_Height;
+ obj->m_Top = m_Top;
+ obj->m_Bottom = m_Bottom;
+ obj->SetUserData(m_UserData);
+ return obj;
+}
+
+
+void
+wxLayoutObjectText::Write(wxString &ostr)
+{
+ ostr << (int) WXLO_TYPE_TEXT << '\n'
+ << m_Text << '\n';
}
+/* static */
+wxLayoutObjectText *
+wxLayoutObjectText::Read(wxString &istr)
+{
+ wxString text;
+ ReadString(text, istr);
+ return new wxLayoutObjectText(text);
+}
wxPoint
-wxLayoutObjectText::GetSize(CoordType *baseLine) const
+wxLayoutObjectText::GetSize(CoordType *top, CoordType *bottom) const
{
- if(baseLine) *baseLine = m_BaseLine;
+
+ *top = m_Top; *bottom = m_Bottom;
return wxPoint(m_Width, m_Height);
}
void
-wxLayoutObjectText::Draw(wxDC &dc, wxPoint const &translate)
+wxLayoutObjectText::Draw(wxDC &dc, wxPoint const &coords,
+ wxLayoutList *wxllist,
+ CoordType begin, CoordType end)
{
- dc.DrawText(Str(m_Text), m_Position.x + translate.x, m_Position.y+translate.y);
- m_IsDirty = false;
+ if( end <= 0)
+ dc.DrawText(m_Text, coords.x, coords.y-m_Top);
+ else
+ {
+ // highlight the bit between begin and len
+ wxString str;
+ CoordType
+ xpos = coords.x,
+ ypos = coords.y-m_Top;
+ long width, height, descent;
+
+ if(begin < 0) begin = 0;
+ if( end > (signed)m_Text.Length() )
+ end = m_Text.Length();
+
+ str = m_Text.Mid(0, begin);
+ dc.DrawText(str, xpos, ypos);
+ dc.GetTextExtent(str, &width, &height, &descent);
+ xpos += width;
+ wxllist->StartHighlighting(dc);
+ str = m_Text.Mid(begin, end-begin);
+ dc.DrawText(str, xpos, ypos);
+ dc.GetTextExtent(str, &width, &height, &descent);
+ xpos += width;
+ wxllist->EndHighlighting(dc);
+ str = m_Text.Mid(end, m_Text.Length()-end);
+ dc.DrawText(str, xpos, ypos);
+ }
}
+CoordType
+wxLayoutObjectText::GetOffsetScreen(wxDC &dc, CoordType xpos) const
+{
+ CoordType
+ offs = 1,
+ maxlen = m_Text.Length();
+ long
+ width = 0,
+ height, descent = 0l;
+
+ if(xpos == 0) return 0; // easy
+
+ while(width < xpos && offs < maxlen)
+ {
+ dc.GetTextExtent(m_Text.substr(0,offs),
+ &width, &height, &descent);
+ offs++;
+ }
+ /* We have to substract 1 to compensate for the offs++, and another
+ one because we don't want to position the cursor behind the
+ object what we clicked on, but before - otherwise it looks
+ funny. */
+ return (xpos > 2) ? offs-2 : 0;
+}
void
-wxLayoutObjectText::Layout(wxDC &dc, wxPoint position, CoordType baseLine)
+wxLayoutObjectText::Layout(wxDC &dc, class wxLayoutList *llist)
{
long descent = 0l;
- if(m_Position.x != position.x || m_Position.y != position.y)
- m_IsDirty = true;
-
- m_Position = position;
- dc.GetTextExtent(Str(m_Text),&m_Width, &m_Height, &descent);
- m_BaseLine = m_Height - descent;
- if(m_Position.x != position.x || m_Position.y != position.y)
- m_IsDirty = true;
+ CoordType widthOld = m_Width,
+ heightOld = m_Height;
+ dc.GetTextExtent(m_Text, &m_Width, &m_Height, &descent);
+
+ if ( widthOld != m_Width || heightOld != m_Height )
+ {
+ // as the text length changed, it must be refreshed
+ wxLayoutLine *line = GetLine();
+
+ wxCHECK_RET( line, "wxLayoutObjectText can't refresh itself" );
+
+ // as our size changed, we need to repaint the part which was appended
+ wxPoint position(line->GetPosition());
+
+ // this is not the most efficient way (we repaint the whole line), but
+ // it's not too slow and is *simple*
+ if ( widthOld < m_Width )
+ widthOld = m_Width;
+ if ( heightOld < m_Height )
+ heightOld = m_Height;
+
+ llist->SetUpdateRect(position.x + widthOld + MSW_CORRECTION,
+ position.y + heightOld + MSW_CORRECTION);
+ }
+
+ m_Bottom = descent;
+ m_Top = m_Height - m_Bottom;
}
+
#ifdef WXLAYOUT_DEBUG
void
wxLayoutObjectText::Debug(void)
{
- wxLayoutObjectBase::Debug();
- wxLogDebug(" `%s`", m_Text.c_str());
+ wxLayoutObject::Debug();
+ WXLO_DEBUG((" `%s`", m_Text.c_str()));
}
#endif
-//-------------------------- wxLayoutObjectIcon
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ wxLayoutObjectIcon
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+wxLayoutObjectIcon::wxLayoutObjectIcon(wxBitmap const &icon)
+{
+ m_Icon = new wxBitmap(icon);
+}
+
+
+void
+wxLayoutObjectIcon::Write(wxString &ostr)
+{
+ /* Exports icon through a temporary file. */
+
+ wxString file = wxGetTempFileName("wxloexport");
+
+ ostr << WXLO_TYPE_ICON << '\n'
+ << file << '\n';
+ m_Icon->SaveFile(file, WXLO_BITMAP_FORMAT);
+}
+/* static */
+wxLayoutObjectIcon *
+wxLayoutObjectIcon::Read(wxString &istr)
+{
+ wxString file;
+ ReadString(file, istr);
+
+ if(! wxFileExists(file))
+ return NULL;
+ wxLayoutObjectIcon *obj = new wxLayoutObjectIcon;
+
+ if(!obj->m_Icon->LoadFile(file, WXLO_BITMAP_FORMAT))
+ {
+ delete obj;
+ return NULL;
+ }
+ else
+ return obj;
+}
-wxLayoutObjectIcon::wxLayoutObjectIcon(wxIcon const &icon)
+wxLayoutObject *
+wxLayoutObjectIcon::Copy(void)
{
- m_Position = wxPoint(-1,-1);
- m_Icon = new wxIcon(icon);
+ wxLayoutObjectIcon *obj = new wxLayoutObjectIcon(new
+ wxBitmap(*m_Icon));
+ obj->SetUserData(m_UserData);
+ return obj;
}
-wxLayoutObjectIcon::wxLayoutObjectIcon(wxIcon *icon)
+wxLayoutObjectIcon::wxLayoutObjectIcon(wxBitmap *icon)
{
m_Icon = icon;
}
void
-wxLayoutObjectIcon::Draw(wxDC &dc, wxPoint const &translate)
+wxLayoutObjectIcon::Draw(wxDC &dc, wxPoint const &coords,
+ wxLayoutList *wxllist,
+ CoordType begin, CoordType /* len */)
{
- dc.DrawIcon(m_Icon,m_Position.x+translate.x, m_Position.y+translate.y);
+ dc.DrawBitmap(*m_Icon, coords.x, coords.y-m_Icon->GetHeight(),
+ (m_Icon->GetMask() == NULL) ? FALSE : TRUE);
}
void
-wxLayoutObjectIcon::Layout(wxDC &dc, wxPoint position, CoordType baseLine)
+wxLayoutObjectIcon::Layout(wxDC & /* dc */, class wxLayoutList * )
{
- if(m_Position.x != position.x || m_Position.y != position.y)
- m_IsDirty = true;
- m_Position = position;
}
wxPoint
-wxLayoutObjectIcon::GetSize(CoordType *baseLine) const
+wxLayoutObjectIcon::GetSize(CoordType *top, CoordType *bottom) const
{
- if(baseLine) *baseLine = m_Icon->GetHeight();
+ *top = m_Icon->GetHeight();
+ *bottom = 0;
return wxPoint(m_Icon->GetWidth(), m_Icon->GetHeight());
}
-//-------------------------- wxLayoutObjectCmd
-wxLayoutObjectCmd::wxLayoutObjectCmd(int size, int family, int style, int
- weight, bool underline,
- wxColour const *fg, wxColour const *bg)
-
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ wxLayoutObjectCmd
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+wxLayoutStyleInfo::wxLayoutStyleInfo(int ifamily,
+ int isize,
+ int istyle,
+ int iweight,
+ int iul,
+ wxColour *fg,
+ wxColour *bg)
{
- m_font = new wxFont(size,family,style,weight,underline);
- m_ColourFG = fg;
- m_ColourBG = bg;
+ family = ifamily; size = isize;
+ style = istyle; weight = iweight;
+ underline = iul != 0;
+ if(fg)
+ {
+ m_fg = *fg;
+ m_fg_valid = TRUE;
+ }
+ else
+ m_fg = *wxBLACK;
+ if(bg)
+ {
+ m_bg = *bg;
+ m_bg_valid = TRUE;
+ }
+ else
+ m_bg = *wxWHITE;
}
-wxLayoutObjectCmd::~wxLayoutObjectCmd()
+#define COPY_SI_(what) if(right.what != -1) what = right.what;
+
+wxLayoutStyleInfo &
+wxLayoutStyleInfo::operator=(const wxLayoutStyleInfo &right)
{
- delete m_font;
+ COPY_SI_(family);
+ COPY_SI_(style);
+ COPY_SI_(size);
+ COPY_SI_(weight);
+ COPY_SI_(underline);
+ if(right.m_fg_valid) m_fg = right.m_fg;
+ if(right.m_bg_valid) m_bg = right.m_bg;
+ return *this;
}
-wxLayoutStyleInfo *
-wxLayoutObjectCmd::GetStyle(void) const
+wxLayoutObjectCmd::wxLayoutObjectCmd(int family, int size, int style, int
+ weight, int underline,
+ wxColour *fg, wxColour *bg)
+
+{
+ m_StyleInfo = new wxLayoutStyleInfo(family, size,style,weight,underline,fg,bg);
+}
+
+wxLayoutObject *
+wxLayoutObjectCmd::Copy(void)
{
- wxLayoutStyleInfo *si = new wxLayoutStyleInfo();
+ wxLayoutObjectCmd *obj = new wxLayoutObjectCmd(
+ m_StyleInfo->size,
+ m_StyleInfo->family,
+ m_StyleInfo->style,
+ m_StyleInfo->weight,
+ m_StyleInfo->underline,
+ m_StyleInfo->m_fg_valid ?
+ &m_StyleInfo->m_fg : NULL,
+ m_StyleInfo->m_bg_valid ?
+ &m_StyleInfo->m_bg : NULL);
+ obj->SetUserData(m_UserData);
+ return obj;
+}
+void
+wxLayoutObjectCmd::Write(wxString &ostr)
+{
+ ostr << WXLO_TYPE_CMD << '\n'
+ << m_StyleInfo->size << '\n'
+ << m_StyleInfo->family << '\n'
+ << m_StyleInfo->style << '\n'
+ << m_StyleInfo->weight << '\n'
+ << m_StyleInfo->underline << '\n'
+ << m_StyleInfo->m_fg_valid << '\n'
+ << m_StyleInfo->m_bg_valid << '\n';
+ if(m_StyleInfo->m_fg_valid)
+ {
+ ostr << m_StyleInfo->m_fg.Red() << '\n'
+ << m_StyleInfo->m_fg.Green() << '\n'
+ << m_StyleInfo->m_fg.Blue() << '\n';
+ }
+ if(m_StyleInfo->m_bg_valid)
+ {
+ ostr << m_StyleInfo->m_bg.Red() << '\n'
+ << m_StyleInfo->m_bg.Green() << '\n'
+ << m_StyleInfo->m_bg.Blue() << '\n';
+ }
+}
+/* static */
+wxLayoutObjectCmd *
+wxLayoutObjectCmd::Read(wxString &istr)
+{
+ wxLayoutObjectCmd *obj = new wxLayoutObjectCmd;
+
+ wxString tmp;
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->size);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->family);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->style);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->weight);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->underline);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->m_fg_valid);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &obj->m_StyleInfo->m_bg_valid);
+ if(obj->m_StyleInfo->m_fg_valid)
+ {
+ int red, green, blue;
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &red);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &green);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &blue);
+ obj->m_StyleInfo->m_fg = wxColour(red, green, blue);
+ }
+ if(obj->m_StyleInfo->m_bg_valid)
+ {
+ int red, green, blue;
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &red);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &green);
+ ReadString(tmp, istr);
+ sscanf(tmp.c_str(),"%d", &blue);
+ obj->m_StyleInfo->m_bg = wxColour(red, green, blue);
+ }
+ return obj;
+}
- si->size = m_font->GetPointSize();
- si->family = m_font->GetFamily();
- si->style = m_font->GetStyle();
- si->underline = m_font->GetUnderlined();
- si->weight = m_font->GetWeight();
- si->fg_red = m_ColourFG->Red();
- si->fg_green = m_ColourFG->Green();
- si->fg_blue = m_ColourFG->Blue();
- si->bg_red = m_ColourBG->Red();
- si->bg_green = m_ColourBG->Green();
- si->bg_blue = m_ColourBG->Blue();
+wxLayoutObjectCmd::~wxLayoutObjectCmd()
+{
+ delete m_StyleInfo;
+}
- return si;
+wxLayoutStyleInfo *
+wxLayoutObjectCmd::GetStyle(void) const
+{
+ return m_StyleInfo;
}
void
-wxLayoutObjectCmd::Draw(wxDC &dc, wxPoint const &translate)
+wxLayoutObjectCmd::Draw(wxDC &dc, wxPoint const & /* coords */,
+ wxLayoutList *wxllist,
+ CoordType begin, CoordType /* len */)
{
- wxASSERT(m_font);
- dc.SetFont(m_font);
- if(m_ColourFG)
- dc.SetTextForeground(*m_ColourFG);
- if(m_ColourBG)
- dc.SetTextBackground(*m_ColourBG);
+ wxASSERT(m_StyleInfo);
+ wxllist->ApplyStyle(m_StyleInfo, dc);
}
+
void
-wxLayoutObjectCmd::Layout(wxDC &dc, wxPoint p, CoordType baseline)
+wxLayoutObjectCmd::Layout(wxDC &dc, class wxLayoutList * llist)
{
- m_Position = p; // required so we can find the right object for cursor
// this get called, so that recalculation uses right font sizes
- Draw(dc,wxPoint(0,0));
+ Draw(dc, wxPoint(0,0), llist);
}
-//-------------------------- wxLayoutList
-wxLayoutList::wxLayoutList()
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ The wxLayoutLine object
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+wxLayoutLine::wxLayoutLine(wxLayoutLine *prev, wxLayoutList *llist)
{
- m_DefaultSetting = NULL;
- Clear();
+ m_LineNumber = 0;
+ m_Width = m_Height = 0;
+ m_Length = 0;
+ m_Dirty = true;
+ m_Previous = prev;
+ m_Next = NULL;
+ RecalculatePosition(llist);
+ if(m_Previous)
+ {
+ m_LineNumber = m_Previous->GetLineNumber()+1;
+ m_Next = m_Previous->GetNextLine();
+ m_Previous->m_Next = this;
+ }
+ if(m_Next)
+ {
+ m_Next->m_Previous = this;
+ m_Next->MoveLines(+1);
+ m_Next->RecalculatePositions(1,llist);
+ }
}
-wxLayoutList::~wxLayoutList()
+wxLayoutLine::~wxLayoutLine()
{
- if(m_DefaultSetting)
- delete m_DefaultSetting;
- // no deletion of objects, they are owned by the list
+ // kbList cleans itself
}
-void
-wxLayoutList::LineBreak(void)
+wxPoint
+wxLayoutLine::RecalculatePosition(wxLayoutList *llist)
{
- Insert(new wxLayoutObjectLineBreak);
- m_CursorPosition.x = 0; m_CursorPosition.y++;
+ wxASSERT(m_Previous || GetLineNumber() == 0);
+
+ if(m_Previous)
+ {
+ m_Position = m_Previous->GetPosition();
+ m_Position.y += m_Previous->GetHeight();
+ }
+ else
+ m_Position = wxPoint(0,0);
+ llist->SetUpdateRect(m_Position);
+ return m_Position;
}
void
-wxLayoutList::SetFont(int family, int size, int style, int weight,
- int underline, wxColour const *fg,
- wxColour const *bg)
-{
- if(family != -1) m_FontFamily = family;
- if(size != -1) m_FontPtSize = size;
- if(style != -1) m_FontStyle = style;
- if(weight != -1) m_FontWeight = weight;
- if(underline != -1) m_FontUnderline = underline != 0;
-
- if(fg != NULL) m_ColourFG = fg;
- if(bg != NULL) m_ColourBG = bg;
-
- Insert(
- new wxLayoutObjectCmd(m_FontPtSize,m_FontFamily,m_FontStyle,m_FontWeight,m_FontUnderline,
- m_ColourFG, m_ColourBG));
+wxLayoutLine::RecalculatePositions(int recurse, wxLayoutList *llist)
+{
+ //FIXME: is this really needed? We run Layout() anyway.
+ // Recursing here, drives computation time up exponentially, as
+ // each line will cause all following lines to be recalculated.
+ // Yes, or linenumbers go wrong.
+
+ wxASSERT(recurse >= 0);
+ wxPoint pos = m_Position;
+ CoordType height = m_Height;
+
+// WXLO_TRACE("RecalculatePositions()");
+ RecalculatePosition(llist);
+ if(m_Next)
+ {
+ if(recurse > 0)
+ m_Next->RecalculatePositions(--recurse, llist);
+ else if(pos != m_Position || m_Height != height)
+ m_Next->RecalculatePositions(0, llist);
+ }
}
-void
-wxLayoutList::SetFont(int family, int size, int style, int weight,
- int underline, char const *fg, char const *bg)
+wxLayoutObjectList::iterator
+wxLayoutLine::FindObject(CoordType xpos, CoordType *offset) const
+{
+ wxASSERT(xpos >= 0);
+ wxASSERT(offset);
+ wxLayoutObjectList::iterator
+ i,
+ found = NULLIT;
+ CoordType x = 0, len;
+
+ /* We search through the objects. As we don't like returning the
+ object that the cursor is behind, we just remember such an
+ object in "found" so we can return it if there is really no
+ further object following it. */
+ for(i = m_ObjectList.begin(); i != NULLIT; i++)
+ {
+ len = (**i).GetLength();
+ if( x <= xpos && xpos <= x + len )
+ {
+ *offset = xpos-x;
+ if(xpos == x + len) // is there another object behind?
+ found = i;
+ else // we are really inside this object
+ return i;
+ }
+ x += (**i).GetLength();
+ }
+ return found; // ==NULL if really none found
+}
+wxLayoutObjectList::iterator
+wxLayoutLine::FindObjectScreen(wxDC &dc,
+ CoordType xpos, CoordType *cxpos,
+ bool *found) const
{
- wxColour const
- * cfg = NULL,
- * cbg = NULL;
+ wxASSERT(cxpos);
+ wxASSERT(cxpos);
+ wxLayoutObjectList::iterator i;
+ CoordType x = 0, cx = 0, width;
- if( fg )
- cfg = wxTheColourDatabase->FindColour(fg);
- if( bg )
- cbg = wxTheColourDatabase->FindColour(bg);
-
- SetFont(family,size,style,weight,underline,cfg,cbg);
+ for(i = m_ObjectList.begin(); i != NULLIT; i++)
+ {
+ width = (**i).GetWidth();
+ if( x <= xpos && xpos <= x + width )
+ {
+ *cxpos = cx + (**i).GetOffsetScreen(dc, xpos-x);
+ if(found) *found = true;
+ return i;
+ }
+ x += (**i).GetWidth();
+ cx += (**i).GetLength();
+ }
+ // behind last object:
+ *cxpos = cx;
+ if(found) *found = false;
+ return m_ObjectList.tail();
}
-
-/// for access by wxLayoutWindow:
-void
-wxLayoutList::GetSize(CoordType *max_x, CoordType *max_y,
- CoordType *lineHeight)
+/** Finds text in this line.
+ @param needle the text to find
+ @param xpos the position where to start the search
+ @return the cursoor coord where it was found or -1
+*/
+CoordType
+wxLayoutLine::FindText(const wxString &needle, CoordType xpos) const
{
-
- if(max_x) *max_x = m_MaxX;
- if(max_y) *max_y = m_MaxY;
- if(lineHeight) *lineHeight = m_LineHeight;
+ int
+ cpos = 0,
+ relpos = -1;
+ wxString const *text;
+
+ for(wxLOiterator i = m_ObjectList.begin(); i != m_ObjectList.end(); i++)
+ {
+ if(cpos >= xpos) // search from here!
+ {
+ if((**i).GetType() == WXLO_TYPE_TEXT)
+ {
+ text = & ((wxLayoutObjectText*)(*i))->GetText();
+ relpos = text->Find(needle);
+ if(relpos >= cpos-xpos) // -1 if not found
+ {
+ return cpos+relpos;
+ }
+ }
+ cpos += (**i).GetLength();
+ }
+ }
+ return -1; // not found
}
-void
-wxLayoutList::ResetSettings(wxDC &dc)
+bool
+wxLayoutLine::Insert(CoordType xpos, wxLayoutObject *obj)
{
- // setting up the default:
- dc.SetTextForeground( *wxBLACK );
- dc.SetTextBackground( *wxWHITE );
- dc.SetBackgroundMode( wxSOLID ); // to enable setting of text background
- dc.SetFont( *wxNORMAL_FONT );
- if(m_DefaultSetting)
- m_DefaultSetting->Draw(dc,wxPoint(0,0));
+ wxASSERT(xpos >= 0);
+ wxASSERT(obj != NULL);
+
+ // in any case, the object is going to belong to this line
+ obj->AttachToLine(this);
+
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+ CoordType offset;
+ wxLOiterator i = FindObject(xpos, &offset);
+ if(i == NULLIT)
+ {
+ if(xpos == 0 ) // aha, empty line!
+ {
+ m_ObjectList.push_back(obj);
+ m_Length += obj->GetLength();
+ return true;
+ }
+ else
+ return false;
+ }
+
+ CoordType len = (**i).GetLength();
+ if(offset == 0 /*&& i != m_ObjectList.begin()*/) // why?
+ { // insert before this object
+ m_ObjectList.insert(i,obj);
+ m_Length += obj->GetLength();
+ return true;
+ }
+ if(offset == len )
+ {
+ if( i == m_ObjectList.tail()) // last object?
+ m_ObjectList.push_back(obj);
+ else
+ { // insert after current object
+ i++;
+ m_ObjectList.insert(i,obj);
+ }
+ m_Length += obj->GetLength();
+ return true;
+ }
+ /* Otherwise we need to split the current object.
+ Fortunately this can only be a text object. */
+ wxASSERT((**i).GetType() == WXLO_TYPE_TEXT);
+ wxString left, right;
+ wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
+ left = tobj->GetText().substr(0,offset);
+ right = tobj->GetText().substr(offset,len-offset);
+ // current text object gets set to right half
+ tobj->GetText() = right; // set new text
+ // before it we insert the new object
+ m_ObjectList.insert(i,obj);
+ m_Length += obj->GetLength();
+ // and before that we insert the left half
+ m_ObjectList.insert(i,new wxLayoutObjectText(left));
+ return true;
}
-void
-wxLayoutList::Layout(wxDC &dc, wxLayoutMargins *margins)
+bool
+wxLayoutLine::Insert(CoordType xpos, wxString text)
{
- iterator i;
+ wxASSERT(xpos >= 0);
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+ CoordType offset;
+ wxLOiterator i = FindObject(xpos, &offset);
+ if(i != NULLIT && (**i).GetType() == WXLO_TYPE_TEXT)
+ {
+ wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
+ tobj->GetText().insert(offset, text);
+ m_Length += text.Length();
- // first object in current line
- wxLayoutObjectList::iterator headOfLine;
- // where we draw next
- wxPoint position, position_HeadOfLine;
- // size of last object
- wxPoint size;
- CoordType baseLine = m_FontPtSize;
- CoordType baseLineSkip = (BASELINESTRETCH * baseLine)/10;
- CoordType objBaseLine = baseLine;
- wxLayoutObjectType type;
-
- // we need to count cursor positions
- wxPoint cursorPos = wxPoint(0,0);
-
- wxLayoutObjectBase *cursorObject = NULL; // let's find it again
-
- if(margins)
- {
- position.y = margins->top;
- position.x = margins->left;
+ return true;
}
else
- {
- position.y = 0;
- position.x = 0;
- }
-
- ResetSettings(dc);
-
- i = begin();
- headOfLine = i;
- position_HeadOfLine = position;
+ return Insert(xpos, new wxLayoutObjectText(text));
+}
- do
+CoordType
+wxLayoutLine::Delete(CoordType xpos, CoordType npos)
+{
+ CoordType offset, len;
+
+ wxASSERT(xpos >= 0);
+ wxASSERT(npos >= 0);
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+ wxLOiterator i = FindObject(xpos, &offset);
+ while(npos > 0)
{
- if(i == end())
- return;
-
- type = (*i)->GetType();
- (*i)->Layout(dc, position, baseLine);
- size = (*i)->GetSize(&objBaseLine);
- // calculate next object's position:
- position.x += size.x;
-
- // do we need to increase the line's height?
- if(size.y > baseLineSkip)
+ if(i == NULLIT) return npos;
+ // now delete from that object:
+ if((**i).GetType() != WXLO_TYPE_TEXT)
{
- baseLineSkip = size.y;
- i = headOfLine; position = position_HeadOfLine;
- continue;
+ if(offset != 0) // at end of line after a non-text object
+ return npos;
+ // always len == 1:
+ len = (**i).GetLength();
+ m_Length -= len;
+ npos -= len;
+ m_ObjectList.erase(i);
}
- if(objBaseLine > baseLine)
+ else
{
- baseLine = objBaseLine;
- i = headOfLine; position = position_HeadOfLine;
- continue;
+ // tidy up: remove empty text objects
+ if((**i).GetLength() == 0)
+ {
+ m_ObjectList.erase(i);
+ continue;
+ }
+ // Text object:
+ CoordType max = (**i).GetLength() - offset;
+ if(npos < max) max = npos;
+ if(max == 0)
+ {
+ if(xpos == GetLength())
+ return npos;
+ else
+ { // at the end of an object
+ // move to begin of next object:
+ i++; offset = 0;
+ continue; // start over
+ }
+ }
+ npos -= max;
+ m_Length -= max;
+ if(offset == 0 && max == (**i).GetLength())
+ m_ObjectList.erase(i); // remove the whole object
+ else
+ ((wxLayoutObjectText *)(*i))->GetText().Remove(offset,max);
}
+ }
- // when we reach here, the coordinates are valid, this part of
- // the loop gets run only once per object
- if(position.x > m_MaxX)
- m_MaxX = position.x;
- if(type == WXLO_TYPE_LINEBREAK)
+ return npos;
+}
+
+bool
+wxLayoutLine::DeleteWord(CoordType xpos)
+{
+ wxASSERT(xpos >= 0);
+ CoordType offset;
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+
+ wxLOiterator i = FindObject(xpos, &offset);
+
+ for(;;)
+ {
+ if(i == NULLIT) return false;
+ if((**i).GetType() != WXLO_TYPE_TEXT)
{
- cursorPos.x = 0; cursorPos.y ++;
+ // This should only happen when at end of line, behind a non-text
+ // object:
+ if(offset == (**i).GetLength()) return false;
+ m_Length -= (**i).GetLength(); // -1
+ m_ObjectList.erase(i);
+ return true; // we are done
}
else
- cursorPos.x += (**i).CountPositions();
-
- // now check whether we have finished handling this line:
- if(type == WXLO_TYPE_LINEBREAK && i != tail())
- {
- position.x = margins ? margins->left : 0;
- position.y += baseLineSkip;
- baseLine = m_FontPtSize;
- objBaseLine = baseLine; // not all objects set it
- baseLineSkip = (BASELINESTRETCH * baseLine)/10;
- headOfLine = i;
- headOfLine++;
- position_HeadOfLine = position;
+ { // text object:
+ if(offset == (**i).GetLength()) // at end of object
+ {
+ i++; offset = 0;
+ continue;
+ }
+ wxLayoutObjectText *tobj = (wxLayoutObjectText *)*i;
+ size_t count = 0;
+ wxString str = tobj->GetText();
+ str = str.substr(offset,str.Length()-offset);
+ // Find out how many positions we need to delete:
+ // 1. eat leading space
+ while(isspace(str.c_str()[count])) count++;
+ // 2. eat the word itself:
+ while(isalnum(str.c_str()[count])) count++;
+ // now delete it:
+ wxASSERT(count+offset <= (size_t) (**i).GetLength());
+ ((wxLayoutObjectText *)*i)->GetText().erase(offset,count);
+ m_Length -= count;
+ return true;
}
- if(cursorObject == NULL && cursorPos.y == m_CursorPosition.y) // look for cursor
+ }
+ wxASSERT(0); // we should never arrive here
+}
+
+wxLayoutLine *
+wxLayoutLine::DeleteLine(bool update, wxLayoutList *llist)
+{
+ if(m_Next) m_Next->m_Previous = m_Previous;
+ if(m_Previous) m_Previous->m_Next = m_Next;
+ if(update)
+ {
+ m_Next->MoveLines(-1);
+ m_Next->RecalculatePositions(1, llist);
+ }
+ wxLayoutLine *next = m_Next;
+ delete this;
+ return next;
+}
+
+void
+wxLayoutLine::Draw(wxDC &dc,
+ wxLayoutList *llist,
+ const wxPoint & offset) const
+{
+ wxLayoutObjectList::iterator i;
+ wxPoint pos = offset;
+ pos = pos + GetPosition();
+
+ pos.y += m_BaseLine;
+
+ CoordType xpos = 0; // cursorpos, lenght of line
+
+ CoordType from, to, tempto;
+ //FIXME This doesn't work yet, needs updating afterr default
+ //settings for list or a wxLayoutObjectCmd have changed:
+ //llist->ApplyStyle(&((wxLayoutLine *)this)->m_StyleInfo, dc);
+ int highlight = llist->IsSelected(this, &from, &to);
+// WXLO_DEBUG(("highlight=%d", highlight ));
+ if(highlight == 1) // we need to draw the whole line inverted!
+ llist->StartHighlighting(dc);
+ else
+ llist->EndHighlighting(dc);
+
+ for(i = m_ObjectList.begin(); i != NULLIT; i++)
+ {
+ if(highlight == -1) // partially highlight line
+ {
+ // parts of the line need highlighting
+ tempto = xpos+(**i).GetLength();
+ (**i).Draw(dc, pos, llist, from-xpos, to-xpos);
+ }
+ else
+ (**i).Draw(dc, pos, llist);
+ pos.x += (**i).GetWidth();
+ xpos += (**i).GetLength();
+ }
+}
+
+void
+wxLayoutLine::Layout(wxDC &dc,
+ wxLayoutList *llist,
+ wxPoint *cursorPos,
+ wxPoint *cursorSize,
+ int cx)
+{
+ wxLayoutObjectList::iterator i;
+
+ CoordType
+ oldWidth = m_Width,
+ oldHeight = m_Height;
+ CoordType
+ topHeight, bottomHeight; // above and below baseline
+ CoordType
+ objHeight = 0,
+ objTopHeight, objBottomHeight;
+ CoordType
+ len, count = 0;
+ m_Height = 0; m_BaseLine = 0;
+ m_Width = 0;
+ topHeight = 0; bottomHeight = 0;
+ wxPoint size;
+ bool cursorFound = false;
+
+ m_Dirty = false;
+
+ if(cursorPos)
+ {
+ *cursorPos = m_Position;
+ if(cursorSize) *cursorSize = wxPoint(0,0);
+ }
+
+ //FIXME This doesn't work yet, needs updating afterr default
+ //settings for list or a wxLayoutObjectCmd have changed:
+ //llist->ApplyStyle(&m_StyleInfo, dc);
+ for(i = m_ObjectList.begin(); i != NULLIT; i++)
+ {
+ (**i).Layout(dc, llist);
+ size = (**i).GetSize(&objTopHeight, &objBottomHeight);
+
+ if(cursorPos && ! cursorFound)
+ { // we need to check whether the text cursor is here
+ len = (**i).GetLength();
+ if(count <= cx && count+len > cx)
+ {
+ if((**i).GetType() == WXLO_TYPE_TEXT)
+ {
+ len = cx - count; // pos in object
+ CoordType width, height, descent;
+ dc.GetTextExtent((*(wxLayoutObjectText*)*i).GetText().substr(0,len),
+ &width, &height, &descent);
+ cursorPos->x += width;
+ cursorPos->y = m_Position.y;
+ wxString str;
+ if(len < (**i).GetLength())
+ str = (*(wxLayoutObjectText*)*i).GetText().substr(len,1);
+ else
+ str = WXLO_CURSORCHAR;
+ dc.GetTextExtent(str, &width, &height, &descent);
+ wxASSERT(cursorSize);
+ // Just in case some joker inserted an empty string object:
+ if(width == 0) width = WXLO_MINIMUM_CURSOR_WIDTH;
+ if(height == 0) height = objHeight;
+ cursorSize->x = width;
+ cursorSize->y = height;
+ cursorFound = true; // no more checks
+ }
+ else
+ { // on some other object
+ CoordType top, bottom; // unused
+ *cursorSize = (**i).GetSize(&top,&bottom);
+ cursorPos->y = m_Position.y;
+ cursorFound = true; // no more checks
+ }
+ }
+ else
+ {
+ count += len;
+ cursorPos->x += (**i).GetWidth();
+ }
+ } // cursor finding
+ objHeight = size.y;
+ m_Width += size.x;
+ if(objHeight > m_Height) m_Height = objHeight;
+ if(objTopHeight > topHeight) topHeight = objTopHeight;
+ if(objBottomHeight > bottomHeight) bottomHeight = objBottomHeight;
+ }
+
+ // special case of a line which becomes empty (after deletion, for example):
+ // we should invalidate the screen space it occupied (usually this happens
+ // from wxLayoutObject::Layout called in the loop above)
+ if ( m_ObjectList.empty() )
+ {
+ wxPoint position(GetPosition());
+ llist->SetUpdateRect(position.x + oldWidth + MSW_CORRECTION,
+ position.y + oldHeight + MSW_CORRECTION);
+ }
+
+ if(topHeight + bottomHeight > m_Height)
+ m_Height = topHeight+bottomHeight;
+ m_BaseLine = topHeight;
+
+ if(m_Height == 0)
+ {
+ CoordType width, height, descent;
+ dc.GetTextExtent(WXLO_CURSORCHAR, &width, &height, &descent);
+ m_Height = height;
+ m_BaseLine = m_Height - descent;
+ }
+
+
+ // tell next line about coordinate change
+ if(m_Next && objHeight != oldHeight)
+ m_Next->RecalculatePositions(0, llist);
+
+ // We need to check whether we found a valid cursor size:
+ if(cursorPos)
+ {
+ // this might be the case if the cursor is at the end of the
+ // line or on a command object:
+ if(cursorSize->y < WXLO_MINIMUM_CURSOR_WIDTH)
+ {
+ CoordType width, height, descent;
+ dc.GetTextExtent(WXLO_CURSORCHAR, &width, &height, &descent);
+ cursorSize->x = width;
+ cursorSize->y = height;
+ }
+ if(m_BaseLine >= cursorSize->y) // the normal case anyway
+ cursorPos->y += m_BaseLine-cursorSize->y;
+ }
+ RecalculatePositions(1, llist);
+}
+
+
+wxLayoutLine *
+wxLayoutLine::Break(CoordType xpos, wxLayoutList *llist)
+{
+ wxASSERT(xpos >= 0);
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+
+ /* If we are at the begin of a line, we want to move all other
+ lines down and stay with the cursor where we are. However, if we
+ are in an empty line, we want to move down with it. */
+ if(xpos == 0 && GetLength() > 0)
+ { // insert an empty line before this one
+ wxLayoutLine *prev = new wxLayoutLine(m_Previous, llist);
+ if(m_Previous == NULL)
+ { // We were in first line, need to link in new empty line
+ // before this.
+ prev->m_Next = this;
+ m_Previous = prev;
+ m_Previous->m_Height = 0; // this is a wild guess
+ }
+ if(m_Next)
+ m_Next->RecalculatePositions(1, llist);
+ return m_Previous;
+ }
+
+ CoordType offset;
+ wxLOiterator i = FindObject(xpos, &offset);
+ if(i == NULLIT)
+ // must be at the end of the line then
+ return new wxLayoutLine(this, llist);
+ // split this line:
+
+ wxLayoutLine *newLine = new wxLayoutLine(this, llist);
+ // split object at i:
+ if((**i).GetType() == WXLO_TYPE_TEXT && offset != 0)
+ {
+ wxString left, right;
+ wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
+ left = tobj->GetText().substr(0,offset);
+ right = tobj->GetText().substr(offset,tobj->GetLength()-offset);
+ // current text object gets set to left half
+ tobj->GetText() = left; // set new text
+ newLine->Append(new wxLayoutObjectText(right));
+ m_Length -= right.Length();
+ i++; // don't move this object to the new list
+ }
+ else
+ if(offset > 0)
+ i++; // move objects from here to new list
+
+ while(i != m_ObjectList.end())
+ {
+ newLine->Append(*i);
+ m_Length -= (**i).GetLength();
+ m_ObjectList.remove(i); // remove without deleting it
+ }
+ if(m_Next)
+ m_Next->RecalculatePositions(2, llist);
+ return newLine;
+}
+
+
+void
+wxLayoutLine::MergeNextLine(wxLayoutList *llist)
+{
+ wxCHECK_RET(GetNextLine(),"wxLayout internal error: no next line to merge");
+ wxLayoutObjectList &list = GetNextLine()->m_ObjectList;
+ wxLOiterator i;
+ //FIXME: this could be optimised, for now be prudent:
+ m_Dirty = true;
+
+ wxLayoutObject *last = NULL;
+ for(i = list.begin(); i != list.end();)
+ {
+ wxLayoutObject *current = *i;
+
+ // merge text objects together for efficiency
+ if ( last && last->GetType() == WXLO_TYPE_TEXT &&
+ current->GetType() == WXLO_TYPE_TEXT )
+ {
+ wxLayoutObjectText *textObj = (wxLayoutObjectText *)last;
+ wxString text(textObj->GetText());
+ text += ((wxLayoutObjectText *)current)->GetText();
+ textObj->SetText(text);
+
+ list.erase(i); // remove and delete it
+ }
+ else
+ {
+ // just append the object "as was"
+ current->UnattachFromLine();
+ Append(current);
+
+ list.remove(i); // remove without deleting it
+ }
+ }
+ wxASSERT(list.empty());
+
+ wxLayoutLine *oldnext = GetNextLine();
+ wxLayoutLine *nextLine = oldnext->GetNextLine();
+ SetNext(nextLine);
+ delete oldnext;
+ if ( nextLine )
+ {
+ nextLine->MoveLines(-1);
+ }
+
+ // no RecalculatePositions needed - called from Delete() anyhow
+}
+
+CoordType
+wxLayoutLine::GetWrapPosition(CoordType column)
+{
+ CoordType offset;
+ wxLOiterator i = FindObject(column, &offset);
+ if(i == NULLIT) return -1; // cannot wrap
+
+ // go backwards through the list and look for space in text objects
+ do
+ {
+ if((**i).GetType() == WXLO_TYPE_TEXT)
+ {
+ do
+ {
+ if( isspace(((wxLayoutObjectText*)*i)->GetText().c_str()[(size_t)offset]))
+ return column;
+ else
+ {
+ offset--;
+ column--;
+ }
+ }while(offset != -1);
+ i--; // move on to previous object
+ }
+ else
+ {
+ column -= (**i).GetLength();
+ i--;
+ }
+ if( i != NULLIT)
+ offset = (**i).GetLength();
+ }while(i != NULLIT);
+ /* If we reached the begin of the list and have more than one
+ object, that one is longer than the margin, so break behind
+ it. */
+ CoordType pos = 0;
+ i = m_ObjectList.begin();
+ while(i != NULLIT && (**i).GetType() != WXLO_TYPE_TEXT)
+ {
+ pos += (**i).GetLength();
+ i++;
+ }
+ if(i == NULLIT) return -1; //why should this happen?
+ pos += (**i).GetLength();
+ i++;
+ while(i != NULLIT && (**i).GetType() != WXLO_TYPE_TEXT)
+ {
+ pos += (**i).GetLength();
+ i++;
+ }
+ if(i == NULLIT) return -1; //this is possible, if there is only one text object
+ // now we are at the second text object:
+ pos -= (**i).GetLength();
+ return pos; // in front of it
+}
+
+
+#ifdef WXLAYOUT_DEBUG
+void
+wxLayoutLine::Debug(void)
+{
+ wxString tmp;
+ wxPoint pos = GetPosition();
+ WXLO_DEBUG(("Line %ld, Pos (%ld,%ld), Height %ld",
+ (long int) GetLineNumber(),
+ (long int) pos.x, (long int) pos.y,
+ (long int) GetHeight()));
+ if(m_ObjectList.begin() != NULLIT)
+ (**m_ObjectList.begin()).Debug();
+
+}
+#endif
+
+void
+wxLayoutLine::Copy(wxLayoutList *llist,
+ CoordType from,
+ CoordType to)
+{
+ CoordType firstOffset, lastOffset;
+
+ if(to == -1) to = GetLength();
+ if(from == to) return;
+
+ wxLOiterator first = FindObject(from, &firstOffset);
+ wxLOiterator last = FindObject(to, &lastOffset);
+
+ // Common special case: only one object
+ if( first != NULLIT && last != NULLIT && *first == *last )
+ {
+ if( (**first).GetType() == WXLO_TYPE_TEXT )
+ {
+ llist->Insert(new wxLayoutObjectText(
+ ((wxLayoutObjectText
+ *)*first)->GetText().substr(firstOffset,
+ lastOffset-firstOffset))
+ );
+ return;
+ }
+ else // what can we do?
+ {
+ if(lastOffset > firstOffset) // i.e. +1 :-)
+ llist->Insert( (**first).Copy() );
+ return;
+ }
+ }
+
+ // If we reach here, we can safely copy the whole first object from
+ // the firstOffset position on:
+ if((**first).GetType() == WXLO_TYPE_TEXT && firstOffset != 0)
+ {
+ llist->Insert(new wxLayoutObjectText(
+ ((wxLayoutObjectText *)*first)->GetText().substr(firstOffset))
+ );
+ }
+ else if(firstOffset == 0)
+ llist->Insert( (**first).Copy() );
+ // else nothing to copy :-(
+
+ // Now we copy all objects before the last one:
+ wxLOiterator i = first; i++;
+ for( ; i != last; i++)
+ llist->Insert( (**i).Copy() );
+
+ // And now the last object:
+ if(lastOffset != 0)
+ {
+ if( (**last).GetType() == WXLO_TYPE_TEXT )
+ {
+ llist->Insert(new wxLayoutObjectText(
+ ((wxLayoutObjectText *)*last)->GetText().substr(0,lastOffset))
+ );
+ }
+ else
+ llist->Insert( (**last).Copy() );
+ }
+}
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ The wxLayoutList object
+
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+wxLayoutList::wxLayoutList()
+{
+#ifdef WXLAYOUT_USE_CARET
+ m_caret = NULL;
+#endif // WXLAYOUT_USE_CARET
+
+ m_FirstLine = NULL;
+ InvalidateUpdateRect();
+ Clear();
+}
+
+wxLayoutList::~wxLayoutList()
+{
+ InternalClear();
+ m_FirstLine->DeleteLine(false, this);
+}
+
+void
+wxLayoutList::Empty(void)
+{
+ while(m_FirstLine)
+ m_FirstLine = m_FirstLine->DeleteLine(false, this);
+
+ m_CursorPos = wxPoint(0,0);
+ m_CursorScreenPos = wxPoint(0,0);
+ m_CursorSize = wxPoint(0,0);
+ m_FirstLine = new wxLayoutLine(NULL, this); // empty first line
+ m_CursorLine = m_FirstLine;
+ InvalidateUpdateRect();
+}
+
+
+void
+wxLayoutList::InternalClear(void)
+{
+ Empty();
+ m_Selection.m_selecting = false;
+ m_Selection.m_valid = false;
+
+ m_DefaultSetting.family = wxSWISS;
+ m_DefaultSetting.size = WXLO_DEFAULTFONTSIZE;
+ m_DefaultSetting.style = wxNORMAL;
+ m_DefaultSetting.weight = wxNORMAL;
+ m_DefaultSetting.underline = 0;
+ m_DefaultSetting.m_fg_valid = TRUE;
+ m_DefaultSetting.m_fg = *wxBLACK;
+ m_DefaultSetting.m_bg_valid = TRUE;
+ m_DefaultSetting.m_bg = *wxWHITE;
+
+ m_CurrentSetting = m_DefaultSetting;
+}
+
+void
+wxLayoutList::SetFont(int family, int size, int style, int weight,
+ int underline, wxColour *fg,
+ wxColour *bg)
+{
+ if(family != -1) m_CurrentSetting.family = family;
+ if(size != -1) m_CurrentSetting.size = size;
+ if(style != -1) m_CurrentSetting.style = style;
+ if(weight != -1) m_CurrentSetting.weight = weight;
+ if(underline != -1) m_CurrentSetting.underline = underline != 0;
+ if(fg) m_CurrentSetting.m_fg = *fg;
+ if(bg) m_CurrentSetting.m_bg = *bg;
+ Insert(
+ new wxLayoutObjectCmd(
+ m_CurrentSetting.family,
+ m_CurrentSetting.size,
+ m_CurrentSetting.style,
+ m_CurrentSetting.weight,
+ m_CurrentSetting.underline,
+ fg, bg));
+}
+
+void
+wxLayoutList::SetFont(int family, int size, int style, int weight,
+ int underline, char const *fg, char const *bg)
+
+{
+ wxColour
+ *cfg = NULL,
+ *cbg = NULL;
+
+ if( fg )
+ cfg = wxTheColourDatabase->FindColour(fg);
+ if( bg )
+ cbg = wxTheColourDatabase->FindColour(bg);
+
+ SetFont(family,size,style,weight,underline,cfg,cbg);
+}
+
+void
+wxLayoutList::Clear(int family, int size, int style, int weight,
+ int underline, wxColour *fg, wxColour *bg)
+{
+ InternalClear();
+ m_DefaultSetting = wxLayoutStyleInfo(family, size, style, weight,
+ underline, fg, bg);
+ m_CurrentSetting = m_DefaultSetting;
+}
+
+wxPoint
+wxLayoutList::FindText(const wxString &needle, const wxPoint &cpos) const
+{
+ int xpos;
+
+ wxLayoutLine *line;
+ for(line = m_FirstLine;
+ line;
+ line = line->GetNextLine())
+ {
+ if(line->GetLineNumber() >= cpos.y)
+ {
+ xpos = line->FindText(needle,
+ (line->GetLineNumber() == cpos.y) ?
+ cpos.x : 0);
+ if(xpos != -1)
+ return wxPoint(xpos, line->GetLineNumber());
+ }
+ }
+ return wxPoint(-1,-1);
+}
+
+
+bool
+wxLayoutList::MoveCursorTo(wxPoint const &p)
+{
+ AddCursorPosToUpdateRect();
+
+ wxLayoutLine *line = m_FirstLine;
+ while(line && line->GetLineNumber() != p.y)
+ line = line->GetNextLine();
+ if(line && line->GetLineNumber() == p.y) // found it
+ {
+ m_CursorPos.y = p.y;
+ m_CursorLine = line;
+ CoordType len = line->GetLength();
+ if(len >= p.x)
+ {
+ m_CursorPos.x = p.x;
+ return true;
+ }
+ else
+ {
+ m_CursorPos.x = len;
+ return false;
+ }
+ }
+ return false;
+}
+
+bool
+wxLayoutList::MoveCursorVertically(int n)
+{
+ AddCursorPosToUpdateRect();
+
+ bool rc;
+ if(n < 0) // move up
+ {
+ if(m_CursorLine == m_FirstLine) return false;
+ while(n < 0 && m_CursorLine)
+ {
+ m_CursorLine = m_CursorLine->GetPreviousLine();
+ m_CursorPos.y--;
+ n++;
+ }
+ if(! m_CursorLine)
+ {
+ m_CursorLine = m_FirstLine;
+ m_CursorPos.y = 0;
+ rc = false;
+ }
+ else
+ {
+ if(m_CursorPos.x > m_CursorLine->GetLength())
+ m_CursorPos.x = m_CursorLine->GetLength();
+ rc = true;
+ }
+ }
+ else // move down
+ {
+ wxLayoutLine *last = m_CursorLine;
+ if(! m_CursorLine->GetNextLine()) return false;
+ while(n > 0 && m_CursorLine)
+ {
+ n--;
+ m_CursorPos.y ++;
+ m_CursorLine = m_CursorLine->GetNextLine();
+ }
+ if(! m_CursorLine)
+ {
+ m_CursorLine = last;
+ m_CursorPos.y ++;
+ rc = false;
+ }
+ else
+ {
+ if(m_CursorPos.x > m_CursorLine->GetLength())
+ m_CursorPos.x = m_CursorLine->GetLength();
+ rc = true;
+ }
+ }
+ return rc;
+}
+
+bool
+wxLayoutList::MoveCursorHorizontally(int n)
+{
+ AddCursorPosToUpdateRect();
+
+ int move;
+ while(n < 0)
+ {
+ if(m_CursorPos.x == 0) // at begin of line
+ {
+ if(! MoveCursorVertically(-1))
+ break;
+ MoveCursorToEndOfLine();
+ n++;
+ continue;
+ }
+ move = -n;
+ if(move > m_CursorPos.x) move = m_CursorPos.x;
+ m_CursorPos.x -= move; n += move;
+ }
+
+ while(n > 0)
+ {
+ int len = m_CursorLine->GetLength();
+ if(m_CursorPos.x == len) // at end of line
+ {
+ if(! MoveCursorVertically(1))
+ break;
+ MoveCursorToBeginOfLine();
+ n--;
+ continue;
+ }
+ move = n;
+ if( move >= len-m_CursorPos.x) move = len-m_CursorPos.x;
+ m_CursorPos.x += move;
+ n -= move;
+ }
+ return n == 0;
+}
+
+bool
+wxLayoutList::Insert(wxString const &text)
+{
+ wxASSERT(m_CursorLine);
+
+ AddCursorPosToUpdateRect();
+
+ m_CursorLine->Insert(m_CursorPos.x, text);
+ m_CursorPos.x += text.Length();
+ m_CursorLine->RecalculatePositions(true, this); //FIXME needed?
+ return true;
+}
+
+bool
+wxLayoutList::Insert(wxLayoutObject *obj)
+{
+ wxASSERT(m_CursorLine);
+
+ if(! m_CursorLine)
+ m_CursorLine = GetFirstLine();
+
+ AddCursorPosToUpdateRect();
+
+ m_CursorLine->Insert(m_CursorPos.x, obj);
+ m_CursorPos.x += obj->GetLength();
+ m_CursorLine->RecalculatePositions(true, this); //FIXME needed?
+ return true;
+}
+
+bool
+wxLayoutList::Insert(wxLayoutList *llist)
+{
+ wxASSERT(llist);
+ bool rc = TRUE;
+
+ for(wxLayoutLine *line = llist->GetFirstLine();
+ line;
+ line = line->GetNextLine()
+ )
+ {
+ for(wxLOiterator i = line->GetFirstObject();
+ i != NULLIT;
+ i++)
+ rc |= Insert(*i);
+ LineBreak();
+ }
+ return rc;
+}
+
+bool
+wxLayoutList::LineBreak(void)
+{
+ wxASSERT(m_CursorLine);
+ bool setFirst = (m_CursorLine == m_FirstLine && m_CursorPos.x == 0);
+
+ AddCursorPosToUpdateRect();
+
+ wxPoint position(m_CursorLine->GetPosition());
+
+ wxCoord width = m_CursorLine->GetWidth(),
+ height = m_CursorLine->GetHeight();
+
+ m_CursorLine = m_CursorLine->Break(m_CursorPos.x, this);
+ if(setFirst) // we were at beginning of first line
+ m_FirstLine = m_CursorLine->GetPreviousLine();
+ if(m_CursorPos.x != 0)
+ m_CursorPos.y++;
+ m_CursorPos.x = 0;
+// doesn't help m_CursorLine.MarkDirty();
+
+ wxLayoutLine *prev = m_CursorLine->GetPreviousLine();
+ wxCHECK_MSG(prev, false, "just broke the line, where is the previous one?");
+
+ height += prev->GetHeight();
+
+ SetUpdateRect(position);
+ SetUpdateRect(position.x + width + MSW_CORRECTION,
+ position.y + height + MSW_CORRECTION);
+
+ return true;
+}
+
+bool
+wxLayoutList::WrapLine(CoordType column)
+{
+ if(m_CursorPos.x <= column || column < 1)
+ return false; // do nothing yet
+ else
+ {
+ CoordType xpos = m_CursorLine->GetWrapPosition(column);
+ if(xpos == -1)
+ return false; // cannot break line
+ //else:
+ CoordType newpos = m_CursorPos.x - xpos - 1;
+ m_CursorPos.x = xpos;
+
+ AddCursorPosToUpdateRect();
+
+ LineBreak();
+ Delete(1); // delete the space
+ m_CursorPos.x = newpos;
+ m_CursorLine->RecalculatePositions(true, this); //FIXME needed?
+ return true;
+ }
+}
+
+bool
+wxLayoutList::Delete(CoordType npos)
+{
+ wxCHECK_MSG(m_CursorLine, false, "can't delete in non existing line");
+ wxASSERT_MSG(npos > 0, "nothing to delete?");
+
+ AddCursorPosToUpdateRect();
+
+ // were other lines appended to this one (this is important to know because
+ // this means that our width _increased_ as the result of deletion)
+ bool wasMerged = false;
+
+ // the size of the region to update
+ CoordType totalHeight = m_CursorLine->GetHeight(),
+ totalWidth = m_CursorLine->GetWidth();
+
+ CoordType left;
+ do
+ {
+ left = m_CursorLine->Delete(m_CursorPos.x, npos);
+
+ if( left > 0 )
+ {
+ // More to delete, continue on next line.
+
+ // First, check if line is empty:
+ if(m_CursorLine->GetLength() == 0)
+ {
+ // in this case, updating could probably be optimised
+#ifdef WXLO_DEBUG
+ wxASSERT(DeleteLines(1) == 0);
+#else
+ DeleteLines(1);
+#endif
+
+ left--;
+ }
+ else
+ {
+ // Need to join next line
+ if(! m_CursorLine->GetNextLine())
+ break; // cannot
+ else
+ {
+ wasMerged = true;
+ wxLayoutLine *next = m_CursorLine->GetNextLine();
+ if ( next )
+ totalHeight += next->GetHeight();
+ m_CursorLine->MergeNextLine(this);
+ left--;
+ }
+ }
+ }
+ }
+ while ( left> 0 );
+
+ // we need to update the whole tail of the line and the lines which
+ // disappeared
+ if ( wasMerged )
+ {
+ wxPoint position(m_CursorLine->GetPosition());
+ SetUpdateRect(position.x + totalWidth + MSW_CORRECTION,
+ position.y + totalHeight + MSW_CORRECTION);
+ }
+
+ return left == 0;
+}
+
+int
+wxLayoutList::DeleteLines(int n)
+{
+ wxASSERT(m_CursorLine);
+ wxLayoutLine *line;
+
+ AddCursorPosToUpdateRect();
+
+ while(n > 0)
+ {
+ if(!m_CursorLine->GetNextLine())
+ { // we cannot delete this line, but we can clear it
+ MoveCursorToBeginOfLine();
+ DeleteToEndOfLine();
+ m_CursorLine->RecalculatePositions(2, this);
+ return n-1;
+ }
+ //else:
+ line = m_CursorLine;
+ m_CursorLine = m_CursorLine->DeleteLine(true, this);
+ n--;
+ if(line == m_FirstLine) m_FirstLine = m_CursorLine;
+ wxASSERT(m_FirstLine);
+ wxASSERT(m_CursorLine);
+ }
+ m_CursorLine->RecalculatePositions(2, this);
+ return n;
+}
+
+void
+wxLayoutList::Recalculate(wxDC &dc, CoordType bottom)
+{
+ wxLayoutLine *line = m_FirstLine;
+
+ // first, make sure everything is calculated - this might not be
+ // needed, optimise it later
+ ApplyStyle(&m_DefaultSetting, dc);
+ while(line)
+ {
+ line->RecalculatePosition(this); // so we don't need to do it all the time
+ // little condition to speed up redrawing:
+ if(bottom != -1 && line->GetPosition().y > bottom) break;
+ line = line->GetNextLine();
+ }
+}
+
+void
+wxLayoutList::UpdateCursorScreenPos(wxDC &dc)
+{
+ wxASSERT(m_CursorLine);
+ m_CursorLine->Layout(dc, this, (wxPoint *)&m_CursorScreenPos, (wxPoint *)&m_CursorSize, m_CursorPos.x);
+}
+
+wxPoint
+wxLayoutList::GetCursorScreenPos(wxDC &dc)
+{
+ UpdateCursorScreenPos(dc);
+ return m_CursorScreenPos;
+}
+
+/*
+ Is called before each Draw(). Now, it will re-layout all lines which
+ have changed.
+*/
+void
+wxLayoutList::Layout(wxDC &dc, CoordType bottom, bool forceAll)
+{
+ wxLayoutLine *line = m_FirstLine;
+
+ // first, make sure everything is calculated - this might not be
+ // needed, optimise it later
+ ApplyStyle(&m_DefaultSetting, dc);
+ while(line)
+ {
+ if(forceAll || line->IsDirty())
{
- if(cursorPos.x >= m_CursorPosition.x &&
- m_CursorPosition.x-cursorPos.x+(**i).CountPositions()) // cursor is in current object
- {
- cursorObject = *i;
- CalculateCursor(dc);
- }
+ line->GetStyleInfo() = m_CurrentSetting;
+ if(line == m_CursorLine)
+ line->Layout(dc, this, (wxPoint *)&m_CursorScreenPos,
+ (wxPoint *)&m_CursorSize, m_CursorPos.x);
+ else
+ line->Layout(dc, this);
+ // little condition to speed up redrawing:
+ if(bottom != -1 && line->GetPosition().y > bottom) break;
}
- i++;
+ line->RecalculatePositions(1,this);
+ line = line->GetNextLine();
}
- while(i != end());
- m_MaxY = position.y + baseLineSkip;
+
+///FIXME: disabled for now
+#if 0
+ // can only be 0 if we are on the first line and have no next line
+ wxASSERT(m_CursorSize.x != 0 || (m_CursorLine &&
+ m_CursorLine->GetNextLine() == NULL &&
+ m_CursorLine == m_FirstLine));
+#endif
+ AddCursorPosToUpdateRect();
}
void
wxLayoutList::Draw(wxDC &dc,
- CoordType fromLine, CoordType toLine,
- iterator start,
- wxPoint const &translate)
+ wxPoint const &offset,
+ CoordType top,
+ CoordType bottom)
{
- Layout(dc); // FIXME just for now
+ wxLayoutLine *line = m_FirstLine;
- ResetSettings(dc);
+ Layout(dc);
+ ApplyStyle(&m_DefaultSetting, dc);
+ wxBrush brush(m_CurrentSetting.m_bg, wxSOLID);
+ dc.SetBrush(brush);
+ dc.SetBackgroundMode(wxTRANSPARENT);
- wxLayoutObjectList::iterator i;
-
- if(start == iterator(NULL))
- start = begin();
- else // we need to restore font settings
+ while(line)
+ {
+ // only draw if between top and bottom:
+ if((top == -1 || line->GetPosition().y + line->GetHeight() >= top))
+ line->Draw(dc, this, offset);
+ else
+ line->Layout(dc, this);
+ // little condition to speed up redrawing:
+ if(bottom != -1 && line->GetPosition().y > bottom) break;
+ line = line->GetNextLine();
+ }
+ InvalidateUpdateRect();
+
+ WXLO_DEBUG(("Selection is %s : l%d,%ld/%ld,%ld",
+ m_Selection.m_valid ? "valid" : "invalid",
+ m_Selection.m_CursorA.x, m_Selection.m_CursorA.y,
+ m_Selection.m_CursorB.x, m_Selection.m_CursorB.y));
+}
+
+wxLayoutObject *
+wxLayoutList::FindObjectScreen(wxDC &dc, wxPoint const pos,
+ wxPoint *cursorPos,
+ bool *found)
+{
+ // First, find the right line:
+ wxLayoutLine *line = m_FirstLine;
+ wxPoint p;
+
+ // we need to run a layout here to get font sizes right :-(
+ ApplyStyle(&m_DefaultSetting, dc);
+ while(line)
{
- for( i = begin() ; i != start; i++)
- if((**i).GetType() == WXLO_TYPE_CMD)
- (**i).Draw(dc,translate); // apply font settings
+ p = line->GetPosition();
+ if(p.y <= pos.y && p.y+line->GetHeight() >= pos.y)
+ break;
+ line->Layout(dc, this);
+ line = line->GetNextLine();
}
-
- while( start != end() && (**start).GetPosition().y < fromLine)
+ if(line == NULL)
{
- if((**start).GetType() == WXLO_TYPE_CMD)
- (**start).Draw(dc,translate); // apply font settings
- start++;
+ if(found) *found = false;
+ return NULL; // not found
}
- for( i = start ;
- i != end() && (toLine == -1 || (**i).GetPosition().y < toLine) ;
- i++ )
- (*i)->Draw(dc,translate);
+ if(cursorPos) cursorPos->y = line->GetLineNumber();
+ // Now, find the object in the line:
+ wxLOiterator i = line->FindObjectScreen(dc, pos.x,
+ cursorPos ? & cursorPos->x : NULL ,
+ found);
+ return (i == NULLIT) ? NULL : *i;
+
}
-/** Erase at least to end of line */
-void
-wxLayoutList::EraseAndDraw(wxDC &dc, iterator start)
-{
- //look for begin of line
- while(start != end() && start != begin() && (**start).GetType() !=
- WXLO_TYPE_LINEBREAK)
- start--;
- if(start == iterator(NULL))
- start = begin();
- if(start == iterator(NULL))
- return;
-
- wxPoint p = (**start).GetPosition();
+wxPoint
+wxLayoutList::GetSize(void) const
+{
+ wxLayoutLine
+ *line = m_FirstLine,
+ *last = line;
+ if(! line)
+ return wxPoint(0,0);
- WXL_VAR(p.x);WXL_VAR(p.y);
- //FIXME: wxGTK: MaxX()/MaxY() broken
- //WXL_VAR(dc.MaxX()); WXL_VAR(dc.MaxY());
- dc.SetBrush(*wxWHITE_BRUSH);
- dc.SetPen(wxPen(*wxWHITE,0,wxTRANSPARENT));
- dc.DrawRectangle(p.x,p.y,2000,2000); //dc.MaxX(),dc.MaxY());
- Draw(dc,-1,-1,start,wxPoint(0,0));
- //dc.DrawRectangle(p.x,p.y,2000,2000); //dc.MaxX(),dc.MaxY());
+ wxPoint maxPoint(0,0);
+
+ // find last line:
+ while(line)
+ {
+ if(line->GetWidth() > maxPoint.x)
+ maxPoint.x = line->GetWidth();
+ last = line;
+ line = line->GetNextLine();
+ }
+
+ maxPoint.y = last->GetPosition().y + last->GetHeight();
+ return maxPoint;
}
void
-wxLayoutList::CalculateCursor(wxDC &dc)
+wxLayoutList::DrawCursor(wxDC &dc, bool active, wxPoint const &translate)
{
- CoordType width, height, descent;
- CoordType baseLineSkip = 20; //FIXME
+ wxPoint coords(m_CursorScreenPos);
+ coords += translate;
- CoordType offset;
- wxLayoutObjectBase &obj = **FindCurrentObject(&offset);
+#ifdef WXLAYOUT_DEBUG
+ WXLO_DEBUG(("Drawing cursor (%ld,%ld) at %ld,%ld, size %ld,%ld, line: %ld, len %ld",
+ (long)m_CursorPos.x, (long)m_CursorPos.y,
+ (long)coords.x, (long)coords.y,
+ (long)m_CursorSize.x, (long)m_CursorSize.y,
+ (long)m_CursorLine->GetLineNumber(),
+ (long)m_CursorLine->GetLength()));
+
+ wxLogStatus("Cursor is at (%d, %d)", m_CursorPos.x, m_CursorPos.y);
+#endif
- WXL_VAR(offset);
- DrawCursor(dc,true); // erase it
- m_CursorCoords = obj.GetPosition();
- WXL_VAR(m_CursorCoords.x);
- if(obj.GetType() == WXLO_TYPE_TEXT)
- {
- wxLayoutObjectText *tobj = (wxLayoutObjectText *)&obj;
- String & str = tobj->GetText();
- String sstr = str.substr(0,offset);
- WXL_VAR(sstr);
- dc.GetTextExtent(sstr,&width,&height,&descent);
- WXL_VAR(width);
- m_CursorCoords = wxPoint(m_CursorCoords.x+width,
- m_CursorCoords.y);
- m_CursorSize = wxPoint(2,height);
- }
- else if(obj.GetType() == WXLO_TYPE_LINEBREAK)
+#ifdef WXLAYOUT_USE_CARET
+ m_caret->Move(coords);
+#else // !WXLAYOUT_USE_CARET
+ dc.SetBrush(*wxBLACK_BRUSH);
+ dc.SetLogicalFunction(wxXOR);
+ dc.SetPen(wxPen(*wxBLACK,1,wxSOLID));
+ if(active)
{
- m_CursorCoords = wxPoint(0, m_CursorCoords.y);
- m_CursorSize = wxPoint(2,baseLineSkip);
+ dc.DrawRectangle(coords.x, coords.y,
+ m_CursorSize.x, m_CursorSize.y);
+ SetUpdateRect(coords.x, coords.y);
+ SetUpdateRect(coords.x+m_CursorSize.x, coords.y+m_CursorSize.y);
}
else
{
- // this is not necessarily the most "beautiful" solution:
- //cursorPosition = wxPoint(position.x, position.y);
- //cursorSize = wxPoint(size.x > 0 ? size.x : 1,size.y > 0 ? size.y : baseLineSkip);
- m_CursorCoords = wxPoint(m_CursorCoords.x+obj.GetSize().x, m_CursorCoords.y);
- m_CursorSize = wxPoint(2, obj.GetSize().y);
- if(m_CursorSize.y < 1) m_CursorSize.y = baseLineSkip;
+ dc.DrawLine(coords.x, coords.y+m_CursorSize.y-1,
+ coords.x, coords.y);
+ SetUpdateRect(coords.x, coords.y+m_CursorSize.y-1);
+ SetUpdateRect(coords.x, coords.y);
}
- WXL_VAR(m_CursorCoords.x);
- m_CursorMoved = false; // coords are valid
+ dc.SetLogicalFunction(wxCOPY);
+ //dc.SetBrush(wxNullBrush);
+#endif // WXLAYOUT_USE_CARET/!WXLAYOUT_USE_CARET
}
void
-wxLayoutList::DrawCursor(wxDC &dc, bool erase)
+wxLayoutList::SetUpdateRect(CoordType x, CoordType y)
{
- if(erase)
- {
- //dc.SetBrush(*wxWHITE_BRUSH);
- //dc.SetPen(wxPen(*wxWHITE,1,wxSOLID));
- //dc.DrawRectangle(m_CursorCoords.x, m_CursorCoords.y, m_CursorSize.x, m_CursorSize.y);
- dc.Blit(m_CursorCoords.x, m_CursorCoords.y, m_CursorSize.x,
- m_CursorSize.y, &m_CursorMemDC,
- 0, 0, 0, 0);
- }
+ if(m_UpdateRectValid)
+ GrowRect(m_UpdateRect, x, y);
else
{
- if(IsDirty() || CursorMoved())
- {
- DrawCursor(dc,true);
- Layout(dc);
- }
- // Save background:
- wxBitmap bm(m_CursorSize.x+1,m_CursorSize.y+1);
- m_CursorMemDC.SelectObject(bm);
- m_CursorMemDC.Blit(0, 0, m_CursorSize.x, m_CursorSize.y,
- &dc, m_CursorCoords.x,
- m_CursorCoords.y, 0, 0);
- dc.SetBrush(*wxBLACK_BRUSH);
- dc.SetPen(wxPen(*wxBLACK,1,wxSOLID));
- dc.DrawRectangle(m_CursorCoords.x, m_CursorCoords.y,
- m_CursorSize.x, m_CursorSize.y);
+ m_UpdateRect.x = x;
+ m_UpdateRect.y = y;
+ m_UpdateRect.width = 4; // large enough to avoid surprises from
+ m_UpdateRect.height = 4;// wxGTK :-)
+ m_UpdateRectValid = true;
}
}
-
-
-
-
-
-
-#ifdef WXLAYOUT_DEBUG
void
-wxLayoutList::Debug(void)
+wxLayoutList::StartSelection(wxPoint cpos)
{
- CoordType offs;
- wxLayoutObjectList::iterator i;
-
- wxLogDebug("------------------------debug start-------------------------");
- for(i = begin(); i != end(); i++)
- (*i)->Debug();
- wxLogDebug("-----------------------debug end----------------------------");
-
- // show current object:
- ShowCurrentObject();
- i = FindCurrentObject(&offs);
- wxLogDebug(" line length: %l", (long int) GetLineLength(i,offs));
- if(i == end())
- {
- wxLogDebug("<<no object found>>");
- return; // FIXME we should set cursor position to maximum allowed
- // value then
- }
- if((*i)->GetType() == WXLO_TYPE_TEXT)
- wxLogDebug(" \"%s\", offs=%d",((wxLayoutObjectText *)(*i))->GetText().c_str(), (int) offs);
- else
- wxLogDebug(g_aTypeStrings[(*i)->GetType()]);
-
+ if(cpos.x == -1)
+ cpos = m_CursorPos;
+ WXLO_DEBUG(("Starting selection at %ld/%ld", cpos.x, cpos.y));
+ m_Selection.m_CursorA = cpos;
+ m_Selection.m_CursorB = cpos;
+ m_Selection.m_selecting = true;
+ m_Selection.m_valid = false;
}
void
-wxLayoutList::ShowCurrentObject()
+wxLayoutList::ContinueSelection(wxPoint cpos)
{
- CoordType offs;
- wxLayoutObjectList::iterator i = FindCurrentObject(&offs);
-
- wxLayoutDebug("Cursor is at (%d, %d)",
- m_CursorPosition.x, m_CursorPosition.y);
-
- i = FindCurrentObject(&offs);
- wxLogDebug(" Line length: %d", GetLineLength(i));
-
- if(i == end())
+ if(cpos.x == -1)
+ cpos = m_CursorPos;
+ wxASSERT(m_Selection.m_selecting == true);
+ wxASSERT(m_Selection.m_valid == false);
+ WXLO_DEBUG(("Continuing selection at %ld/%ld", cpos.x, cpos.y));
+ if(m_Selection.m_CursorB <= cpos)
+ m_Selection.m_CursorB = cpos;
+ else
+ m_Selection.m_CursorA = cpos;
+ // We always want m_CursorA <= m_CursorB!
+ if(! (m_Selection.m_CursorA <= m_Selection.m_CursorB))
{
- wxLogDebug("<<no object found>>");
- return; // FIXME we should set cursor position to maximum allowed
-// value then
+ wxPoint help = m_Selection.m_CursorB;
+ m_Selection.m_CursorB = m_Selection.m_CursorA;
+ m_Selection.m_CursorA = help;
}
- if((*i)->GetType() == WXLO_TYPE_TEXT)
- wxLogDebug(" \"%s\", offs: %d",
- ((wxLayoutObjectText *)(*i))->GetText().c_str(), offs);
- else
- wxLogDebug(" %s", TypeString((*i)->GetType()));
}
-#endif
-
-/******************** editing stuff ********************/
-
-// don't change this, I know how to optimise this and will do it real
-// soon (KB)
-
-/*
- * FindObjectCursor:
- * Finds the object belonging to a given cursor position cpos and
- * returns an iterator to that object and stores the relative cursor
- * position in offset.
- *
- * For linebreaks, the offset can be 0=before or 1=after.
- *
- * If the cpos coordinates don't exist, they are modified.
- */
+void
+wxLayoutList::EndSelection(wxPoint cpos)
+{
+ if(cpos.x == -1)
+ cpos = m_CursorPos;
+ ContinueSelection(cpos);
+ WXLO_DEBUG(("Ending selection at %ld/%ld", cpos.x, cpos.y));
+ m_Selection.m_selecting = false;
+ m_Selection.m_valid = true;
+}
-wxLayoutObjectList::iterator
-wxLayoutList::FindObjectCursor(wxPoint *cpos, CoordType *offset)
-{
- wxPoint object = wxPoint(0,0); // runs along the objects
- CoordType width = 0;
- wxLayoutObjectList::iterator i, begin_it;
- int go_up;
-
-//#ifdef WXLAYOUT_DEBUG
-// wxLayoutDebug("Looking for object at (%d, %d)", cpos->x, cpos->y);
-//#endif
-
- // optimisation: compare to last looked at object:
- if(cpos->y > m_FoundCursor.y || (cpos->y == m_FoundCursor.y &&
- cpos->x >= m_FoundCursor.x))
- go_up = 1;
- else
- go_up = 0;
- //broken at the moment
- //begin_it = m_FoundIterator;
- //m_FoundCursor = *cpos;
- begin_it = begin();
- go_up = 1;
- for(i = begin_it; i != end() && object.y <= cpos->y; )
- {
- width = (**i).CountPositions();
- if(cpos->y == object.y) // a possible candidate
- {
- if((**i).GetType() ==WXLO_TYPE_LINEBREAK)
- {
- if(cpos->x == object.x)
- {
- if(offset) *offset = 0;
- return m_FoundIterator = i;
- }
- if(offset) *offset=1;
- cpos->x = object.x;
- return m_FoundIterator = i;
- }
- if(cpos->x >= object.x && cpos->x <= object.x+width) // overlap
- {
- if(offset) *offset = cpos->x-object.x;
-//#ifdef WXLAYOUT_DEBUG
-// wxLayoutDebug(" found object at (%d, %d), type: %s",
-// object.x, object.y, TypeString((*i)->GetType()));
-//#endif
- return m_FoundIterator = i;
- }
- }
- // no overlap, increment coordinates
- object.x += width;
- if((**i).GetType() == WXLO_TYPE_LINEBREAK)
- {
- object.x = 0;
- object.y++;
- }
- if(go_up)
- i++;
- else
- i--;
- }//for
-//#ifdef WXLAYOUT_DEBUG
-// wxLayoutDebug(" not found");
-//#endif
-// return last object, coordinates of that one:
- i = tail();
- if(i == end())
- return m_FoundIterator = i;
- if((**i).GetType()==WXLO_TYPE_LINEBREAK)
- {
- if(offset)
- *offset = 1;
- return m_FoundIterator = i;
- }
- cpos->x = object.x; // would be the coordinate of next object
- cpos->y = object.y;
- cpos->x += width; // last object's width
- if(*offset) *offset = cpos->x-object.x;
- return m_FoundIterator = i; // not found
+bool
+wxLayoutList::IsSelecting(void)
+{
+ return m_Selection.m_selecting;
}
-wxLayoutObjectList::iterator
-wxLayoutList::FindCurrentObject(CoordType *offset)
+bool
+wxLayoutList::IsSelected(const wxPoint &cursor)
{
- wxLayoutObjectList::iterator obj = end();
-
- obj = FindObjectCursor(&m_CursorPosition, offset);
- if(obj == end()) // not ideal yet
- {
- obj = tail();
- if(obj != end()) // tail really exists
- *offset = (*obj)->CountPositions(); // at the end of it
- }
- return obj;
+ if(! m_Selection.m_valid && ! m_Selection.m_selecting)
+ return false;
+ return m_Selection.m_CursorA <= cursor
+ && cursor <= m_Selection.m_CursorB;
}
-bool
-wxLayoutList::MoveCursor(int dx, int dy)
+
+/** Tests whether this layout line is selected and needs
+ highlighting.
+ @param line to test for
+ @return 0 = not selected, 1 = fully selected, -1 = partially
+ selected
+ */
+int
+wxLayoutList::IsSelected(const wxLayoutLine *line, CoordType *from,
+ CoordType *to)
{
- CoordType offs, lineLength;
- wxLayoutObjectList::iterator i;
+ wxASSERT(line); wxASSERT(to); wxASSERT(from);
- m_CursorMoved = true;
-
- bool rc = true; // have we moved?
+ if(! m_Selection.m_valid && ! m_Selection.m_selecting)
+ return 0;
- if(dy > 0 && m_CursorPosition.y < m_MaxLine)
- m_CursorPosition.y += dy;
- else if(dy < 0 && m_CursorPosition.y > 0)
- m_CursorPosition.y += dy; // dy is negative
- if(m_CursorPosition.y < 0)
- {
- m_CursorPosition.y = 0;
- rc = false;
- }
- else if (m_CursorPosition.y > m_MaxLine)
+ CoordType y = line->GetLineNumber();
+ if(m_Selection.m_CursorA.y < y && m_Selection.m_CursorB.y > y)
+ return 1;
+ else if(m_Selection.m_CursorA.y == y)
{
- m_CursorPosition.y = m_MaxLine;
- rc = false;
- }
-
- while(dx > 0)
- {
- i = FindCurrentObject(&offs);
- lineLength = GetLineLength(i,offs);
- if(m_CursorPosition.x < lineLength)
- {
- m_CursorPosition.x ++;
- dx--;
- continue;
- }
+ *from = m_Selection.m_CursorA.x;
+ if(m_Selection.m_CursorB.y == y)
+ *to = m_Selection.m_CursorB.x;
else
- {
- if(m_CursorPosition.y < m_MaxLine)
- {
- m_CursorPosition.y++;
- m_CursorPosition.x = 0;
- dx--;
- }
- else
- {
- rc = false;
- break; // cannot move there
- }
- }
+ *to = line->GetLength();
+ return -1;
}
- while(dx < 0)
+ else if(m_Selection.m_CursorB.y == y)
{
- if(m_CursorPosition.x > 0)
- {
- m_CursorPosition.x --;
- dx++;
- }
+ *to = m_Selection.m_CursorB.x;
+ if(m_Selection.m_CursorA.y == y)
+ *from = m_Selection.m_CursorA.x;
else
- {
- if(m_CursorPosition.y > 0)
- {
- m_CursorPosition.y --;
- m_CursorPosition.x = 0;
- i = FindCurrentObject(&offs);
- lineLength = GetLineLength(i,offs);
- m_CursorPosition.x = lineLength;
- dx++;
- continue;
- }
- else
- {
- rc = false;
- break; // cannot move left any more
- }
- }
- }
-// final adjustment:
- i = FindCurrentObject(&offs);
- lineLength = GetLineLength(i,offs);
- if(m_CursorPosition.x > lineLength)
- {
- m_CursorPosition.x = lineLength;
- rc = false;
+ *from = 0;
+ return -1;
}
-#ifdef WXLAYOUT_DEBUG
- ShowCurrentObject();
-#endif
- return rc;
+ else
+ return 0;
}
void
-wxLayoutList::Delete(CoordType count)
+wxLayoutList::DeleteSelection(void)
{
- WXL_TRACE(Delete);
-
- if(!m_Editable)
+ if(! m_Selection.m_valid)
return;
- WXL_VAR(count);
+ m_Selection.m_valid = false;
- m_bModified = true;
-
- CoordType offs;
- wxLayoutObjectList::iterator i;
-
- do
+ // Only delete part of the current line?
+ if(m_Selection.m_CursorA.y == m_Selection.m_CursorB.y)
{
- i = FindCurrentObject(&offs);
- startover: // ugly, but easiest way to do it
- if(i == end())
- return; // we cannot delete anything more
-
-/* Here we need to treat linebreaks differently.
- If offs==0 we are before the linebreak, otherwise behind. */
- if((*i)->GetType() == WXLO_TYPE_LINEBREAK)
- {
- if(offs == 0)
- {
- m_MaxLine--;
- erase(i);
- count--;
- continue; // we're done
- }
- else // delete the object behind the linebreak
- {
- i++; // we increment and continue as normal
- offs=0;
- goto startover;
- }
- }
- else if((*i)->GetType() == WXLO_TYPE_TEXT)
- {
- wxLayoutObjectText *tobj = (wxLayoutObjectText *)*i;
- CoordType len = tobj->CountPositions();
-// If we find the end of a text object, this means that we
-// have to delete from the object following it.
- if(len == offs)
- {
- i++;
- offs = 0;
- goto startover;
- }
- else if(len <= count) // delete this object
- {
- count -= len;
- erase(i);
- continue;
- }
- else
- {
- len = count;
- tobj->GetText().erase(offs,len);
- return; // we are done
- }
- }
- else// all other objects: delete the object
-// this only works as expected if the non-text object has 0/1
-// as offset values. Not tested with "longer" objects.
- {
- CoordType len = (*i)->CountPositions();
- if(offs == 0)
- {
- count = count > len ? count -= len : 0;
- erase(i); // after this, i is the iterator for the following object
- continue;
- }
- else // delete the following object
- {
- i++; // we increment and continue as normal
- offs=0;
- goto startover;
- }
- }
+ MoveCursorTo(m_Selection.m_CursorA);
+ Delete(m_Selection.m_CursorB.x - m_Selection.m_CursorA.x);
+ return;
}
- while(count && i != end());
+
+
+ wxLayoutLine
+ * firstLine = NULL,
+ * lastLine = NULL;
+
+ for(firstLine = m_FirstLine;
+ firstLine && firstLine->GetLineNumber() < m_Selection.m_CursorA.y;
+ firstLine=firstLine->GetNextLine())
+ ;
+ if(!firstLine || firstLine->GetLineNumber() != m_Selection.m_CursorA.y)
+ return;
+
+
+ for(lastLine = m_FirstLine;
+ lastLine && lastLine->GetLineNumber() < m_Selection.m_CursorB.y;
+ lastLine=lastLine->GetNextLine())
+ ;
+ if(!lastLine || lastLine->GetLineNumber() != m_Selection.m_CursorB.y)
+ return;
+
+
+ // We now know that the two lines are different:
+
+ // First, delete what's left of this line:
+ MoveCursorTo(m_Selection.m_CursorA);
+ DeleteToEndOfLine();
+
+ wxLayoutLine *nextLine = firstLine->GetNextLine();
+ while(nextLine && nextLine != lastLine)
+ nextLine = nextLine->DeleteLine(false, this);
+
+ // Now nextLine = lastLine;
+ Delete(1); // This joins firstLine and nextLine
+ Delete(m_Selection.m_CursorB.x); // This deletes the first x
+ // positions
+
+ /// Recalculate:
+ firstLine->RecalculatePositions(1, this);
+}
+
+/// Starts highlighting the selection
+void
+wxLayoutList::StartHighlighting(wxDC &dc)
+{
+#if SHOW_SELECTIONS
+ dc.SetTextForeground(m_CurrentSetting.m_bg);
+ dc.SetTextBackground(m_CurrentSetting.m_fg);
+ dc.SetBackgroundMode(wxSOLID);
+#endif
}
+/// Ends highlighting the selection
void
-wxLayoutList::Insert(wxLayoutObjectBase *obj)
+wxLayoutList::EndHighlighting(wxDC &dc)
{
- wxCHECK_RET( obj, "no object to insert" );
+#if SHOW_SELECTIONS
+ dc.SetTextForeground(m_CurrentSetting.m_fg);
+ dc.SetTextBackground(m_CurrentSetting.m_bg);
+ dc.SetBackgroundMode(wxTRANSPARENT);
+#endif
+}
- m_bModified = true;
- CoordType offs;
- wxLayoutObjectList::iterator i = FindCurrentObject(&offs);
+wxLayoutList *
+wxLayoutList::Copy(const wxPoint &from,
+ const wxPoint &to)
+{
+ wxLayoutLine
+ * firstLine = NULL,
+ * lastLine = NULL;
+
+ for(firstLine = m_FirstLine;
+ firstLine && firstLine->GetLineNumber() < from.y;
+ firstLine=firstLine->GetNextLine())
+ ;
+ if(!firstLine || firstLine->GetLineNumber() != from.y)
+ return NULL;
+
+ for(lastLine = m_FirstLine;
+ lastLine && lastLine->GetLineNumber() < to.y;
+ lastLine=lastLine->GetNextLine())
+ ;
+ if(!lastLine || lastLine->GetLineNumber() != to.y)
+ return NULL;
+
+ if(to <= from)
+ {
+ wxLayoutLine *tmp = firstLine;
+ firstLine = lastLine;
+ lastLine = tmp;
+ }
-// WXL_TRACE(Insert(obj));
+ wxLayoutList *llist = new wxLayoutList();
- if(i == end())
- push_back(obj);
- else if(offs == 0)
- insert(i,obj);
-// do we have to split a text object?
- else if((*i)->GetType() == WXLO_TYPE_TEXT && offs != (*i)->CountPositions())
+ if(firstLine == lastLine)
{
- wxLayoutObjectText *tobj = (wxLayoutObjectText *) *i;
-#ifdef WXLAYOUT_DEBUG
- wxLayoutDebug("text: %s", tobj->GetText().c_str());
- WXL_VAR(offs);
-#endif
- String left = tobj->GetText().substr(0,offs); // get part before cursor
- WXL_VAR(left.c_str());
- tobj->GetText() = tobj->GetText().substr(offs,(*i)->CountPositions()-offs); // keeps the right half
- WXL_VAR(tobj->GetText().c_str());
- insert(i,obj);
- insert(i,new wxLayoutObjectText(left)); // inserts before
+ firstLine->Copy(llist, from.x, to.x);
}
else
{
-// all other cases, append after object:
- wxLayoutObjectList::iterator j = i; // we want to apend after this object
- j++;
- if(j != end())
- insert(j, obj);
- else
- push_back(obj);
+ // Extract objects from first line
+ firstLine->Copy(llist, from.x);
+ llist->LineBreak();
+ // Extract all lines between
+ for(wxLayoutLine *line = firstLine->GetNextLine();
+ line != lastLine;
+ line = line->GetNextLine())
+ {
+ line->Copy(llist);
+ llist->LineBreak();
+ }
+ // Extract objects from last line
+ lastLine->Copy(llist, 0, to.x);
}
-
- m_CursorPosition.x += obj->CountPositions();
- if(obj->GetType() == WXLO_TYPE_LINEBREAK)
- m_MaxLine++;
- m_CursorMoved = true;
+ return llist;
}
-void
-wxLayoutList::Insert(String const &text)
+wxLayoutList *
+wxLayoutList::GetSelection(wxLayoutDataObject *wxlo, bool invalidate)
{
- wxLayoutObjectText *tobj = NULL;
- wxLayoutObjectList::iterator j;
-
-// WXL_TRACE(Insert(text));
-
- if(! m_Editable)
- return;
+ if(! m_Selection.m_valid)
+ {
+ if(m_Selection.m_selecting)
+ EndSelection();
+ else
+ return NULL;
+ }
- m_bModified = true;
+ if(invalidate) m_Selection.m_valid = false;
- CoordType offs;
- wxLayoutObjectList::iterator i = FindCurrentObject(&offs);
+ wxLayoutList *llist = Copy( m_Selection.m_CursorA,
+ m_Selection.m_CursorB );
- if(i == end())
+ if(llist && wxlo) // export as data object, too
{
- Insert(new wxLayoutObjectText(text));
- return;
- }
+ wxString string;
- switch((**i).GetType())
- {
- case WXLO_TYPE_TEXT:
-// insert into an existing text object:
- WXL_TRACE(inserting into existing object);
- tobj = (wxLayoutObjectText *)*i ;
- wxASSERT(tobj);
- tobj->GetText().insert(offs,text);
- break;
- case WXLO_TYPE_LINEBREAK:
- default:
- j = i;
- if(offs == 0) // try to append to previous object
- {
- j--;
- if(j != end() && (**j).GetType() == WXLO_TYPE_TEXT)
- {
- tobj = (wxLayoutObjectText *)*j;
- tobj->GetText()+=text;
- }
- else
- insert(i,new wxLayoutObjectText(text));
- }
- else // cursor after linebreak
+ wxLayoutExportObject *export;
+ wxLayoutExportStatus status(llist);
+ while((export = wxLayoutExport( &status, WXLO_EXPORT_AS_OBJECTS)) != NULL)
{
- j++;
- if(j != end() && (**j).GetType() == WXLO_TYPE_TEXT)
- {
- tobj = (wxLayoutObjectText *)*j;
- tobj->GetText()=text+tobj->GetText();
- }
+ if(export->type == WXLO_EXPORT_EMPTYLINE)
+ ; //FIXME missing support for linebreaks in string format
else
- {
- if(j == end())
- push_back(new wxLayoutObjectText(text));
- else
- insert(j,new wxLayoutObjectText(text));
- }
+ export->content.object->Write(string);
+ delete export;
}
- break;
+
+ wxlo->SetData(string.c_str(), string.Length()+1);
}
- m_CursorPosition.x += strlen(text.c_str());
- m_CursorMoved = true;
+ return llist;
}
-CoordType
-wxLayoutList::GetLineLength(wxLayoutObjectList::iterator i, CoordType offs)
-{
- if(i == end())
- return 0;
- CoordType len = 0;
- if(offs == 0 && (**i).GetType() == WXLO_TYPE_LINEBREAK)
-// we are before a linebrak
- return 0;
-// search backwards for beginning of line:
- while(i != begin() && (*i)->GetType() != WXLO_TYPE_LINEBREAK)
- i--;
- if((*i)->GetType() == WXLO_TYPE_LINEBREAK)
- i++;
-// now we can start counting:
- while(i != end() && (*i)->GetType() != WXLO_TYPE_LINEBREAK)
+#define COPY_SI(what) if(si->what != -1) { m_CurrentSetting.what = si->what; fontChanged = TRUE; }
+
+void
+wxLayoutList::ApplyStyle(wxLayoutStyleInfo *si, wxDC &dc)
+{
+ bool fontChanged = FALSE;
+ COPY_SI(family);
+ COPY_SI(size);
+ COPY_SI(style);
+ COPY_SI(weight);
+ COPY_SI(underline);
+ if(fontChanged)
+ dc.SetFont( m_FontCache.GetFont(m_CurrentSetting) );
+
+ if(si->m_fg_valid)
{
- len += (*i)->CountPositions();
- i++;
+ m_CurrentSetting.m_fg = si->m_fg;
+ dc.SetTextForeground(m_CurrentSetting.m_fg);
+ }
+ if(si->m_bg_valid)
+ {
+ m_CurrentSetting.m_bg = si->m_bg;
+ dc.SetTextBackground(m_CurrentSetting.m_bg);
}
- return len;
}
+
+#ifdef WXLAYOUT_DEBUG
+
void
-wxLayoutList::Clear(int family, int size, int style, int weight,
- int underline, char const *fg, char const *bg)
+wxLayoutList::Debug(void)
{
- m_bModified = true;
- m_CursorMoved = true;
- m_dirty = true; // force redraw/recalc
- wxLayoutObjectList::iterator i = begin();
+ wxLayoutLine *line;
- wxBitmap bm(1,1);
- m_CursorMemDC.SelectObject(bm);
- while(i != end()) // == while valid
- erase(i);
+ for(line = m_FirstLine;
+ line;
+ line = line->GetNextLine())
+ line->Debug();
+}
- // set defaults
- m_FontPtSize = size;
- m_FontUnderline = false;
- m_FontFamily = family;
- m_FontStyle = style;
- m_FontWeight = weight;
- m_ColourFG = wxTheColourDatabase->FindColour(fg);
- m_ColourBG = wxTheColourDatabase->FindColour(bg);
+#endif
- if(! m_ColourFG) m_ColourFG = wxBLACK;
- if(! m_ColourBG) m_ColourBG = wxWHITE;
-
- m_Position = wxPoint(0,0);
- m_CursorPosition = wxPoint(0,0);
- m_MaxLine = 0;
- m_LineHeight = (BASELINESTRETCH*m_FontPtSize)/10;
- m_MaxX = 0; m_MaxY = 0;
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- m_FoundCursor = wxPoint(0,0);
- m_FoundIterator = begin();
-
- if(m_DefaultSetting)
- delete m_DefaultSetting;
+ wxLayoutPrintout
- m_DefaultSetting = new
- wxLayoutObjectCmd(m_FontPtSize,m_FontFamily,m_FontStyle,
- m_FontWeight,m_FontUnderline,
- m_ColourFG, m_ColourBG);
-}
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+wxLayoutPrintout::wxLayoutPrintout(wxLayoutList *llist,
+ wxString const & title)
+:wxPrintout(title)
+{
+ m_llist = llist;
+ m_title = title;
+ // remove any highlighting which could interfere with printing:
+ m_llist->StartSelection();
+ m_llist->EndSelection();
+}
-wxLayoutObjectBase *
-wxLayoutList::Find(wxPoint coords) const
+wxLayoutPrintout::~wxLayoutPrintout()
{
- wxLayoutObjectList::iterator i = begin();
+}
- wxPoint topleft, bottomright;
-
- while(i != end()) // == while valid
+float
+wxLayoutPrintout::ScaleDC(wxDC *dc)
+{
+ // The following bit is taken from the printing sample, let's see
+ // whether it works for us.
+
+ /* You might use THIS code to set the printer DC to ROUGHLY reflect
+ * the screen text size. This page also draws lines of actual length 5cm
+ * on the page.
+ */
+ // Get the logical pixels per inch of screen and printer
+ int ppiScreenX, ppiScreenY;
+ GetPPIScreen(&ppiScreenX, &ppiScreenY);
+ int ppiPrinterX, ppiPrinterY;
+ GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
+
+ if(ppiScreenX == 0) // not yet set, need to guess
{
- wxLayoutObjectBase *object = *i;
- topleft = object->GetPosition();
- if(coords.y >= topleft.y && coords.x >= topleft.x)
- {
- bottomright = topleft;
- bottomright.x += object->GetSize().x;
- bottomright.y += object->GetSize().y;
- if(coords.x <= bottomright.x && coords.y <= bottomright.y)
- return *i;
- }
- i++;
+ ppiScreenX = 100;
+ ppiScreenY = 100;
+ }
+ if(ppiPrinterX == 0) // not yet set, need to guess
+ {
+ ppiPrinterX = 72;
+ ppiPrinterY = 72;
}
- return NULL;
-}
-
-/******************** printing stuff ********************/
+ // This scales the DC so that the printout roughly represents the
+ // the screen scaling. The text point size _should_ be the right size
+ // but in fact is too small for some reason. This is a detail that will
+ // need to be addressed at some point but can be fudged for the
+ // moment.
+ float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
+
+ // Now we have to check in case our real page size is reduced
+ // (e.g. because we're drawing to a print preview memory DC)
+ int pageWidth, pageHeight;
+ int w, h;
+ dc->GetSize(&w, &h);
+ GetPageSizePixels(&pageWidth, &pageHeight);
+ if(pageWidth != 0) // doesn't work always
+ {
+ // If printer pageWidth == current DC width, then this doesn't
+ // change. But w might be the preview bitmap width, so scale down.
+ scale = scale * (float)(w/(float)pageWidth);
+ }
+ dc->SetUserScale(scale, scale);
+ return scale;
+}
bool wxLayoutPrintout::OnPrintPage(int page)
{
wxDC *dc = GetDC();
+
+ ScaleDC(dc);
+
if (dc)
{
- DrawHeader(*dc,wxPoint(m_Margins.left,m_Margins.top/2),wxPoint(m_Margins.right,m_Margins.top),page);
int top, bottom;
top = (page - 1)*m_PrintoutHeight;
bottom = top + m_PrintoutHeight;
// SetDeviceOrigin() doesn't work here, so we need to manually
// translate all coordinates.
- wxPoint translate(m_Margins.left,-top+m_Margins.top);
- m_llist->Draw(*dc,top,bottom,wxLayoutObjectList::iterator(NULL),translate);
+ wxPoint translate(m_Offset.x,m_Offset.y-top);
+ m_llist->Draw(*dc, translate, top, bottom);
return true;
}
else
return false;
}
-bool wxLayoutPrintout::OnBeginDocument(int startPage, int endPage)
-{
- if (!wxPrintout::OnBeginDocument(startPage, endPage))
- return false;
-
- return true;
-}
-
-void
-wxLayoutPrintout::OnPreparePrinting(void)
-{
-
-}
-
-
void wxLayoutPrintout::GetPageInfo(int *minPage, int *maxPage, int *selPageFrom, int *selPageTo)
{
- // ugly hack to get number of pages
+ /* We allocate a temporary wxDC for printing, so that we can
+ determine the correct paper size and scaling. We don't actually
+ print anything on it. */
#ifdef __WXMSW__
- wxPrinterDC psdc(WXLLIST_TEMPFILE,false);
+ wxPrinterDC psdc("","",WXLLIST_TEMPFILE,false);
#else
wxPostScriptDC psdc(WXLLIST_TEMPFILE,false);
#endif
- psdc.GetSize(&m_PageWidth, &m_PageHeight); // that's all we need it for
- // We do 5% margins on top and bottom, and a 5% high header line.
- m_Margins.top = m_PageHeight / 10 ; // 10%, half of it header
- m_Margins.bottom = m_PageHeight - m_PageHeight / 20; // 95%
- // On the sides we reserve 10% each for the margins.
- m_Margins.left = m_PageWidth / 10;
- m_Margins.right = m_PageWidth - m_PageWidth / 10;
+ float scale = ScaleDC(&psdc);
+
+ psdc.GetSize(&m_PageWidth, &m_PageHeight);
+ // This sets a left/top origin of 15% and 20%:
+ m_Offset = wxPoint((15*m_PageWidth)/100, m_PageHeight/20);
// This is the length of the printable area.
- m_PrintoutHeight = m_PageHeight - (int) (m_PageHeight * 0.15);
+ m_PrintoutHeight = m_PageHeight - (int) (m_PageHeight * 0.15);
+ m_PrintoutHeight = (int)( m_PrintoutHeight / scale); // we want to use the real paper height
- //FIXME this is wrong but not used at the moment
- m_PageWidth = m_Margins.right - m_Margins.left;
- m_NumOfPages = (int)( m_llist->GetSize().y / (float)(m_PrintoutHeight) + 0.5);
+ m_NumOfPages = 1 +
+ (int)( m_llist->GetSize().y / (float)(m_PrintoutHeight));
+
*minPage = 1;
*maxPage = m_NumOfPages;
bool wxLayoutPrintout::HasPage(int pageNum)
{
- return pageNum < m_NumOfPages;
+ return pageNum <= m_NumOfPages;
}
-
+/*
+ Stupid wxWindows doesn't draw proper ellipses, so we comment this
+ out. It's a waste of paper anyway.
+*/
+#if 0
void
wxLayoutPrintout::DrawHeader(wxDC &dc,
wxPoint topleft, wxPoint bottomright,
int pageno)
{
// make backups of all essential parameters
- wxBrush *brush = dc.GetBrush();
- wxPen *pen = dc.GetPen();
- wxFont *font = dc.GetFont(),
- *myfont;;
-
+ const wxBrush& brush = dc.GetBrush();
+ const wxPen& pen = dc.GetPen();
+ const wxFont& font = dc.GetFont();
+
dc.SetBrush(*wxWHITE_BRUSH);
dc.SetPen(wxPen(*wxBLACK,0,wxSOLID));
dc.DrawRoundedRectangle(topleft.x,
topleft.y,bottomright.x-topleft.x,
- bottomright.y-topleft.y);
+ bottomright.y-topleft.y);
dc.SetBrush(*wxBLACK_BRUSH);
- myfont = new wxFont((WXLO_DEFAULTFONTSIZE*12)/10,wxSWISS,wxNORMAL,wxBOLD,false,"Helvetica");
- dc.SetFont(*myfont);
+ wxFont myfont = wxFont((WXLO_DEFAULTFONTSIZE*12)/10,
+ wxSWISS,wxNORMAL,wxBOLD,false,"Helvetica");
+ dc.SetFont(myfont);
wxString page;
page = "9999/9999 "; // many pages...
dc.DrawText(m_title, topleft.x+w,topleft.y+h/2);
// restore settings
- dc.SetPen(*pen);
- dc.SetBrush(*brush);
- dc.SetFont(*font);
-
- delete myfont;
+ dc.SetPen(pen);
+ dc.SetBrush(brush);
+ dc.SetFont(font);
}
+#endif
-wxLayoutPrintout *
-wxLayoutList::MakePrintout(wxString const &name)
+wxFont &
+wxFontCache::GetFont(int family, int size, int style, int weight,
+ bool underline)
{
- return new wxLayoutPrintout(*this,name);
+ for(wxFCEList::iterator i = m_FontList.begin();
+ i != m_FontList.end(); i++)
+ if( (**i).Matches(family, size, style, weight, underline) )
+ return (**i).GetFont();
+ // not found:
+ wxFontCacheEntry *fce = new wxFontCacheEntry(family, size, style,
+ weight, underline);
+ m_FontList.push_back(fce);
+ return fce->GetFont();
}
+
projects / wxWidgets.git / blobdiff