← Back to branch summary

~registry/texmacs/trunk

« back to all changes in this revision

Viewing changes to src/src/Typeset/boxes.hpp

  • Committer: mgubi
  • Date: 2009-06-04 15:13:41 UTC
  • Revision ID: svn-v4:64cb5145-927a-446d-8aed-2fb7b4773692:trunk:2717
Support for X11 TeXmacs.app on Mac

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/src/Typeset/boxes.hpp
 
1
 
 
2
/******************************************************************************
 
3
* MODULE     : boxes.hpp
 
4
* DESCRIPTION: the low level box structure
 
5
*              and formatting routines
 
6
* COPYRIGHT  : (C) 1999  Joris van der Hoeven
 
7
*******************************************************************************
 
8
* This software falls under the GNU general public license version 3 or later.
 
9
* It comes WITHOUT ANY WARRANTY WHATSOEVER. For details, see the file LICENSE
 
10
* in the root directory or <http://www.gnu.org/licenses/gpl-3.0.html>.
 
11
******************************************************************************/
 
12
 
 
13
#ifndef BOXES_H
 
14
#define BOXES_H
 
15
#include "basic.hpp"
 
16
#include "rectangles.hpp"
 
17
#include "path.hpp"
 
18
#include "renderer.hpp"
 
19
#include "font.hpp"
 
20
#include "language.hpp"
 
21
#include "hashmap.hpp"
 
22
#include "Graphics/frame.hpp"
 
23
#include "Graphics/grid.hpp"
 
24
 
 
25
#define MAX_SI 0x7fffffff
 
26
#define MIN_SI 0x80000000
 
27
 
 
28
#define STD_BOX       0
 
29
#define STACK_BOX     1
 
30
#define CONTROL_BOX   2
 
31
#define MOVE_BOX      3
 
32
#define SCROLL_BOX    4
 
33
 
 
34
/******************************************************************************
 
35
* The cursor class
 
36
******************************************************************************/
 
37
 
 
38
struct cursor_rep: concrete_struct {
 
39
  SI ox, oy;    // main cursor position
 
40
  SI delta;     // infinitesimal shift to the right
 
41
  SI y1;        // under base line
 
42
  SI y2;        // upper base line
 
43
  double slope; // slope of cursor
 
44
  bool valid;   // the cursor is valid
 
45
};
 
46
 
 
47
struct cursor {
 
48
  CONCRETE(cursor);
 
49
  cursor (SI x=0, SI y=0, SI delta=0, SI y1=0, SI y2=0,
 
50
          double slope=0.0, bool valid=true);
 
51
};
 
52
CONCRETE_CODE(cursor);
 
53
 
 
54
cursor copy (cursor cu);
 
55
bool operator == (cursor cu1, cursor cu2);
 
56
bool operator != (cursor cu1, cursor cu2);
 
57
ostream& operator << (ostream& out, cursor cu);
 
58
 
 
59
/******************************************************************************
 
60
* The selection class
 
61
******************************************************************************/
 
62
 
 
63
struct selection_rep: concrete_struct {
 
64
  rectangles rs;
 
65
  path start;
 
66
  path end;
 
67
  bool valid;
 
68
};
 
69
 
 
70
struct selection {
 
71
  CONCRETE(selection);
 
72
  selection (rectangles rs= rectangles(),
 
73
             path start= path(), path end= path (),
 
74
             bool valid= true);
 
75
};
 
76
CONCRETE_CODE(selection);
 
77
 
 
78
bool operator == (selection sel1, selection sel2);
 
79
bool operator != (selection sel1, selection sel2);
 
80
ostream& operator << (ostream& out, selection sel);
 
81
 
 
82
/******************************************************************************
 
83
* The graphical selection class
 
84
******************************************************************************/
 
85
 
 
86
struct gr_selection_rep;
 
87
struct gr_selection {
 
88
  CONCRETE(gr_selection);
 
89
  gr_selection (array<path> cp= array<path> (), SI dist= 0);
 
90
};
 
91
 
 
92
ostream& operator << (ostream& out, gr_selection sel);
 
93
 
 
94
typedef array<gr_selection> gr_selections;
 
95
tree as_tree (gr_selections sels);
 
96
 
 
97
/******************************************************************************
 
98
* The box class
 
99
******************************************************************************/
 
100
 
 
101
class box_rep;
 
102
struct lazy;
 
103
typedef array<double> point;
 
104
 
 
105
class box {
 
106
  ABSTRACT_NULL(box);
 
107
  inline box operator [] (int i);
 
108
  box operator [] (path p);
 
109
  operator tree ();
 
110
  bool operator == (box b2);
 
111
  bool operator != (box b2);
 
112
  friend inline int N (box b);
 
113
};
 
114
 
 
115
class box_rep: public abstract_struct {
 
116
private:
 
117
  SI x0, y0;    // offset w.r.t. parent box
 
118
 
 
119
public:
 
120
  SI x1, y1;    // under left corner (logical)
 
121
  SI x2, y2;    // upper right corner (logical)
 
122
  SI x3, y3;    // under left corner (ink)
 
123
  SI x4, y4;    // upper right corner (ink)
 
124
 
 
125
  path ip;      // corresponding inverse path in source tree
 
126
 
 
127
  /****************************** main routines ******************************/
 
128
 
 
129
  inline            box_rep (path ip);
 
130
  inline            virtual ~box_rep ();
 
131
  void              relocate (path p, bool force= false);
 
132
  virtual box       transform (frame fr);
 
133
  virtual operator  tree () = 0;
 
134
  virtual void      pre_display (renderer& ren);
 
135
  virtual void      post_display (renderer& ren);
 
136
  virtual void      display (renderer ren) = 0;
 
137
  virtual void      clear_incomplete (rectangles& rs, SI pixel,
 
138
                                      int i, int i1, int i2);
 
139
  virtual int       subnr ();
 
140
  virtual box       subbox (int i);
 
141
  virtual tree      action (tree t, SI x, SI y, SI delta);
 
142
  virtual void      loci (SI x, SI y, SI d, list<string>& ids, rectangles& rs);
 
143
  virtual void      position_at (SI x, SI y, rectangles& change_log);
 
144
  virtual void      collect_page_numbers (hashmap<string,tree>& h, tree page);
 
145
  virtual path      find_tag (string name);
 
146
 
 
147
  virtual int  reindex (int i, int item, int n);
 
148
  void redraw (renderer ren, path p, rectangles& l);
 
149
  void redraw (renderer ren, path p, rectangles& l, SI x, SI y);
 
150
 
 
151
  /*************************** positioning routines **************************/
 
152
 
 
153
  inline SI   w ();
 
154
  inline SI   h ();
 
155
  inline SI&  sx (int i);
 
156
  inline SI&  sy (int i);
 
157
  inline SI   sx1 (int i);
 
158
  inline SI   sy1 (int i);
 
159
  inline SI   sx2 (int i);
 
160
  inline SI   sy2 (int i);
 
161
  inline SI   sx3 (int i);
 
162
  inline SI   sy3 (int i);
 
163
  inline SI   sx4 (int i);
 
164
  inline SI   sy4 (int i);
 
165
  inline bool test_in (SI x, SI y);
 
166
 
 
167
  inline bool accessible ();
 
168
  inline bool decoration ();
 
169
 
 
170
  SI distance (int i, SI x, SI y, SI delta);
 
171
  bool in_rectangle (SI x1, SI y1, SI x2, SI y2);
 
172
  bool contains_rectangle (SI x1, SI y1, SI x2, SI y2);
 
173
 
 
174
  /******************* path conversions and cursor routines ******************/
 
175
 
 
176
  virtual path      find_lip ();
 
177
  virtual path      find_rip ();
 
178
  virtual path      find_left_box_path ();
 
179
  virtual path      find_right_box_path ();
 
180
  virtual path      find_box_path (SI x, SI y, SI delta, bool force);
 
181
  virtual cursor    find_cursor (path bp);
 
182
  virtual selection find_selection (path lbp, path rbp);
 
183
  virtual path      find_tree_path (path bp);
 
184
  virtual path      find_box_path (path p, bool& found);
 
185
       
 
186
  path      find_tree_path (SI x, SI y, SI delta);
 
187
  cursor    find_check_cursor (path p);
 
188
  selection find_check_selection (path lp, path rp);
 
189
 
 
190
  /************************ fine typesetting routines ************************/
 
191
 
 
192
  virtual double    left_slope ();
 
193
  virtual double    right_slope ();
 
194
  virtual SI        left_correction ();
 
195
  virtual SI        right_correction ();
 
196
  virtual SI        lsub_correction ();
 
197
  virtual SI        lsup_correction ();
 
198
  virtual SI        rsub_correction ();
 
199
  virtual SI        rsup_correction ();
 
200
  virtual SI        sub_lo_base (int level);
 
201
  virtual SI        sub_hi_lim  (int level);
 
202
  virtual SI        sup_lo_lim  (int level);
 
203
  virtual SI        sup_lo_base (int level);
 
204
  virtual SI        sup_hi_lim  (int level);
 
205
 
 
206
  /*************************** for graphical boxes ***************************/
 
207
 
 
208
  virtual frame     get_frame ();
 
209
  virtual grid      get_grid ();
 
210
  virtual void      get_limits (point& lim1, point& lim2);
 
211
 
 
212
  frame     find_frame (path bp, bool last= false);
 
213
  grid      find_grid (path bp);
 
214
  void      find_limits (path bp, point& lim1, point& lim2);
 
215
 
 
216
  virtual SI             graphical_distance (SI x, SI y);
 
217
  virtual gr_selections  graphical_select (SI x, SI y, SI dist);
 
218
  virtual gr_selections  graphical_select (SI x1, SI y1, SI x2, SI y2);
 
219
 
 
220
  /************************** retrieving information *************************/
 
221
 
 
222
  virtual int       get_type ();
 
223
  virtual tree      get_info (tree in);
 
224
  virtual int       get_leaf_left_pos ();
 
225
  virtual int       get_leaf_right_pos ();
 
226
  virtual string    get_leaf_string ();
 
227
  virtual font      get_leaf_font ();
 
228
  virtual color     get_leaf_color ();
 
229
  virtual language  get_leaf_language ();
 
230
  virtual tree      get_leaf_tree ();
 
231
  virtual lazy      get_leaf_lazy ();
 
232
  virtual SI        get_leaf_offset (string search);
 
233
 
 
234
  /******************************** animations *******************************/
 
235
 
 
236
  virtual int    anim_length ();
 
237
  virtual bool   anim_started ();
 
238
  virtual bool   anim_finished ();
 
239
  virtual void   anim_start_at (time_t at);
 
240
  virtual void   anim_finish_now ();
 
241
  virtual time_t anim_next_update ();
 
242
          void   anim_check_invalid (bool& flag, time_t& at, rectangles& rs);
 
243
  virtual void   anim_get_invalid (bool& flag, time_t& at, rectangles& rs);
 
244
 
 
245
  /********************************* obsolete ********************************/
 
246
 
 
247
  friend struct page_box_rep; // temporary friends for accessing x0 and y0
 
248
  friend struct lazy_paragraph_rep;
 
249
  friend class  phrase_box_rep;
 
250
  friend class  remember_box_rep;
 
251
  friend void make_eps (url dest, box b, int dpi= 600);
 
252
};
 
253
ABSTRACT_NULL_CODE(box);
 
254
 
 
255
extern int box_count;
 
256
inline box_rep::box_rep (path ip2):
 
257
  x0(0), y0(0), x1(0), y1(0), x2(0), y2(0), x3(0), y3(0), x4(0), y4(0),
 
258
  ip (ip2) { DEBUG(box_count++); }
 
259
inline box_rep::~box_rep () { DEBUG(box_count--); }
 
260
inline bool box_rep::test_in (SI x, SI y) {
 
261
  return (x>=x1) && (x<x2) && (y>=y1) && (y<y2); }
 
262
inline SI box_rep::w () { return x2-x1; }
 
263
inline SI box_rep::h () { return y2-y1; }
 
264
inline SI& box_rep::sx (int i) { return subbox(i)->x0; }
 
265
inline SI& box_rep::sy (int i) { return subbox(i)->y0; }
 
266
inline SI box_rep::sx1 (int i) { box b= subbox(i); return b->x0+ b->x1; }
 
267
inline SI box_rep::sy1 (int i) { box b= subbox(i); return b->y0+ b->y1; }
 
268
inline SI box_rep::sx2 (int i) { box b= subbox(i); return b->x0+ b->x2; }
 
269
inline SI box_rep::sy2 (int i) { box b= subbox(i); return b->y0+ b->y2; }
 
270
inline SI box_rep::sx3 (int i) { box b= subbox(i); return b->x0+ b->x3; }
 
271
inline SI box_rep::sy3 (int i) { box b= subbox(i); return b->y0+ b->y3; }
 
272
inline SI box_rep::sx4 (int i) { box b= subbox(i); return b->x0+ b->x4; }
 
273
inline SI box_rep::sy4 (int i) { box b= subbox(i); return b->y0+ b->y4; }
 
274
 
 
275
inline box box::operator [] (int i) { return rep->subbox(i); }
 
276
inline int N (box b) { return b.rep->subnr(); }
 
277
ostream& operator << (ostream& out, box b);
 
278
SI   get_delta (SI x, SI x1, SI x2);
 
279
bool outside (SI x, SI delta, SI x1, SI x2);
 
280
void make_eps (url dest, box b, int dpi);
 
281
path find_innermost_scroll (box b, path p);
 
282
path find_scrolled_tree_path (box b, path sp, SI x, SI y, SI delta);
 
283
void find_canvas_info (box b, path sp, SI& x, SI& y, SI& sx, SI& sy,
 
284
                       rectangle& outer, rectangle& inner);
 
285
 
 
286
extern bool   refresh_needed;
 
287
extern time_t refresh_next;
 
288
void          refresh_at (time_t t);
 
289
 
 
290
#define DECORATION        (-1)
 
291
#define DECORATION_LEFT   (-2)
 
292
#define DECORATION_MIDDLE (-3)
 
293
#define DECORATION_RIGHT  (-4)
 
294
#define DETACHED          (-5)
 
295
#define is_accessible(p) ((is_nil (p)) || ((p)->item >= 0))
 
296
#define is_decoration(p) ((!is_nil (p)) && ((p)->item < 0))
 
297
inline path descend (path ip, int i) {
 
298
  return (is_nil (ip) || (ip->item >= 0))? path (i, ip): ip; }
 
299
inline path decorate () {
 
300
  return path (DECORATION); }
 
301
inline path decorate (path ip) {
 
302
  return (is_nil (ip) || (ip->item >= 0))? path (DECORATION, ip): ip; }
 
303
inline path decorate_left (path ip) {
 
304
  return (is_nil (ip) || (ip->item >= 0))? path (DECORATION_LEFT, ip): ip; }
 
305
inline path decorate_middle (path ip) {
 
306
  return (is_nil (ip) || (ip->item >= 0))? path (DECORATION_MIDDLE, ip): ip; }
 
307
inline path decorate_right (path ip) {
 
308
  return (is_nil (ip) || (ip->item >= 0))? path (DECORATION_RIGHT, ip): ip; }
 
309
path descend_decode (path ip, int side);
 
310
 
 
311
inline bool box_rep::accessible () { return is_accessible (find_lip ()); }
 
312
inline bool box_rep::decoration () { return is_decoration (find_lip ()); }
 
313
 
 
314
tree attach_dip (tree ref, path ip);
 
315
#define attach_here(t,ip) attach_dip(t,ip),ip
 
316
#define attach_deco(t,ip) attach_dip(t,decorate(ip)),decorate(ip)
 
317
#define attach_left(t,ip) attach_dip(t,decorate_left(ip)),decorate_left(ip)
 
318
#define attach_middle(t,ip) \
 
319
  attach_dip(t,decorate_middle(ip)),decorate_middle(ip)
 
320
#define attach_right(t,ip) attach_dip(t,decorate_right(ip)),decorate_right(ip)
 
321
 
 
322
/******************************************************************************
 
323
* The graphical selection class (continued)
 
324
******************************************************************************/
 
325
 
 
326
struct gr_selection_rep: concrete_struct {
 
327
  array<path> cp;
 
328
  array<point> pts;
 
329
  point p;
 
330
  SI dist;
 
331
  curve c;
 
332
};
 
333
CONCRETE_CODE(gr_selection);
 
334
 
 
335
#endif // defined BOXES_H