← Back to branch summary

~h-e-6/inkscape/connector-wip

« back to all changes in this revision

Viewing changes to src/attribute-rel-css.cpp

  • Committer: tavmjong-free
  • Date: 2011-11-29 11:27:10 UTC
  • Revision ID: tavmjong@free.fr-20111129112710-w6r61y9ynzup7cdl
Add possibility to check validity of attributes and usefulness of properties.

This code adds the ability to check for every elment in an SVG document if its
attributes are valid and the styling properties are useful. Options under the
SVG Output section of the Inkscape Preferences dialog control what should
be checked when, and what actions should be taken if invalid attributes
or non-useful properties are found.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/attribute-rel-css.cpp
 
1
/*
 
2
 * attribute-rel-css.cpp
 
3
 *
 
4
 *  Created on: Jul 25, 2011
 
5
 *      Author: abhishek
 
6
 */
 
7
 
 
8
/** \class SPAttributeRelCSS
 
9
 *
 
10
 * SPAttributeRelCSS class stores the mapping of element->style_properties
 
11
 * relationship and provides a static function to access that
 
12
 * mapping indirectly(only reading).
 
13
 */
 
14
 
 
15
#ifdef HAVE_CONFIG_H
 
16
# include <config.h>
 
17
#endif
 
18
 
 
19
#include <fstream>
 
20
#include <sstream>
 
21
#include <string>
 
22
#include <iostream>
 
23
 
 
24
#include "attribute-rel-css.h"
 
25
 
 
26
#include "path-prefix.h"
 
27
#include "preferences.h"
 
28
 
 
29
SPAttributeRelCSS * SPAttributeRelCSS::instance = NULL;
 
30
 
 
31
/*
 
32
 * This function checks whether an element -> CSS property pair 
 
33
 * is allowed or not
 
34
 */
 
35
bool SPAttributeRelCSS::findIfValid(Glib::ustring property, Glib::ustring element)
 
36
{
 
37
    if (SPAttributeRelCSS::instance == NULL) {
 
38
        SPAttributeRelCSS::instance = new SPAttributeRelCSS();
 
39
    }
 
40
    
 
41
    // Strip of "svg:" from the element's name
 
42
    Glib::ustring temp = element;
 
43
    if ( temp.find("svg:") != std::string::npos ) {
 
44
        temp.erase( temp.find("svg:"), 4 );
 
45
    }
 
46
 
 
47
    // Don't check for properties with -, role, aria etc. to allow for more accessbility
 
48
    // FixMe: Name space list should be created when file read in.
 
49
    if (property[0] == '-'
 
50
        || property.substr(0,4) == "role"
 
51
        || property.substr(0,4) == "aria"
 
52
        || property.substr(0,5) == "xmlns"
 
53
        || property.substr(0,8) == "inkscape:"
 
54
        || property.substr(0,9) == "sodipodi:"
 
55
        || property.substr(0,4) == "rdf:"
 
56
        || property.substr(0,3) == "cc:"
 
57
        || (SPAttributeRelCSS::instance->propertiesOfElements[temp].find(property)
 
58
            != SPAttributeRelCSS::instance->propertiesOfElements[temp].end()) ) {
 
59
        return true;
 
60
    } else {
 
61
        //g_warning( "Invalid attribute: %s used on <%s>", property.c_str(), element.c_str() );
 
62
        return false;
 
63
    }
 
64
}
 
65
 
 
66
/*
 
67
 * This function checks whether an CSS property -> default value 
 
68
 * pair is allowed or not
 
69
 */
 
70
bool SPAttributeRelCSS::findIfDefault(Glib::ustring property, Glib::ustring value)
 
71
{
 
72
    if (SPAttributeRelCSS::instance == NULL) {
 
73
        SPAttributeRelCSS::instance = new SPAttributeRelCSS();
 
74
    }
 
75
 
 
76
    if( instance->defaultValuesOfProps[property] == value) {
 
77
        return true;
 
78
    } else {
 
79
        return false;
 
80
    }
 
81
}
 
82
 
 
83
/*
 
84
 * Check if property can be inherited.
 
85
 */
 
86
bool SPAttributeRelCSS::findIfInherit(Glib::ustring property)
 
87
{
 
88
    if (SPAttributeRelCSS::instance == NULL) {
 
89
        SPAttributeRelCSS::instance = new SPAttributeRelCSS();
 
90
    }
 
91
 
 
92
    return instance->inheritProps[property];
 
93
}
 
94
 
 
95
/*
 
96
 * Check if attribute is a property.
 
97
 */
 
98
bool SPAttributeRelCSS::findIfProperty(Glib::ustring property)
 
99
{
 
100
    if (SPAttributeRelCSS::instance == NULL) {
 
101
        SPAttributeRelCSS::instance = new SPAttributeRelCSS();
 
102
    }
 
103
 
 
104
    return ( instance->defaultValuesOfProps.find( property )
 
105
             != instance->defaultValuesOfProps.end() );
 
106
}
 
107
 
 
108
SPAttributeRelCSS::SPAttributeRelCSS()
 
109
{
 
110
    // Read data from standard path
 
111
    std::string filepath = INKSCAPE_ATTRRELDIR;
 
112
    filepath += "/cssprops";
 
113
 
 
114
    // Try and load data from filepath
 
115
    if (!readDataFromFileIn(filepath, SPAttributeRelCSS::prop_element_pair)) {
 
116
        // Set default preference for CSS property checking to ignore
 
117
        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
118
        prefs->setInt("/options/svgoutput/incorrect_style_properties", 3);
 
119
    }
 
120
    
 
121
    // Read data from standard path
 
122
    filepath = INKSCAPE_ATTRRELDIR;
 
123
    filepath += "/css_defaults";
 
124
    
 
125
    // Try and load data from filepath
 
126
    if (!readDataFromFileIn(filepath, SPAttributeRelCSS::prop_defValue_pair)) {
 
127
        // Set default preference for CSS defaults checking to ignore
 
128
        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
129
        prefs->setInt("/options/svgoutput/style_defaults", 3);
 
130
    }
 
131
}
 
132
 
 
133
bool SPAttributeRelCSS::readDataFromFileIn(Glib::ustring fileName, storageType type)
 
134
{
 
135
    std::fstream file;
 
136
    file.open(fileName.c_str(), std::ios::in);
 
137
    
 
138
    if (!file.is_open()) {
 
139
        // Display warning for file not open
 
140
        g_warning("Could not open the data file for CSS attribute-element map construction: %s", fileName.c_str());
 
141
        file.close();
 
142
        return false;
 
143
    }
 
144
 
 
145
    while (!file.eof()) {
 
146
        std::stringstream ss;
 
147
        std::string s;
 
148
 
 
149
        std::getline(file,s,'"');
 
150
        std::getline(file,s,'"');
 
151
        if (s.size() > 0 && s[0] != '\n') {
 
152
            std::string prop = s;
 
153
            getline(file,s);
 
154
            ss << s;
 
155
            
 
156
            // Load data to structure that holds element -> set of CSS props
 
157
            if (type == SPAttributeRelCSS::prop_element_pair) {
 
158
                while (std::getline(ss,s,'"')) {
 
159
                    std::string element;
 
160
                    std::getline(ss,s,'"');
 
161
                    element = s;                               
 
162
                    propertiesOfElements[element].insert(prop);
 
163
                }
 
164
            // Load data to structure that holds CSS prop -> default value    
 
165
            } else if (type == SPAttributeRelCSS::prop_defValue_pair) {
 
166
                std::string value;
 
167
                std::getline(ss,s,'"');
 
168
                std::getline(ss,s,'"');
 
169
                value = s;
 
170
                defaultValuesOfProps[prop] = value;
 
171
                std::getline(ss,s,'"');
 
172
                std::getline(ss,s,'"');
 
173
                gboolean inherit = false;
 
174
                if ( s.find( "yes" ) != std::string::npos ) {
 
175
                    inherit = true;
 
176
                }
 
177
                inheritProps[prop] = inherit;
 
178
            }
 
179
        }
 
180
    }
 
181
    
 
182
    file.close();
 
183
    return true;
 
184
}
 
185
 
 
186
/*
 
187
  Local Variables:
 
188
  mode:c++
 
189
  c-file-style:"stroustrup"
 
190
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 
191
  indent-tabs-mode:nil
 
192
  fill-column:99
 
193
  End:
 
194
*/
 
195
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :