/** Recursive clear function - searches recursively for a proper node
* and finally clears the string map.
*
* \param[in] pNodePtr - pointer to a node to be processed
* \param[in] pszName - name of the property to search for in the given node
*/
void ini_cfg::clear(const tchar_t* pszName)
{
if(pszName == NULL || pszName[0] == _t('*'))
m_pMainNode->clear();
else
{
tstring_t strSection;
tstring_t strAttr;
if(!parse_property_name(pszName, strSection, strAttr))
THROW(_t("Invalid name"), 0, 0, 0);
ini_storage::iterator iterSection = m_pMainNode->find(strSection);
if(iterSection != m_pMainNode->end())
{
attr_storage& rAttrs = (*iterSection).second;
std::pair<attr_storage::iterator, attr_storage::iterator> pairRange;
if(strAttr == _t("*"))
{
pairRange.first = rAttrs.begin();
pairRange.second = rAttrs.end();
}
else
pairRange = (*iterSection).second.equal_range(strAttr);
rAttrs.erase(pairRange.first, pairRange.second);
}
}
}
/** Function starts a search operation. Given the name of the property
* to be searched for(ie. "ch/program/startup"), funtion searches for
* itAttr and returns a handle that can be used by subsequent calls to the
* find_next(). Free the handle using find_close() after finish.
*
* \param[in] pszName - name of the property to search for(in the form of
* "ch/program/startup"
* \return Handle to the search (NULL if not found).
*/
ptr_t ini_cfg::find(const tchar_t* pszName)
{
if(pszName == NULL || pszName[0] == _t('*'))
{
INIFINDHANDLE* pHandle = new INIFINDHANDLE;
pHandle->bOnlyAttributes = false;
pHandle->bSection = true;
pHandle->itSection = m_pMainNode->begin();
pHandle->itSectionEnd = m_pMainNode->end();
return pHandle;
}
else
{
// parse the path
tstring_t strSection;
tstring_t strAttr;
if(!parse_property_name(pszName, strSection, strAttr))
return NULL;
ini_storage::iterator iterSection = m_pMainNode->find(strSection);
if(iterSection == m_pMainNode->end())
return NULL;
std::pair<attr_storage::iterator, attr_storage::iterator> pairRange;
if(strAttr == _t("*"))
{
pairRange.first = (*iterSection).second.begin();
pairRange.second = (*iterSection).second.end();
}
else
pairRange = (*iterSection).second.equal_range(strAttr);
if(pairRange.first != (*iterSection).second.end() && pairRange.first != pairRange.second)
{
INIFINDHANDLE* pHandle = new INIFINDHANDLE;
pHandle->bSection = false;
pHandle->bOnlyAttributes = true;
pHandle->itAttr = pairRange.first;
pHandle->itAttrEnd = pairRange.second;
return pHandle;
}
}
return NULL;
}
/** Sets the specified value in the given key name. Value can be either added to
* the current ones (multi-string support) or replace them completely.
*
* \param[in] pszName - key name for which the string should be set at
* \param[in] pszValue - value to set
* \param[in] a - action to take while setting
*/
void ini_cfg::set_value(const tchar_t* pszName, const tchar_t* pszValue, actions a)
{
// parse the path
tstring_t strSection;
tstring_t strAttr;
if(!parse_property_name(pszName, strSection, strAttr))
THROW(_t("Property not found"), 0, 0, 0);
if(strAttr == _t("*"))
THROW(_t("Wildcards not available in set_value mode"), 0, 0, 0);
// search
ini_storage::iterator iterSection = m_pMainNode->find(strSection.c_str());
if(iterSection == m_pMainNode->end())
{
std::pair<ini_storage::iterator, bool> pairSection = m_pMainNode->insert(ini_storage::value_type(strSection, attr_storage()));
iterSection = pairSection.first;
if(iterSection == m_pMainNode->end())
THROW(_t("Problem with creating section"), 0, 0, 0);
}
attr_storage& rAttrs = (*iterSection).second;
// clear if we're replacing
switch(a)
{
case config_base::action_replace:
{
std::pair<attr_storage::iterator, attr_storage::iterator> pairRange = (*iterSection).second.equal_range(strAttr);
rAttrs.erase(pairRange.first, pairRange.second);
// do not break here - we are about to insert the data
}
case config_base::action_add:
{
rAttrs.insert(attr_storage::value_type(strAttr, pszValue ? pszValue : tstring_t(_t(""))));
break;
}
default:
assert(false);
}
}
bool LVCssDeclaration::parse( const char * &decl )
{
#define MAX_DECL_SIZE 512
int buf[MAX_DECL_SIZE];
int buf_pos = 0;
if ( !decl )
return false;
skip_spaces( decl );
if (*decl!='{')
return false;
decl++;
while (*decl && *decl!='}') {
skip_spaces( decl );
css_decl_code prop_code = parse_property_name( decl );
skip_spaces( decl );
lString8 strValue;
if (prop_code != cssd_unknown)
{
// parsed ok
int n = -1;
switch ( prop_code )
{
case cssd_display:
n = parse_name( decl, css_d_names, -1 );
break;
case cssd_white_space:
n = parse_name( decl, css_ws_names, -1 );
break;
case cssd_text_align:
n = parse_name( decl, css_ta_names, -1 );
break;
case cssd_text_align_last:
n = parse_name( decl, css_ta_names, -1 );
break;
case cssd_text_decoration:
n = parse_name( decl, css_td_names, -1 );
break;
case cssd_hyphenate:
case cssd_hyphenate2:
case cssd_hyphenate3:
case cssd_hyphenate4:
prop_code = cssd_hyphenate;
n = parse_name( decl, css_hyph_names, -1 );
if ( n==-1 )
n = parse_name( decl, css_hyph_names2, -1 );
if ( n==-1 )
n = parse_name( decl, css_hyph_names3, -1 );
break;
case cssd_page_break_before:
n = parse_name( decl, css_pb_names, -1 );
break;
case cssd_page_break_inside:
n = parse_name( decl, css_pb_names, -1 );
break;
case cssd_page_break_after:
n = parse_name( decl, css_pb_names, -1 );
break;
case cssd_list_style_type:
n = parse_name( decl, css_lst_names, -1 );
break;
case cssd_list_style_position:
n = parse_name( decl, css_lsp_names, -1 );
break;
case cssd_vertical_align:
n = parse_name( decl, css_va_names, -1 );
break;
case cssd_font_family:
{
lString8Collection list;
int processed = splitPropertyValueList( decl, list );
decl += processed;
n = -1;
if (list.length())
{
for (int i=list.length()-1; i>=0; i--)
{
const char * name = list[i].c_str();
int nn = parse_name( name, css_ff_names, -1 );
if (n==-1 && nn!=-1)
{
n = nn;
}
if (nn!=-1)
{
// remove family name from font list
list.erase( i, 1 );
}
}
strValue = joinPropertyValueList( list );
}
}
break;
case cssd_font_style:
n = parse_name( decl, css_fs_names, -1 );
break;
case cssd_font_weight:
n = parse_name( decl, css_fw_names, -1 );
break;
case cssd_text_indent:
{
// read length
css_length_t len;
bool negative = false;
if ( *decl == '-' ) {
decl++;
negative = true;
}
if ( parse_number_value( decl, len ) )
{
// read optional "hanging" flag
skip_spaces( decl );
int attr = parse_name( decl, css_ti_attribute_names, -1 );
if ( attr==0 || negative ) {
len.value = -len.value;
}
// save result
buf[ buf_pos++ ] = prop_code;
buf[ buf_pos++ ] = len.type;
buf[ buf_pos++ ] = len.value;
}
}
break;
case cssd_line_height:
case cssd_letter_spacing:
case cssd_font_size:
case cssd_width:
case cssd_height:
case cssd_margin_left:
case cssd_margin_right:
case cssd_margin_top:
case cssd_margin_bottom:
case cssd_padding_left:
case cssd_padding_right:
case cssd_padding_top:
case cssd_padding_bottom:
{
css_length_t len;
if ( parse_number_value( decl, len ) )
{
buf[ buf_pos++ ] = prop_code;
buf[ buf_pos++ ] = len.type;
buf[ buf_pos++ ] = len.value;
}
}
break;
case cssd_margin:
case cssd_padding:
{
css_length_t len[4];
int i;
for (i = 0; i < 4; ++i)
if (!parse_number_value( decl, len[i]))
break;
if (i)
{
switch (i)
{
case 1: len[1] = len[0]; /* fall through */
case 2: len[2] = len[0]; /* fall through */
case 3: len[3] = len[1];
}
buf[ buf_pos++ ] = prop_code;
for (i = 0; i < 4; ++i)
{
buf[ buf_pos++ ] = len[i].type;
buf[ buf_pos++ ] = len[i].value;
}
}
}
break;
case cssd_color:
case cssd_background_color:
{
css_length_t len;
if ( parse_color_value( decl, len ) )
{
buf[ buf_pos++ ] = prop_code;
buf[ buf_pos++ ] = len.type;
buf[ buf_pos++ ] = len.value;
}
}
break;
case cssd_stop:
case cssd_unknown:
default:
break;
}
if ( n!= -1)
{
// add enum property
buf[buf_pos++] = prop_code;
buf[buf_pos++] = n;
}
if (!strValue.empty())
{
// add string property
if (prop_code==cssd_font_family)
{
// font names
buf[buf_pos++] = cssd_font_names;
buf[buf_pos++] = strValue.length();
for (int i=0; i < strValue.length(); i++)
buf[buf_pos++] = strValue[i];
}
}
}
else
{
// error: unknown property?
}
next_property( decl );
}
// store parsed result
if (buf_pos)
{
buf[buf_pos++] = cssd_stop; // add end marker
_data = new int[buf_pos];
for (int i=0; i<buf_pos; i++)
_data[i] = buf[i];
}
// skip }
skip_spaces( decl );
if (*decl == '}')
{
decl++;
return true;
}
return false;
}
