git.maemo.org Git - erwise/blob - Xl/XlFormatText.c

   1 /*
   2  * XlFormatText.c --
   3  *
   4  * Author: Teemu Rantanen <tvr@cs.hut.fi>
   5  * Copyright (c) 1992 Teemu Rantanen
   6  *                    All rights reserved
   7  *
   8  * Created: Tue Mar  3 02:54:45 1992 tvr
   9  * Last modified: Tue May 12 04:26:29 1992 tvr
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <sys/types.h>
  15 #include <limits.h>
  16
  17 #include "HTAnchor.h"
  18 #include "HTStyle.h"
  19 #include "../HText/HText.h"
  20
  21 #include "XlFormatText.h"
  22
  23 int xl_calc_position();
  24 int xl_character_width();
  25
  26 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  27
  28 /*
  29  * Set up how to format text (current left and right margins)
  30  */
  31 void xl_set_margins(p, left, right, c_l, c_r, x, y, low_y, m)
  32 HTextObject_t *p;
  33 int left, right;
  34 int *c_l, *c_r;
  35 int *x, *y;
  36 int low_y;
  37 int m;
  38 {
  39     int i;
  40
  41     switch (m) {
  42     case MARGIN_START_STYLE:
  43         i = xl_object_mode(p);
  44
  45         *c_l = xl_calc_position(p, I_LEFT, left, right);
  46
  47         *x = xl_calc_position(p, I_LEFT | I_FIRST, left, right);
  48
  49         if (i & STYLE_RAW) {
  50             *c_r = INT_MAX;
  51         } else {
  52
  53             if (i & STYLE_CHANGE_REGION_ON_TAB) {
  54
  55                 *c_r = xl_calc_position(p, I_MIDDLE_L, left, right);
  56
  57             } else {
  58
  59                 *c_r = xl_calc_position(p, I_RIGHT, left, right);
  60
  61             }
  62         }
  63         break;
  64
  65     case MARGIN_HANDLE_P_OBJECT:
  66         if (xl_object_mode(p) & STYLE_CHANGE_REGION_ON_TAB) {
  67
  68             *c_l = xl_calc_position(p, I_MIDDLE_R, left, right);
  69             *c_r = xl_calc_position(p, I_RIGHT, left, right);
  70             *y = low_y;
  71             *x = xl_calc_position(p, I_MIDDLE_R | I_FIRST, left, right);
  72
  73         } else {
  74
  75             *x += 60;           /* :-) */
  76
  77 #ifdef XL_DEBUG
  78             printf("xl_set_margins(): normal tab ... barf\n");
  79 #endif
  80         }
  81         break;
  82
  83 #ifdef XL_DEBUG
  84     default:
  85         printf("xl_set_margins: illegal mode\n");
  86 #endif
  87     }
  88 }
  89
  90
  91 /*
  92  * Check how many objects belongs to this line.
  93  */
  94 int xl_check_objects(pp, x_corner, y, right)
  95 HTextObject_t **pp;
  96 int *x_corner;
  97 int y;
  98 int right;
  99 {
 100     HTextObject_t *p, *p_old;
 101
 102     int x;
 103
 104     int r = 0;
 105
 106     p = *pp;
 107
 108     p_old = NULL;
 109
 110     x = *x_corner;
 111
 112     while (!r) {
 113         /*
 114          * Region ends ?
 115          */
 116         if (!p || (p->paragraph)) {
 117             r |= FORMAT_REGION_ENDS;
 118         }
 119         /*
 120          * End of text
 121          */
 122         if (!p) {
 123             break;
 124         }
 125         /*
 126          * New style?
 127          */
 128         if (p_old && (p_old->style != p->style)) {
 129             r |= FORMAT_NEW_STYLE;
 130             r |= FORMAT_REGION_ENDS;
 131         }
 132         /*
 133          * Text full ?
 134          */
 135         if ((x + p->width) >= right) {
 136             r |= FORMAT_NEXT_OBJECT_TOO_LONG;
 137         }
 138         /*
 139          * Setup object
 140          */
 141         p->x = x;
 142         p->y = y;
 143
 144         x += p->width + xl_wordgap(p);
 145
 146
 147         if (!r) {
 148             p_old = p;
 149
 150             p = p->next;
 151         }
 152     }
 153
 154     /*
 155      * Return pointer to where to go on.
 156      */
 157     if (p_old) {
 158         *pp = p;
 159     }
 160     *x_corner = x;
 161
 162     return r;
 163 }
 164
 165 /*
 166  * Set new x-koordinate if line of objects is not 'leftified'
 167  * Set new y coordinate above all objects.
 168  */
 169 void xl_modify_objects(p_start, p_end, right, mode)
 170 HTextObject_t *p_start;
 171 HTextObject_t *p_end;
 172 int right;
 173 int mode;
 174 {
 175     HTextObject_t *p = p_start;
 176     HTextObject_t *p_last;
 177
 178     int offset;
 179
 180     /*
 181      * Set last object
 182      */
 183
 184     if (p_start == p_end) {
 185
 186 #ifdef XL_DEBUG
 187         if (!p_start->paragraph) {
 188             printf("zero object ?\n");
 189         }
 190 #endif
 191         p_last = p_start;
 192
 193     } else if (p_end) {
 194
 195         p_last = p_end->prev;
 196
 197     } else {
 198
 199         for (p_last = p; p_last->next; p_last = p_last->next);
 200
 201     }
 202
 203     switch (xl_object_style(p_start)) {
 204     case STYLE_LEFTIFY:
 205         /*
 206          * Do nothing.
 207          */
 208         break;
 209
 210     case STYLE_CENTER:
 211
 212         offset = (right - (p_last->x + p_last->width)) / 2;
 213
 214         for (p; p != p_end; p = p->next) {
 215             p->x += offset;
 216         }
 217         break;
 218
 219 #ifdef XL_DEBUG
 220     default:
 221         printf("Style not supported yet\n");
 222 #endif
 223     }
 224 #if 0
 225     *newy = p_start->y + xl_lineheightandgap(p_start, p_end);
 226 #endif
 227 }
 228
 229
 230 /*
 231  *  width is a request which can be denied (in case of ftp-text for
 232  *  example)
 233  *  Maximum width used on the page is returned. Everything else on the screen
 234  *  is formatted using given width.
 235  */
 236 int XlFormatText(leftmargin, width, topmargin, vwidth, vheight, htext)
 237 int leftmargin, width;
 238 int topmargin;
 239 int *vwidth, *vheight;
 240 HText_t *htext;
 241 {
 242     int stepped_y;
 243
 244     int max_right_position = leftmargin;
 245
 246     /*
 247      * Current x,y coordinates.
 248      */
 249     int x, y;
 250
 251     /*
 252      * When there are many regions next to other, store starting
 253      * upper and lower levels
 254      */
 255     int low_y = 0;
 256     int high_y = 0;
 257
 258     /*
 259      * current format region
 260      */
 261     int current_left;
 262     int current_right;
 263
 264     /*
 265      * Point out line
 266      */
 267     HTextObject_t *p = htext->first;
 268
 269     HTextObject_t *p_start = 0;
 270
 271     /*
 272      * Should check ascend (if there is any text)
 273      */
 274     if (p) {
 275
 276         low_y = high_y = y = topmargin;
 277
 278         xl_set_margins(p, leftmargin, leftmargin + width,
 279                        &current_left, &current_right,
 280                        &x, &y, low_y, MARGIN_START_STYLE);
 281     }
 282     /*
 283      * Loop through text
 284      */
 285     while (p) {
 286         int mode;
 287
 288         int high_y_old;
 289
 290         stepped_y = 0;
 291
 292         high_y_old = y;
 293
 294         /*
 295          * What objects are on this line ?
 296          */
 297         p_start = p;
 298
 299         mode = xl_check_objects(&p, &x, y, current_right);
 300
 301         /*
 302          * Check for zero objects. This prevents endless loop and makes
 303          * sure this object will be modified
 304          */
 305         if ((p == p_start) && p && !p->paragraph &&
 306             (mode & FORMAT_NEXT_OBJECT_TOO_LONG)) {
 307             mode |= FORMAT_ONLY_OBJECT_TOO_LONG;
 308             p = p->next;
 309         }
 310         /*
 311          * Update object positions if needs justifying etc
 312          */
 313         xl_modify_objects(p_start, p, current_right, mode);
 314
 315         /*
 316          * Check maximum object x position
 317          */
 318
 319         if (p && p->prev &&
 320             ((p->prev->x + p->prev->width) > max_right_position)) {
 321             max_right_position = p->prev->x + p->prev->width;
 322         }
 323         if (xl_object_mode(p_start) & STYLE_RAW) {
 324             /*
 325              * Raw style HTextObject paragraphs
 326              */
 327
 328             if (p && p_start->paragraph) {
 329                 p = p->next;
 330
 331             }
 332             switch (p_start->paragraph) {
 333             case HTEXT_NEWLINE:
 334                 /*
 335                  * New line
 336                  */
 337                 x = current_left;
 338
 339                 y += xl_linespace(p_start, p);
 340
 341                 low_y = high_y = MAX(y, high_y);
 342                 break;
 343
 344             case HTEXT_TAB:
 345                 /*
 346                  * Tabulator
 347                  */
 348 #if 0
 349                 {
 350                     int i = 0;
 351                     HTextObject_t *pp;
 352
 353                     for (pp = p_start; pp != p; pp = pp->next) {
 354                         switch (pp->paragraph) {
 355                         case 0:
 356                             i += pp->length;
 357                             break;
 358
 359                         case HTEXT_TAB:
 360                             i = 0;
 361                         }
 362                     }
 363
 364                     i = 8 - (i % 8);
 365
 366                     x += xl_character_width(p_start) * i;
 367                 }
 368 #endif
 369                 {
 370                     int i;
 371                     int cl = xl_character_width(p_start);
 372
 373                     i = ((x - leftmargin) % (cl * 8));
 374
 375                     x += (cl * 8) - i;
 376                 }
 377
 378                 break;
 379             }
 380         } else {
 381             /*
 382              * Hypertext style
 383              */
 384
 385             /*
 386              * Wrap
 387              */
 388             if (mode & FORMAT_NEXT_OBJECT_TOO_LONG) {
 389                 x = current_left;
 390                 y += xl_linespace(p_start, p);
 391
 392                 high_y = MAX(y, high_y);
 393
 394                 if (mode & FORMAT_ONLY_OBJECT_TOO_LONG) {
 395                     low_y = high_y;
 396                 }
 397                 stepped_y++;
 398             }
 399             /*
 400              * Check paragraph objects
 401              */
 402             if (p_start->paragraph) {
 403                 switch (p_start->paragraph) {
 404                 case HTEXT_NEWLINE:
 405
 406                     x = current_left;
 407                     if (!stepped_y) {
 408                         y += xl_linespace(p_start, p);
 409
 410                         stepped_y++;
 411
 412                         high_y = MAX(y, high_y);
 413                     }
 414                     high_y = y;
 415
 416 #ifdef XL_DEBUG
 417                     printf("XlFormatText(): there should not be newlines in htext\n");
 418 #endif
 419                     break;
 420
 421                 case HTEXT_PARAGRAPH:
 422
 423                     if (!stepped_y) {
 424                         y += xl_linespace(p_start, p);
 425                         y += xl_paragraphspace(p_start, p);
 426
 427                         stepped_y++;
 428                     }
 429                     low_y = high_y = y;
 430
 431                     xl_set_margins(p, leftmargin, leftmargin + width,
 432                                    &current_left, &current_right,
 433                                    &x, &y, low_y, MARGIN_START_STYLE);
 434                     break;
 435
 436                 case HTEXT_TAB:
 437
 438                     xl_set_margins(p, leftmargin, leftmargin + width,
 439                                    &current_left, &current_right, &x, &y,
 440                                    low_y, MARGIN_HANDLE_P_OBJECT);
 441                     break;
 442
 443                 case HTEXT_CONTINUE:
 444                     printf("format: dont understand continued objects here\n");
 445                     exit(1);
 446                     break;
 447
 448                 }
 449
 450                 p = p->next;
 451
 452             }
 453         }
 454
 455         /*
 456          * Make sure paragraph endings happen
 457          */
 458         if (p && (p->style != p_start->style)) {
 459             mode |= FORMAT_NEW_STYLE;
 460         }
 461         /*
 462          * Check for new style
 463          */
 464         if (mode & FORMAT_NEW_STYLE) {
 465             /*
 466              * Make sure one and only line is advanced always
 467              */
 468             if (y < high_y) {
 469                 if (!stepped_y) {
 470                     high_y += xl_linespace(p_start, p);
 471                 }
 472                 high_y += xl_stylespace(p_start, p);
 473
 474                 y = low_y = high_y;
 475
 476                 stepped_y++;
 477             } else {
 478                 if (high_y_old == high_y) {
 479                     high_y += xl_linespace(p_start, p);
 480                 }
 481                 if (p) {
 482                     high_y += xl_stylespace_before(p, p);
 483                 }
 484                 high_y += xl_stylespace(p_start, p);
 485
 486                 y = low_y = high_y;
 487
 488                 stepped_y++;
 489             }
 490
 491             xl_set_margins(p, leftmargin, leftmargin + width,
 492                            &current_left, &current_right,
 493                            &x, &y, low_y, MARGIN_START_STYLE);
 494         }
 495     }
 496
 497 #if 0
 498     /*
 499      * Check region ending
 500      */
 501     /* tab sivulle tai tab sivulleyl|s depending on object and so on */
 502     /* p = p->next */
 503     /* set regions with margin_handle_p_object */
 504     /* check where to start (y, x). x = regionstart or tab */
 505
 506     if ((mode & FORMAT_REGION_ENDS) && p) {
 507         int i;
 508
 509         i = p->paragraph;
 510
 511         switch (i) {
 512         case HTEXT_PARAGRAPH:
 513             high_y += xl_lineheightandgap(p_start, p);
 514
 515             y = low_y = high_y;
 516
 517             xl_set_margins(p, leftmargin, leftmargin + width,
 518                            &current_left, &current_right,
 519                            &x, &y, low_y, MARGIN_START_STYLE);
 520             break;
 521
 522         case HTEXT_NEWLINE:
 523             /*high_y += xl_lineheightandgap(p_start, p);*/
 524             y = low_y = high_y;
 525             x = current_left;
 526
 527             break;
 528
 529         case HTEXT_TAB:
 530             xl_set_margins(p, leftmargin, leftmargin + width,
 531                            &current_left, &current_right, &x, &y, low_y,
 532                            MARGIN_HANDLE_P_OBJECT);
 533             break;
 534
 535         case HTEXT_CONTINUE:
 536             printf("format: dont understand continued objects here\n");
 537             exit(1);
 538             break;
 539
 540         }
 541
 542         if (i) {
 543             p = p->next;
 544         }
 545     }
 546     /*
 547      * Check New style
 548      */
 549     if (mode & FORMAT_NEW_STYLE) {
 550         high_y = low_y = y;
 551
 552         xl_set_margins(p, leftmargin, leftmargin + width,
 553                        &current_left, &current_right,
 554                        &x, &y, low_y, MARGIN_START_STYLE);
 555     }
 556 #endif
 557
 558     /*
 559      * Give width and height to caller
 560      */
 561
 562     if (!stepped_y) {
 563         if (p_start)
 564             y += xl_linespace(p_start, p);
 565         else
 566             y = 1;
 567     }
 568     *vwidth = MAX(max_right_position, width);
 569
 570     *vheight = y;
 571
 572     return 0;
 573 }