// If this is a floating object, size may not be recalculated
// after floats have been collected in an early stage of Layout.
// So avoid resetting the cache for floating objects during layout.
- if (!IsFloating())
+ if (!IsFloating() || !wxRichTextBuffer::GetFloatingLayoutMode())
SetCachedSize(wxDefaultSize);
SetMaxSize(wxDefaultSize);
SetMinSize(wxDefaultSize);
wxRichTextBuffer* wxRichTextObject::GetBuffer() const
{
const wxRichTextObject* obj = this;
- while (obj && !obj->IsKindOf(CLASSINFO(wxRichTextBuffer)))
+ while (obj && !wxDynamicCast(obj, wxRichTextBuffer))
obj = obj->GetParent();
return wxDynamicCast(obj, wxRichTextBuffer);
}
// If a paragraph, align the whole paragraph.
// Problem with this: if we're limited by a floating object, a line may be centered
// w.r.t. the smaller resulting box rather than the actual available width.
- if (attr.HasAlignment() && !GetContainer()->GetFloatCollector()->HasFloats()) // FIXME: aligning whole paragraph not compatible with floating objects
+ // FIXME: aligning whole paragraph not compatible with floating objects
+ if (attr.HasAlignment() && (!wxRichTextBuffer::GetFloatingLayoutMode() || (GetContainer()->GetFloatCollector() && !GetContainer()->GetFloatCollector()->HasFloats())))
{
// centering, right-justification
if (attr.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
if (!child->GetRange().IsOutside(range))
{
// Floating objects have a zero size within the paragraph.
- if (child->IsFloating())
+ if (child->IsFloating() && wxRichTextBuffer::GetFloatingLayoutMode())
{
if (partialExtents)
{
}
else if (child->IsTopLevel())
{
- if (invalidRange == wxRICHTEXT_NONE)
- child->Invalidate(wxRICHTEXT_NONE);
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && child->IsFloating() && GetBuffer()->GetFloatCollector() && GetBuffer()->GetFloatCollector()->HasFloat(child))
+ {
+ // Don't invalidate subhierarchy if we've already been laid out
+ }
else
- child->Invalidate(wxRICHTEXT_ALL); // All children must be invalidated if within parent range
+ {
+ if (invalidRange == wxRICHTEXT_NONE)
+ child->Invalidate(wxRICHTEXT_NONE);
+ else
+ child->Invalidate(wxRICHTEXT_ALL); // All children must be invalidated if within parent range
+ }
}
else
child->Invalidate(invalidRange);
return wxRICHTEXT_HITTEST_NONE;
int ret = wxRICHTEXT_HITTEST_NONE;
- if (m_floatCollector && (flags & wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS) == 0)
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && m_floatCollector && (flags & wxRICHTEXT_HITTEST_NO_FLOATING_OBJECTS) == 0)
ret = m_floatCollector->HitTest(dc, context, pt, textPosition, obj, flags);
if (ret == wxRICHTEXT_HITTEST_NONE)
/// Draw the floating objects
void wxRichTextParagraphLayoutBox::DrawFloats(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style)
{
- if (m_floatCollector)
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && m_floatCollector)
m_floatCollector->Draw(dc, context, range, selection, rect, descent, style);
}
theseFlags &= ~wxRICHTEXT_DRAW_GUIDELINES;
DrawBoxAttributes(dc, GetBuffer(), attr, thisRect, theseFlags);
- DrawFloats(dc, context, range, selection, rect, descent, style);
+ if (wxRichTextBuffer::GetFloatingLayoutMode())
+ DrawFloats(dc, context, range, selection, rect, descent, style);
+
wxRichTextObjectList::compatibility_iterator node = m_children.GetFirst();
while (node)
{
// Gather information about only those floating objects that will not be formatted,
// after which floats will be gathered per-paragraph during layout.
- UpdateFloatingObjects(availableSpace, node ? node->GetData() : (wxRichTextObject*) NULL);
+ if (wxRichTextBuffer::GetFloatingLayoutMode())
+ UpdateFloatingObjects(availableSpace, node ? node->GetData() : (wxRichTextObject*) NULL);
// A way to force speedy rest-of-buffer layout (the 'else' below)
bool forceQuickLayout = false;
maxHeight = 0; // topMargin + bottomMargin;
// Check the bottom edge of any floating object
- if (GetFloatCollector() && GetFloatCollector()->HasFloats())
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && GetFloatCollector() && GetFloatCollector()->HasFloats())
{
int bottom = GetFloatCollector()->GetLastRectBottom();
if (bottom > maxHeight)
{
style = wxRichTextAttr();
- wxRichTextAttr clashingAttr;
+ wxRichTextAttr clashingAttrPara, clashingAttrChar;
wxRichTextAttr absentAttrPara, absentAttrChar;
wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
{
wxRichTextAttr paraStyle = para->GetCombinedAttributes(true /* use box attributes */);
- CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
+ CollectStyle(style, paraStyle, clashingAttrPara, absentAttrPara);
}
else
{
// First collect paragraph attributes only
wxRichTextAttr paraStyle = para->GetCombinedAttributes();
paraStyle.SetFlags(paraStyle.GetFlags() & wxTEXT_ATTR_PARAGRAPH);
- CollectStyle(style, paraStyle, clashingAttr, absentAttrPara);
+ CollectStyle(style, paraStyle, clashingAttrPara, absentAttrPara);
wxRichTextObjectList::compatibility_iterator childNode = para->GetChildren().GetFirst();
// Now collect character attributes only
childStyle.SetFlags(childStyle.GetFlags() & wxTEXT_ATTR_CHARACTER);
- CollectStyle(style, childStyle, clashingAttr, absentAttrChar);
+ CollectStyle(style, childStyle, clashingAttrChar, absentAttrChar);
}
childNode = childNode->GetNext();
if (childRange.GetLength() == 0 && GetRange().GetLength() == 1)
childRange.SetEnd(childRange.GetEnd()+1);
- if (!childRange.IsOutside(range) && child->IsKindOf(CLASSINFO(wxRichTextPlainText)))
+ if (!childRange.IsOutside(range) && wxDynamicCast(child, wxRichTextPlainText))
{
foundCount ++;
wxRichTextAttr textAttr = para->GetCombinedAttributes(child->GetAttributes());
wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
// Now we need to do numbering
- if (renumber)
+ // Preserve the existing list item continuation bullet style, if any
+ if (para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION))
+ newPara->GetAttributes().SetBulletStyle(newPara->GetAttributes().GetBulletStyle()|wxTEXT_ATTR_BULLET_STYLE_CONTINUATION);
+ else
{
- newPara->GetAttributes().SetBulletNumber(n);
- }
+ if (renumber)
+ {
+ newPara->GetAttributes().SetBulletNumber(n);
+ }
- n ++;
+ n ++;
+ }
}
else if (!newPara->GetAttributes().GetListStyleName().IsEmpty())
{
newPara->GetAttributes().SetListStyleName(wxEmptyString);
newPara->GetAttributes().SetLeftIndent(0, 0);
newPara->GetAttributes().SetBulletText(wxEmptyString);
+ newPara->GetAttributes().SetBulletStyle(0);
// Eliminate the main list-related attributes
newPara->GetAttributes().SetFlags(newPara->GetAttributes().GetFlags() & ~wxTEXT_ATTR_LEFT_INDENT & ~wxTEXT_ATTR_BULLET_STYLE & ~wxTEXT_ATTR_BULLET_NUMBER & ~wxTEXT_ATTR_BULLET_TEXT & wxTEXT_ATTR_LIST_STYLE_NAME);
wxRichTextAttr listStyle(defToUse->GetCombinedStyleForLevel(thisLevel, styleSheet));
wxRichTextApplyStyle(newPara->GetAttributes(), listStyle);
+ // Preserve the existing list item continuation bullet style, if any
+ if (para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION))
+ newPara->GetAttributes().SetBulletStyle(newPara->GetAttributes().GetBulletStyle()|wxTEXT_ATTR_BULLET_STYLE_CONTINUATION);
+
// OK, we've (re)applied the style, now let's get the numbering right.
if (currentLevel == -1)
}
else
{
- levels[currentLevel] ++;
+ if (!(para->GetAttributes().HasBulletStyle() && (para->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION)))
+ levels[currentLevel] ++;
}
newPara->GetAttributes().SetBulletNumber(levels[currentLevel]);
/// position of the paragraph that it had to start looking from.
bool wxRichTextParagraphLayoutBox::FindNextParagraphNumber(wxRichTextParagraph* previousParagraph, wxRichTextAttr& attr) const
{
- if (!previousParagraph->GetAttributes().HasFlag(wxTEXT_ATTR_BULLET_STYLE) || previousParagraph->GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE)
+ // TODO: add GetNextChild/GetPreviousChild to composite
+ // Search for a paragraph that isn't a continuation paragraph (no bullet)
+ while (previousParagraph && previousParagraph->GetAttributes().HasBulletStyle() && previousParagraph->GetAttributes().GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION)
+ {
+ wxRichTextObjectList::compatibility_iterator node = ((wxRichTextCompositeObject*) previousParagraph->GetParent())->GetChildren().Find(previousParagraph);
+ if (node)
+ {
+ node = node->GetPrevious();
+ if (node)
+ previousParagraph = wxDynamicCast(node->GetData(), wxRichTextParagraph);
+ else
+ previousParagraph = NULL;
+ }
+ else
+ previousParagraph = NULL;
+ }
+
+ if (!previousParagraph || !previousParagraph->GetAttributes().HasFlag(wxTEXT_ATTR_BULLET_STYLE) || previousParagraph->GetAttributes().GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE)
return false;
wxRichTextBuffer* buffer = GetBuffer();
DrawBoxAttributes(dc, GetBuffer(), attr, paraRect);
// Draw the bullet, if any
- if (attr.GetBulletStyle() != wxTEXT_ATTR_BULLET_STYLE_NONE)
+ if ((attr.GetBulletStyle() == wxTEXT_ATTR_BULLET_STYLE_NONE) == 0 && (attr.GetBulletStyle() & wxTEXT_ATTR_BULLET_STYLE_CONTINUATION) == 0)
{
if (attr.GetLeftSubIndent() != 0)
{
{
wxRichTextObject* child = node2->GetData();
- if (!child->IsFloating() && child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange) && !lineRange.IsOutside(range))
+ if ((!child->IsFloating() || !wxRichTextBuffer::GetFloatingLayoutMode()) && child->GetRange().GetLength() > 0 && !child->GetRange().IsOutside(lineRange) && !lineRange.IsOutside(range))
{
// Draw this part of the line at the correct position
wxRichTextRange objectRange(child->GetRange());
// Deal with floating objects firstly before the normal layout
wxRichTextBuffer* buffer = GetBuffer();
wxASSERT(buffer);
+
wxRichTextFloatCollector* collector = GetContainer()->GetFloatCollector();
- wxASSERT(collector);
- LayoutFloat(dc, context, rect, style, collector);
+
+ if (wxRichTextBuffer::GetFloatingLayoutMode())
+ {
+ wxASSERT(collector != NULL);
+ if (collector)
+ LayoutFloat(dc, context, rect, parentRect, style, collector);
+ }
wxRichTextAttr attr = GetCombinedAttributes();
context.ApplyVirtualAttributes(attr, this);
// If floating, ignore. We already laid out floats.
// Also ignore if empty object, except if we haven't got any
// size yet.
- if (child->IsFloating() || !child->IsShown() ||
- (child->GetRange().GetLength() == 0 && maxHeight > spaceBeforePara)
+ if ((child->IsFloating() && wxRichTextBuffer::GetFloatingLayoutMode())
+ || !child->IsShown() || (child->GetRange().GetLength() == 0 && maxHeight > spaceBeforePara)
)
{
node = node->GetNext();
lineAscent = wxMax(childSize.y-childDescent, maxAscent);
}
lineHeight = wxMax(lineHeight, (lineDescent + lineAscent));
- wxRect floatAvailableRect = collector->GetAvailableRect(rect.y + currentPosition.y, rect.y + currentPosition.y + lineHeight);
-
- // Adjust availableRect to the space that is available when taking floating objects into account.
- if (floatAvailableRect.x + startOffset > availableRect.x)
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && collector)
{
- int newX = floatAvailableRect.x + startOffset;
- int newW = availableRect.width - (newX - availableRect.x);
- availableRect.x = newX;
- availableRect.width = newW;
- }
+ wxRect floatAvailableRect = collector->GetAvailableRect(rect.y + currentPosition.y, rect.y + currentPosition.y + lineHeight);
- if (floatAvailableRect.width < availableRect.width)
- availableRect.width = floatAvailableRect.width;
+ // Adjust availableRect to the space that is available when taking floating objects into account.
+
+ if (floatAvailableRect.x + startOffset > availableRect.x)
+ {
+ int newX = floatAvailableRect.x + startOffset;
+ int newW = availableRect.width - (newX - availableRect.x);
+ availableRect.x = newX;
+ availableRect.width = newW;
+ }
+
+ if (floatAvailableRect.width < availableRect.width)
+ availableRect.width = floatAvailableRect.width;
+ }
currentPosition.x = availableRect.x - rect.x;
// Line end position shouldn't be the same as the end, or greater.
if (wrapPosition >= GetRange().GetEnd())
- wrapPosition = GetRange().GetEnd()-1;
+ wrapPosition = wxMax(0, GetRange().GetEnd()-1);
// wxLogDebug(wxT("Split at %ld"), wrapPosition);
// If floating, ignore. We already laid out floats.
// Also ignore if empty object, except if we haven't got any
// size yet.
- if (!child->IsFloating() && child->GetRange().GetLength() != 0 && !child->IsKindOf(CLASSINFO(wxRichTextPlainText)))
+ if ((!child->IsFloating() || !wxRichTextBuffer::GetFloatingLayoutMode()) && child->GetRange().GetLength() != 0 && !wxDynamicCast(child, wxRichTextPlainText))
{
if (child->GetCachedSize().x > minWidth)
minWidth = child->GetMinSize().x;
if (!child->GetRange().IsOutside(range))
{
// Floating objects have a zero size within the paragraph.
- if (child->IsFloating())
+ if (child->IsFloating() && wxRichTextBuffer::GetFloatingLayoutMode())
{
if (partialExtents)
{
{
wxRichTextObject* child = node2->GetData();
- if (!child->IsFloating() && !child->GetRange().IsOutside(lineRange))
+ if ((!child->IsFloating() || !wxRichTextBuffer::GetFloatingLayoutMode()) && !child->GetRange().IsOutside(lineRange))
{
wxRichTextRange rangeToUse = lineRange;
rangeToUse.LimitTo(child->GetRange());
sm_defaultTabs.Clear();
}
-void wxRichTextParagraph::LayoutFloat(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, int style, wxRichTextFloatCollector* floatCollector)
+void wxRichTextParagraph::LayoutFloat(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style, wxRichTextFloatCollector* floatCollector)
{
wxRichTextObjectList::compatibility_iterator node = GetChildren().GetFirst();
while (node)
wxRichTextObject* anchored = node->GetData();
if (anchored && anchored->IsFloating() && !floatCollector->HasFloat(anchored))
{
+ int x = 0;
+ wxRichTextAttr parentAttr(GetAttributes());
+ context.ApplyVirtualAttributes(parentAttr, this);
+#if 1
+ // 27-09-2012
+ wxRect availableSpace = GetParent()->GetAvailableContentArea(dc, context, rect);
+
+ anchored->LayoutToBestSize(dc, context, GetBuffer(),
+ parentAttr, anchored->GetAttributes(),
+ parentRect, availableSpace,
+ style);
+ wxSize size = anchored->GetCachedSize();
+#else
wxSize size;
- int descent, x = 0;
+ int descent = 0;
anchored->GetRangeSize(anchored->GetRange(), size, descent, dc, context, style);
+#endif
int offsetY = 0;
if (anchored->GetAttributes().GetTextBoxAttr().GetTop().IsValid())
else if (anchored->GetAttributes().GetTextBoxAttr().GetFloatMode() == wxTEXT_BOX_ATTR_FLOAT_RIGHT)
x = rect.x + rect.width - size.x;
- anchored->SetPosition(wxPoint(x, pos));
+ //anchored->SetPosition(wxPoint(x, pos));
+ anchored->Move(wxPoint(x, pos)); // should move children
anchored->SetCachedSize(size);
floatCollector->CollectFloat(this, anchored);
}
wxString str = m_text;
wxString toRemove = wxRichTextLineBreakChar;
str.Replace(toRemove, wxT(" "));
- if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
+ if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & (wxTEXT_ATTR_EFFECT_CAPITALS|wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)))
str.MakeUpper();
long len = range.GetLength();
int x, y;
if ( textFont.IsOk() )
{
+ if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SMALL_CAPITALS))
+ {
+ textFont.SetPointSize((int) (textFont.GetPointSize()*0.75));
+ wxCheckSetFont(dc, textFont);
+ charHeight = dc.GetCharHeight();
+ }
+
if ( textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SUPERSCRIPT) )
{
if (textFont.IsUsingSizeInPixels())
{
double size = static_cast<double>(textFont.GetPixelSize().y) / wxSCRIPT_MUL_FACTOR;
- textFont.SetPixelSize(wxSize(0, static_cast<int>(size)) );
+ textFont.SetPixelSize(wxSize(0, static_cast<int>(size)));
x = rect.x;
y = rect.y;
}
else
{
double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
- textFont.SetPointSize( static_cast<int>(size) );
+ textFont.SetPointSize(static_cast<int>(size));
x = rect.x;
y = rect.y;
}
double size = static_cast<double>(textFont.GetPixelSize().y) / wxSCRIPT_MUL_FACTOR;
textFont.SetPixelSize(wxSize(0, static_cast<int>(size)));
x = rect.x;
- int sub_height = static_cast<int>( static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
+ int sub_height = static_cast<int>(static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
y = rect.y + (rect.height - sub_height + (descent - m_descent));
}
else
{
double size = static_cast<double>(textFont.GetPointSize()) / wxSCRIPT_MUL_FACTOR;
- textFont.SetPointSize( static_cast<int>(size) );
+ textFont.SetPointSize(static_cast<int>(size));
x = rect.x;
- int sub_height = static_cast<int>( static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
+ int sub_height = static_cast<int>(static_cast<double>(charHeight) / wxSCRIPT_MUL_FACTOR);
y = rect.y + (rect.height - sub_height + (descent - m_descent));
}
wxCheckSetFont(dc, textFont);
wxCheckSetFont(dc, textFont);
bScript = true;
}
+ else if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_SMALL_CAPITALS))
+ {
+ wxFont textFont = font;
+ textFont.SetPointSize((int) (textFont.GetPointSize()*0.75));
+ wxCheckSetFont(dc, textFont);
+ bScript = true;
+ }
else
{
wxCheckSetFont(dc, font);
wxString stringChunk = str.Mid(startPos, (size_t) len);
- if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & wxTEXT_ATTR_EFFECT_CAPITALS))
+ if (textAttr.HasTextEffects() && (textAttr.GetTextEffects() & (wxTEXT_ATTR_EFFECT_CAPITALS|wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)))
stringChunk.MakeUpper();
wxCoord w, h;
/// Returns true if this object can merge itself with the given one.
bool wxRichTextPlainText::CanMerge(wxRichTextObject* object) const
{
- return object->GetClassInfo() == CLASSINFO(wxRichTextPlainText) &&
+ return object->GetClassInfo() == wxCLASSINFO(wxRichTextPlainText) &&
(m_text.empty() || (wxTextAttrEq(GetAttributes(), object->GetAttributes()) && m_properties == object->GetProperties()));
}
wxRichTextRenderer* wxRichTextBuffer::sm_renderer = NULL;
int wxRichTextBuffer::sm_bulletRightMargin = 20;
float wxRichTextBuffer::sm_bulletProportion = (float) 0.3;
+bool wxRichTextBuffer::sm_floatingLayoutMode = true;
/// Initialisation
void wxRichTextBuffer::Init()
wxRichTextObjectPropertiesDialog cellDlg(this, wxGetTopLevelParent(parent), wxID_ANY, caption);
cellDlg.SetAttributes(attr);
- wxRichTextSizePage* sizePage = wxDynamicCast(cellDlg.FindPage(CLASSINFO(wxRichTextSizePage)), wxRichTextSizePage);
+ wxRichTextSizePage* sizePage = wxDynamicCast(cellDlg.FindPage(wxCLASSINFO(wxRichTextSizePage)), wxRichTextSizePage);
if (sizePage)
{
// We don't want position and floating controls for a cell.
// first, but of course this means we'll be doing it twice.
if (!m_buffer->IsDirty() && m_ctrl) // can only do optimisation if the buffer is already laid out correctly
{
- wxSize clientSize = m_ctrl->GetClientSize();
- wxPoint firstVisiblePt = m_ctrl->GetFirstVisiblePoint();
+ wxSize clientSize = m_ctrl->GetUnscaledSize(m_ctrl->GetClientSize());
+ wxPoint firstVisiblePt = m_ctrl->GetUnscaledPoint(m_ctrl->GetFirstVisiblePoint());
int lastY = firstVisiblePt.y + clientSize.y;
wxRichTextParagraph* para = container->GetParagraphAtPosition(GetRange().GetStart());
{
ApplyParagraphs(GetNewParagraphs());
- // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
- // Layout() would stop prematurely at the top level.
- container->InvalidateHierarchy(GetRange());
+ // Invalidate the whole buffer if there were floating objects
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && container->GetFloatingObjectCount() > 0)
+ m_buffer->InvalidateHierarchy(wxRICHTEXT_ALL);
+ else
+ {
+ // InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
+ // Layout() would stop prematurely at the top level.
+ container->InvalidateHierarchy(GetRange());
+ }
UpdateAppearance(GetPosition());
// InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
// Layout() would stop prematurely at the top level.
- container->InvalidateHierarchy(GetRange());
+ // Invalidate the whole buffer if there were floating objects
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && container->GetFloatingObjectCount() > 0)
+ m_buffer->InvalidateHierarchy(wxRICHTEXT_ALL);
+ else
+ container->InvalidateHierarchy(GetRange());
UpdateAppearance(GetPosition());
// InvalidateHierarchy goes up the hierarchy as well as down, otherwise with a nested object,
// Layout() would stop prematurely at the top level.
- container->InvalidateHierarchy(GetRange());
+ // Invalidate the whole buffer if there were floating objects
+ if (wxRichTextBuffer::GetFloatingLayoutMode() && container->GetFloatingObjectCount() > 0)
+ m_buffer->InvalidateHierarchy(wxRICHTEXT_ALL);
+ else
+ container->InvalidateHierarchy(GetRange());
UpdateAppearance(GetPosition());
// Refresh everything if there were floating objects or the container changed size
// (we can't yet optimize in these cases, since more complex interaction with other content occurs)
- if (container->GetFloatingObjectCount() > 0 || (container->GetParent() && containerRect != container->GetRect()))
+ if ((wxRichTextBuffer::GetFloatingLayoutMode() && container->GetFloatingObjectCount() > 0) || (container->GetParent() && containerRect != container->GetRect()))
{
m_ctrl->Refresh(false);
}
{
size_t i;
- wxSize clientSize = m_ctrl->GetClientSize();
- wxPoint firstVisiblePt = m_ctrl->GetFirstVisiblePoint();
+ wxSize clientSize = m_ctrl->GetUnscaledSize(m_ctrl->GetClientSize());
+ wxPoint firstVisiblePt = m_ctrl->GetUnscaledPoint(m_ctrl->GetFirstVisiblePoint());
// Start/end positions
int firstY = 0;
lastY = firstVisiblePt.y + clientSize.y;
// Convert to device coordinates
- wxRect rect(m_ctrl->GetPhysicalPoint(wxPoint(firstVisiblePt.x, firstY)), wxSize(clientSize.x, lastY - firstY));
+ wxRect rect(m_ctrl->GetPhysicalPoint(m_ctrl->GetScaledPoint(wxPoint(firstVisiblePt.x, firstY))), m_ctrl->GetScaledSize(wxSize(clientSize.x, lastY - firstY)));
m_ctrl->RefreshRect(rect);
}
else
// the image so long as the new cached bitmap size hasn't changed.
wxImage image;
- if (resetCache || m_originalImageSize == wxSize(-1, -1))
+ if (resetCache || m_originalImageSize.GetWidth() <= 0 || m_originalImageSize.GetHeight() <= 0)
{
m_imageCache = wxNullBitmap;
// Subtract borders
sz = buffer->GetRichTextCtrl()->GetClientSize();
+ // Use a minimum size to stop images becoming very small
+ sz.x = wxMax(sz.x, 100);
+ sz.y = wxMax(sz.y, 100);
+
wxRect marginRect, borderRect, contentRect, paddingRect, outlineRect;
marginRect = wxRect(0, 0, sz.x, sz.y);
buffer->GetBoxRects(dc, buffer, buffer->GetAttributes(), marginRect, borderRect, contentRect, paddingRect, outlineRect);
width = (int) (float(m_originalImageSize.GetWidth()) * (float(height)/float(m_originalImageSize.GetHeight())));
}
+ // Prevent the use of zero size
+ width = wxMax(1, width);
+ height = wxMax(1, height);
+
if (m_imageCache.IsOk() && m_imageCache.GetWidth() == width && m_imageCache.GetHeight() == height)
{
// Do nothing, we didn't need to change the image cache
{
if (fontSpec.HasFontPixelSize() && !fontSpec.HasFontPointSize())
{
- wxFont font(wxSize(0, fontSize), wxDEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename.c_str());
+ wxFont font(wxSize(0, fontSize), wxFONTFAMILY_DEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename);
if (fontSpec.HasFontStrikethrough() && fontSpec.GetFontStrikethrough())
font.SetStrikethrough(true);
m_hashMap[spec] = font;
}
else
{
- wxFont font(fontSize, wxDEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename.c_str());
+ wxFont font(fontSize, wxFONTFAMILY_DEFAULT, fontSpec.GetFontStyle(), fontSpec.GetFontWeight(), fontSpec.GetFontUnderlined(), facename.c_str());
if (fontSpec.HasFontStrikethrough() && fontSpec.GetFontStrikethrough())
font.SetStrikethrough(true);
long forbiddenFlags = clashingAttr.GetFlags()|absentAttr.GetFlags();
- if (attr.HasFont())
+ // If different font size units are being used, this is a clash.
+ if (((attr.GetFlags() & wxTEXT_ATTR_FONT_SIZE) | (currentStyle.GetFlags() & wxTEXT_ATTR_FONT_SIZE)) == wxTEXT_ATTR_FONT_SIZE)
+ {
+ currentStyle.SetFontSize(0);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_SIZE);
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_SIZE);
+ }
+ else
{
if (attr.HasFontPointSize() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_POINT_SIZE))
{
else
currentStyle.SetFontSize(attr.GetFontSize());
}
+ else if (!attr.HasFontPointSize() && currentStyle.HasFontPointSize())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_POINT_SIZE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_POINT_SIZE);
+ }
if (attr.HasFontPixelSize() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_PIXEL_SIZE))
{
else
currentStyle.SetFontPixelSize(attr.GetFontSize());
}
+ else if (!attr.HasFontPixelSize() && currentStyle.HasFontPixelSize())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_PIXEL_SIZE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_PIXEL_SIZE);
+ }
+ }
- if (attr.HasFontItalic() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_ITALIC))
+ if (attr.HasFontItalic() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_ITALIC))
+ {
+ if (currentStyle.HasFontItalic())
{
- if (currentStyle.HasFontItalic())
+ if (currentStyle.GetFontStyle() != attr.GetFontStyle())
{
- if (currentStyle.GetFontStyle() != attr.GetFontStyle())
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_ITALIC);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_ITALIC);
- }
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_ITALIC);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_ITALIC);
}
- else
- currentStyle.SetFontStyle(attr.GetFontStyle());
}
+ else
+ currentStyle.SetFontStyle(attr.GetFontStyle());
+ }
+ else if (!attr.HasFontItalic() && currentStyle.HasFontItalic())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_ITALIC);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_ITALIC);
+ }
- if (attr.HasFontFamily() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FAMILY))
+ if (attr.HasFontFamily() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FAMILY))
+ {
+ if (currentStyle.HasFontFamily())
{
- if (currentStyle.HasFontFamily())
+ if (currentStyle.GetFontFamily() != attr.GetFontFamily())
{
- if (currentStyle.GetFontFamily() != attr.GetFontFamily())
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FAMILY);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FAMILY);
- }
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FAMILY);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FAMILY);
}
- else
- currentStyle.SetFontFamily(attr.GetFontFamily());
}
+ else
+ currentStyle.SetFontFamily(attr.GetFontFamily());
+ }
+ else if (!attr.HasFontFamily() && currentStyle.HasFontFamily())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FAMILY);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FAMILY);
+ }
- if (attr.HasFontWeight() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_WEIGHT))
+ if (attr.HasFontWeight() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_WEIGHT))
+ {
+ if (currentStyle.HasFontWeight())
{
- if (currentStyle.HasFontWeight())
+ if (currentStyle.GetFontWeight() != attr.GetFontWeight())
{
- if (currentStyle.GetFontWeight() != attr.GetFontWeight())
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_WEIGHT);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_WEIGHT);
- }
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_WEIGHT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_WEIGHT);
}
- else
- currentStyle.SetFontWeight(attr.GetFontWeight());
}
+ else
+ currentStyle.SetFontWeight(attr.GetFontWeight());
+ }
+ else if (!attr.HasFontWeight() && currentStyle.HasFontWeight())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_WEIGHT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_WEIGHT);
+ }
- if (attr.HasFontFaceName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FACE))
+ if (attr.HasFontFaceName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_FACE))
+ {
+ if (currentStyle.HasFontFaceName())
{
- if (currentStyle.HasFontFaceName())
- {
- wxString faceName1(currentStyle.GetFontFaceName());
- wxString faceName2(attr.GetFontFaceName());
+ wxString faceName1(currentStyle.GetFontFaceName());
+ wxString faceName2(attr.GetFontFaceName());
- if (faceName1 != faceName2)
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FACE);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FACE);
- }
+ if (faceName1 != faceName2)
+ {
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FACE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FACE);
}
- else
- currentStyle.SetFontFaceName(attr.GetFontFaceName());
}
+ else
+ currentStyle.SetFontFaceName(attr.GetFontFaceName());
+ }
+ else if (!attr.HasFontFaceName() && currentStyle.HasFontFaceName())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_FACE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_FACE);
+ }
- if (attr.HasFontUnderlined() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_UNDERLINE))
+ if (attr.HasFontUnderlined() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_UNDERLINE))
+ {
+ if (currentStyle.HasFontUnderlined())
{
- if (currentStyle.HasFontUnderlined())
+ if (currentStyle.GetFontUnderlined() != attr.GetFontUnderlined())
{
- if (currentStyle.GetFontUnderlined() != attr.GetFontUnderlined())
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_UNDERLINE);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_UNDERLINE);
- }
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_UNDERLINE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_UNDERLINE);
}
- else
- currentStyle.SetFontUnderlined(attr.GetFontUnderlined());
}
+ else
+ currentStyle.SetFontUnderlined(attr.GetFontUnderlined());
+ }
+ else if (!attr.HasFontUnderlined() && currentStyle.HasFontUnderlined())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_UNDERLINE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_UNDERLINE);
+ }
- if (attr.HasFontStrikethrough() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_STRIKETHROUGH))
+ if (attr.HasFontStrikethrough() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_FONT_STRIKETHROUGH))
+ {
+ if (currentStyle.HasFontStrikethrough())
{
- if (currentStyle.HasFontStrikethrough())
+ if (currentStyle.GetFontStrikethrough() != attr.GetFontStrikethrough())
{
- if (currentStyle.GetFontStrikethrough() != attr.GetFontStrikethrough())
- {
- // Clash of attr - mark as such
- clashingAttr.AddFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
- currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
- }
+ // Clash of attr - mark as such
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
}
- else
- currentStyle.SetFontStrikethrough(attr.GetFontStrikethrough());
}
+ else
+ currentStyle.SetFontStrikethrough(attr.GetFontStrikethrough());
+ }
+ else if (!attr.HasFontStrikethrough() && currentStyle.HasFontStrikethrough())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_FONT_STRIKETHROUGH);
}
if (attr.HasTextColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TEXT_COLOUR))
else
currentStyle.SetTextColour(attr.GetTextColour());
}
+ else if (!attr.HasTextColour() && currentStyle.HasTextColour())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_TEXT_COLOUR);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_TEXT_COLOUR);
+ }
if (attr.HasBackgroundColour() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BACKGROUND_COLOUR))
{
else
currentStyle.SetBackgroundColour(attr.GetBackgroundColour());
}
+ else if (!attr.HasBackgroundColour() && currentStyle.HasBackgroundColour())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_BACKGROUND_COLOUR);
+ }
if (attr.HasAlignment() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_ALIGNMENT))
{
else
currentStyle.SetAlignment(attr.GetAlignment());
}
+ else if (!attr.HasAlignment() && currentStyle.HasAlignment())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_ALIGNMENT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_ALIGNMENT);
+ }
if (attr.HasTabs() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_TABS))
{
else
currentStyle.SetTabs(attr.GetTabs());
}
+ else if (!attr.HasTabs() && currentStyle.HasTabs())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_TABS);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_TABS);
+ }
if (attr.HasLeftIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LEFT_INDENT))
{
else
currentStyle.SetLeftIndent(attr.GetLeftIndent(), attr.GetLeftSubIndent());
}
+ else if (!attr.HasLeftIndent() && currentStyle.HasLeftIndent())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_LEFT_INDENT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_LEFT_INDENT);
+ }
if (attr.HasRightIndent() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_RIGHT_INDENT))
{
else
currentStyle.SetRightIndent(attr.GetRightIndent());
}
+ else if (!attr.HasRightIndent() && currentStyle.HasRightIndent())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_RIGHT_INDENT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_RIGHT_INDENT);
+ }
if (attr.HasParagraphSpacingAfter() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_AFTER))
{
else
currentStyle.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter());
}
+ else if (!attr.HasParagraphSpacingAfter() && currentStyle.HasParagraphSpacingAfter())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_AFTER);
+ }
if (attr.HasParagraphSpacingBefore() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARA_SPACING_BEFORE))
{
else
currentStyle.SetParagraphSpacingBefore(attr.GetParagraphSpacingBefore());
}
+ else if (!attr.HasParagraphSpacingBefore() && currentStyle.HasParagraphSpacingBefore())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_PARA_SPACING_BEFORE);
+ }
if (attr.HasLineSpacing() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LINE_SPACING))
{
else
currentStyle.SetLineSpacing(attr.GetLineSpacing());
}
+ else if (!attr.HasLineSpacing() && currentStyle.HasLineSpacing())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_LINE_SPACING);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_LINE_SPACING);
+ }
if (attr.HasCharacterStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_CHARACTER_STYLE_NAME))
{
else
currentStyle.SetCharacterStyleName(attr.GetCharacterStyleName());
}
+ else if (!attr.HasCharacterStyleName() && currentStyle.HasCharacterStyleName())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME);
+ }
if (attr.HasParagraphStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_PARAGRAPH_STYLE_NAME))
{
else
currentStyle.SetParagraphStyleName(attr.GetParagraphStyleName());
}
+ else if (!attr.HasParagraphStyleName() && currentStyle.HasParagraphStyleName())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME);
+ }
if (attr.HasListStyleName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_LIST_STYLE_NAME))
{
else
currentStyle.SetListStyleName(attr.GetListStyleName());
}
+ else if (!attr.HasListStyleName() && currentStyle.HasListStyleName())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_LIST_STYLE_NAME);
+ }
if (attr.HasBulletStyle() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_STYLE))
{
else
currentStyle.SetBulletStyle(attr.GetBulletStyle());
}
+ else if (!attr.HasBulletStyle() && currentStyle.HasBulletStyle())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_STYLE);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_STYLE);
+ }
if (attr.HasBulletNumber() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NUMBER))
{
else
currentStyle.SetBulletNumber(attr.GetBulletNumber());
}
+ else if (!attr.HasBulletNumber() && currentStyle.HasBulletNumber())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NUMBER);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NUMBER);
+ }
if (attr.HasBulletText() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_TEXT))
{
currentStyle.SetBulletFont(attr.GetBulletFont());
}
}
+ else if (!attr.HasBulletText() && currentStyle.HasBulletText())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_TEXT);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_TEXT);
+ }
if (attr.HasBulletName() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_BULLET_NAME))
{
currentStyle.SetBulletName(attr.GetBulletName());
}
}
+ else if (!attr.HasBulletName() && currentStyle.HasBulletName())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_BULLET_NAME);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_BULLET_NAME);
+ }
if (attr.HasURL() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_URL))
{
currentStyle.SetURL(attr.GetURL());
}
}
+ else if (!attr.HasURL() && currentStyle.HasURL())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_URL);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_URL);
+ }
if (attr.HasTextEffects() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_EFFECTS))
{
if (currentStyle.GetTextEffectFlags() == 0)
currentStyle.RemoveFlag(wxTEXT_ATTR_EFFECTS);
}
+ else if (!attr.HasTextEffects() && currentStyle.HasTextEffects())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_EFFECTS);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_EFFECTS);
+ }
if (attr.HasOutlineLevel() && !wxHasStyle(forbiddenFlags, wxTEXT_ATTR_OUTLINE_LEVEL))
{
else
currentStyle.SetOutlineLevel(attr.GetOutlineLevel());
}
+ else if (!attr.HasOutlineLevel() && currentStyle.HasOutlineLevel())
+ {
+ clashingAttr.AddFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
+ currentStyle.RemoveFlag(wxTEXT_ATTR_OUTLINE_LEVEL);
+ }
}
WX_DEFINE_OBJARRAY(wxRichTextVariantArray);
projects / wxWidgets.git / blobdiff