/src/libcdr/src/lib/CDROutputElementList.cpp

Source
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
 * This file is part of the libcdr project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include "CDROutputElementList.h"

namespace libcdr
{

namespace
{

static void separateTabsAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)
{
  if (!iface || text.empty())
    return;
  librevenge::RVNGString tmpText;
  librevenge::RVNGString::Iter i(text);
  for (i.rewind(); i.next();)
  {
    if (*(i()) == '\t')
    {
      if (!tmpText.empty())
      {
        if (iface)
          iface->insertText(tmpText);
        tmpText.clear();
      }

      if (iface)
        iface->insertTab();
    }
    else if (*(i()) == '\n')
    {
      if (!tmpText.empty())
      {
        if (iface)
          iface->insertText(tmpText);
        tmpText.clear();
      }

      if (iface)
        iface->insertLineBreak();
    }
    else
    {
      tmpText.append(i());
    }
  }
  if (iface && !tmpText.empty())
    iface->insertText(tmpText);
}

static void separateSpacesAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)
{
  if (!iface)
    return;
  if (text.empty())
  {
    iface->insertText(text);
    return;
  }
  librevenge::RVNGString tmpText;
  int numConsecutiveSpaces = 0;
  librevenge::RVNGString::Iter i(text);
  for (i.rewind(); i.next();)
  {
    if (*(i()) == ' ')
      numConsecutiveSpaces++;
    else
      numConsecutiveSpaces = 0;

    if (numConsecutiveSpaces > 1)
    {
      if (!tmpText.empty())
      {
        separateTabsAndInsertText(iface, tmpText);
        tmpText.clear();
      }

      if (iface)
        iface->insertSpace();
    }
    else
    {
      tmpText.append(i());
    }
  }
  separateTabsAndInsertText(iface, tmpText);
}

} // anonymous namespace

class CDROutputElement
{
public:
  CDROutputElement() {}
  virtual ~CDROutputElement() {}
  virtual void draw(librevenge::RVNGDrawingInterface *painter) = 0;
};


class CDRStyleOutputElement : public CDROutputElement
{
public:
  CDRStyleOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDRStyleOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDRPathOutputElement : public CDROutputElement
{
public:
  CDRPathOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDRPathOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDRGraphicObjectOutputElement : public CDROutputElement
{
public:
  CDRGraphicObjectOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDRGraphicObjectOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDRStartTextObjectOutputElement : public CDROutputElement
{
public:
  CDRStartTextObjectOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDRStartTextObjectOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDROpenParagraphOutputElement : public CDROutputElement
{
public:
  CDROpenParagraphOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDROpenParagraphOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDROpenSpanOutputElement : public CDROutputElement
{
public:
  CDROpenSpanOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDROpenSpanOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};


class CDRInsertTextOutputElement : public CDROutputElement
{
public:
  CDRInsertTextOutputElement(const librevenge::RVNGString &text);
  ~CDRInsertTextOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGString m_text;
};


class CDRCloseSpanOutputElement : public CDROutputElement
{
public:
  CDRCloseSpanOutputElement();
  ~CDRCloseSpanOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
};


class CDRCloseParagraphOutputElement : public CDROutputElement
{
public:
  CDRCloseParagraphOutputElement();
  ~CDRCloseParagraphOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
};


class CDREndTextObjectOutputElement : public CDROutputElement
{
public:
  CDREndTextObjectOutputElement();
  ~CDREndTextObjectOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
};

class CDRStartLayerOutputElement : public CDROutputElement
{
public:
  CDRStartLayerOutputElement(const librevenge::RVNGPropertyList &propList);
  ~CDRStartLayerOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
private:
  librevenge::RVNGPropertyList m_propList;
};

class CDREndLayerOutputElement : public CDROutputElement
{
public:
  CDREndLayerOutputElement();
  ~CDREndLayerOutputElement() override {}
  void draw(librevenge::RVNGDrawingInterface *painter) override;
};

CDRStyleOutputElement::CDRStyleOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDRStyleOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->setStyle(m_propList);
}


CDRPathOutputElement::CDRPathOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDRPathOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->drawPath(m_propList);
}


CDRGraphicObjectOutputElement::CDRGraphicObjectOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDRGraphicObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->drawGraphicObject(m_propList);
}


CDRStartTextObjectOutputElement::CDRStartTextObjectOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDRStartTextObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->startTextObject(m_propList);
}

CDROpenSpanOutputElement::CDROpenSpanOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDROpenSpanOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->openSpan(m_propList);
}


CDROpenParagraphOutputElement::CDROpenParagraphOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDROpenParagraphOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->openParagraph(m_propList);
}


CDRInsertTextOutputElement::CDRInsertTextOutputElement(const librevenge::RVNGString &text) :
  m_text(text) {}

void CDRInsertTextOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    separateSpacesAndInsertText(painter, m_text);
}

CDRCloseSpanOutputElement::CDRCloseSpanOutputElement() {}

void CDRCloseSpanOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->closeSpan();
}


CDRCloseParagraphOutputElement::CDRCloseParagraphOutputElement() {}

void CDRCloseParagraphOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->closeParagraph();
}


CDREndTextObjectOutputElement::CDREndTextObjectOutputElement() {}

void CDREndTextObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->endTextObject();
}


CDREndLayerOutputElement::CDREndLayerOutputElement() {}

void CDREndLayerOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->endLayer();
}


CDRStartLayerOutputElement::CDRStartLayerOutputElement(const librevenge::RVNGPropertyList &propList) :
  m_propList(propList) {}

void CDRStartLayerOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
{
  if (painter)
    painter->startLayer(m_propList);
}


CDROutputElementList::CDROutputElementList()
  : m_elements()
{
}

CDROutputElementList::~CDROutputElementList()
{
}

void CDROutputElementList::draw(librevenge::RVNGDrawingInterface *painter) const
{
  for (const auto &element : m_elements)
    element->draw(painter);
}

void CDROutputElementList::addStyle(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDRStyleOutputElement>(propList));
}

void CDROutputElementList::addPath(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDRPathOutputElement>(propList));
}

void CDROutputElementList::addGraphicObject(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDRGraphicObjectOutputElement>(propList));
}

void CDROutputElementList::addStartTextObject(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDRStartTextObjectOutputElement>(propList));
}

void CDROutputElementList::addOpenParagraph(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDROpenParagraphOutputElement>(propList));
}

void CDROutputElementList::addOpenSpan(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDROpenSpanOutputElement>(propList));
}

void CDROutputElementList::addInsertText(const librevenge::RVNGString &text)
{
  m_elements.push_back(std::make_shared<CDRInsertTextOutputElement>(text));
}

void CDROutputElementList::addCloseSpan()
{
  m_elements.push_back(std::make_shared<CDRCloseSpanOutputElement>());
}

void CDROutputElementList::addCloseParagraph()
{
  m_elements.push_back(std::make_shared<CDRCloseParagraphOutputElement>());
}

void CDROutputElementList::addEndTextObject()
{
  m_elements.push_back(std::make_shared<CDREndTextObjectOutputElement>());
}

void CDROutputElementList::addStartGroup(const librevenge::RVNGPropertyList &propList)
{
  m_elements.push_back(std::make_shared<CDRStartLayerOutputElement>(propList));
}

void CDROutputElementList::addEndGroup()
{
  m_elements.push_back(std::make_shared<CDREndLayerOutputElement>());
}

} // namespace libcdr

/* vim:set shiftwidth=2 softtabstop=2 expandtab: */

Coverage Report

Created: 2026-06-13 06:44

Line	Count	Source
1		/* -- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2		/*
3		* This file is part of the libcdr project.
4		*
5		* This Source Code Form is subject to the terms of the Mozilla Public
6		* License, v. 2.0. If a copy of the MPL was not distributed with this
7		* file, You can obtain one at http://mozilla.org/MPL/2.0/.
8		*/
9
10		#include "CDROutputElementList.h"
11
12		namespace libcdr
13		{
14
15		namespace
16		{
17
18		static void separateTabsAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)
19	360k	{
20	360k	if (!iface \|\| text.empty())
21	442	return;
22	360k	librevenge::RVNGString tmpText;
23	360k	librevenge::RVNGString::Iter i(text);
24	881k	for (i.rewind(); i.next();)
25	521k	{
26	521k	if (*(i()) == '\t')
27	1.24k	{
28	1.24k	if (!tmpText.empty())
29	433	{
30	433	if (iface)
31	433	iface->insertText(tmpText);
32	433	tmpText.clear();
33	433	}
34
35	1.24k	if (iface)
36	1.24k	iface->insertTab();
37	1.24k	}
38	519k	else if (*(i()) == '\n')
39	9.44k	{
40	9.44k	if (!tmpText.empty())
41	3.59k	{
42	3.59k	if (iface)
43	3.59k	iface->insertText(tmpText);
44	3.59k	tmpText.clear();
45	3.59k	}
46
47	9.44k	if (iface)
48	9.44k	iface->insertLineBreak();
49	9.44k	}
50	510k	else
51	510k	{
52	510k	tmpText.append(i());
53	510k	}
54	521k	}
55	360k	if (iface && !tmpText.empty())
56	353k	iface->insertText(tmpText);
57	360k	}
58
59		static void separateSpacesAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)
60	360k	{
61	360k	if (!iface)
62	0	return;
63	360k	if (text.empty())
64	0	{
65	0	iface->insertText(text);
66	0	return;
67	0	}
68	360k	librevenge::RVNGString tmpText;
69	360k	int numConsecutiveSpaces = 0;
70	360k	librevenge::RVNGString::Iter i(text);
71	883k	for (i.rewind(); i.next();)
72	523k	{
73	523k	if (*(i()) == ' ')
74	9.99k	numConsecutiveSpaces++;
75	513k	else
76	513k	numConsecutiveSpaces = 0;
77
78	523k	if (numConsecutiveSpaces > 1)
79	2.25k	{
80	2.25k	if (!tmpText.empty())
81	790	{
82	790	separateTabsAndInsertText(iface, tmpText);
83	790	tmpText.clear();
84	790	}
85
86	2.25k	if (iface)
87	2.25k	iface->insertSpace();
88	2.25k	}
89	521k	else
90	521k	{
91	521k	tmpText.append(i());
92	521k	}
93	523k	}
94	360k	separateTabsAndInsertText(iface, tmpText);
95	360k	}
96
97		} // anonymous namespace
98
99		class CDROutputElement
100		{
101		public:
102	4.36M	CDROutputElement() {}
103	4.36M	virtual ~CDROutputElement() {}
104		virtual void draw(librevenge::RVNGDrawingInterface *painter) = 0;
105		};
106
107
108		class CDRStyleOutputElement : public CDROutputElement
109		{
110		public:
111		CDRStyleOutputElement(const librevenge::RVNGPropertyList &propList);
112	350k	~CDRStyleOutputElement() override {}
113		void draw(librevenge::RVNGDrawingInterface *painter) override;
114		private:
115		librevenge::RVNGPropertyList m_propList;
116		};
117
118
119		class CDRPathOutputElement : public CDROutputElement
120		{
121		public:
122		CDRPathOutputElement(const librevenge::RVNGPropertyList &propList);
123	318k	~CDRPathOutputElement() override {}
124		void draw(librevenge::RVNGDrawingInterface *painter) override;
125		private:
126		librevenge::RVNGPropertyList m_propList;
127		};
128
129
130		class CDRGraphicObjectOutputElement : public CDROutputElement
131		{
132		public:
133		CDRGraphicObjectOutputElement(const librevenge::RVNGPropertyList &propList);
134	5.41k	~CDRGraphicObjectOutputElement() override {}
135		void draw(librevenge::RVNGDrawingInterface *painter) override;
136		private:
137		librevenge::RVNGPropertyList m_propList;
138		};
139
140
141		class CDRStartTextObjectOutputElement : public CDROutputElement
142		{
143		public:
144		CDRStartTextObjectOutputElement(const librevenge::RVNGPropertyList &propList);
145	4.19k	~CDRStartTextObjectOutputElement() override {}
146		void draw(librevenge::RVNGDrawingInterface *painter) override;
147		private:
148		librevenge::RVNGPropertyList m_propList;
149		};
150
151
152		class CDROpenParagraphOutputElement : public CDROutputElement
153		{
154		public:
155		CDROpenParagraphOutputElement(const librevenge::RVNGPropertyList &propList);
156	8.24k	~CDROpenParagraphOutputElement() override {}
157		void draw(librevenge::RVNGDrawingInterface *painter) override;
158		private:
159		librevenge::RVNGPropertyList m_propList;
160		};
161
162
163		class CDROpenSpanOutputElement : public CDROutputElement
164		{
165		public:
166		CDROpenSpanOutputElement(const librevenge::RVNGPropertyList &propList);
167	1.21M	~CDROpenSpanOutputElement() override {}
168		void draw(librevenge::RVNGDrawingInterface *painter) override;
169		private:
170		librevenge::RVNGPropertyList m_propList;
171		};
172
173
174		class CDRInsertTextOutputElement : public CDROutputElement
175		{
176		public:
177		CDRInsertTextOutputElement(const librevenge::RVNGString &text);
178	1.21M	~CDRInsertTextOutputElement() override {}
179		void draw(librevenge::RVNGDrawingInterface *painter) override;
180		private:
181		librevenge::RVNGString m_text;
182		};
183
184
185		class CDRCloseSpanOutputElement : public CDROutputElement
186		{
187		public:
188		CDRCloseSpanOutputElement();
189	0	~CDRCloseSpanOutputElement() override {}
190		void draw(librevenge::RVNGDrawingInterface *painter) override;
191		};
192
193
194		class CDRCloseParagraphOutputElement : public CDROutputElement
195		{
196		public:
197		CDRCloseParagraphOutputElement();
198	0	~CDRCloseParagraphOutputElement() override {}
199		void draw(librevenge::RVNGDrawingInterface *painter) override;
200		};
201
202
203		class CDREndTextObjectOutputElement : public CDROutputElement
204		{
205		public:
206		CDREndTextObjectOutputElement();
207	0	~CDREndTextObjectOutputElement() override {}
208		void draw(librevenge::RVNGDrawingInterface *painter) override;
209		};
210
211		class CDRStartLayerOutputElement : public CDROutputElement
212		{
213		public:
214		CDRStartLayerOutputElement(const librevenge::RVNGPropertyList &propList);
215	1.75k	~CDRStartLayerOutputElement() override {}
216		void draw(librevenge::RVNGDrawingInterface *painter) override;
217		private:
218		librevenge::RVNGPropertyList m_propList;
219		};
220
221		class CDREndLayerOutputElement : public CDROutputElement
222		{
223		public:
224		CDREndLayerOutputElement();
225	0	~CDREndLayerOutputElement() override {}
226		void draw(librevenge::RVNGDrawingInterface *painter) override;
227		};
228
229		CDRStyleOutputElement::CDRStyleOutputElement(const librevenge::RVNGPropertyList &propList) :
230	350k	m_propList(propList) {}
231
232		void CDRStyleOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
233	209k	{
234	209k	if (painter)
235	209k	painter->setStyle(m_propList);
236	209k	}
237
238
239		CDRPathOutputElement::CDRPathOutputElement(const librevenge::RVNGPropertyList &propList) :
240	318k	m_propList(propList) {}
241
242		void CDRPathOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
243	206k	{
244	206k	if (painter)
245	206k	painter->drawPath(m_propList);
246	206k	}
247
248
249		CDRGraphicObjectOutputElement::CDRGraphicObjectOutputElement(const librevenge::RVNGPropertyList &propList) :
250	5.41k	m_propList(propList) {}
251
252		void CDRGraphicObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
253	2.73k	{
254	2.73k	if (painter)
255	2.73k	painter->drawGraphicObject(m_propList);
256	2.73k	}
257
258
259		CDRStartTextObjectOutputElement::CDRStartTextObjectOutputElement(const librevenge::RVNGPropertyList &propList) :
260	4.19k	m_propList(propList) {}
261
262		void CDRStartTextObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
263	2.06k	{
264	2.06k	if (painter)
265	2.06k	painter->startTextObject(m_propList);
266	2.06k	}
267
268		CDROpenSpanOutputElement::CDROpenSpanOutputElement(const librevenge::RVNGPropertyList &propList) :
269	1.21M	m_propList(propList) {}
270
271		void CDROpenSpanOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
272	360k	{
273	360k	if (painter)
274	360k	painter->openSpan(m_propList);
275	360k	}
276
277
278		CDROpenParagraphOutputElement::CDROpenParagraphOutputElement(const librevenge::RVNGPropertyList &propList) :
279	8.24k	m_propList(propList) {}
280
281		void CDROpenParagraphOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
282	3.76k	{
283	3.76k	if (painter)
284	3.76k	painter->openParagraph(m_propList);
285	3.76k	}
286
287
288		CDRInsertTextOutputElement::CDRInsertTextOutputElement(const librevenge::RVNGString &text) :
289	1.21M	m_text(text) {}
290
291		void CDRInsertTextOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
292	360k	{
293	360k	if (painter)
294	360k	separateSpacesAndInsertText(painter, m_text);
295	360k	}
296
297	1.21M	CDRCloseSpanOutputElement::CDRCloseSpanOutputElement() {}
298
299		void CDRCloseSpanOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
300	360k	{
301	360k	if (painter)
302	360k	painter->closeSpan();
303	360k	}
304
305
306	8.24k	CDRCloseParagraphOutputElement::CDRCloseParagraphOutputElement() {}
307
308		void CDRCloseParagraphOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
309	3.76k	{
310	3.76k	if (painter)
311	3.76k	painter->closeParagraph();
312	3.76k	}
313
314
315	4.19k	CDREndTextObjectOutputElement::CDREndTextObjectOutputElement() {}
316
317		void CDREndTextObjectOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
318	2.06k	{
319	2.06k	if (painter)
320	2.06k	painter->endTextObject();
321	2.06k	}
322
323
324	1.75k	CDREndLayerOutputElement::CDREndLayerOutputElement() {}
325
326		void CDREndLayerOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
327	1.67k	{
328	1.67k	if (painter)
329	1.67k	painter->endLayer();
330	1.67k	}
331
332
333		CDRStartLayerOutputElement::CDRStartLayerOutputElement(const librevenge::RVNGPropertyList &propList) :
334	1.75k	m_propList(propList) {}
335
336		void CDRStartLayerOutputElement::draw(librevenge::RVNGDrawingInterface *painter)
337	1.67k	{
338	1.67k	if (painter)
339	1.67k	painter->startLayer(m_propList);
340	1.67k	}
341
342
343		CDROutputElementList::CDROutputElementList()
344	780k	: m_elements()
345	780k	{
346	780k	}
347
348		CDROutputElementList::~CDROutputElementList()
349	1.13M	{
350	1.13M	}
351
352		void CDROutputElementList::draw(librevenge::RVNGDrawingInterface *painter) const
353	214k	{
354	214k	for (const auto &element : m_elements)
355	1.51M	element->draw(painter);
356	214k	}
357
358		void CDROutputElementList::addStyle(const librevenge::RVNGPropertyList &propList)
359	350k	{
360	350k	m_elements.push_back(std::make_shared<CDRStyleOutputElement>(propList));
361	350k	}
362
363		void CDROutputElementList::addPath(const librevenge::RVNGPropertyList &propList)
364	318k	{
365	318k	m_elements.push_back(std::make_shared<CDRPathOutputElement>(propList));
366	318k	}
367
368		void CDROutputElementList::addGraphicObject(const librevenge::RVNGPropertyList &propList)
369	5.41k	{
370	5.41k	m_elements.push_back(std::make_shared<CDRGraphicObjectOutputElement>(propList));
371	5.41k	}
372
373		void CDROutputElementList::addStartTextObject(const librevenge::RVNGPropertyList &propList)
374	4.19k	{
375	4.19k	m_elements.push_back(std::make_shared<CDRStartTextObjectOutputElement>(propList));
376	4.19k	}
377
378		void CDROutputElementList::addOpenParagraph(const librevenge::RVNGPropertyList &propList)
379	8.24k	{
380	8.24k	m_elements.push_back(std::make_shared<CDROpenParagraphOutputElement>(propList));
381	8.24k	}
382
383		void CDROutputElementList::addOpenSpan(const librevenge::RVNGPropertyList &propList)
384	1.21M	{
385	1.21M	m_elements.push_back(std::make_shared<CDROpenSpanOutputElement>(propList));
386	1.21M	}
387
388		void CDROutputElementList::addInsertText(const librevenge::RVNGString &text)
389	1.21M	{
390	1.21M	m_elements.push_back(std::make_shared<CDRInsertTextOutputElement>(text));
391	1.21M	}
392
393		void CDROutputElementList::addCloseSpan()
394	1.21M	{
395	1.21M	m_elements.push_back(std::make_shared<CDRCloseSpanOutputElement>());
396	1.21M	}
397
398		void CDROutputElementList::addCloseParagraph()
399	8.24k	{
400	8.24k	m_elements.push_back(std::make_shared<CDRCloseParagraphOutputElement>());
401	8.24k	}
402
403		void CDROutputElementList::addEndTextObject()
404	4.19k	{
405	4.19k	m_elements.push_back(std::make_shared<CDREndTextObjectOutputElement>());
406	4.19k	}
407
408		void CDROutputElementList::addStartGroup(const librevenge::RVNGPropertyList &propList)
409	1.75k	{
410	1.75k	m_elements.push_back(std::make_shared<CDRStartLayerOutputElement>(propList));
411	1.75k	}
412
413		void CDROutputElementList::addEndGroup()
414	1.75k	{
415	1.75k	m_elements.push_back(std::make_shared<CDREndLayerOutputElement>());
416	1.75k	}
417
418		} // namespace libcdr
419
420		/* vim:set shiftwidth=2 softtabstop=2 expandtab: */