home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / CSAPE32.ARJ / SOURCE / CSSRC / SDPLOAT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-04  |  15.5 KB  |  645 lines
  1. /*
  2.     sdploat.c
  3.  
  4.     % sed_Ploat
  5.  
  6.     C-scape 3.2
  7.     Copyright (c) 1988 by Oakland Group, Inc.
  8.     ALL RIGHTS RESERVED.
  9.  
  10.     Revision History
  11.     ---------------------
  12.      8/22/88 jmd    is now called tbdraw
  13.      9/15/88 jmd    changed winptd_struct to ptd_struct, preened phlush_s
  14.                     made phlush static, removed viddecl.h
  15.  
  16.      1/25/89 jdc    fixed trailing color bug
  17.      3/24/89 jmd    added sed_ macros, removed sed back attr
  18.      3/29/89 jmd    Added CSPRIV modifier
  19.      5/19/89 jmd    renamed exp to expan to shut up lint
  20.      5/26/89 jmd    Sped up by using ptd_Clear
  21.      5/27/89 jmd    added field painting
  22.      5/29/89 jmd    added shadows
  23.      6/11/89 jmd    added field only paint mode
  24.      6/12/89 jmd    is now called sdploat
  25.      7/21/89 jmd/gam fixed attr problem with FIELDS only
  26.      8/08/89 jmd     added some NULL tests
  27.      8/16/89 jdc    Fixed field marking
  28.      8/24/89 jdc    Fixed call to opbox_clip
  29.      9/10/89 jmd    Fixed initialization problem in field only case
  30.      9/12/89 jmd    Fixed last bug in sed_Ploat
  31.  
  32.      3/28/90 jmd    ansi-fied
  33.      5/01/90 jdc    removed trailing '\n' requirement
  34.      6/01/90 jmd    changed flag to flagg to avoid DG conflict
  35.      6/05/90 jmd    moved prototype of phlush to after the struct
  36.      8/09/90 jdc    added wrap_char
  37.     12/04/90 jdc    fixed wrap past window width problem
  38. */
  39.  
  40. #include "sed.h"            /* these routines need access to the dmgr */
  41. #include "tbpriv.h"            /* For tb_FindLine() */
  42.  
  43. #define SAVE_HINTS
  44.  
  45. #define TEXT    1
  46. #define CHR        2
  47. #define DONE    3
  48. #define FIELDS    4        /* ploat fields only */
  49.  
  50. struct phlush_s {
  51.  
  52.     sed_type            sed;
  53.     ptd_struct            *ptd;
  54.  
  55.     bblock_type            b, phlushb;
  56.     char               *t, *phlusht;
  57.     char                phlushs;
  58.     unsigned int        phlusho, off, blen;
  59.     int                    col, phlushc, flen, mark, done;
  60.     ocbox                paintbox, markbox;
  61.     opcoord                ytext;
  62.     opcoord                fwid, fhgt;
  63.  
  64.     int                    blankrow;
  65.     int                    fldno;                /* field hints */
  66.     int                    fldrow;
  67.  
  68.     byte                attr;
  69. };
  70.  
  71. OSTATIC void CSPRIV phlush(struct phlush_s *f, int flagg);
  72.  
  73. #define f_reset(f)  { f.phlushb = f.b; f.phlusht = f.t;\
  74.     f.phlushc = (f.paintbox.leftcol > f.col) ? f.paintbox.leftcol : f.col;}
  75.  
  76.  
  77. void sed_Ploat(sed_type sed, ptd_struct *ptd, int blankrow)
  78. /*
  79.     Ploats text and fields within the region of the sed specified by the ptd.
  80.     This is only called by sedwin_Class
  81. */
  82. {
  83.     struct phlush_s f;
  84.     tb_type     tb;
  85.     bblock_type b;
  86.     unsigned int off;
  87.     long         offset, space, boff;
  88.     int         scol, width, back, tab_size, dif, expan;
  89.  
  90.     tb = sed_GetTextbuf(sed);
  91.     cs_Assert(tb_Ok(tb), CS_TB_DL_TB, 0);
  92.  
  93.     f.sed = sed;
  94.     f.ptd = ptd;
  95.  
  96.     opbox_charcoords(ptd->relboxp, win_GetFont(sed), &(f.paintbox));
  97.     f.fhgt = win_GetFontHeight(sed);
  98.     f.fwid = win_GetFontWidth(sed);
  99.     f.ytext = (f.paintbox.toprow + 1) * f.fhgt;
  100.     f.paintbox.toprow += sed_GetYoffset(sed);
  101.     f.paintbox.botrow += sed_GetYoffset(sed);
  102.     f.paintbox.leftcol += sed_GetXoffset(sed);
  103.     f.paintbox.rightcol += sed_GetXoffset(sed);
  104.  
  105.     /* initialize field hints */
  106.     f.fldrow = f.paintbox.toprow;
  107.     f.fldno = menu_GetGRow(sed_GetMenu(sed), f.fldrow) - 1;
  108.     f.blankrow = blankrow;
  109.  
  110.     if (sed_GetPaintFlag(sed) == SDPF_FIELDS) {
  111.         /* only ploat the fields */
  112.         for (; f.paintbox.toprow <= f.paintbox.botrow;
  113.             f.paintbox.toprow++, f.ytext += f.fhgt) {
  114.  
  115.             f.phlushc = f.paintbox.leftcol;
  116.             f.col    = f.paintbox.rightcol;
  117.             phlush(&f, FIELDS);
  118.         }
  119.  
  120.         return;
  121.     }
  122.  
  123.     b = tb->bbc->b;                        /* save current hints */
  124.     off = b->off;
  125.     space = b->row;
  126.     boff = tb->offset;
  127.     scol = tb->exp_len;
  128.     dif = tb->len;
  129.     back = tb->nend;
  130.  
  131.     f.done = FALSE;
  132.     if (tb_FindLine(tb, f.paintbox.toprow) <= 0) {
  133.         f.done = TRUE;
  134.         f.b = tb->bbc->b;
  135.         while (f.b->next != NULL) {
  136.             f.b = f.b->next;
  137.         }
  138.     }
  139.     else {
  140.         f.b = tb->bbc->b;
  141.     }
  142.     offset = tb->offset;                        /* initialize */
  143.     f.t = f.b->start;
  144.     f.off = f.b->off;
  145.     f.blen = f.b->len;
  146.     tab_size = tb->tab_size;
  147.     width = tb->width;
  148.     if ((f.mark = tb->mark) != TED_NOMARK) {
  149.         box_sort(&(f.markbox), &(tb->markbox), (f.mark == TED_MARK) ? BOXSORT_ROW:BOXSORT_COL);
  150.     }
  151.  
  152.     tb->bbc->b = b;                        /* reset hints */
  153.     b->off = off;
  154.     b->row = space;
  155.     tb->offset = boff;
  156.     tb->exp_len = scol;
  157.     tb->len = dif;
  158.     tb->nend = back;
  159.                                             /* loop through all the rows */
  160.     for (; f.paintbox.toprow <= f.paintbox.botrow;
  161.         f.paintbox.toprow++, f.ytext += f.fhgt) {
  162.  
  163.         f.col    = 0;
  164.         space    = -1L;
  165.         f.phlushb = f.b;
  166.         f.phlusht = f.t;
  167.         f.phlusho = f.off;
  168.         f.phlushc = f.paintbox.leftcol;
  169.         f.attr     = f.b->attr;
  170.  
  171.         while (!f.done) {
  172.  
  173.             if (f.t[f.off] == '\t') {
  174.                 if (f.col >= width + WRAP_CUTOFF) {
  175.                     space = -1L;
  176.                     break;
  177.                 }
  178.                 expan = tab_size - (f.col % tab_size);
  179.                 phlush(&f, TEXT);
  180.                 if ((dif = f.paintbox.leftcol - f.col) >= expan) {
  181.                     f.col += expan;
  182.                     dif = expan;
  183.                     f.flen = 0;
  184.                 }
  185.                 else if (dif <= 0) {
  186.                     dif = 1;
  187.                     f.flen = 1;
  188.                 }
  189.                 else {
  190.                     f.col += dif;
  191.                     f.flen = 0;
  192.                 }
  193.                 f.phlushs = tb->tab_char;
  194.                 phlush(&f, CHR);
  195.                 f.flen = expan - dif;
  196.                 phlush(&f, DONE);
  197.                 offset++;
  198.                 space = offset;
  199.                 scol = f.col;
  200.             }
  201.              else if (f.t[f.off] == '\n') {
  202.                 phlush(&f, TEXT);
  203.                 if (f.col < f.paintbox.leftcol) {
  204.                     f.col++;
  205.                     f.flen = 0;
  206.                 }
  207.                 else {
  208.                     f.flen = 1;
  209.                 }
  210.                 f.phlushs = tb->newline_char;
  211.                 phlush(&f, CHR);
  212.                 offset++;
  213.                 space = -1L;
  214.                 break;
  215.             }
  216.             else {
  217.                 if (f.t[f.off] == ' ' || f.t[f.off] == tb->wrap_char) {
  218.                     if (f.col >= width + WRAP_CUTOFF) {
  219.                         space = -1L;
  220.                         break;
  221.                     }
  222.                     f.col++;
  223.                     offset++;
  224.                     space = offset;                /* parms for char after space */
  225.                     scol = f.col;
  226.                 }
  227.                 else if (f.col >= width) {
  228.                     break;
  229.                 }
  230.                 else {
  231.                     f.col++;
  232.                     offset++;
  233.                 }
  234.                 (f.off)++;
  235.                 if (f.off >= f.blen) {
  236.                     if (f.b->next == NULL) {
  237.                         f.done = TRUE;
  238.                         break;
  239.                     }
  240.                     f.b = f.b->next;
  241.                     f.t = f.b->start;
  242.                     f.off = 0;
  243.                     f.blen = f.b->len;
  244.                     f.attr = f.b->attr;
  245.                 }
  246.             }
  247.             if (f.col <= f.phlushc) {
  248.                 f.phlushb = f.b;
  249.                 f.phlusht = f.t;
  250.                 f.phlusho = f.off;
  251.             }
  252.         }
  253.         if (!f.done && space != -1L) {         /* do wrap */
  254.             back = (int)(offset - space);    /* walk back bblocks */
  255.             while (back > f.off) {
  256.                 back -= (f.off + 1);
  257.                 f.b = f.b->prev;
  258.                 f.off = f.b->len - 1;
  259.             }
  260.             f.t = f.b->start;
  261.             f.off -= back;
  262.             f.blen = f.b->len;
  263.             offset = space;
  264.             f.col = scol;
  265.             f.attr = f.b->attr;
  266.         }
  267.         phlush(&f, TEXT);
  268.         f.flen = f.paintbox.rightcol - f.col + 1;
  269.         phlush(&f, DONE);
  270.     }
  271. }
  272.  
  273. static void CSPRIV phlush(struct phlush_s *f, int flagg)
  274. /*
  275.     Ploat a strip of text/fields as requested by sed_Ploat
  276.     flag can be:
  277.         FIELDS    paint only fields.
  278.         TEXT    paint text and fields.
  279.         CHR        paint a single characters, repeated (with fields also).
  280.         DONE    paint trailing spaces (with fields).
  281. */
  282. {
  283.     int     len, len2, len3, dif;
  284.     byte     attr;
  285.     ocbox     pbox, mbox;
  286.     opbox  *relboxp, clrbox;
  287.     ptd_struct *ptd;
  288.  
  289.     int               pcol;        /* current paint column */
  290.     int               endcol;        /* current last paint column */
  291.     int               fcol;        /* firct column of current field */
  292.     int               fldno;        /* current field number */
  293.     opcoord        xcol;
  294.     field_type     field;
  295.     sed_type    sed;
  296.     menu_type    menu;
  297.     int            tlen;
  298.     boolean        painting, fpaint;
  299.     boolean        pclear = FALSE;
  300.     boolean        mark = FALSE;
  301.  
  302.     /* save repeated indirections */
  303.     pbox.toprow = f->paintbox.toprow;
  304.     pbox.botrow = f->paintbox.botrow;
  305.     pbox.leftcol = f->paintbox.leftcol;
  306.     pbox.rightcol = f->paintbox.rightcol;
  307.  
  308.     mbox.toprow = f->markbox.toprow;
  309.     mbox.botrow = f->markbox.botrow;
  310.     mbox.leftcol = f->markbox.leftcol;
  311.     mbox.rightcol = f->markbox.rightcol;
  312.  
  313.     ptd = f->ptd;
  314.     sed = f->sed;
  315.     menu = sed_GetMenu(f->sed);
  316.  
  317.     /** figure out how much we have to flush **/
  318.     /*         len is the total number of characters to paint */
  319.     /*        len3 is the amount to paint during one pass */
  320.     /*         phlushc is the starting column */
  321.  
  322.     if (f->phlushc > pbox.rightcol) {         /* nothing to display */
  323.         len = 0;
  324.         if (flagg != TEXT) {
  325.             f->col += f->flen;
  326.         }
  327.     }
  328.     else if (flagg == TEXT || flagg == FIELDS) {
  329.         len = f->col - f->phlushc;
  330.     }
  331.     else { /* flagg == CHR || DONE */
  332.         len = f->flen - (f->phlushc - f->col);     /* those fields! */
  333.         f->col += f->flen;
  334.     }
  335.  
  336.     /* clip against endcol */
  337.     if ((dif = f->phlushc + len - 1 - pbox.rightcol) > 0) {
  338.         len = len - dif;
  339.     }
  340.  
  341.     /** Loop until everything is painted **/
  342.  
  343.     while (len > 0) {
  344.  
  345.         if (flagg == FIELDS) {
  346.             len3 = len;
  347.             attr = win_GetAttr(sed);
  348.         }
  349.         else {
  350.             /* clip against bblock */
  351.             if (flagg != TEXT || (len2 = f->phlushb->len - f->phlusho) > len) {
  352.                 len2 = len;
  353.             }
  354.  
  355.             /* test for marking */
  356.             mark = FALSE;
  357.             len3 = len2;
  358.             if (pbox.toprow > mbox.botrow || pbox.toprow < mbox.toprow) {
  359.                 /* skip marking tests */
  360.                 ;
  361.             }
  362.             else if (f->mark == TED_MARK) {
  363.                 /* figure out how to handle the marked region */
  364.  
  365.                 if (pbox.toprow == mbox.toprow && pbox.toprow == mbox.botrow) {
  366.                     if (f->phlushc < mbox.leftcol) {
  367.                         len3 = mbox.leftcol - f->phlushc;
  368.                     }
  369.                     else if (f->phlushc <= mbox.rightcol) {
  370.                         len3 = mbox.rightcol - f->phlushc + 1;
  371.                         mark = TRUE;
  372.                     }
  373.                 }
  374.                 else if (pbox.toprow == mbox.toprow) {
  375.                     if (f->phlushc < mbox.leftcol) {
  376.                         len3 = mbox.leftcol - f->phlushc;
  377.                     }
  378.                     else {
  379.                         mark = TRUE;
  380.                     }
  381.                 }
  382.                 else if (pbox.toprow == mbox.botrow) {
  383.                     if (f->phlushc <= mbox.rightcol) {
  384.                         len3 = mbox.rightcol - f->phlushc + 1;
  385.                         mark = TRUE;
  386.                     }
  387.                 }
  388.                 else {
  389.                     mark = TRUE;
  390.                 }
  391.             }
  392.             else if (f->mark == TED_COLMARK) {
  393.                 /* figure out how to handle the column marked region */
  394.  
  395.                 if (f->phlushc > mbox.rightcol) {
  396.                     ;
  397.                 }
  398.                 else if (f->phlushc < mbox.leftcol) {
  399.                     len3 = mbox.leftcol - f->phlushc;
  400.                 }
  401.                 else {
  402.                     mark = TRUE;
  403.                     len3 = mbox.rightcol - f->phlushc + 1;
  404.                 }
  405.             }
  406.  
  407.             /* compare plot length with block length */
  408.             if (len3 < 0 || len2 < len3) {
  409.                 len3 = len2;
  410.             }
  411.  
  412.             /* figure out the attribute to use */
  413.             if (sed_GetPaintFlag(sed) == SDPF_SHADOW) {
  414.                 /* use the shadow color */
  415.                 attr = win_GetShadowAttr(sed);
  416.             }
  417.             else if (mark) {
  418.                 attr = sed_GetSelAttr(sed);
  419.             }
  420.             else if (flagg == DONE) {
  421.                 attr = (f->attr == DEF_COLOR) ? win_GetAttr(sed) : f->attr;
  422.             }
  423.             else {
  424.                 attr = (f->phlushb->attr == DEF_COLOR) ? win_GetAttr(sed) : f->phlushb->attr;
  425.             }
  426.         }
  427.  
  428.         /** sit in a nasty loop and plot all the text and fields within len3 **/
  429.  
  430.         if (f->fldrow != pbox.toprow) {
  431.             /* different row than last time */
  432.             fldno = menu_GetGRow(menu, pbox.toprow) - 1;
  433.             f->fldrow = pbox.toprow;
  434.         }
  435.         else {
  436.             fldno = f->fldno;
  437.         }
  438.  
  439.         pcol = f->phlushc;
  440.         endcol = pcol + len3 - 1;
  441.         painting = TRUE;
  442.  
  443.         /* paint a series of text/field slots (either of which can be 0 long) */
  444.  
  445.         while (painting) {
  446.             /* reset flags */
  447.             fpaint = FALSE;
  448.             tlen = 0;
  449.  
  450.             if (fldno < 0 || 
  451.                 ((fcol = field_GetCol(field = menu_GetField(menu, fldno))) > endcol)) {
  452.  
  453.                 /* paint rest of the text */
  454.                 tlen = endcol - pcol + 1; 
  455.                 painting = FALSE;
  456.  
  457.                 /* remember what field we were on */
  458.                 f->fldno = fldno;
  459.             }
  460.             else if (field_GetLastCol(field) >= pcol) {
  461.                 /* a field lies within the slot */
  462.                 fpaint = TRUE;
  463.  
  464.                 /* test for text before the field */
  465.                 if (fcol > pcol) {
  466.                     tlen = fcol - pcol;
  467.                 }
  468.             }
  469.  
  470.             /* text paint */
  471.             if (tlen > 0) {
  472.                 if (flagg != FIELDS) {
  473.                     /* set up paint data */
  474.                     xcol = (pcol - sed_GetXoffset(f->sed)) * f->fwid;
  475.  
  476.                     /* plot the text */
  477.                     if (flagg == TEXT) {
  478.                          ptd_PlotText(ptd, xcol, f->ytext, 
  479.                                  f->phlusht + f->phlusho + (pcol - f->phlushc), 
  480.                                  0, attr, tlen);
  481.                     }
  482.                     else if (flagg == CHR) {
  483.                         ptd_PlotText(ptd, xcol, f->ytext, NULL, f->phlushs, attr, tlen);
  484.                     }
  485.                     else {
  486.                         /* Clear the region directly.
  487.                            Set up coords for clear (handled below).
  488.                         */
  489.                         pclear = TRUE;
  490.  
  491.                         clrbox.xmin = xcol;
  492.                         clrbox.xmax = xcol + (tlen * f->fwid);
  493.                         clrbox.ymin = f->ytext - f->fhgt;
  494.                         clrbox.ymax = f->ytext;
  495.                     }
  496.                 }
  497.  
  498.                 /* advance pcol */
  499.                 pcol += tlen;
  500.             }
  501.  
  502.             /* field paint */
  503.             if (fpaint) {
  504.  
  505.                 /* Paint field, if it isn't blanked */
  506.                 if (f->blankrow < 0 || field_GetRow(field) < f->blankrow) {
  507.                     /** Paint the field **/
  508.                     sd_plot_field(sed, field, fldno, ptd);
  509.                 }
  510.                 else {
  511.                     /** paint a blank field **/
  512.                     /* Clear the region directly.
  513.                        Set up coords for clear (handled below).
  514.                        If text is also cleared combine into one operation
  515.                     */
  516.                     if (pclear) {
  517.                         /* use the text clear coords */
  518.                         clrbox.xmax = (field_GetLastCol(field) - sed_GetXoffset(sed) + 1) * f->fwid;
  519.                     }
  520.                     else {
  521.                         pclear = TRUE;
  522.                         clrbox.ymin = (field_GetRow(field) - sed_GetYoffset(sed)) * f->fhgt;
  523.                         clrbox.ymax = (field_GetRow(field) - sed_GetYoffset(sed) + 1) * f->fhgt;
  524.                         clrbox.xmin = (field_GetCol(field) - sed_GetXoffset(sed)) * f->fwid;
  525.                         clrbox.xmax = (field_GetLastCol(field) - sed_GetXoffset(sed) + 1) * f->fwid;
  526.                     }
  527.                 }
  528.  
  529.                 /* advance pcol */
  530.                 if (field_GetLastCol(field) >= pcol) {
  531.                     pcol = field_GetLastCol(field) + 1;
  532.                 }
  533.             }
  534.  
  535.             if (pclear) {
  536.                 /* a request to clear a region 
  537.                    temporarily substitute the ptd's relbox with a new
  538.                    one so we can clear the field box with ptd_Clear
  539.                 */
  540.                 pclear = FALSE;
  541.  
  542.                 /* clip against the ptd */
  543.                 relboxp = ptd->relboxp;
  544.                 if (opbox_clipbox(relboxp, &clrbox) != 0) {
  545.                     ptd->relboxp = &clrbox;
  546.                     ptd_Clear(ptd, disp_GetAttrBgColor(attr));
  547.                     ptd->relboxp = relboxp;
  548.                 }
  549.             }
  550.  
  551.             /* get next field in row */
  552.             if (fldno >= 0) {
  553.                 fldno = field_GetRight(field);
  554.             }
  555.  
  556.         }    /* while (painting) */
  557.  
  558.         /* adjust len3 (we may have painted more than asked for) */
  559.         len3 = pcol - f->phlushc;
  560.  
  561.         /* compute how much more there is to ploat */
  562.         len -= len3;
  563.         if (f->phlushc <= f->col) {
  564.             f->phlushc += len3;
  565.         }
  566.  
  567.         /* test if we've crossed a block boudary */
  568.         if (flagg == TEXT) {
  569.             f->phlusho += len3;
  570.  
  571.  
  572.             while (f->phlusho >= f->phlushb->len) {
  573.                 f->phlusho -= f->phlushb->len;
  574.  
  575.                 if ((f->phlushb = f->phlushb->next) == NULL) {
  576.                     break;
  577.                 }
  578.  
  579.                 f->phlusht = f->phlushb->start;
  580.             }
  581.         }
  582.     }        /* while (len > 0) */
  583.  
  584.  
  585.     if (flagg == CHR) {
  586.         (f->off)++;
  587.         f->attr = f->b->attr;
  588.         while (f->off >= f->blen) {
  589.             if (f->b->next == NULL) {
  590.                 f->done = TRUE;
  591.                 break;
  592.             }
  593.             f->b = f->b->next;
  594.             f->t = f->b->start;
  595.             f->off = 0;
  596.             f->blen = f->b->len;
  597.         }
  598.     }
  599.  
  600.     if (flagg != FIELDS) {
  601.         f->phlushb = f->b;
  602.         f->phlusht = f->t;
  603.         f->phlusho = f->off;
  604.     }
  605. }
  606.  
  607. void box_sort(ocbox *dbox, mcbox *sbox, int mode)
  608. /*
  609.     'mode'  is either BOXSORT_ROW or BOXSORT_COL
  610. */
  611. {
  612.     if (sbox->anchor_row <= sbox->cleat_row) {
  613.         dbox->toprow = sbox->anchor_row;
  614.         dbox->botrow = sbox->cleat_row;
  615.         if (mode == BOXSORT_ROW) {
  616.             if (sbox->anchor_row == sbox->cleat_row) {
  617.                 dbox->leftcol  = (sbox->anchor_col < sbox->cleat_col) ? sbox->anchor_col : sbox->cleat_col;
  618.                 dbox->rightcol = (sbox->anchor_col > sbox->cleat_col) ? sbox->anchor_col : sbox->cleat_col;
  619.             }
  620.             else {
  621.                 dbox->leftcol  = sbox->anchor_col;
  622.                 dbox->rightcol = sbox->cleat_col;
  623.             }
  624.         }
  625.     }
  626.     else {
  627.         dbox->toprow = sbox->cleat_row;
  628.         dbox->botrow = sbox->anchor_row;
  629.         if (mode == BOXSORT_ROW) {
  630.             dbox->leftcol  = sbox->cleat_col;
  631.             dbox->rightcol = sbox->anchor_col;
  632.         }
  633.     }
  634.     if (mode == BOXSORT_COL) {
  635.         if (sbox->anchor_col <  sbox->cleat_col) {
  636.             dbox->leftcol  = sbox->anchor_col;
  637.             dbox->rightcol = sbox->cleat_col;
  638.         }
  639.         else {
  640.             dbox->leftcol  = sbox->cleat_col;
  641.             dbox->rightcol = sbox->anchor_col;
  642.         }
  643.     }
  644. }
  645.