]> git.wh0rd.org Git - ICEs.git/blob - 138653/ice.ii.3
initial import
[ICEs.git] / 138653 / ice.ii.3
1 typedef struct _GObject {
2 } GObject;
3 namespace std {
4         struct random_access_iterator_tag {
5         };
6          template < typename _Iterator > struct iterator_traits {
7         };
8          template < typename _Tp > struct iterator_traits <_Tp * > {
9         struct iterator_category {};
10         };
11 } namespace __gnu_cxx {
12         using std::iterator_traits;
13          template < typename _Iterator,
14             typename _Container > class __normal_iterator {
15               protected:_Iterator _M_current;
16               public:typedef typename iterator_traits <
17                     _Iterator >::
18                     iterator_category iterator_category;
19                 typedef typename iterator_traits <
20                     _Iterator >::int int;
21                 explicit __normal_iterator(const _Iterator &
22                                            __i):_M_current(__i) {
23                 } const _Iterator & base() const {
24                         return _M_current;
25         }};
26         template < typename _IteratorL, typename _IteratorR,
27             typename _Container > inline typename __normal_iterator <
28             _IteratorL,
29             _Container >::int operator-(const __normal_iterator <
30                                                     _IteratorL,
31                                                     _Container > &__lhs,
32                                                     const __normal_iterator <
33                                                     _IteratorR,
34                                                     _Container > &__rhs) {
35                 return __lhs.base() - __rhs.base();
36         }
37         template < typename _Tp > class new_allocator {
38               public:typedef const _Tp *const_pointer;
39                 typedef const _Tp & const_reference;
40                 template < typename _Tp1 > struct rebind {
41                         typedef new_allocator < _Tp1 > other;
42                 };
43         };
44 }
45
46 namespace std {
47         template < typename _Tp >
48             class allocator:public __gnu_cxx::new_allocator < _Tp > {
49         };
50 }
51 extern double fabs(double);
52 namespace Inkscape {
53         namespace GC {
54                 enum ScanPolicy {
55                         SCANNED
56                 };
57                 enum CollectionPolicy {
58                         AUTO, MANUAL
59                 };
60                  template < ScanPolicy default_scan =
61                     SCANNED, CollectionPolicy default_collect =
62                     AUTO > class Managed {
63                 };
64                 class Finalized {
65                       public:Finalized() {
66                 }};
67                 class Anchored {
68                       protected:Anchored():_anchor(__null)
69                         {
70                       } private:struct Anchor:public Managed < SCANNED,
71                             MANUAL > {
72                         };
73                         mutable Anchor *_anchor;
74                 };
75         }
76         namespace UI {
77                 namespace View {
78                         class View:public GC::Managed <>, public GC::Finalized,
79                             public GC::Anchored {
80                         };
81 }}} struct SPDesktop:public Inkscape::UI::View::View {
82 };
83 enum SPMarkerLoc {
84         SP_CSS_UNIT_NONE, SP_CSS_UNIT_PX, SP_CSS_UNIT_PT, SP_CSS_UNIT_PC,
85             SP_CSS_UNIT_MM, SP_CSS_UNIT_CM, SP_CSS_UNIT_IN, SP_CSS_UNIT_EM,
86             SP_CSS_UNIT_EX, SP_CSS_UNIT_PERCENT
87 };
88 struct SPILengthOrNormal {
89         unsigned unit;
90         float value;
91         float computed;
92 };
93 struct SPStyle {
94         SPILengthOrNormal line_height;
95 };
96 namespace std {
97         template < typename _Tp, typename _Alloc > struct _Vector_base {
98                 typedef typename _Alloc::template rebind <
99                     _Tp >::other _Tp_alloc_type;
100                 struct _Vector_impl:public _Tp_alloc_type {
101                         _Tp *_M_start;
102                         _Tp *_M_finish;
103                 };
104               public:_Vector_impl _M_impl;
105         };
106       template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp,
107             _Alloc >
108         {
109                 typedef _Vector_base < _Tp, _Alloc > _Base;
110                 typedef vector < _Tp, _Alloc > vector_type;
111                 typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
112               public:typedef _Tp value_type;
113                 typedef typename _Tp_alloc_type::const_pointer const_pointer;
114                 typedef typename _Tp_alloc_type::
115                     const_reference const_reference;
116                 typedef __gnu_cxx::__normal_iterator < const_pointer,
117                     vector_type > const_iterator;
118                 const_iterator begin() const {
119                         return const_iterator(this->_M_impl._M_start);
120                 } const_iterator end() const {
121                         return const_iterator(this->_M_impl._M_finish);
122                 } unsigned int size() const {
123                         return end() - begin();
124                 } const_reference operator[] (unsigned int __n)const {
125         }};
126 }
127
128 namespace Inkscape {
129         namespace Text {
130                 class Layout {
131                       public:class iterator;
132                         inline iterator end() const;
133                         inline unsigned lineIndex(iterator const &it) const;
134                         struct Chunk;
135                         struct Glyph {
136                         };
137                         struct Character {
138                                 inline Chunk const &chunk(Layout const *l) const {
139                         }};
140                         struct Chunk {
141                                 unsigned in_line;
142                         };
143                         struct Line {
144                         };
145                         std::vector < Line > _lines;
146                         std::vector < Character > _characters;
147                         std::vector < Glyph > _glyphs;
148                         class PredicateLineToCharacter {
149                                 Layout const *const _flow;
150                               public:inline PredicateLineToCharacter(Layout const
151                                                                 *flow):_flow
152                                     (flow) {
153                         }};
154                 };
155                 class Layout::iterator {
156                       public:friend class Layout;
157                       private:Layout const
158                             *_parent_layout;
159                         int _glyph_index;
160                         unsigned _char_index;
161                         bool _cursor_moving_vertically;
162                         double _x_coordinate;
163                         inline iterator(Layout const *p, unsigned c,
164                                         int g):_parent_layout(p),
165                             _glyph_index(g), _char_index(c),
166                             _cursor_moving_vertically(false),
167                             _x_coordinate(0.0) {
168                 }};
169                 inline Layout::iterator Layout::end() const {
170                         return iterator(this, _characters.size(),
171                                         _glyphs.size());
172                 } inline unsigned Layout::lineIndex(iterator const &it) const {
173                         return it._char_index ==
174                             _characters.size()? _lines.size() -
175                             1 : _characters[it._char_index].chunk(this).in_line;
176 }}};
177 void sp_te_adjust_linespacing_screen(GObject * text,
178                                      Inkscape::Text::Layout::
179                                      iterator const &start,
180                                      Inkscape::Text::Layout::
181                                      iterator const &end, SPDesktop * desktop,
182                                      double by)
183 {
184         Inkscape::Text::Layout const *layout;
185         SPStyle *style;
186         unsigned line_count = layout->lineIndex(layout->end());
187         double all_lines_height;
188         double average_line_height =
189             all_lines_height / (line_count == 0 ? 1 : line_count);
190         double zby;
191         switch (style->line_height.unit) {
192         case SP_CSS_UNIT_NONE:
193         default:
194                 if (fabs(style->line_height.computed) < 0.001)
195                         style->line_height.computed = by;
196                 else
197                         style->line_height.computed *=
198                             (average_line_height + zby) / average_line_height;
199         case SP_CSS_UNIT_EM:
200         case SP_CSS_UNIT_EX:
201         case SP_CSS_UNIT_PERCENT:
202                 if (fabs(style->line_height.value) < 0.001)
203                         style->line_height.value = by;
204                 else
205                         style->line_height.value *=
206                             (average_line_height + zby) / average_line_height;
207         }
208 }