| Geant4 Cross Reference |
1 // Copyright (C) 2010, Guy Barrand. All rights 1 // Copyright (C) 2010, Guy Barrand. All rights reserved.
2 // See the file tools.license for terms. 2 // See the file tools.license for terms.
3 3
4 #ifndef tools_xml_styles 4 #ifndef tools_xml_styles
5 #define tools_xml_styles 5 #define tools_xml_styles
6 6
7 #include "../vpair" 7 #include "../vpair"
8 #include "../sg/style_colormap" 8 #include "../sg/style_colormap"
9 #include "../smatch" 9 #include "../smatch"
10 #include "../sout" 10 #include "../sout"
11 #include "../forit" 11 #include "../forit"
12 #include "../sbeg" 12 #include "../sbeg"
13 13
14 namespace tools { 14 namespace tools {
15 namespace xml { 15 namespace xml {
16 16
17 class styles { 17 class styles {
18 public: 18 public:
19 styles(std::ostream& a_out):m_out(a_out){} 19 styles(std::ostream& a_out):m_out(a_out){}
20 virtual ~styles(){} 20 virtual ~styles(){}
21 public: 21 public:
22 styles(const styles& a_from) 22 styles(const styles& a_from)
23 :m_out(a_from.m_out) 23 :m_out(a_from.m_out)
24 ,m_named_styles(a_from.m_named_styles) 24 ,m_named_styles(a_from.m_named_styles)
25 ,m_aliases(a_from.m_aliases) 25 ,m_aliases(a_from.m_aliases)
26 ,m_cmaps(a_from.m_cmaps) 26 ,m_cmaps(a_from.m_cmaps)
27 {} 27 {}
28 styles& operator=(const styles& a_from){ 28 styles& operator=(const styles& a_from){
29 m_named_styles = a_from.m_named_styles; 29 m_named_styles = a_from.m_named_styles;
30 m_aliases = a_from.m_aliases; 30 m_aliases = a_from.m_aliases;
31 m_cmaps = a_from.m_cmaps; 31 m_cmaps = a_from.m_cmaps;
32 return *this; 32 return *this;
33 } 33 }
34 public: 34 public:
35 std::ostream& out() const {return m_out;} 35 std::ostream& out() const {return m_out;}
36 36
37 const sg::cmaps_t& cmaps() const {return m_c 37 const sg::cmaps_t& cmaps() const {return m_cmaps;}
38 sg::cmaps_t& cmaps() {return m_cmaps;} 38 sg::cmaps_t& cmaps() {return m_cmaps;}
39 39
40 typedef std::pair<std::string,std::string> s 40 typedef std::pair<std::string,std::string> style_item_t;
41 typedef std::vector<style_item_t> style_t; 41 typedef std::vector<style_item_t> style_t;
42 typedef std::pair<std::string,style_t> named 42 typedef std::pair<std::string,style_t> named_style_t;
43 43
44 const std::vector<named_style_t>& named_styl 44 const std::vector<named_style_t>& named_styles() const {return m_named_styles;}
45 std::vector<named_style_t>& named_styles() { 45 std::vector<named_style_t>& named_styles() {return m_named_styles;}
46 46
47 typedef std::pair<std::string,std::string> a 47 typedef std::pair<std::string,std::string> alias_t;
48 const std::vector<alias_t>& aliases() const 48 const std::vector<alias_t>& aliases() const {return m_aliases;}
49 std::vector<alias_t>& aliases() {return m_al 49 std::vector<alias_t>& aliases() {return m_aliases;}
50 50
51 const style_t* find_style(const std::string& 51 const style_t* find_style(const std::string& a_name) const {
52 tools_vforcit(named_style_t,m_named_styles 52 tools_vforcit(named_style_t,m_named_styles,it){
53 if((*it).first==a_name) return &((*it).s 53 if((*it).first==a_name) return &((*it).second);
54 } 54 }
55 return 0; 55 return 0;
56 } 56 }
57 57
58 /* 58 /*
59 style_t* find_style(const std::string& a_nam 59 style_t* find_style(const std::string& a_name) {
60 tools_vforit(named_style_t,m_named_styles, 60 tools_vforit(named_style_t,m_named_styles,it){
61 if((*it).first==a_name) return &((*it).s 61 if((*it).first==a_name) return &((*it).second);
62 } 62 }
63 return 0; 63 return 0;
64 } 64 }
65 void remove_item_in_style(style_t& a_style,c 65 void remove_item_in_style(style_t& a_style,const std::string& a_item) {
66 remove<std::string,std::string>(a_style,a_ 66 remove<std::string,std::string>(a_style,a_item);
67 } 67 }
68 */ 68 */
69 69
70 void find_styles(const std::string& a_patter 70 void find_styles(const std::string& a_pattern,std::vector<std::string>& a_v) const {
71 a_v.clear(); 71 a_v.clear();
72 tools_vforcit(named_style_t,m_named_styles 72 tools_vforcit(named_style_t,m_named_styles,it){
73 if(match((*it).first,a_pattern)) a_v.pus 73 if(match((*it).first,a_pattern)) a_v.push_back((*it).first);
74 } 74 }
75 } 75 }
76 76
77 void add_style(const std::string& a_name,con 77 void add_style(const std::string& a_name,const style_t& a_style) {
78 tools_vforit(named_style_t,m_named_styles, 78 tools_vforit(named_style_t,m_named_styles,it){
79 if((*it).first==a_name) { //override 79 if((*it).first==a_name) { //override
80 //::printf("debug : styles::add_style 80 //::printf("debug : styles::add_style : override : \"%s\"\n",a_name.c_str());
81 (*it).second = a_style; 81 (*it).second = a_style;
82 return; 82 return;
83 } 83 }
84 } 84 }
85 //::printf("debug : styles::add_style : pu 85 //::printf("debug : styles::add_style : push_back \"%s\"\n",a_name.c_str());
86 m_named_styles.push_back(named_style_t(a_n 86 m_named_styles.push_back(named_style_t(a_name,a_style));
87 } 87 }
88 88
89 void remove_styles(const std::string& a_patt 89 void remove_styles(const std::string& a_pattern) {
90 std::vector<named_style_t>::iterator it; 90 std::vector<named_style_t>::iterator it;
91 for(it=m_named_styles.begin();it!=m_named_ 91 for(it=m_named_styles.begin();it!=m_named_styles.end();) {
92 if(match((*it).first,a_pattern)) { 92 if(match((*it).first,a_pattern)) {
93 it = m_named_styles.erase(it); 93 it = m_named_styles.erase(it);
94 } else { 94 } else {
95 it++; 95 it++;
96 } 96 }
97 } 97 }
98 } 98 }
99 99
100 void append(const styles& a_from) { 100 void append(const styles& a_from) {
101 //::printf("debug : styles::append ...\n") 101 //::printf("debug : styles::append ...\n");
102 tools_vforcit(named_style_t,a_from.m_named 102 tools_vforcit(named_style_t,a_from.m_named_styles,it) {
103 //::printf("debug : styles::append \"%s\ 103 //::printf("debug : styles::append \"%s\"\n",(*it).first.c_str());
104 m_named_styles.push_back(*it); 104 m_named_styles.push_back(*it);
105 } 105 }
106 } 106 }
107 107
108 bool is_alias(const std::string& a_wanted,st 108 bool is_alias(const std::string& a_wanted,std::string& a_style) const {
109 if(find(m_aliases,a_wanted,a_style)) retur 109 if(find(m_aliases,a_wanted,a_style)) return true;
110 a_style = a_wanted; 110 a_style = a_wanted;
111 return false; 111 return false;
112 } 112 }
113 113
114 /* 114 /*
115 bool res_string(const std::string& a_style, 115 bool res_string(const std::string& a_style,
116 const std::string& a_ 116 const std::string& a_key,
117 std::string& a_v) con 117 std::string& a_v) const {
118 std::map<std::string,style_t>::const_itera 118 std::map<std::string,style_t>::const_iterator it = m_styles.find(a_style);
119 if(it==m_styles.end()) {a_v.clear();return 119 if(it==m_styles.end()) {a_v.clear();return false;}
120 const style_t& sty = (*it).second; 120 const style_t& sty = (*it).second;
121 if(!find(sty,a_key,a_v)) {a_v.clear();retu 121 if(!find(sty,a_key,a_v)) {a_v.clear();return false;}
122 return true; 122 return true;
123 } 123 }
124 */ 124 */
125 template <class T> 125 template <class T>
126 bool res_value(const style_t& a_sty,const st 126 bool res_value(const style_t& a_sty,const std::string& a_key,T& a_v,const std::string& a_msg) const {
127 //NOTE : if ret false, we do not set a_v t 127 //NOTE : if ret false, we do not set a_v to something.
128 128
129 std::string _s; 129 std::string _s;
130 if(!find(a_sty,a_key,_s)) { 130 if(!find(a_sty,a_key,_s)) {
131 if(a_msg.size()) { 131 if(a_msg.size()) {
132 m_out << "tools::xml::styles::res_valu 132 m_out << "tools::xml::styles::res_value :"
133 << " key " << sout(a_key) << " n 133 << " key " << sout(a_key) << " not found"
134 << " in style " << sout(a_msg) < 134 << " in style " << sout(a_msg) << "."
135 << std::endl; 135 << std::endl;
136 } 136 }
137 return false; 137 return false;
138 } 138 }
139 T v; 139 T v;
140 if(!to(_s,v)) { 140 if(!to(_s,v)) {
141 m_out << "tools::xml::styles::res_value 141 m_out << "tools::xml::styles::res_value :"
142 << " for key " << sout(a_key) << " 142 << " for key " << sout(a_key) << " not found"
143 << " in style " << sout(a_msg) << 143 << " in style " << sout(a_msg) << "."
144 << " can't convert " << sout(_s) < 144 << " can't convert " << sout(_s) << " to value."
145 << std::endl; 145 << std::endl;
146 return false; 146 return false;
147 } 147 }
148 a_v = v; 148 a_v = v;
149 return true; 149 return true;
150 } 150 }
151 151
152 template <class T> 152 template <class T>
153 bool res_value(const std::string& a_style,co 153 bool res_value(const std::string& a_style,const std::string& a_key,T& a_v) const {
154 //NOTE : if ret false, we do not set a_v t 154 //NOTE : if ret false, we do not set a_v to something.
155 155
156 //look if a_style is an alias : 156 //look if a_style is an alias :
157 std::string style; 157 std::string style;
158 is_alias(a_style,style); 158 is_alias(a_style,style);
159 159
160 const style_t* sty = find_style(style); 160 const style_t* sty = find_style(style);
161 if(!sty) { 161 if(!sty) {
162 //m_out << "tools::xml::styles::res_valu 162 //m_out << "tools::xml::styles::res_value :"
163 // << " style " << sout(style) << " 163 // << " style " << sout(style) << " not found."
164 // << std::endl; 164 // << std::endl;
165 return false; 165 return false;
166 } 166 }
167 T v; 167 T v;
168 if(!res_value<T>(*sty,a_key,v,style)) retu 168 if(!res_value<T>(*sty,a_key,v,style)) return false;
169 a_v = v; 169 a_v = v;
170 return true; 170 return true;
171 } 171 }
172 172
173 bool res_color(const style_t& a_sty,const st 173 bool res_color(const style_t& a_sty,const std::string& a_key,colorf& a_color,const std::string& a_msg) const {
174 //NOTE : if ret false, we do not set a_col 174 //NOTE : if ret false, we do not set a_color to something.
175 std::string _s; 175 std::string _s;
176 if(!find(a_sty,a_key,_s)) { 176 if(!find(a_sty,a_key,_s)) {
177 if(a_msg.size()) { 177 if(a_msg.size()) {
178 m_out << "tools::xml::styles::res_colo 178 m_out << "tools::xml::styles::res_color :"
179 << " key " << sout(a_key) << " n 179 << " key " << sout(a_key) << " not found"
180 << " in style " << sout(a_msg) < 180 << " in style " << sout(a_msg) << "."
181 << std::endl; 181 << std::endl;
182 } 182 }
183 return false; 183 return false;
184 } 184 }
185 if(!sg::find_color(m_cmaps,_s,a_color)) { 185 if(!sg::find_color(m_cmaps,_s,a_color)) {
186 m_out << "tools::xml::styles::res_color 186 m_out << "tools::xml::styles::res_color :"
187 << " key " << sout(a_key) << " is 187 << " key " << sout(a_key) << " is not a color"
188 << " in style " << sout(a_msg) << 188 << " in style " << sout(a_msg) << "."
189 << std::endl; 189 << std::endl;
190 return false; 190 return false;
191 } 191 }
192 return true; 192 return true;
193 } 193 }
194 194
195 bool res_color(const std::string& a_style,co 195 bool res_color(const std::string& a_style,const std::string& a_key,colorf& a_color) const {
196 //NOTE : if ret false, we do not set a_col 196 //NOTE : if ret false, we do not set a_color to something.
197 197
198 //look if a_style is an alias : 198 //look if a_style is an alias :
199 std::string style; 199 std::string style;
200 is_alias(a_style,style); 200 is_alias(a_style,style);
201 201
202 const style_t* sty = find_style(style); 202 const style_t* sty = find_style(style);
203 if(!sty) { 203 if(!sty) {
204 //m_out << "tools::xml::styles::res_colo 204 //m_out << "tools::xml::styles::res_color :"
205 // << " style " << sout(style) << " 205 // << " style " << sout(style) << " not found."
206 // << std::endl; 206 // << std::endl;
207 return false; 207 return false;
208 } 208 }
209 209
210 return res_color(*sty,a_key,a_color,style) 210 return res_color(*sty,a_key,a_color,style);
211 } 211 }
212 212
213 bool res_bool(const style_t& a_sty,const std 213 bool res_bool(const style_t& a_sty,const std::string& a_key,bool& a_v,const std::string& a_msg) const {
214 //NOTE : if ret false, we do not set a_v t 214 //NOTE : if ret false, we do not set a_v to something.
215 std::string _s; 215 std::string _s;
216 if(!find(a_sty,a_key,_s)) { 216 if(!find(a_sty,a_key,_s)) {
217 if(a_msg.size()) { 217 if(a_msg.size()) {
218 m_out << "tools::xml::styles::res_bool 218 m_out << "tools::xml::styles::res_bool :"
219 << " key " << sout(a_key) << " n 219 << " key " << sout(a_key) << " not found"
220 << " in style " << sout(a_msg) < 220 << " in style " << sout(a_msg) << "."
221 << std::endl; 221 << std::endl;
222 } 222 }
223 return false; 223 return false;
224 } 224 }
225 bool v; 225 bool v;
226 if(!to(_s,v)) { 226 if(!to(_s,v)) {
227 m_out << "tools::xml::styles::res_bool : 227 m_out << "tools::xml::styles::res_bool :"
228 << " for key " << sout(a_key) << " 228 << " for key " << sout(a_key) << " not found"
229 << " in style " << sout(a_msg) << 229 << " in style " << sout(a_msg) << "."
230 << " can't convert " << sout(_s) < 230 << " can't convert " << sout(_s) << " to bool."
231 << std::endl; 231 << std::endl;
232 return false; 232 return false;
233 } 233 }
234 a_v = v; 234 a_v = v;
235 return true; 235 return true;
236 } 236 }
237 237
238 bool res_bool(const std::string& a_style,con 238 bool res_bool(const std::string& a_style,const std::string& a_key,bool& a_v) const {
239 //NOTE : if ret false, we do not set a_col 239 //NOTE : if ret false, we do not set a_color to something.
240 240
241 //look if a_style is an alias : 241 //look if a_style is an alias :
242 std::string style; 242 std::string style;
243 is_alias(a_style,style); 243 is_alias(a_style,style);
244 244
245 const style_t* sty = find_style(style); 245 const style_t* sty = find_style(style);
246 if(!sty) { 246 if(!sty) {
247 //m_out << "tools::xml::styles::res_colo 247 //m_out << "tools::xml::styles::res_color :"
248 // << " style " << sout(style) << " 248 // << " style " << sout(style) << " not found."
249 // << std::endl; 249 // << std::endl;
250 return false; 250 return false;
251 } 251 }
252 252
253 return res_bool(*sty,a_key,a_v,style); 253 return res_bool(*sty,a_key,a_v,style);
254 } 254 }
255 255
256 // for plotter : 256 // for plotter :
257 template <class T> //T = [style,text_style,l 257 template <class T> //T = [style,text_style,line_style]
258 bool res_sg_style(const std::string& a_style 258 bool res_sg_style(const std::string& a_style,T& a_sg_style) const {
259 //NOTE : a_sg_style is changed according t 259 //NOTE : a_sg_style is changed according to what is found.
260 // Then it is not fully reset by thi 260 // Then it is not fully reset by this method.
261 const style_t* sty = find_style(a_style); 261 const style_t* sty = find_style(a_style);
262 if(!sty) { 262 if(!sty) {
263 //could be ok to not find a plotter sub 263 //could be ok to not find a plotter sub style.
264 //m_out << "tools::sg::gui_viewer::res_s 264 //m_out << "tools::sg::gui_viewer::res_sg_style :"
265 // << " style " << sout(a_style) << 265 // << " style " << sout(a_style) << " not found."
266 // << std::endl; 266 // << std::endl;
267 return false; 267 return false;
268 } 268 }
269 269
270 std::string _s; 270 std::string _s;
271 tools_vforcit(style_item_t,*sty,vit) { 271 tools_vforcit(style_item_t,*sty,vit) {
272 if(vit!=(*sty).begin()) _s += "\n"; 272 if(vit!=(*sty).begin()) _s += "\n";
273 _s += (*vit).first; 273 _s += (*vit).first;
274 _s += " "; 274 _s += " ";
275 _s += (*vit).second; 275 _s += (*vit).second;
276 } 276 }
277 return a_sg_style.from_string(m_out,m_cmap 277 return a_sg_style.from_string(m_out,m_cmaps,_s);
278 } 278 }
279 279
280 typedef sg::style_colormap cmap_t; 280 typedef sg::style_colormap cmap_t;
281 bool find_colormap(const std::string& a_name 281 bool find_colormap(const std::string& a_name,cmap_t& a_cmap) const {
282 std::map<std::string,cmap_t>::const_iterat 282 std::map<std::string,cmap_t>::const_iterator it = m_cmaps.find(a_name);
283 if(it==m_cmaps.end()) return false; 283 if(it==m_cmaps.end()) return false;
284 a_cmap = (*it).second; 284 a_cmap = (*it).second;
285 return true; 285 return true;
286 } 286 }
287 void add_colormap(const std::string& a_name, 287 void add_colormap(const std::string& a_name,const cmap_t& a_cmap) {
288 m_cmaps[a_name] = a_cmap; 288 m_cmaps[a_name] = a_cmap;
289 } 289 }
290 //void clear_colormaps() {m_cmaps.clear();/* 290 //void clear_colormaps() {m_cmaps.clear();/*add default*/}
291 291
292 public: 292 public:
293 static bool is_plotter_style(const style_t& 293 static bool is_plotter_style(const style_t& a_sty) {
294 tools_vforcit(style_item_t,a_sty,it) { 294 tools_vforcit(style_item_t,a_sty,it) {
295 const std::string& key = (*it).first; 295 const std::string& key = (*it).first;
296 const std::string& sv = (*it).second; 296 const std::string& sv = (*it).second;
297 if((key=="tag")&&(sv=="plotter_style")) 297 if((key=="tag")&&(sv=="plotter_style")) return true;
298 } 298 }
299 return false; 299 return false;
300 } 300 }
301 301
302 public: 302 public:
303 void find_plotter_styles(std::vector<std::st 303 void find_plotter_styles(std::vector<std::string>& a_v) const {
304 a_v.clear(); 304 a_v.clear();
305 tools_vforcit(named_style_t,m_named_styles 305 tools_vforcit(named_style_t,m_named_styles,it) {
306 if(is_plotter_style((*it).second)) a_v.p 306 if(is_plotter_style((*it).second)) a_v.push_back((*it).first);
307 } 307 }
308 } 308 }
309 309
310 void dump() { 310 void dump() {
311 tools_vforcit(named_style_t,m_named_styles 311 tools_vforcit(named_style_t,m_named_styles,it) {
312 312
313 m_out << "////////////////////////////// 313 m_out << "/////////////////////////////////////" << std::endl;
314 m_out << "/// " << (*it).first << std::e 314 m_out << "/// " << (*it).first << std::endl;
315 m_out << "////////////////////////////// 315 m_out << "/////////////////////////////////////" << std::endl;
316 316
317 const style_t& sty = (*it).second; 317 const style_t& sty = (*it).second;
318 318
319 tools_vforcit(style_item_t,sty,vit) { 319 tools_vforcit(style_item_t,sty,vit) {
320 m_out << " " << (*vit).first << " " << 320 m_out << " " << (*vit).first << " " << (*vit).second << std::endl;
321 } 321 }
322 322
323 } 323 }
324 } 324 }
325 325
326 bool print_plotter_style(std::ostream& a_out 326 bool print_plotter_style(std::ostream& a_out,const std::string& a_style) {
327 std::string _beg = a_style+"."; 327 std::string _beg = a_style+".";
328 bool found = false; 328 bool found = false;
329 tools_vforcit(named_style_t,m_named_styles 329 tools_vforcit(named_style_t,m_named_styles,it) {
330 const std::string& _name = (*it).first; 330 const std::string& _name = (*it).first;
331 if((_name==a_style)||is_beg(_name,_beg)) 331 if((_name==a_style)||is_beg(_name,_beg)) {
332 found = true; 332 found = true;
333 a_out << (*it).first << " :" << std::e 333 a_out << (*it).first << " :" << std::endl;
334 const style_t& sty = (*it).second; 334 const style_t& sty = (*it).second;
335 tools_vforcit(style_item_t,sty,vit) { 335 tools_vforcit(style_item_t,sty,vit) {
336 if((*vit).first=="tag") continue; 336 if((*vit).first=="tag") continue;
337 a_out << " " << (*vit).first << " " 337 a_out << " " << (*vit).first << " " << (*vit).second << std::endl;
338 } 338 }
339 } 339 }
340 } 340 }
341 return found; 341 return found;
342 } 342 }
343 343
344 void list_plotter_styles(std::ostream& a_out 344 void list_plotter_styles(std::ostream& a_out) {
345 tools_vforcit(named_style_t,m_named_styles 345 tools_vforcit(named_style_t,m_named_styles,it) {
346 const style_t& sty = (*it).second; 346 const style_t& sty = (*it).second;
347 if(!styles::is_plotter_style(sty)) conti 347 if(!styles::is_plotter_style(sty)) continue;
348 a_out << (*it).first << std::endl; 348 a_out << (*it).first << std::endl;
349 } 349 }
350 } 350 }
351 protected: 351 protected:
352 std::ostream& m_out; 352 std::ostream& m_out;
353 //styles : 353 //styles :
354 std::vector<named_style_t> m_named_styles; 354 std::vector<named_style_t> m_named_styles;
355 std::vector<alias_t> m_aliases; 355 std::vector<alias_t> m_aliases;
356 //cmaps : 356 //cmaps :
357 sg::cmaps_t m_cmaps; 357 sg::cmaps_t m_cmaps;
358 }; 358 };
359 359
360 }} 360 }}
361 361
362 #include "tree" 362 #include "tree"
363 #include "../vmanip" 363 #include "../vmanip"
364 364
365 namespace tools { 365 namespace tools {
366 namespace xml { 366 namespace xml {
367 367
368 inline void load_style(styles& a_styles,const 368 inline void load_style(styles& a_styles,const tree& a_tree) {
369 std::string name; 369 std::string name;
370 a_tree.attribute_value("name",name); 370 a_tree.attribute_value("name",name);
371 if(name.empty()) { 371 if(name.empty()) {
372 a_styles.out() << "tools::sg::gui_viewer:: 372 a_styles.out() << "tools::sg::gui_viewer::load_style :"
373 << " <style> without name." 373 << " <style> without name."
374 << std::endl; 374 << std::endl;
375 return; 375 return;
376 } 376 }
377 377
378 styles::style_t sty; 378 styles::style_t sty;
379 379
380 {looper _for(a_tree); 380 {looper _for(a_tree);
381 while(element* _elem = _for.next_element()) 381 while(element* _elem = _for.next_element()) {
382 382
383 if(_elem->name()=="copy") { 383 if(_elem->name()=="copy") {
384 384
385 std::string from; 385 std::string from;
386 _elem->attribute_value("from",from); / 386 _elem->attribute_value("from",from); //expect another style name.
387 if(from.empty()) { 387 if(from.empty()) {
388 a_styles.out() << "tools::sg::gui_vi 388 a_styles.out() << "tools::sg::gui_viewer::load_style :"
389 << " <copy> without f 389 << " <copy> without from."
390 << std::endl; 390 << std::endl;
391 return; 391 return;
392 } 392 }
393 393
394 const styles::style_t* csty = a_styles 394 const styles::style_t* csty = a_styles.find_style(from);
395 if(!csty) { 395 if(!csty) {
396 a_styles.out() << "tools::sg::gui_vi 396 a_styles.out() << "tools::sg::gui_viewer::load_style :"
397 << " <copy> : from " << s 397 << " <copy> : from " << sout(from) << " not found."
398 << std::endl; 398 << std::endl;
399 return; 399 return;
400 } 400 }
401 401
402 append(sty,*csty); 402 append(sty,*csty);
403 403
404 } else { 404 } else {
405 sty.push_back(styles::style_item_t(_el 405 sty.push_back(styles::style_item_t(_elem->name(),_elem->value()));
406 } 406 }
407 407
408 }} 408 }}
409 409
410 if(sty.size()) a_styles.add_style(name,sty); 410 if(sty.size()) a_styles.add_style(name,sty);
411 } 411 }
412 412
413 inline void load_plotter_style(styles& a_style 413 inline void load_plotter_style(styles& a_styles,const tree& a_tree) {
414 std::string pname; 414 std::string pname;
415 a_tree.attribute_value("name",pname); 415 a_tree.attribute_value("name",pname);
416 if(pname.empty()) { 416 if(pname.empty()) {
417 a_styles.out() << "tools::sg::gui_viewer:: 417 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style :"
418 << " <plotter_style> without name." 418 << " <plotter_style> without name."
419 << std::endl; 419 << std::endl;
420 return; 420 return;
421 } 421 }
422 422
423 {styles::style_t sty; 423 {styles::style_t sty;
424 sty.push_back(styles::style_item_t("tag","pl 424 sty.push_back(styles::style_item_t("tag","plotter_style"));
425 425
426 {looper _for(a_tree); 426 {looper _for(a_tree);
427 while(element* _elem = _for.next_element()) 427 while(element* _elem = _for.next_element()) {
428 428
429 if(_elem->name()=="copy") { 429 if(_elem->name()=="copy") {
430 430
431 std::string from; 431 std::string from;
432 _elem->attribute_value("from",from); / 432 _elem->attribute_value("from",from); //expect a plotter_style name.
433 if(from.empty()) { 433 if(from.empty()) {
434 a_styles.out() << "tools::sg::gui_vi 434 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style :"
435 << " <copy> without from." 435 << " <copy> without from."
436 << std::endl; 436 << std::endl;
437 return; 437 return;
438 } 438 }
439 439
440 const styles::style_t* csty = a_styles 440 const styles::style_t* csty = a_styles.find_style(from);
441 if(!csty) { 441 if(!csty) {
442 a_styles.out() << "tools::sg::gui_vi 442 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style :"
443 << " <copy> : from " << sout(f 443 << " <copy> : from " << sout(from) << " not found."
444 << std::endl; 444 << std::endl;
445 return; 445 return;
446 } 446 }
447 if(csty->size()) a_styles.add_style(pn 447 if(csty->size()) a_styles.add_style(pname,*csty);
448 448
449 if(styles::is_plotter_style(*csty)) { 449 if(styles::is_plotter_style(*csty)) {
450 //search all <from>.<sub_style> styl 450 //search all <from>.<sub_style> styles :
451 std::string head = from+"."; 451 std::string head = from+".";
452 std::string::size_type l = head.size 452 std::string::size_type l = head.size();
453 453
454 styles sts(a_styles.out()); 454 styles sts(a_styles.out());
455 455
456 const std::vector<styles::named_styl 456 const std::vector<styles::named_style_t>& nss = a_styles.named_styles();
457 tools_vforcit(styles::named_style_t, 457 tools_vforcit(styles::named_style_t,nss,it){
458 const std::string& name = (*it).fi 458 const std::string& name = (*it).first;
459 if(name.substr(0,l)==head) { 459 if(name.substr(0,l)==head) {
460 std::string tail = name.substr(l 460 std::string tail = name.substr(l,name.size()-l);
461 const styles::style_t& ssty = (* 461 const styles::style_t& ssty = (*it).second;
462 if(ssty.size()) sts.add_style(pn 462 if(ssty.size()) sts.add_style(pname+"."+tail,ssty);
463 } 463 }
464 } 464 }
465 465
466 a_styles.append(sts); 466 a_styles.append(sts);
467 467
468 } 468 }
469 469
470 470
471 } else { 471 } else {
472 sty.push_back(styles::style_item_t(_el 472 sty.push_back(styles::style_item_t(_elem->name(),_elem->value()));
473 } 473 }
474 474
475 }} 475 }}
476 476
477 if(sty.size()) a_styles.add_style(pname,sty) 477 if(sty.size()) a_styles.add_style(pname,sty);}
478 478
479 {looper _for(a_tree); 479 {looper _for(a_tree);
480 while(tree* _tree = _for.next_tree()) { 480 while(tree* _tree = _for.next_tree()) {
481 481
482 const std::string& tag = _tree->tag_name 482 const std::string& tag = _tree->tag_name();
483 if(tag=="style") { 483 if(tag=="style") {
484 484
485 std::string name; 485 std::string name;
486 _tree->attribute_value("name",name); 486 _tree->attribute_value("name",name);
487 if(name.empty()) { 487 if(name.empty()) {
488 a_styles.out() << "tools::sg::gui_vi 488 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style :"
489 << " <style> without name." 489 << " <style> without name."
490 << std::endl; 490 << std::endl;
491 return; 491 return;
492 } 492 }
493 493
494 {styles::style_t sty; 494 {styles::style_t sty;
495 495
496 {looper _for2(*_tree); 496 {looper _for2(*_tree);
497 while(element* _elem = _for2.next_elem 497 while(element* _elem = _for2.next_element()) {
498 if(_elem->name()=="copy") { 498 if(_elem->name()=="copy") {
499 std::string from; 499 std::string from;
500 _elem->attribute_value("from",from 500 _elem->attribute_value("from",from); //expect another style name.
501 if(from.empty()) { 501 if(from.empty()) {
502 a_styles.out() << "tools::sg::gu 502 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style : (2) :"
503 << " <copy> witho 503 << " <copy> without from."
504 << std::endl; 504 << std::endl;
505 return; 505 return;
506 } 506 }
507 const styles::style_t* csty = a_st 507 const styles::style_t* csty = a_styles.find_style(from);
508 if(!csty) { 508 if(!csty) {
509 a_styles.out() << "tools::sg::gu 509 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style : (2) :"
510 << " <copy> : fro 510 << " <copy> : from " << sout(from) << " not found."
511 << std::endl; 511 << std::endl;
512 return; 512 return;
513 } 513 }
514 append(sty,*csty); 514 append(sty,*csty);
515 } else { 515 } else {
516 sty.push_back(styles::style_item_t 516 sty.push_back(styles::style_item_t(_elem->name(),_elem->value()));
517 } 517 }
518 }} 518 }}
519 519
520 if(sty.size()) { 520 if(sty.size()) {
521 std::string path = pname+"."+name; 521 std::string path = pname+"."+name;
522 a_styles.add_style(path,sty); 522 a_styles.add_style(path,sty);
523 }} 523 }}
524 524
525 } else { 525 } else {
526 a_styles.out() << "tools::sg::gui_view 526 a_styles.out() << "tools::sg::gui_viewer::load_plotter_style :"
527 << " unexpected tag " << sout(ta 527 << " unexpected tag " << sout(tag) << "."
528 << std::endl; 528 << std::endl;
529 } 529 }
530 530
531 }} 531 }}
532 532
533 } 533 }
534 534
535 inline bool scan_style_tree(styles& a_styles,c 535 inline bool scan_style_tree(styles& a_styles,const tree& a_tree) {
536 536
537 if(a_tree.tag_name()!="styles") return false 537 if(a_tree.tag_name()!="styles") return false;
538 538
539 // look for aliases : 539 // look for aliases :
540 {looper _for(a_tree); 540 {looper _for(a_tree);
541 while(element* _elem = _for.next_element()) 541 while(element* _elem = _for.next_element()) {
542 542
543 std::string name; 543 std::string name;
544 _elem->attribute_value("name",name); 544 _elem->attribute_value("name",name);
545 if(name.empty()) { 545 if(name.empty()) {
546 a_styles.out() << "tools::sg::gui_view 546 a_styles.out() << "tools::sg::gui_viewer::load_style :"
547 << " <alias> without name." 547 << " <alias> without name."
548 << std::endl; 548 << std::endl;
549 continue; 549 continue;
550 } 550 }
551 add<std::string,std::string>(a_styles.al 551 add<std::string,std::string>(a_styles.aliases(),name,_elem->value());
552 }} 552 }}
553 553
554 // scan children : 554 // scan children :
555 {looper _for(a_tree); 555 {looper _for(a_tree);
556 while(tree* _tree = _for.next_tree()) { 556 while(tree* _tree = _for.next_tree()) {
557 557
558 const std::string& tag = _tree->tag_name 558 const std::string& tag = _tree->tag_name();
559 if(tag=="style") { 559 if(tag=="style") {
560 load_style(a_styles,*_tree); 560 load_style(a_styles,*_tree);
561 } else if(tag=="plotter_style") { 561 } else if(tag=="plotter_style") {
562 load_plotter_style(a_styles,*_tree); 562 load_plotter_style(a_styles,*_tree);
563 } 563 }
564 564
565 }} 565 }}
566 566
567 return true; 567 return true;
568 } 568 }
569 }} 569 }}
570 570
571 #endif 571 #endif