COPASI API  4.16.103
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
CLRenderResolver Class Reference

#include <CLRenderResolver.h>

Collaboration diagram for CLRenderResolver:
Collaboration graph
[legend]

Public Member Functions

 CLRenderResolver (const CLLocalRenderInformation &renderInformation, const CCopasiVector< CLLocalRenderInformation > &localList, const CCopasiVector< CLGlobalRenderInformation > &globalList)
 
 CLRenderResolver (const CLGlobalRenderInformation &renderInformation, const CCopasiVector< CLGlobalRenderInformation > &globalList)
 
const CLColorDefinitiongetBackgroundColor () const
 
const CLColorDefinitiongetColorDefinition (const std::string &id) const
 
const CLGradientBasegetGradientBase (const std::string &id) const
 
const CLLineEndinggetLineEnding (const std::string &id) const
 
const CLStyleresolveStyle (const CLGraphicalObject *pObject) const
 
const CLStyleresolveStyleForKey (const std::string &key) const
 
const CLStyleresolveStyleForRole (const std::string &role) const
 
const CLStyleresolveStyleForType (const std::string &type) const
 
void setDeducedObjectRoles (const std::map< const CLMetabReferenceGlyph *, std::string > &deducedObjectRoles)
 
 ~CLRenderResolver ()
 

Protected Member Functions

void fill_base_maps (const CLRenderInformationBase *pRenderInformation)
 
void fill_global_maps (const CLGlobalRenderInformation *pRenderInformation)
 
void fill_local_maps (const CLLocalRenderInformation *pRenderInformation)
 
void setBackgroundColor ()
 

Protected Attributes

std::map< std::string, const
CLColorDefinition * > 
mColorMap
 
std::map< const
CLMetabReferenceGlyph
*, std::string > 
mDeducedObjectRoles
 
std::map< std::string, const
CLGradientBase * > 
mGradientMap
 
std::map< std::string, const
CLStyle * > 
mKeyMap
 
std::map< std::string, const
CLLineEnding * > 
mLineEndingMap
 
bool mLocal
 
CLColorDefinitionmpBackgroundColor
 
CLRenderInformationBasempRenderInformation
 
std::map< std::string, const
CLStyle * > 
mRoleMap
 
std::map< std::string, const
CLStyle * > 
mTypeMap
 

Private Member Functions

 CLRenderResolver (const CLRenderResolver &)
 
CLRenderResolveroperator= (const CLRenderResolver &)
 

Detailed Description

Display list could be used to cache the styles. For styles with only relative coordinates, a display list for a unit box can be created. The display list only has to be scaled and translated. For styles with only absolute coordinates, a display list can be created, this display list may only be translated, but not scaled later on. Styles that use relative and absolute coordinates are more difficult. Here the bounding box has to be known in order to draw the elements. We could still create one display list per use of the style if that would to create to many display lists. Another optimization option for this would be to collect all usages of the style where the boundinng box has the same size into one. Display lists for line endings could also be useful, the same restriction as for styles apply here.

Definition at line 47 of file CLRenderResolver.h.

Constructor & Destructor Documentation

CLRenderResolver::CLRenderResolver ( const CLRenderResolver )
inlineprivate

Definition at line 108 of file CLRenderResolver.h.

108 {}
CLRenderResolver::CLRenderResolver ( const CLLocalRenderInformation renderInformation,
const CCopasiVector< CLLocalRenderInformation > &  localList,
const CCopasiVector< CLGlobalRenderInformation > &  globalList 
)

Constructor that takes a local render information object as the argument as well as a list of local and a list of global render information objects that are needed to resolve external references.

Definition at line 27 of file CLRenderResolver.cpp.

References fill_base_maps(), fill_local_maps(), mpRenderInformation, and setBackgroundColor().

30  : mpRenderInformation(CLRenderFlattener::flatten_render_information(renderInformation, localList, globalList)),
31  mLocal(true),
32  mpBackgroundColor(NULL)
33 {
34  // fill the maps
36  this->fill_local_maps(dynamic_cast<const CLLocalRenderInformation*>(mpRenderInformation));
37  this->setBackgroundColor();
38 }
void fill_base_maps(const CLRenderInformationBase *pRenderInformation)
static CLGlobalRenderInformation * flatten_render_information(const CLGlobalRenderInformation &globalRenderInformation, const CCopasiVector< CLGlobalRenderInformation > &globalList)
CLColorDefinition * mpBackgroundColor
void fill_local_maps(const CLLocalRenderInformation *pRenderInformation)
CLRenderInformationBase * mpRenderInformation
CLRenderResolver::CLRenderResolver ( const CLGlobalRenderInformation renderInformation,
const CCopasiVector< CLGlobalRenderInformation > &  globalList 
)

Constructor that takes a global render information object as the argument and a list of additional global render information objects that might be needed to resolve external references. means it should contain all information from referenced render information objects.

Definition at line 73 of file CLRenderResolver.cpp.

References fill_base_maps(), fill_global_maps(), mpRenderInformation, and setBackgroundColor().

76  mLocal(false),
77  mpBackgroundColor(NULL)
78 {
79  // fill the maps
81  this->fill_global_maps(dynamic_cast<const CLGlobalRenderInformation*>(this->mpRenderInformation));
82  this->setBackgroundColor();
83 }
void fill_global_maps(const CLGlobalRenderInformation *pRenderInformation)
void fill_base_maps(const CLRenderInformationBase *pRenderInformation)
static CLGlobalRenderInformation * flatten_render_information(const CLGlobalRenderInformation &globalRenderInformation, const CCopasiVector< CLGlobalRenderInformation > &globalList)
CLColorDefinition * mpBackgroundColor
CLRenderInformationBase * mpRenderInformation
CLRenderResolver::~CLRenderResolver ( )

Destructor.

Definition at line 85 of file CLRenderResolver.cpp.

References mpBackgroundColor, and mpRenderInformation.

86 {
87  // we need to delete the render information object that has been created by
88  // the flattener
89  if (this->mpRenderInformation != NULL) delete this->mpRenderInformation;
90 
91  // delete the background color
92  if (this->mpBackgroundColor != NULL) delete this->mpBackgroundColor;
93 }
CLColorDefinition * mpBackgroundColor
CLRenderInformationBase * mpRenderInformation

Member Function Documentation

void CLRenderResolver::fill_base_maps ( const CLRenderInformationBase pRenderInformation)
protected

This method fills the color, gradient and line ending maps for a render information object.

Definition at line 99 of file CLRenderResolver.cpp.

References CLRenderInformationBase::getColorDefinition(), CLRenderInformationBase::getGradientDefinition(), CLLineEnding::getId(), CLGradientBase::getId(), CLColorDefinition::getId(), CLRenderInformationBase::getLineEnding(), CLRenderInformationBase::getNumColorDefinitions(), CLRenderInformationBase::getNumGradientDefinitions(), CLRenderInformationBase::getNumLineEndings(), mColorMap, mGradientMap, and mLineEndingMap.

Referenced by CLRenderResolver().

100 {
101  // fill maps for colors, gradients and line endings
102  size_t i, iMax = pRenderInformation->getNumColorDefinitions();
103  const CLColorDefinition* pColor = NULL;
104 
105  for (i = 0; i < iMax; ++i)
106  {
107  pColor = pRenderInformation->getColorDefinition(i);
108  this->mColorMap[pColor->getId()] = pColor;
109  }
110 
111  iMax = pRenderInformation->getNumGradientDefinitions();
112  const CLGradientBase* pGradient = NULL;
113 
114  for (i = 0; i < iMax; ++i)
115  {
116  pGradient = pRenderInformation->getGradientDefinition(i);
117  this->mGradientMap[pGradient->getId()] = pGradient;
118  }
119 
120  iMax = pRenderInformation->getNumLineEndings();
121  const CLLineEnding* pLineEnding = NULL;
122 
123  for (i = 0; i < iMax; ++i)
124  {
125  pLineEnding = pRenderInformation->getLineEnding(i);
126  this->mLineEndingMap[pLineEnding->getId()] = pLineEnding;
127  }
128 }
std::map< std::string, const CLGradientBase * > mGradientMap
const std::string & getId() const
CLColorDefinition * getColorDefinition(size_t index)
CLLineEnding * getLineEnding(size_t index)
std::map< std::string, const CLColorDefinition * > mColorMap
const std::string & getId() const
CLGradientBase * getGradientDefinition(size_t index)
const std::string & getId() const
std::map< std::string, const CLLineEnding * > mLineEndingMap
void CLRenderResolver::fill_global_maps ( const CLGlobalRenderInformation pRenderInformation)
protected

This method fills the type and role maps for a global render information object.

Definition at line 134 of file CLRenderResolver.cpp.

References CLGlobalRenderInformation::getNumStyles(), CLStyle::getRoleList(), CLGlobalRenderInformation::getStyle(), CLStyle::getTypeList(), mRoleMap, and mTypeMap.

Referenced by CLRenderResolver().

135 {
136  size_t i, iMax = pRenderInformation->getNumStyles();
137  const CLStyle* pStyle = NULL;
138 
139  for (i = 0 ; i < iMax ; ++i)
140  {
141  pStyle = pRenderInformation->getStyle(i);
142  const std::set<std::string>& roleList = pStyle->getRoleList();
143  std::set<std::string>::const_iterator it = roleList.begin(), endit = roleList.end();
144 
145  while (it != endit)
146  {
147  this->mRoleMap[*it] = pStyle;
148  ++it;
149  }
150 
151  const std::set<std::string>& typeList = pStyle->getTypeList();
152 
153  it = typeList.begin();
154 
155  endit = typeList.end();
156 
157  while (it != endit)
158  {
159  this->mTypeMap[*it] = pStyle;
160  ++it;
161  }
162  }
163 }
std::map< std::string, const CLStyle * > mRoleMap
const std::set< std::string > & getRoleList() const
Definition: CLStyle.cpp:201
const std::set< std::string > & getTypeList() const
Definition: CLStyle.cpp:206
std::map< std::string, const CLStyle * > mTypeMap
void CLRenderResolver::fill_local_maps ( const CLLocalRenderInformation pRenderInformation)
protected

This method fills the type, role and id maps for a local render information object.

Definition at line 169 of file CLRenderResolver.cpp.

References CLLocalStyle::getKeyList(), CLLocalRenderInformation::getNumStyles(), CLStyle::getRoleList(), CLLocalRenderInformation::getStyle(), CLStyle::getTypeList(), mKeyMap, mRoleMap, and mTypeMap.

Referenced by CLRenderResolver().

170 {
171  size_t i, iMax = pRenderInformation->getNumStyles();
172  const CLStyle* pStyle = NULL;
173 
174  for (i = 0; i < iMax; ++i)
175  {
176  pStyle = pRenderInformation->getStyle(i);
177  const std::set<std::string>& roleList = pStyle->getRoleList();
178  std::set<std::string>::const_iterator it = roleList.begin(), endit = roleList.end();
179 
180  while (it != endit)
181  {
182  this->mRoleMap[*it] = pStyle;
183  ++it;
184  }
185 
186  const std::set<std::string>& typeList = pStyle->getTypeList();
187 
188  it = typeList.begin();
189 
190  endit = typeList.end();
191 
192  while (it != endit)
193  {
194  this->mTypeMap[*it] = pStyle;
195  ++it;
196  }
197 
198  const CLLocalStyle* pLocalStyle = dynamic_cast<const CLLocalStyle*>(pStyle);
199 
200  const std::set<std::string>& keyList = pLocalStyle->getKeyList();
201 
202  it = keyList.begin();
203 
204  endit = keyList.end();
205 
206  while (it != endit)
207  {
208  this->mKeyMap[*it] = pStyle;
209  ++it;
210  }
211  }
212 }
std::map< std::string, const CLStyle * > mKeyMap
const std::set< std::string > & getKeyList() const
std::map< std::string, const CLStyle * > mRoleMap
CLLocalStyle * getStyle(size_t i)
const std::set< std::string > & getRoleList() const
Definition: CLStyle.cpp:201
const std::set< std::string > & getTypeList() const
Definition: CLStyle.cpp:206
std::map< std::string, const CLStyle * > mTypeMap
const CLColorDefinition * CLRenderResolver::getBackgroundColor ( ) const

Returns the background color.

Definition at line 436 of file CLRenderResolver.cpp.

References mpBackgroundColor.

Referenced by CLLayoutRenderer::draw_layout().

437 {
438  return this->mpBackgroundColor;
439 }
CLColorDefinition * mpBackgroundColor
const CLColorDefinition * CLRenderResolver::getColorDefinition ( const std::string &  id) const

Returns the color definition for a given id.

Definition at line 404 of file CLRenderResolver.cpp.

References mColorMap, and pResult.

Referenced by getColor(), CLLayoutRenderer::resolve_color(), and setBackgroundColor().

405 {
406  const CLColorDefinition* pResult = NULL;
407  std::map<std::string, const CLColorDefinition*>::const_iterator pos = this->mColorMap.find(id);
408 
409  if (pos != this->mColorMap.end())
410  {
411  pResult = pos->second;
412  }
413 
414  return pResult;
415 }
std::map< std::string, const CLColorDefinition * > mColorMap
const CArrayAnnotation * pResult
const CLGradientBase * CLRenderResolver::getGradientBase ( const std::string &  id) const

Returns the gradient definition for a given id.

Definition at line 388 of file CLRenderResolver.cpp.

References mGradientMap, and pResult.

Referenced by getBrush(), getColor(), and CLLayoutRenderer::update_textures_and_colors().

389 {
390  const CLGradientBase* pResult = NULL;
391  std::map<std::string, const CLGradientBase*>::const_iterator pos = this->mGradientMap.find(id);
392 
393  if (pos != this->mGradientMap.end())
394  {
395  pResult = pos->second;
396  }
397 
398  return pResult;
399 }
std::map< std::string, const CLGradientBase * > mGradientMap
const CArrayAnnotation * pResult
const CLLineEnding * CLRenderResolver::getLineEnding ( const std::string &  id) const

Returns the line ending for a given id.

Definition at line 420 of file CLRenderResolver.cpp.

References mLineEndingMap, and pResult.

Referenced by CQRenderConverter::applyStyle(), fillItemFromRenderCurve(), CLLayoutRenderer::map_arrow_head(), and CLLayoutRenderer::update_textures_and_colors().

421 {
422  const CLLineEnding* pResult = NULL;
423  std::map<std::string, const CLLineEnding*>::const_iterator pos = this->mLineEndingMap.find(id);
424 
425  if (pos != this->mLineEndingMap.end())
426  {
427  pResult = pos->second;
428  }
429 
430  return pResult;
431 }
const CArrayAnnotation * pResult
std::map< std::string, const CLLineEnding * > mLineEndingMap
CLRenderResolver& CLRenderResolver::operator= ( const CLRenderResolver )
inlineprivate

Definition at line 109 of file CLRenderResolver.h.

109 {return *this;};
const CLStyle * CLRenderResolver::resolveStyle ( const CLGraphicalObject pObject) const

Method that tries to find the style for the given graphical object that fits best. If no style is found NULL is returned.

Definition at line 219 of file CLRenderResolver.cpp.

References CLMetabReferenceGlyph::ACTIVATOR, CLGraphicalObject::getKey(), CLGraphicalObject::getObjectRole(), CLReferenceGlyph::getRole(), CLMetabReferenceGlyph::getRole(), CLMetabReferenceGlyph::INHIBITOR, mDeducedObjectRoles, CLMetabReferenceGlyph::MODIFIER, pResult, CLMetabReferenceGlyph::PRODUCT, resolveStyleForKey(), resolveStyleForRole(), resolveStyleForType(), CLMetabReferenceGlyph::SIDEPRODUCT, CLMetabReferenceGlyph::SIDESUBSTRATE, and CLMetabReferenceGlyph::SUBSTRATE.

Referenced by CQConnectionGraphicsItem::CQConnectionGraphicsItem(), and CLLayoutRenderer::update_style_information().

220 {
221  const CLStyle* pResult = NULL;
222  // try to resolve the id first
223  pResult = this->resolveStyleForKey(pObject->getKey());
224 
225  // next try the role
226  if (pResult == NULL)
227  {
228  std::string role = pObject->getObjectRole();
229  const CLReferenceGlyph* pRG = dynamic_cast<const CLReferenceGlyph*>(pObject);
230 
231  if (pRG != NULL && role.empty())
232  role = pRG->getRole();
233 
234  const CLMetabReferenceGlyph* pSRG = dynamic_cast<const CLMetabReferenceGlyph*>(pObject);
235 
236  if (pSRG != NULL && role.empty())
237  {
238  CLMetabReferenceGlyph::Role role_t = pSRG->getRole();
239 
240  switch (role_t)
241  {
243  role = "substrate";
244  break;
245 
247  role = "product";
248  break;
249 
251  role = "sidesubstrate";
252  break;
253 
255  role = "sideproduct";
256  break;
257 
259  role = "modifier";
260  break;
261 
263  role = "activator";
264  break;
265 
267  role = "inhibitor";
268  break;
269 
270  default:
271  role = "";
272  }
273 
274  // try if we can find a role in the deduced role map
275  if (role.empty())
276  {
277  std::map<const CLMetabReferenceGlyph*, std::string>::const_iterator pos = this->mDeducedObjectRoles.find(pSRG);
278 
279  if (pos != this->mDeducedObjectRoles.end())
280  {
281  role = pos->second;
282  }
283  }
284  }
285 
286  if (!role.empty())
287  {
288  pResult = this->resolveStyleForRole(role);
289  }
290 
291  // last try the type
292  if (pResult == NULL)
293  {
294  std::string type = "GRAPHICALOBJECT";
295 
296  if (dynamic_cast<const CLCompartmentGlyph*>(pObject))
297  {
298  type = "COMPARTMENTGLYPH";
299  }
300  else if (dynamic_cast<const CLMetabGlyph*>(pObject))
301  {
302  type = "SPECIESGLYPH";
303  }
304  else if (dynamic_cast<const CLReactionGlyph*>(pObject))
305  {
306  type = "REACTIONGLYPH";
307  }
308  else if (dynamic_cast<const CLMetabReferenceGlyph*>(pObject))
309  {
310  type = "SPECIESREFERENCEGLYPH";
311  }
312  else if (dynamic_cast<const CLTextGlyph*>(pObject))
313  {
314  type = "TEXTGLYPH";
315  }
316 
317  pResult = this->resolveStyleForType(type);
318  }
319  }
320 
321  return pResult;
322 }
std::map< const CLMetabReferenceGlyph *, std::string > mDeducedObjectRoles
const std::string & getObjectRole() const
const CLStyle * resolveStyleForType(const std::string &type) const
const std::string & getRole() const
virtual const std::string & getKey() const
const CArrayAnnotation * pResult
const CLStyle * resolveStyleForRole(const std::string &role) const
const CLStyle * resolveStyleForKey(const std::string &key) const
const CLStyle * CLRenderResolver::resolveStyleForKey ( const std::string &  key) const

Method that tries to find the style for the given key. If no style is found NULL is returned.

Definition at line 372 of file CLRenderResolver.cpp.

References mKeyMap, and pResult.

Referenced by resolveStyle().

373 {
374  const CLStyle* pResult = NULL;
375  std::map<std::string, const CLStyle*>::const_iterator pos = this->mKeyMap.find(key);
376 
377  if (pos != this->mKeyMap.end())
378  {
379  pResult = pos->second;
380  }
381 
382  return pResult;
383 }
std::map< std::string, const CLStyle * > mKeyMap
const CArrayAnnotation * pResult
const CLStyle * CLRenderResolver::resolveStyleForRole ( const std::string &  role) const

Method that tries to find the style for the given role. If no style is found NULL is returned.

Definition at line 328 of file CLRenderResolver.cpp.

References mRoleMap, and pResult.

Referenced by resolveStyle().

329 {
330  const CLStyle* pResult = NULL;
331  std::map<std::string, const CLStyle*>::const_iterator pos = this->mRoleMap.find(role);
332 
333  if (pos != this->mRoleMap.end())
334  {
335  pResult = pos->second;
336  }
337 
338  return pResult;
339 }
std::map< std::string, const CLStyle * > mRoleMap
const CArrayAnnotation * pResult
const CLStyle * CLRenderResolver::resolveStyleForType ( const std::string &  type) const

Method that tries to find the style for the given type. If no style is found NULL is returned.

Definition at line 345 of file CLRenderResolver.cpp.

References mTypeMap, and pResult.

Referenced by resolveStyle().

346 {
347  const CLStyle* pResult = NULL;
348  std::map<std::string, const CLStyle*>::const_iterator pos = this->mTypeMap.find(type);
349 
350  if (pos != this->mTypeMap.end())
351  {
352  pResult = pos->second;
353  }
354  // look for a style that is valid for ANY type
355  else
356  {
357  pos = this->mTypeMap.find("ANY");
358 
359  if (pos != this->mTypeMap.end())
360  {
361  pResult = pos->second;
362  }
363  }
364 
365  return pResult;
366 }
const CArrayAnnotation * pResult
std::map< std::string, const CLStyle * > mTypeMap
void CLRenderResolver::setBackgroundColor ( )
protected

Sets the background color from the given render information.

Definition at line 40 of file CLRenderResolver.cpp.

References CLRenderInformationBase::getBackgroundColor(), getColorDefinition(), mpBackgroundColor, mpRenderInformation, and CLColorDefinition::setColorValue().

Referenced by CLRenderResolver().

41 {
42  if (this->mpRenderInformation)
43  {
44  std::string id = this->mpRenderInformation->getBackgroundColor();
45  assert(!id.empty());
46 
47  // must be a color value
48  if (id[0] == '#')
49  {
50  assert(id.length() == 7 || id.length() == 9);
53  }
54  else // must be an id
55  {
56  const CLColorDefinition* pColor = this->getColorDefinition(id);
57 
58  if (pColor)
59  {
60  // make a copy
61  this->mpBackgroundColor = new CLColorDefinition(*pColor);
62  }
63  }
64  }
65 }
const CLColorDefinition * getColorDefinition(const std::string &id) const
const std::string & getBackgroundColor() const
bool setColorValue(const std::string &valueString)
CLColorDefinition * mpBackgroundColor
CLRenderInformationBase * mpRenderInformation
void CLRenderResolver::setDeducedObjectRoles ( const std::map< const CLMetabReferenceGlyph *, std::string > &  deducedObjectRoles)

Sets the deduced object roles.

Definition at line 444 of file CLRenderResolver.cpp.

References mDeducedObjectRoles.

Referenced by CLLayoutRenderer::change_style().

445 {
446  this->mDeducedObjectRoles = deducedObjectRoles;
447 }
std::map< const CLMetabReferenceGlyph *, std::string > mDeducedObjectRoles

Member Data Documentation

std::map<std::string, const CLColorDefinition*> CLRenderResolver::mColorMap
protected

Map to store references to colord definitions based on id.

Definition at line 83 of file CLRenderResolver.h.

Referenced by fill_base_maps(), and getColorDefinition().

std::map<const CLMetabReferenceGlyph*, std::string> CLRenderResolver::mDeducedObjectRoles
protected

Map to store object roles that were deduced by the renderer and are used to suplement the layout information in case a default stylesheet is used.

Definition at line 102 of file CLRenderResolver.h.

Referenced by resolveStyle(), and setDeducedObjectRoles().

std::map<std::string, const CLGradientBase*> CLRenderResolver::mGradientMap
protected

Map to store references to colord definitions based on id.

Definition at line 88 of file CLRenderResolver.h.

Referenced by fill_base_maps(), and getGradientBase().

std::map<std::string, const CLStyle*> CLRenderResolver::mKeyMap
protected

Map to store references to styles based on ids.

Definition at line 68 of file CLRenderResolver.h.

Referenced by fill_local_maps(), and resolveStyleForKey().

std::map<std::string, const CLLineEnding*> CLRenderResolver::mLineEndingMap
protected

Map to store references to color definitions based on id.

Definition at line 93 of file CLRenderResolver.h.

Referenced by fill_base_maps(), and getLineEnding().

bool CLRenderResolver::mLocal
protected

Flag that determines if the resolver is for a local or a global render information object. Currently it is not used at all.

Definition at line 61 of file CLRenderResolver.h.

CLColorDefinition* CLRenderResolver::mpBackgroundColor
protected

Definition at line 95 of file CLRenderResolver.h.

Referenced by getBackgroundColor(), setBackgroundColor(), and ~CLRenderResolver().

CLRenderInformationBase* CLRenderResolver::mpRenderInformation
protected

The render information object. which is created by the flattener.

Definition at line 54 of file CLRenderResolver.h.

Referenced by CLRenderResolver(), setBackgroundColor(), and ~CLRenderResolver().

std::map<std::string, const CLStyle*> CLRenderResolver::mRoleMap
protected

Map to store references to styles based on roles.

Definition at line 73 of file CLRenderResolver.h.

Referenced by fill_global_maps(), fill_local_maps(), and resolveStyleForRole().

std::map<std::string, const CLStyle*> CLRenderResolver::mTypeMap
protected

Map to store references to styles based on types.

Definition at line 78 of file CLRenderResolver.h.

Referenced by fill_global_maps(), fill_local_maps(), and resolveStyleForType().


The documentation for this class was generated from the following files: