home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / layout / layutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  77.0 KB  |  3,521 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19.  
  20.  
  21. #include "xp.h"
  22. #include "pa_parse.h"
  23. #include "layout.h"
  24. #include "laylayer.h"
  25. #include "laystyle.h"
  26. #include "libmocha.h"
  27. #include "stystruc.h"
  28. #include "stystack.h"
  29. #include "layers.h"
  30. #ifdef NSPR20
  31. #ifdef XP_MAC
  32. #include "prpriv.h"
  33. #else
  34. #include "private/prpriv.h"        /* for PR_NewNamedMonitor */
  35. #endif
  36. #endif /* NSPR20 */
  37. #include "intl_csi.h"
  38.  
  39. #ifdef EDITOR
  40. #include "edt.h"
  41. #endif
  42. #ifdef PROFILE
  43. #pragma profile on
  44. #endif
  45.  
  46. #ifdef XP_WIN16
  47. #define SIZE_LIMIT              32000
  48. #endif /* XP_WIN16 */
  49.  
  50. #define    FONT_FACE_INC    10
  51. #define    FONT_FACE_MAX    1000
  52.  
  53. void
  54. lo_GetElementBbox(LO_Element *element, XP_Rect *rect) 
  55. {
  56.     rect->left = element->lo_any.x + element->lo_any.x_offset;
  57.     rect->top = element->lo_any.y + element->lo_any.y_offset;
  58.     rect->right = rect->left + element->lo_any.width;
  59.     rect->bottom = rect->top + element->lo_any.height;
  60.  
  61.     switch(element->type)
  62.     {
  63.     case LO_IMAGE:
  64.     {
  65.         LO_ImageStruct *image = &element->lo_image;
  66.         rect->right  += 2 * (image->border_width + image->border_horiz_space);
  67.         rect->bottom += 2 * (image->border_width + image->border_vert_space);
  68.     }
  69.     break;
  70.  
  71.     case LO_SUBDOC:
  72.     {
  73.         LO_SubDocStruct *subdoc = &element->lo_subdoc;
  74.         rect->right  += 2 * (subdoc->border_width + subdoc->border_horiz_space);
  75.         rect->bottom += 2 * (subdoc->border_width + subdoc->border_vert_space);
  76.     }
  77.     break;
  78.  
  79.     case LO_TABLE:
  80.     {
  81.         LO_TableStruct *table = &element->lo_table;
  82.         rect->right  += 2 * (table->border_width + table->border_horiz_space);
  83.         rect->bottom += 2 * (table->border_width + table->border_vert_space);
  84.     }
  85.     break;
  86.  
  87.     case LO_CELL:
  88.     {
  89.         LO_CellStruct *cell = &element->lo_cell;
  90.         rect->right  += 2 * (cell->border_width + cell->border_horiz_space);
  91.         rect->bottom += 2 * (cell->border_width + cell->border_vert_space);
  92.     }
  93.     break;
  94.  
  95.     case LO_EMBED:
  96.     {
  97.         LO_EmbedStruct *embed = &element->lo_embed;
  98.         rect->right  += 2 * (embed->border_width + embed->border_horiz_space);
  99.         rect->bottom += 2 * (embed->border_width + embed->border_vert_space);
  100.     }
  101.     break;
  102.  
  103. #ifdef JAVA
  104.     case LO_JAVA:
  105.     {
  106.         LO_JavaAppStruct *java = &element->lo_java;
  107.         rect->right  += 2 * (java->border_width + java->border_horiz_space);
  108.         rect->bottom += 2 * (java->border_width + java->border_vert_space);
  109.     }
  110.     break;
  111. #endif
  112.  
  113.     default:
  114.         break;
  115.     }
  116. }
  117.  
  118. void
  119. lo_RefreshElement(LO_Element *element, CL_Layer *layer, Bool update_now)
  120. {
  121.     XP_Rect rect;
  122.     int32 x_offset, y_offset;
  123.     CL_Compositor *compositor = CL_GetLayerCompositor(layer);
  124.  
  125.     lo_GetElementBbox(element, &rect);
  126.     
  127.     lo_GetLayerXYShift(layer, &x_offset, &y_offset);
  128.     XP_OffsetRect(&rect, -x_offset, -y_offset);
  129.     CL_UpdateLayerRect(compositor, layer, &rect, (PRBool)update_now);
  130. }
  131.  
  132. /* Given a layout element, retrieve its anchor information. */
  133. LO_AnchorData *
  134. lo_GetElementAnchor(LO_Element *element)
  135. {
  136.     switch(element->type)
  137.     {
  138.         case LO_TEXT:
  139.             return element->lo_text.anchor_href;
  140.  
  141.         case LO_IMAGE:
  142.             return element->lo_image.anchor_href;
  143.  
  144.         case LO_TABLE:
  145.             return element->lo_table.anchor_href;
  146.  
  147.         case LO_SUBDOC:
  148.             return element->lo_subdoc.anchor_href;
  149.  
  150.         case LO_LINEFEED:
  151.             return element->lo_linefeed.anchor_href;
  152.  
  153.         default:
  154.             return NULL;
  155.     }
  156. }
  157.  
  158. /* Return an element's foreground color */
  159. void
  160. lo_GetElementFGColor(LO_Element *element, LO_Color *color)
  161. {
  162.     switch (element->type)
  163.     {
  164.     case LO_TEXT:
  165.         color->red   = element->lo_text.text_attr->fg.red;
  166.         color->green = element->lo_text.text_attr->fg.green;
  167.         color->blue  = element->lo_text.text_attr->fg.blue;
  168.         break;
  169.         
  170.     case LO_IMAGE:
  171.         color->red   = element->lo_image.text_attr->fg.red;
  172.         color->green = element->lo_image.text_attr->fg.green;
  173.         color->blue  = element->lo_image.text_attr->fg.blue;
  174.         break;
  175.  
  176.     case LO_SUBDOC:
  177.         color->red   = element->lo_subdoc.text_attr->fg.red;
  178.         color->green = element->lo_subdoc.text_attr->fg.green;
  179.         color->blue  = element->lo_subdoc.text_attr->fg.blue;
  180.         break;
  181.  
  182.     default:
  183.         XP_ASSERT(0);            /* Not implemented */
  184.         break;
  185.     }
  186. }
  187.  
  188. /* Set an element's foreground color */
  189. void
  190. lo_SetElementFGColor(LO_Element *element, LO_Color *color)
  191. {
  192.     switch (element->type)
  193.     {
  194.     case LO_TEXT:
  195.         element->lo_text.text_attr->fg.red = color->red;
  196.         element->lo_text.text_attr->fg.green = color->green;
  197.         element->lo_text.text_attr->fg.blue = color->blue;
  198.         break;
  199.         
  200.     case LO_IMAGE:
  201.         element->lo_image.text_attr->fg.red = color->red;
  202.         element->lo_image.text_attr->fg.green = color->green;
  203.         element->lo_image.text_attr->fg.blue = color->blue;
  204.         break;
  205.  
  206.     case LO_SUBDOC:
  207.         element->lo_subdoc.text_attr->fg.red = color->red;
  208.         element->lo_subdoc.text_attr->fg.green = color->green;
  209.         element->lo_subdoc.text_attr->fg.blue = color->blue;
  210.         break;
  211.  
  212.     default:
  213.         XP_ASSERT(0);            /* Not implemented */
  214.         break;
  215.     }
  216. }
  217.  
  218. void
  219. lo_ShiftElementList(LO_Element *e_list, int32 dx, int32 dy)
  220. {
  221.     LO_Element *eptr;
  222.  
  223.     if (e_list == NULL)
  224.     {
  225.         return;
  226.     }
  227.  
  228.     eptr = e_list;
  229.     while (eptr != NULL)
  230.     {
  231.         eptr->lo_any.x += dx;
  232.         eptr->lo_any.y += dy;
  233.         if (eptr->type == LO_CELL)
  234.         {
  235.             lo_ShiftCell((LO_CellStruct *)eptr, dx, dy);
  236.         }
  237.  
  238.         eptr = eptr->lo_any.next;
  239.     }
  240. }
  241.  
  242. NET_ReloadMethod
  243. LO_GetReloadMethod(MWContext *context)
  244. {
  245.     int32 doc_id;
  246.     lo_TopState *top_state;
  247.     lo_DocState *state;
  248.  
  249.     /*
  250.      * Get the unique document ID, and retreive this
  251.      * documents layout state.
  252.      */
  253.     doc_id = XP_DOCID(context);
  254.     top_state = lo_FetchTopState(doc_id);
  255.     if ((top_state == NULL)||(top_state->doc_state == NULL))
  256.     {
  257.         return NET_NORMAL_RELOAD;
  258.     }
  259.     state = top_state->doc_state;
  260.  
  261.     return (FORCE_RELOAD_FLAG(state->top_state));
  262. }
  263.  
  264.  
  265. void
  266. LO_InvalidateFontData(MWContext *context)
  267. {
  268.     int32 i, doc_id;
  269.     lo_TopState *top_state;
  270.     lo_DocState *state;
  271.     LO_TextAttr **text_attr_hash;
  272.     LO_TextAttr *attr_ptr;
  273.  
  274.     /*
  275.      * Get the unique document ID, and retreive this
  276.      * documents layout state.
  277.      */
  278.     doc_id = XP_DOCID(context);
  279.     top_state = lo_FetchTopState(doc_id);
  280.     if ((top_state == NULL)||(top_state->doc_state == NULL))
  281.     {
  282.         return;
  283.     }
  284.     state = top_state->doc_state;
  285.  
  286.     if (state->top_state->text_attr_hash == NULL)
  287.     {
  288.         return;
  289.     }
  290.  
  291.     XP_LOCK_BLOCK(text_attr_hash, LO_TextAttr **,
  292.         state->top_state->text_attr_hash);
  293.     for (i=0; i < FONT_HASH_SIZE; i++)
  294.     {
  295.         attr_ptr = text_attr_hash[i];
  296.         while (attr_ptr != NULL)
  297.         {
  298.             if (attr_ptr->FE_Data != NULL)
  299.             {
  300.                 FE_ReleaseTextAttrFeData(context, attr_ptr);
  301.             }
  302.             attr_ptr->FE_Data = NULL;
  303.             attr_ptr = attr_ptr->next;
  304.         }
  305.     }
  306. }
  307.  
  308.  
  309. static char *
  310. lo_find_face_in_array(char **face_list, intn len, char *face)
  311. {
  312.     intn i;
  313.     char *the_face;
  314.  
  315.     if (face == NULL)
  316.     {
  317.         return(NULL);
  318.     }
  319.  
  320.     the_face = NULL;
  321.     for (i=0; i<len; i++)
  322.     {
  323.         if ((face_list[i] != NULL)&&
  324.             (XP_STRCMP(face, face_list[i]) == 0))
  325.         {
  326.             the_face = face_list[i];
  327.             break;
  328.         }
  329.     }
  330.  
  331.     return(the_face);
  332. }
  333.  
  334.  
  335. Bool
  336. lo_EvalTrueOrFalse(char *str, Bool default_val)
  337. {
  338.     Bool ret_val;
  339.  
  340.     ret_val = default_val;
  341.  
  342.     if (str == NULL)
  343.     {
  344.         return(ret_val);
  345.     }
  346.  
  347.     if (pa_TagEqual("true", str))
  348.     {
  349.         ret_val = TRUE;
  350.     }
  351.     else if (pa_TagEqual("yes", str))
  352.     {
  353.         ret_val = TRUE;
  354.     }
  355.     else if (pa_TagEqual("no", str))
  356.     {
  357.         ret_val = FALSE;
  358.     }
  359.     else if (pa_TagEqual("false", str))
  360.     {
  361.         ret_val = FALSE;
  362.     }
  363.  
  364.     return(ret_val);
  365. }
  366.  
  367. char *
  368. lo_FetchFontFace(MWContext *context, lo_DocState *state, char *face)
  369. {
  370.     char **face_list;
  371.     char *new_face;
  372.  
  373.     /*
  374.      * If this is our first addition, allocate the array.
  375.      */
  376.     if (state->top_state->font_face_array == NULL)
  377.     {
  378.         PA_Block buff;
  379.  
  380.         buff = PA_ALLOC(FONT_FACE_INC * sizeof(char *));
  381.         if (buff == NULL)
  382.         {
  383.             state->top_state->out_of_memory = TRUE;
  384.             return(NULL);
  385.         }
  386.         state->top_state->font_face_array = buff;
  387.         state->top_state->font_face_array_size = FONT_FACE_INC;
  388.         state->top_state->font_face_array_len = 0;
  389.     }
  390.     /*
  391.      * Else if the list is full, grow the array.
  392.      */
  393.     else if (state->top_state->font_face_array_len >=
  394.             state->top_state->font_face_array_size)
  395.     {
  396.         PA_Block buff;
  397.         intn new_size;
  398.  
  399.         if (state->top_state->font_face_array_size >= FONT_FACE_MAX)
  400.         {
  401.             return(NULL);
  402.         }
  403.  
  404.         new_size = state->top_state->font_face_array_size +
  405.                 FONT_FACE_INC;
  406.         if (new_size > FONT_FACE_MAX)
  407.         {
  408.             new_size = FONT_FACE_MAX;
  409.         }
  410.         buff = XP_REALLOC_BLOCK(state->top_state->font_face_array,
  411.             (new_size * sizeof(char *)));
  412.         if (buff == NULL)
  413.         {
  414.             state->top_state->out_of_memory = TRUE;
  415.             return(NULL);
  416.         }
  417.         state->top_state->font_face_array = buff;
  418.         state->top_state->font_face_array_size = new_size;
  419.     }
  420.  
  421.     PA_LOCK(face_list, char **, state->top_state->font_face_array);
  422.     new_face = lo_find_face_in_array(face_list,
  423.         state->top_state->font_face_array_len, face);
  424.     if (new_face == NULL)
  425.     {
  426.         char *str;
  427.  
  428.         str = XP_STRDUP(face);
  429.         if (str == NULL)
  430.         {
  431.             PA_UNLOCK(state->top_state->font_face_array);
  432.             state->top_state->out_of_memory = TRUE;
  433.             return(NULL);
  434.         }
  435.         face_list[state->top_state->font_face_array_len] = str;
  436.         state->top_state->font_face_array_len++;
  437.         new_face = str;
  438.     }
  439.     PA_UNLOCK(state->top_state->font_face_array);
  440.     return(new_face);
  441. }
  442.  
  443.  
  444. Bool
  445. lo_IsValidTarget(char *target)
  446. {
  447.     if (target == NULL)
  448.     {
  449.         return(FALSE);
  450.     }
  451.     if ((XP_IS_ALPHA(target[0]) != FALSE)||
  452.         (XP_IS_DIGIT(target[0]) != FALSE)||
  453.         (target[0] == '_'))
  454.     {
  455.         return(TRUE);
  456.     }
  457.     return(FALSE);
  458. }
  459.  
  460.  
  461. int32
  462. lo_StripTextNewlines(char *text, int32 text_len)
  463. {
  464.     char *from_ptr;
  465.     char *to_ptr;
  466.     int32 len;
  467.  
  468.     if ((text == NULL)||(text_len < 1))
  469.     {
  470.         return(0);
  471.     }
  472.  
  473.     /*
  474.      * remove all non-space whitespace from the middle of the string.
  475.      */
  476.     from_ptr = text;
  477.     len = text_len;
  478.     to_ptr = text;
  479.     while (*from_ptr != '\0')
  480.     {
  481.         if (XP_IS_SPACE(*from_ptr) && (*from_ptr != ' '))
  482.         {
  483.             from_ptr++;
  484.             len--;
  485.         }
  486.         else
  487.         {
  488.             *to_ptr++ = *from_ptr++;
  489.         }
  490.     }
  491.     *to_ptr = '\0';
  492.  
  493.     return(len);
  494. }
  495.  
  496.  
  497. PA_Block
  498. lo_FEToNetLinebreaks(PA_Block text_block)
  499. {
  500.     PA_Block new_block;
  501.     char *new_text;
  502.     char *text;
  503.     char *from_ptr;
  504.     char *to_ptr;
  505.     char break_char;
  506.     int32 len, new_len;
  507.     int32 linebreak;
  508.  
  509.     if (text_block == NULL)
  510.     {
  511.         return(NULL);
  512.     }
  513.     PA_LOCK(text, char *, text_block);
  514.  
  515.     XP_BCOPY(LINEBREAK, (char *)(&break_char), 1);
  516.     len = 0;
  517.     linebreak = 0;
  518.     from_ptr = text;
  519.     while (*from_ptr != '\0')
  520.     {
  521.         if (*from_ptr == break_char)
  522.         {
  523.             if (strncmp(from_ptr, LINEBREAK, LINEBREAK_LEN) == 0)
  524.             {
  525.                 linebreak++;
  526.                 len += LINEBREAK_LEN;
  527.                 from_ptr = (char *)(from_ptr + LINEBREAK_LEN);
  528.             }
  529.             else
  530.             {
  531.                 len++;
  532.                 from_ptr++;
  533.             }
  534.         }
  535.         else
  536.         {
  537.             len++;
  538.             from_ptr++;
  539.         }
  540.     }
  541.  
  542.     new_len = len - (LINEBREAK_LEN * linebreak) + (2 * linebreak);
  543.     new_block = PA_ALLOC(new_len + 1);
  544.     if (new_block == NULL)
  545.     {
  546.         PA_UNLOCK(text_block);
  547.         return(NULL);
  548.     }
  549.     PA_LOCK(new_text, char *, new_block);
  550.     from_ptr = text;
  551.     to_ptr = new_text;
  552.     while (*from_ptr != '\0')
  553.     {
  554.         if (*from_ptr == break_char)
  555.         {
  556.             if (strncmp(from_ptr, LINEBREAK, LINEBREAK_LEN) == 0)
  557.             {
  558.                 from_ptr = (char *)(from_ptr + LINEBREAK_LEN);
  559.                 *to_ptr++ = CR;
  560.                 *to_ptr++ = LF;
  561.             }
  562.             else
  563.             {
  564.                 *to_ptr++ = *from_ptr++;
  565.             }
  566.         }
  567.         else
  568.         {
  569.             *to_ptr++ = *from_ptr++;
  570.         }
  571.     }
  572.     *to_ptr = '\0';
  573.  
  574.     new_text[new_len] = '\0';
  575.     PA_UNLOCK(new_block);
  576.     PA_UNLOCK(text_block);
  577.     return(new_block);
  578. }
  579.  
  580.  
  581. PA_Block
  582. lo_ConvertToFELinebreaks(char *text, int32 text_len, int32 *new_len_ptr)
  583. {
  584.     PA_Block new_block;
  585.     char *new_text;
  586.     char *from_ptr;
  587.     char *to_ptr;
  588.     char break_char;
  589.     int32 len, new_len;
  590.     int32 skip, linebreak;
  591.  
  592.     if (text == NULL)
  593.     {
  594.         return(NULL);
  595.     }
  596.  
  597.     break_char = '\0';
  598.     len = 0;
  599.     skip = 0;
  600.     linebreak = 0;
  601.     from_ptr = text;
  602.     to_ptr = text;
  603.     while (len < text_len)
  604.     {
  605.         if ((*from_ptr == CR)||(*from_ptr == LF))
  606.         {
  607.             if ((break_char != '\0')&&(break_char != *from_ptr))
  608.             {
  609.                 skip++;
  610.                 break_char = '\0';
  611.             }
  612.             else
  613.             {
  614.                 skip++;
  615.                 linebreak++;
  616.                 break_char = *from_ptr;
  617.             }
  618.         }
  619.         from_ptr++;
  620.         len++;
  621.     }
  622.  
  623.     new_len = len - skip + (LINEBREAK_LEN * linebreak);
  624.     new_block = PA_ALLOC(new_len + 1);
  625.     if (new_block == NULL)
  626.     {
  627.         return(NULL);
  628.     }
  629.     PA_LOCK(new_text, char *, new_block);
  630.     break_char = '\0';
  631.     len = 0;
  632.     from_ptr = text;
  633.     to_ptr = new_text;
  634.     while (len < text_len)
  635.     {
  636.         if ((*from_ptr == CR)||(*from_ptr == LF))
  637.         {
  638.             if ((break_char != '\0')&&(break_char != *from_ptr))
  639.             {
  640.                 break_char = '\0';
  641.             }
  642.             else
  643.             {
  644.                 XP_BCOPY(LINEBREAK, to_ptr, LINEBREAK_LEN);
  645.                 to_ptr = (char *)(to_ptr + LINEBREAK_LEN);
  646.                 break_char = *from_ptr;
  647.             }
  648.             from_ptr++;
  649.             len++;
  650.         }
  651.         else
  652.         {
  653.             *to_ptr++ = *from_ptr++;
  654.             len++;
  655.         }
  656.     }
  657.  
  658.     new_text[new_len] = '\0';
  659.     *new_len_ptr = new_len;
  660.     PA_UNLOCK(new_block);
  661.     return(new_block);
  662. }
  663.  
  664.  
  665. intn
  666. lo_EvalVAlignParam(char *str)
  667. {
  668.     intn alignment;
  669.  
  670.     alignment = LO_ALIGN_TOP;
  671.     if (pa_TagEqual("top", str))
  672.     {
  673.         alignment = LO_ALIGN_TOP;
  674.     }
  675.     else if (pa_TagEqual("bottom", str))
  676.     {
  677.         alignment = LO_ALIGN_BOTTOM;
  678.     }
  679.     else if ((pa_TagEqual("middle", str))||
  680.         (pa_TagEqual("center", str)))
  681.     {
  682.         alignment = LO_ALIGN_CENTER;
  683.     }
  684.     else if (pa_TagEqual("baseline", str))
  685.     {
  686.         alignment = LO_ALIGN_BASELINE;
  687.     }
  688.     return(alignment);
  689. }
  690.  
  691.  
  692. intn
  693. lo_EvalDivisionAlignParam(char *str)
  694. {
  695.     intn alignment;
  696.  
  697.     alignment = LO_ALIGN_LEFT;
  698.     if (pa_TagEqual("left", str))
  699.     {
  700.         alignment = LO_ALIGN_LEFT;
  701.     }
  702.     else if (pa_TagEqual("right", str))
  703.     {
  704.         alignment = LO_ALIGN_RIGHT;
  705.     }
  706.     else if (pa_TagEqual("center", str))
  707.     {
  708.         alignment = LO_ALIGN_CENTER;
  709.     }
  710.     else if (pa_TagEqual("justify", str))
  711.     {
  712.         alignment = LO_ALIGN_JUSTIFY;
  713.     }
  714.     return(alignment);
  715. }
  716.  
  717.  
  718. intn
  719. lo_EvalCellAlignParam(char *str)
  720. {
  721.     intn alignment;
  722.  
  723.     alignment = LO_ALIGN_LEFT;
  724.     if (pa_TagEqual("left", str))
  725.     {
  726.         alignment = LO_ALIGN_LEFT;
  727.     }
  728.     else if (pa_TagEqual("right", str))
  729.     {
  730.         alignment = LO_ALIGN_RIGHT;
  731.     }
  732.     else if ((pa_TagEqual("middle", str))||
  733.         (pa_TagEqual("center", str)))
  734.     {
  735.         alignment = LO_ALIGN_CENTER;
  736.     }
  737.     return(alignment);
  738. }
  739.  
  740. #ifdef EDITOR
  741. /* this is a replacement routine for the non-editor version and should eventually
  742.  *    replace the non-edit version.  It uses an array of values. instead of an 
  743.  *    unrolled loop.  
  744. */
  745.  
  746. /*
  747.  * Indexed by LO_ALIGN_ETC
  748. */
  749. char* lo_alignStrings[] = {
  750.     "abscenter",        /* LO_ALIGN_CENTER */
  751.     "left",                /* LO_ALIGN_LEFT */
  752.     "right",            /* LO_ALIGN_RIGHT */
  753.     "texttop",            /* LO_ALIGN_TOP */
  754.     "absbottom",        /* LO_ALIGN_BOTTOM */
  755.     "baseline",            /* LO_ALIGN_BASELINE */
  756.     "center",            /* LO_ALIGN_NCSA_CENTER */
  757.     "bottom",            /* LO_ALIGN_NCSA_BOTTOM */
  758.     "top",                /* LO_ALIGN_NCSA */
  759.     0
  760. };
  761.  
  762. intn
  763. lo_EvalAlignParam(char *str, Bool *floating)
  764. {
  765.     intn alignment;
  766.  
  767.     *floating = FALSE;
  768.     alignment = LO_ALIGN_BASELINE;
  769.     if (pa_TagEqual("middle", str))
  770.     {
  771.         alignment = LO_ALIGN_NCSA_CENTER;
  772.     }
  773.     else if (pa_TagEqual("absmiddle", str))
  774.     {
  775.         alignment = LO_ALIGN_CENTER;
  776.     }
  777.     else 
  778.     {
  779.         intn i = 0;
  780.         Bool bFound = FALSE;
  781.  
  782.         while( lo_alignStrings[i] != NULL  && bFound == FALSE )
  783.         {
  784.             if( pa_TagEqual( lo_alignStrings[i], str) )
  785.             {
  786.                 bFound = TRUE;
  787.                 alignment = i;
  788.             }
  789.             i++;
  790.         }     
  791.     }
  792.     if( alignment == LO_ALIGN_LEFT || alignment == LO_ALIGN_RIGHT)
  793.     {
  794.         *floating = TRUE;
  795.     }
  796.     return alignment;
  797. } 
  798.  
  799. #else
  800.  
  801. intn
  802. lo_EvalAlignParam(char *str, Bool *floating)
  803. {
  804.     intn alignment;
  805.  
  806.     *floating = FALSE;
  807.     alignment = LO_ALIGN_BASELINE;
  808.     if (pa_TagEqual("top", str))
  809.     {
  810.         alignment = LO_ALIGN_NCSA_TOP;
  811.     }
  812.     else if (pa_TagEqual("texttop", str))
  813.     {
  814.         alignment = LO_ALIGN_TOP;
  815.     }
  816.     else if (pa_TagEqual("bottom", str))
  817.     {
  818.         alignment = LO_ALIGN_NCSA_BOTTOM;
  819.     }
  820.     else if (pa_TagEqual("absbottom", str))
  821.     {
  822.         alignment = LO_ALIGN_BOTTOM;
  823.     }
  824.     else if (pa_TagEqual("baseline", str))
  825.     {
  826.         alignment = LO_ALIGN_BASELINE;
  827.     }
  828.     else if ((pa_TagEqual("middle", str))||
  829.         (pa_TagEqual("center", str)))
  830.     {
  831.         alignment = LO_ALIGN_NCSA_CENTER;
  832.     }
  833.     else if ((pa_TagEqual("absmiddle", str))||
  834.         (pa_TagEqual("abscenter", str)))
  835.     {
  836.         alignment = LO_ALIGN_CENTER;
  837.     }
  838.     else if (pa_TagEqual("left", str))
  839.     {
  840.         alignment = LO_ALIGN_LEFT;
  841.         *floating = TRUE;
  842.     }
  843.     else if (pa_TagEqual("right", str))
  844.     {
  845.         alignment = LO_ALIGN_RIGHT;
  846.         *floating = TRUE;
  847.     }
  848.     return(alignment);
  849. }
  850. #endif
  851.  
  852. /* set *alignment and *floating iff there
  853.  * is a valid stylesheet alignment property.
  854.  */
  855. MODULE_PRIVATE void
  856. lo_EvalStyleSheetAlignment(StyleStruct *style_struct, 
  857.                             intn *alignment,
  858.                                Bool *floating)
  859. {
  860.     char *valign, *halign;
  861.  
  862.     if(!style_struct)
  863.         return;
  864.  
  865.     valign = STYLESTRUCT_GetString(style_struct,VERTICAL_ALIGN_STYLE);
  866.     halign = STYLESTRUCT_GetString(style_struct,HORIZONTAL_ALIGN_STYLE);
  867.  
  868.     if(valign)
  869.     {
  870.         if (pa_TagEqual("top", valign))
  871.         {
  872.             *alignment = LO_ALIGN_NCSA_TOP;
  873.             *floating = FALSE;
  874.         }
  875.         else if (pa_TagEqual("texttop", valign) 
  876.                  || pa_TagEqual("text-top", valign))
  877.         {
  878.             *alignment = LO_ALIGN_TOP;
  879.             *floating = FALSE;
  880.         }
  881.         else if (pa_TagEqual("bottom", valign))
  882.         {
  883.             *alignment = LO_ALIGN_NCSA_BOTTOM;
  884.             *floating = FALSE;
  885.         }
  886.         else if (pa_TagEqual("absbottom", valign)
  887.                  || pa_TagEqual("text-bottom", valign))
  888.         {
  889.             *alignment = LO_ALIGN_BOTTOM;
  890.             *floating = FALSE;
  891.         }
  892.         else if (pa_TagEqual("baseline", valign))
  893.         {
  894.             *alignment = LO_ALIGN_BASELINE;
  895.             *floating = FALSE;
  896.         }
  897.         else if ((pa_TagEqual("middle", valign))||
  898.             (pa_TagEqual("center", valign)))
  899.         {
  900.             *alignment = LO_ALIGN_NCSA_CENTER;
  901.             *floating = FALSE;
  902.         }
  903.         else if ((pa_TagEqual("absmiddle", valign))||
  904.             (pa_TagEqual("abscenter", valign)))
  905.         {
  906.             *alignment = LO_ALIGN_CENTER;
  907.             *floating = FALSE;
  908.         }
  909.     }
  910.  
  911.     if(halign)
  912.     {
  913.         if (pa_TagEqual("left", halign))
  914.         {
  915.             *alignment = LO_ALIGN_LEFT;
  916.             *floating = TRUE;
  917.         }
  918.         else if (pa_TagEqual("right", halign))
  919.         {
  920.             *alignment = LO_ALIGN_RIGHT;
  921.             *floating = TRUE;
  922.         }
  923.     }
  924.  
  925.     XP_FREEIF(valign);
  926.     XP_FREEIF(halign);
  927.  
  928.     return;
  929. }
  930.  
  931. void
  932. lo_CalcAlignOffsets(lo_DocState *state, LO_TextInfo *text_info, intn alignment,
  933.     int32 width, int32 height, int16 *x_offset, int32 *y_offset,
  934.     int32 *line_inc, int32 *baseline_inc)
  935. {
  936.     *line_inc = 0;
  937.     *baseline_inc = 0;
  938.     switch (alignment)
  939.     {
  940.         case LO_ALIGN_CENTER:
  941.             *x_offset = 0;
  942.             /*
  943.              * Center after current text.
  944.              */
  945.             /*
  946.              * If the image is shorter than the height
  947.              * of this line, just increase y_offset
  948.              * to get it centered.
  949.              */
  950.             if (height < state->line_height)
  951.             {
  952.                 *y_offset += ((state->line_height - height)
  953.                         / 2);
  954.             }
  955.             /*
  956.              * Else for images taller than the line
  957.              * we will need to move all their
  958.              * baselines down, plus increase the rest
  959.              * of their lineheights to reflect the
  960.              * big centered image.
  961.              */
  962.             else
  963.             {
  964.                 *y_offset = 0;
  965.                 *baseline_inc = (height - state->line_height)
  966.                         / 2;
  967.                 *line_inc = height - state->line_height -
  968.                     *baseline_inc;
  969.             }
  970.             break;
  971.         case LO_ALIGN_NCSA_CENTER:
  972.             *x_offset = 0;
  973.             /*
  974.              * Center on baseline of current text.
  975.              */
  976.             /*
  977.              * If the image centered on the baseline will not
  978.              * extend below or above the current line,
  979.              * just increase y_offset to get it centered.
  980.              */
  981.             if (((height / 2) <= state->baseline)&&
  982.                 ((height / 2) <= (state->line_height - 
  983.                     state->baseline)))
  984.             {
  985.                 *y_offset = state->baseline -
  986.                     (height / 2);
  987.             }
  988.             /*
  989.              * Else the image extends over the bottom, but
  990.              * not off the top.
  991.              */
  992.             else if ((height / 2) <= state->baseline)
  993.             {
  994.                 *y_offset = state->baseline -
  995.                     (height / 2);
  996.                 *line_inc = *y_offset + height -
  997.                     state->line_height;
  998.             }
  999.             /*
  1000.              * Else for images taller than the line
  1001.              * we will need to move all their
  1002.              * baselines down, plus and maybe increase the rest
  1003.              * of their lineheights to reflect the
  1004.              * big centered image.
  1005.              */
  1006.             else
  1007.             {
  1008.                 *y_offset = 0;
  1009.                 *baseline_inc = (height / 2) - state->baseline;
  1010.                 if ((state->baseline + (height / 2)) >
  1011.                     state->line_height)
  1012.                 {
  1013.                     *line_inc = state->baseline +
  1014.                         (height / 2) -
  1015.                         state->line_height;
  1016.                 }
  1017.             }
  1018.             break;
  1019.         case LO_ALIGN_TOP:
  1020.             *x_offset = 0;
  1021.             /*
  1022.              * Move the top of the image to the top of the
  1023.              * last text placed.  On negative offsets
  1024.              * (such as at the start of a line) just
  1025.              * start the image at the top.
  1026.              */
  1027.             *y_offset = state->baseline - text_info->ascent;
  1028.             if (*y_offset < 0)
  1029.             {
  1030.                 *y_offset = 0;
  1031.             }
  1032.  
  1033.             /*
  1034.              * Top aligned images can easily hang down and make
  1035.              * all the rest of the line taller.  Set line_inc
  1036.              * to properly increase the height of all previous
  1037.              * elements.
  1038.              */
  1039.             if ((*y_offset + height) > state->line_height)
  1040.             {
  1041.                 *line_inc = *y_offset + height -
  1042.                     state->line_height;
  1043.             }
  1044.             break;
  1045.         case LO_ALIGN_NCSA_TOP:
  1046.             *x_offset = 0;
  1047.             /*
  1048.              * Move the top of the image to the top of the
  1049.              * line.
  1050.              */
  1051.             *y_offset = 0;
  1052.  
  1053.             /*
  1054.              * Top aligned images can easily hang down and make
  1055.              * all the rest of the line taller.  Set line_inc
  1056.              * to properly increase the height of all previous
  1057.              * elements.
  1058.              */
  1059.             if ((*y_offset + height) > state->line_height)
  1060.             {
  1061.                 *line_inc = *y_offset + height -
  1062.                     state->line_height;
  1063.             }
  1064.             break;
  1065.         case LO_ALIGN_BOTTOM:
  1066.             *x_offset = 0;
  1067.             /*
  1068.              * Like centered images, images shorter than
  1069.              * the line just get move with y_offset.
  1070.              */
  1071.             if (height < state->line_height)
  1072.             {
  1073.                 *y_offset = state->line_height - height;
  1074.             }
  1075.             /*
  1076.              * Else since they are bottom aligned.
  1077.              * they move everyone's baselines and can't
  1078.              * change the height below the baseline.
  1079.              */
  1080.             else
  1081.             {
  1082.                 *y_offset = 0;
  1083.                 *baseline_inc = height - state->line_height;
  1084.             }
  1085.             break;
  1086.         case LO_ALIGN_NCSA_BOTTOM:
  1087.         case LO_ALIGN_BASELINE:
  1088.         default:
  1089.             *x_offset = 0;
  1090.             /*
  1091.              * Like centered images, images shorter than
  1092.              * the baseline just get move with y_offset.
  1093.              */
  1094.             if (height < state->baseline)
  1095.             {
  1096.                 *y_offset = state->baseline - height;
  1097.             }
  1098.             /*
  1099.              * Else since they are baseline aligned.
  1100.              * they move everyone's baselines and can't
  1101.              * change the height below the baseline.
  1102.              */
  1103.             else
  1104.             {
  1105.                 *y_offset = 0;
  1106.                 *baseline_inc = height - state->baseline;
  1107.             }
  1108.             break;
  1109.     }
  1110. }
  1111.  
  1112.  
  1113. int32
  1114. lo_ValueOrPercent(char *str, Bool *is_percent)
  1115. {
  1116.     int32 val;
  1117.     char *tptr;
  1118.  
  1119.     *is_percent = FALSE;
  1120.  
  1121.     if (str == NULL)
  1122.     {
  1123.         return(0);
  1124.     }
  1125.  
  1126.     tptr = str;
  1127.     while (*tptr != '\0')
  1128.     {
  1129.         if (*tptr == '%')
  1130.         {
  1131.             *is_percent = TRUE;
  1132.             *tptr = '\0';
  1133.             break;
  1134.         }
  1135.         tptr++;
  1136.     }
  1137.     val = XP_ATOI(str);
  1138.         if (*is_percent)
  1139.             *tptr = '%';            /* Restore original string */
  1140.     return(val);
  1141. }
  1142.  
  1143.  
  1144. void
  1145. lo_SetElementTextAttr(LO_Element *element, LO_TextAttr *attr)
  1146. {
  1147.     switch(element->type)
  1148.     {
  1149.     case LO_TEXT:
  1150.         element->lo_text.text_attr = attr;
  1151.         break;
  1152.  
  1153.     case LO_IMAGE:
  1154.         element->lo_image.text_attr = attr;
  1155.         break;
  1156.  
  1157.     case LO_SUBDOC:
  1158.         element->lo_subdoc.text_attr = attr;
  1159.         break;
  1160.  
  1161.     case LO_LINEFEED:
  1162.         element->lo_linefeed.text_attr = attr;
  1163.         break;
  1164.  
  1165.     case LO_FORM_ELE:
  1166.         element->lo_form.text_attr = attr;
  1167.         break;
  1168.  
  1169.     case LO_BULLET:
  1170.         element->lo_bullet.text_attr = attr;
  1171.         break;
  1172.  
  1173.     default:
  1174.         XP_ASSERT(0);
  1175.     }
  1176. }
  1177.  
  1178. LO_TextAttr *
  1179. lo_GetElementTextAttr(LO_Element *element)
  1180. {
  1181.     switch(element->type)
  1182.     {
  1183.     case LO_TEXT:
  1184.         return element->lo_text.text_attr;
  1185.  
  1186.     case LO_IMAGE:
  1187.         return element->lo_image.text_attr;
  1188.  
  1189.     case LO_SUBDOC:
  1190.         return element->lo_subdoc.text_attr;
  1191.  
  1192.     case LO_LINEFEED:
  1193.         return element->lo_linefeed.text_attr;
  1194.  
  1195.     case LO_FORM_ELE:
  1196.         return element->lo_form.text_attr;
  1197.  
  1198.     case LO_BULLET:
  1199.         return element->lo_bullet.text_attr;
  1200.  
  1201.     default:
  1202.         return NULL;
  1203.     }
  1204. }
  1205.  
  1206. void
  1207. lo_CopyTextAttr(LO_TextAttr *old_attr, LO_TextAttr *new_attr)
  1208. {
  1209.     if ((old_attr == NULL)||(new_attr == NULL))
  1210.     {
  1211.         return;
  1212.     }
  1213.  
  1214.     new_attr->size = old_attr->size;
  1215.     new_attr->fontmask = old_attr->fontmask;
  1216.  
  1217.     new_attr->fg.red = old_attr->fg.red;
  1218.     new_attr->fg.green = old_attr->fg.green;
  1219.     new_attr->fg.blue = old_attr->fg.blue;
  1220.  
  1221.     new_attr->bg.red = old_attr->bg.red;
  1222.     new_attr->bg.green = old_attr->bg.green;
  1223.     new_attr->bg.blue = old_attr->bg.blue;
  1224.  
  1225.     new_attr->no_background = old_attr->no_background;
  1226.     new_attr->attrmask = old_attr->attrmask;
  1227.     new_attr->font_face = old_attr->font_face;
  1228.     /*
  1229.      * FE_Data is not copied, it belongs to the FE,
  1230.      * And will need to be generated by the FE the first time this
  1231.      * new TextAttr is used.
  1232.      */
  1233.     new_attr->FE_Data = NULL;
  1234.  
  1235.     new_attr->charset = old_attr->charset;
  1236.     new_attr->point_size = old_attr->point_size;
  1237.     new_attr->font_weight = old_attr->font_weight;
  1238. }
  1239.  
  1240.  
  1241. LO_TextAttr *
  1242. lo_FetchTextAttr(lo_DocState *state, LO_TextAttr *old_attr)
  1243. {
  1244.     LO_TextAttr **text_attr_hash;
  1245.     LO_TextAttr *attr_ptr;
  1246.     int32 hash_index;
  1247.  
  1248.     if (old_attr == NULL)
  1249.     {
  1250.         return(NULL);
  1251.     }
  1252.  
  1253.     hash_index = (old_attr->fontmask & old_attr->attrmask) % FONT_HASH_SIZE;
  1254.  
  1255.     XP_LOCK_BLOCK(text_attr_hash, LO_TextAttr **,
  1256.         state->top_state->text_attr_hash);
  1257.     attr_ptr = text_attr_hash[hash_index];
  1258.  
  1259.     while (attr_ptr != NULL)
  1260.     {
  1261.         if ((attr_ptr->size == old_attr->size)&&
  1262.             (attr_ptr->fontmask == old_attr->fontmask)&&
  1263.             (attr_ptr->attrmask == old_attr->attrmask)&&
  1264.             (attr_ptr->fg.red == old_attr->fg.red)&&
  1265.             (attr_ptr->fg.green == old_attr->fg.green)&&
  1266.             (attr_ptr->fg.blue == old_attr->fg.blue)&&
  1267.             (attr_ptr->bg.red == old_attr->bg.red)&&
  1268.             (attr_ptr->bg.green == old_attr->bg.green)&&
  1269.             (attr_ptr->bg.blue == old_attr->bg.blue)&&
  1270.             (attr_ptr->font_face == old_attr->font_face)&&
  1271.             (attr_ptr->charset == old_attr->charset)&&
  1272.             (attr_ptr->point_size == old_attr->point_size)&&
  1273.             (attr_ptr->font_weight == old_attr->font_weight))
  1274.         {
  1275.             break;
  1276.         }
  1277.         attr_ptr = attr_ptr->next;
  1278.     }
  1279.     if (attr_ptr == NULL)
  1280.     {
  1281.         LO_TextAttr *new_attr;
  1282.  
  1283.         new_attr = XP_NEW(LO_TextAttr);
  1284.         if (new_attr != NULL)
  1285.         {
  1286.             lo_CopyTextAttr(old_attr, new_attr);
  1287.             new_attr->next = text_attr_hash[hash_index];
  1288.             text_attr_hash[hash_index] = new_attr;
  1289.         }
  1290.         else
  1291.         {
  1292.             state->top_state->out_of_memory = TRUE;
  1293.         }
  1294.         attr_ptr = new_attr;
  1295.     }
  1296.  
  1297.     XP_UNLOCK_BLOCK(state->top_state->text_attr_hash);
  1298.     return(attr_ptr);
  1299. }
  1300.  
  1301.  
  1302. void
  1303. lo_AddMarginStack(lo_DocState *state, int32 x, int32 y,
  1304.         int32 width, int32 height,
  1305.         int32 border_width,
  1306.         int32 border_vert_space, int32 border_horiz_space,
  1307.         intn alignment)
  1308. {
  1309.     lo_MarginStack *mptr;
  1310.  
  1311.     mptr = XP_NEW(lo_MarginStack);
  1312.     if (mptr == NULL)
  1313.     {
  1314.         state->top_state->out_of_memory = TRUE;
  1315.         return;
  1316.     }
  1317.  
  1318.     mptr->y_min = y;
  1319.     if (y >= 0)
  1320.     {
  1321.         mptr->y_max = y + height + (2 * border_width) +
  1322.             (2 * border_vert_space);
  1323.     }
  1324.     else
  1325.     {
  1326.         mptr->y_max = height + (2 * border_width) +
  1327.             (2 * border_vert_space);
  1328.     }
  1329.  
  1330.     if (alignment == LO_ALIGN_RIGHT)
  1331.     {
  1332.         if (state->right_margin_stack == NULL)
  1333.         {
  1334.             mptr->margin = state->right_margin - width -
  1335.                 (2 * border_width) - (2 * border_horiz_space);
  1336.         }
  1337.         else
  1338.         {
  1339.             mptr->margin = state->right_margin_stack->margin -
  1340.                 width - (2 * border_width) -
  1341.                 (2 * border_horiz_space);
  1342.         }
  1343.         mptr->next = state->right_margin_stack;
  1344.         state->right_margin_stack = mptr;
  1345.     }
  1346.     else
  1347.     {
  1348.         mptr->margin = state->left_margin + width +
  1349.             (2 * border_width) + (2 * border_horiz_space);
  1350.         mptr->next = state->left_margin_stack;
  1351.         state->left_margin_stack = mptr;
  1352.     }
  1353. }
  1354.  
  1355.  
  1356. /*
  1357.  * When clipping lines we have essentially scrolled the document up.
  1358.  * Move the margin blocks up too.
  1359.  */
  1360. void
  1361. lo_ShiftMarginsUp(MWContext *context, lo_DocState *state, int32 dy)
  1362. {
  1363.     lo_MarginStack *mptr;
  1364.     int32 y;
  1365.  
  1366.     mptr = state->left_margin_stack;
  1367.     while (mptr != NULL)
  1368.     {
  1369.         y = mptr->y_min - dy;
  1370.         if (y < 0)
  1371.         {
  1372.             y = 0;
  1373.         }
  1374.         mptr->y_min = y;
  1375.  
  1376.         y = mptr->y_max - dy;
  1377.         if (y < 0)
  1378.         {
  1379.             y = 0;
  1380.         }
  1381.         mptr->y_max = y;
  1382.         mptr = mptr->next;
  1383.     }
  1384.  
  1385.     mptr = state->right_margin_stack;
  1386.     while (mptr != NULL)
  1387.     {
  1388.         y = mptr->y_min - dy;
  1389.         if (y < 0)
  1390.         {
  1391.             y = 0;
  1392.         }
  1393.         mptr->y_min = y;
  1394.  
  1395.         y = mptr->y_max - dy;
  1396.         if (y < 0)
  1397.         {
  1398.             y = 0;
  1399.         }
  1400.         mptr->y_max = y;
  1401.         mptr = mptr->next;
  1402.     }
  1403. }
  1404.  
  1405.  
  1406. void
  1407. lo_ClearToLeftMargin(MWContext *context, lo_DocState *state)
  1408. {
  1409.     lo_MarginStack *mptr;
  1410.     int32 y;
  1411.  
  1412.     mptr = state->left_margin_stack;
  1413.     if (mptr == NULL)
  1414.     {
  1415.         return;
  1416.     }
  1417.     y = state->y;
  1418.  
  1419.     if (mptr->y_max > y)
  1420.     {
  1421.         y = mptr->y_max;
  1422.     }
  1423.     while (mptr->next != NULL)
  1424.     {
  1425.         lo_MarginStack *margin;
  1426.  
  1427.         if (mptr->y_max > y)
  1428.         {
  1429.             y = mptr->y_max;
  1430.         }
  1431.         margin = mptr;
  1432.         mptr = mptr->next;
  1433.         XP_DELETE(margin);
  1434.     }
  1435.     XP_DELETE(mptr);
  1436.     state->y = y;
  1437.     state->left_margin_stack = NULL;
  1438.     state->left_margin = state->win_left;
  1439.     state->x = state->left_margin;
  1440.  
  1441.     /*
  1442.      * Find where we hit the right margin, popping old
  1443.      * obsolete elements as we go.
  1444.      */
  1445.     mptr = state->right_margin_stack;
  1446.     while ((mptr != NULL)&&(state->y > mptr->y_max))
  1447.     {
  1448.         lo_MarginStack *margin;
  1449.  
  1450.         margin = mptr;
  1451.         mptr = mptr->next;
  1452.         XP_DELETE(margin);
  1453.     }
  1454.     if (mptr != NULL)
  1455.     {
  1456.         state->right_margin_stack = mptr;
  1457.         state->right_margin = mptr->margin;
  1458.     }
  1459.     else
  1460.     {
  1461.         state->right_margin_stack = NULL;
  1462.         state->right_margin = (state->list_stack != NULL)
  1463.                             ? state->list_stack->old_right_margin
  1464.                             : 0;
  1465.     }
  1466. }
  1467.  
  1468.  
  1469. void
  1470. lo_ClearToRightMargin(MWContext *context, lo_DocState *state)
  1471. {
  1472.     lo_MarginStack *mptr;
  1473.     int32 y;
  1474.  
  1475.     mptr = state->right_margin_stack;
  1476.     if (mptr == NULL)
  1477.     {
  1478.         return;
  1479.     }
  1480.     y = state->y;
  1481.  
  1482.     if (mptr->y_max > y)
  1483.     {
  1484.         y = mptr->y_max;
  1485.     }
  1486.     while (mptr->next != NULL)
  1487.     {
  1488.         lo_MarginStack *margin;
  1489.  
  1490.         if (mptr->y_max > y)
  1491.         {
  1492.             y = mptr->y_max;
  1493.         }
  1494.         margin = mptr;
  1495.         mptr = mptr->next;
  1496.         XP_DELETE(margin);
  1497.     }
  1498.     XP_DELETE(mptr);
  1499.     state->y = y;
  1500.     state->right_margin_stack = NULL;
  1501.     state->right_margin = state->win_width - state->win_right;
  1502.  
  1503.     /*
  1504.      * Find where we hit the left margin, popping old
  1505.      * obsolete elements as we go.
  1506.      */
  1507.     mptr = state->left_margin_stack;
  1508.     while ((mptr != NULL)&&(state->y > mptr->y_max))
  1509.     {
  1510.         lo_MarginStack *margin;
  1511.  
  1512.         margin = mptr;
  1513.         mptr = mptr->next;
  1514.         XP_DELETE(margin);
  1515.     }
  1516.     if (mptr != NULL)
  1517.     {
  1518.         state->left_margin_stack = mptr;
  1519.         state->left_margin = mptr->margin;
  1520.     }
  1521.     else
  1522.     {
  1523.         state->left_margin_stack = NULL;
  1524.         state->left_margin = (state->list_stack != NULL)
  1525.                            ? state->list_stack->old_left_margin
  1526.                            : 0;
  1527.     }
  1528. }
  1529.  
  1530.  
  1531. void
  1532. lo_ClearToBothMargins(MWContext *context, lo_DocState *state)
  1533. {
  1534.     lo_MarginStack *mptr;
  1535.     int32 y;
  1536.  
  1537.     y = state->y;
  1538.  
  1539.     mptr = state->right_margin_stack;
  1540.     if (mptr != NULL)
  1541.     {
  1542.         if (mptr->y_max > y)
  1543.         {
  1544.             y = mptr->y_max;
  1545.         }
  1546.         while (mptr->next != NULL)
  1547.         {
  1548.             lo_MarginStack *margin;
  1549.  
  1550.             if (mptr->y_max > y)
  1551.             {
  1552.                 y = mptr->y_max;
  1553.             }
  1554.             margin = mptr;
  1555.             mptr = mptr->next;
  1556.             XP_DELETE(margin);
  1557.         }
  1558.         XP_DELETE(mptr);
  1559.         state->y = y;
  1560.         state->right_margin_stack = NULL;
  1561.  
  1562.         state->right_margin = state->win_width - state->win_right;
  1563.     }
  1564.  
  1565.     mptr = state->left_margin_stack;
  1566.     if (mptr != NULL)
  1567.     {
  1568.         if (mptr->y_max > y)
  1569.         {
  1570.             y = mptr->y_max;
  1571.         }
  1572.         while (mptr->next != NULL)
  1573.         {
  1574.             lo_MarginStack *margin;
  1575.  
  1576.             if (mptr->y_max > y)
  1577.             {
  1578.                 y = mptr->y_max;
  1579.             }
  1580.             margin = mptr;
  1581.             mptr = mptr->next;
  1582.             XP_DELETE(margin);
  1583.         }
  1584.         XP_DELETE(mptr);
  1585.         if (y > state->y)
  1586.         {
  1587.             state->y = y;
  1588.         }
  1589.         state->left_margin_stack = NULL;
  1590.  
  1591.         state->left_margin = state->win_left;
  1592.         state->x = state->left_margin;
  1593.     }
  1594. }
  1595.  
  1596.  
  1597. void
  1598. lo_FindLineMargins(MWContext *context, lo_DocState *state, Bool updateFE)
  1599. {
  1600.     lo_MarginStack *mptr;
  1601.     LO_Element *eptr;
  1602.  
  1603.     eptr = state->float_list;
  1604.     /*
  1605.     while ((eptr != NULL)&&(eptr->lo_any.y < 0))
  1606.     */
  1607.     while (eptr != NULL)
  1608.     {
  1609.         LO_Element *next_eptr = NULL;
  1610.  
  1611.         if (eptr->lo_any.y < 0) 
  1612.         {
  1613.             int32 expose_y;
  1614.             int32 expose_height;
  1615.             /* LO_Element *next_eptr; */
  1616.  
  1617.             next_eptr = NULL;
  1618.             /*
  1619.              * Float the y to our current position.
  1620.              */
  1621.             eptr->lo_any.y = state->y;
  1622.  
  1623.             /*
  1624.              * These get coppied into special variables because they
  1625.              * may get changed by a table in the floating list.
  1626.              */
  1627.             expose_y = eptr->lo_any.y;
  1628.             expose_height = eptr->lo_any.height;
  1629.  
  1630.             /*
  1631.              * Special case:  If we have just placed a TABLE element,
  1632.              * we need to properly offset all the CELLs inside it.
  1633.              */
  1634.             if (eptr->type == LO_TABLE)
  1635.             {
  1636.                 int32 y2;
  1637.                 int32 change_y;
  1638.                 LO_Element *tptr;
  1639.  
  1640.                 /*
  1641.                  * We need to know the bottom and top extents of
  1642.                  * the table to know big an area to refresh.
  1643.                  */
  1644.                 y2 = expose_y + eptr->lo_any.y_offset + expose_height;
  1645.  
  1646.                 /*
  1647.                  * This is how far to move the cells based on
  1648.                  * where the table thought it was placed.
  1649.                  */
  1650.                 change_y = state->y - eptr->lo_table.expected_y;
  1651.  
  1652.                 /*
  1653.                  * set tptr to the start of the cell list.
  1654.                  */
  1655.                 tptr = eptr->lo_any.next;
  1656.                 while ((tptr != NULL)&&(tptr->type == LO_CELL))
  1657.                 {
  1658.                     /*
  1659.                      * Only do this work if the table has moved.
  1660.                      */
  1661.                     if (change_y != 0)
  1662.                     {
  1663.                         tptr->lo_any.y += change_y;
  1664.                         lo_ShiftCell((LO_CellStruct *)tptr,
  1665.                             0, change_y);
  1666.                     }
  1667.  
  1668.                     /*
  1669.                      * Find upper and lower bounds of the
  1670.                      * cells.
  1671.                      */
  1672.                     if (tptr->lo_any.y < expose_y)
  1673.                     {
  1674.                         expose_y = tptr->lo_any.y;
  1675.                     }
  1676.                     if ((tptr->lo_any.y + tptr->lo_any.y_offset +
  1677.                         tptr->lo_any.height) > y2)
  1678.                     {
  1679.                         y2 = tptr->lo_any.y +
  1680.                             tptr->lo_any.y_offset +
  1681.                             tptr->lo_any.height;
  1682.                     }
  1683.  
  1684.                     tptr = tptr->lo_any.next;
  1685.                 }
  1686.  
  1687.                 /*
  1688.                  * Whatever is after all the table cells will
  1689.                  * really be the next eptr.
  1690.                  */
  1691.                 if (tptr != NULL)
  1692.                 {
  1693.                     next_eptr = tptr;
  1694.                 }
  1695.  
  1696.                 /*
  1697.                  * Adjust exposed area height for lower bound.
  1698.                  * Upper bound already possibly moved.
  1699.                  */
  1700.                 if ((y2 - expose_y - eptr->lo_any.y_offset) >
  1701.                     expose_height)
  1702.                 {
  1703.                     expose_height = y2 - expose_y -
  1704.                         eptr->lo_any.y_offset;
  1705.                 }
  1706.             }
  1707.  
  1708.             if (updateFE) 
  1709.             {
  1710.                 /*
  1711.                  * We may have been blocking display on this floating image.
  1712.                  * If so deal with it here.
  1713.                  */
  1714.                 if ((state->display_blocked != FALSE)&&
  1715.                     (state->is_a_subdoc == SUBDOC_NOT)&&
  1716.                     (state->display_blocking_element_y == 0)&&
  1717.                     (state->display_blocking_element_id != -1)&&
  1718.                     (eptr->lo_any.ele_id >=
  1719.                     state->display_blocking_element_id))
  1720.                 {
  1721.                     state->display_blocking_element_y =
  1722.                         state->y;
  1723.                     /*
  1724.                      * Special case, if the blocking element
  1725.                      * is on the first line, no blocking
  1726.                      * at all needs to happen.
  1727.                      */
  1728.                     if (state->y == state->win_top)
  1729.                     {
  1730.                         state->display_blocked = FALSE;
  1731.                         FE_SetDocPosition(context,
  1732.                             FE_VIEW, 0, state->base_y);
  1733.  
  1734.                         if (context->compositor)
  1735.                         {
  1736.                             XP_Rect rect;
  1737.                     
  1738.                             rect.left = 0;
  1739.                             rect.top = 0;
  1740.                             rect.right = state->win_width;
  1741.                             rect.bottom = state->win_height;
  1742.                             CL_UpdateDocumentRect(context->compositor,
  1743.                                                   &rect, (PRBool)FALSE);
  1744.                         }
  1745.                     }
  1746.                 }
  1747.  
  1748.             }    /* end if (updateFE) */
  1749.  
  1750.  
  1751.  
  1752.             if (context->compositor)
  1753.             {
  1754.                 XP_Rect rect;
  1755.            
  1756.                 rect.left = eptr->lo_any.x + eptr->lo_any.x_offset;
  1757.                 rect.top = expose_y + eptr->lo_any.y_offset;
  1758.                 rect.right = rect.left + eptr->lo_any.width;
  1759.                 rect.bottom = rect.top + expose_height;
  1760.                 CL_UpdateDocumentRect(context->compositor,
  1761.                                           &rect, (PRBool)FALSE);
  1762.  
  1763.             }            
  1764.  
  1765.             /*
  1766.              * In case these floating elements are the only thing in the
  1767.              * doc (or subdoc) we need to set the state min and max widths
  1768.              * when we place them.
  1769.              */
  1770.         {
  1771.             int32 width;
  1772.             XP_Rect rect;
  1773.  
  1774.             rect.left = 0;
  1775.             rect.right = 0;
  1776.             lo_GetElementBbox(eptr, &rect);
  1777.             width = rect.right - rect.left;
  1778.             if (width > 0)
  1779.             {
  1780.                 if (width > state->min_width)
  1781.                 {
  1782.                     state->min_width = width;
  1783.                 }
  1784.  
  1785.                 /*
  1786.                  * Only do this if not in a table
  1787.                  */
  1788.                 if (state->is_a_subdoc == SUBDOC_NOT)
  1789.                 {
  1790.                     width += rect.left;
  1791.                 }
  1792.                 if (width > state->max_width)
  1793.                 {
  1794.                     state->max_width = width;
  1795.                 }
  1796.             }
  1797.         
  1798.         }
  1799.             /*
  1800.             eptr = eptr->lo_any.next;
  1801.             */
  1802.             /*
  1803.              * If we are skipping a table's cells, set eptr
  1804.              * properly now.
  1805.              */
  1806.             /*
  1807.             if (next_eptr != NULL)
  1808.             {
  1809.                 eptr = next_eptr;
  1810.             }
  1811.             */
  1812.         }  /* End if (eptr->lo_any.y < 0) */
  1813.  
  1814.         eptr = eptr->lo_any.next;
  1815.  
  1816.         /*
  1817.          * If we are skipping a table's cells, set eptr
  1818.          * properly now.
  1819.          */
  1820.         if (next_eptr != NULL)
  1821.         {
  1822.             eptr = next_eptr;
  1823.         }
  1824.     }  /* End while */
  1825.     
  1826.     /*
  1827.      * Find floating elements just added to the left margin stack
  1828.      * from the last line, and set their absolute
  1829.      * coordinates.
  1830.      */
  1831.     mptr = state->left_margin_stack;
  1832.     while ((mptr != NULL)&&(mptr->y_min < 0))
  1833.     {
  1834.         mptr->y_min = state->y;
  1835.         mptr->y_max = mptr->y_min + mptr->y_max;
  1836.         mptr = mptr->next;
  1837.     }
  1838.  
  1839.     /*
  1840.      * Find where we hit the left margin, popping old
  1841.      * obsolete elements as we go.
  1842.      */
  1843.     mptr = state->left_margin_stack;
  1844.     while ((mptr != NULL)&&(state->y > mptr->y_max))
  1845.     {
  1846.         lo_MarginStack *margin;
  1847.  
  1848.         margin = mptr;
  1849.         mptr = mptr->next;
  1850.         XP_DELETE(margin);
  1851.     }
  1852.     if (mptr != NULL)
  1853.     {
  1854.         state->left_margin_stack = mptr;
  1855.         state->left_margin = mptr->margin;
  1856.         /*
  1857.          * For a list wrapped around a floating image we may
  1858.          * need to be indented from the image edge.
  1859.          */
  1860.         if (state->list_stack->old_left_margin > mptr->margin)
  1861.         {
  1862.             state->left_margin = state->list_stack->old_left_margin;
  1863.         }
  1864.     }
  1865.     else
  1866.     {
  1867.         state->left_margin_stack = NULL;
  1868.         state->left_margin = (state->list_stack != NULL)
  1869.                            ? state->list_stack->old_left_margin
  1870.                            : 0;
  1871.     }
  1872.  
  1873.     /*
  1874.      * Find floating elements just added to the right margin stack
  1875.      * from the last line, and set their absolute
  1876.      * coordinates.
  1877.      */
  1878.     mptr = state->right_margin_stack;
  1879.     while ((mptr != NULL)&&(mptr->y_min < 0))
  1880.     {
  1881.         mptr->y_min = state->y;
  1882.         mptr->y_max = mptr->y_min + mptr->y_max;
  1883.         mptr = mptr->next;
  1884.     }
  1885.  
  1886.     /*
  1887.      * Find where we hit the right margin, popping old
  1888.      * obsolete elements as we go.
  1889.      */
  1890.     mptr = state->right_margin_stack;
  1891.     while ((mptr != NULL)&&(state->y > mptr->y_max))
  1892.     {
  1893.         lo_MarginStack *margin;
  1894.  
  1895.         margin = mptr;
  1896.         mptr = mptr->next;
  1897.         XP_DELETE(margin);
  1898.     }
  1899.     if (mptr != NULL)
  1900.     {
  1901.         state->right_margin_stack = mptr;
  1902.         state->right_margin = mptr->margin;
  1903.     }
  1904.     else
  1905.     {
  1906.         state->right_margin_stack = NULL;
  1907.         state->right_margin = (state->list_stack != NULL)
  1908.                             ? state->list_stack->old_right_margin
  1909.                             : 0;
  1910.     }
  1911. }
  1912.  
  1913. void
  1914. lo_RecycleElements(MWContext *context, lo_DocState *state, LO_Element *elements)
  1915. {
  1916.     LO_Element *eptr;
  1917.  
  1918.     if (elements == NULL)
  1919.     {
  1920.         return;
  1921.     }
  1922.  
  1923.     eptr = elements;
  1924.     while(eptr->lo_any.next != NULL)
  1925.     {
  1926.         lo_ScrapeElement(context, eptr);
  1927.         eptr = eptr->lo_any.next;
  1928.     }
  1929.     lo_ScrapeElement(context, eptr);
  1930. #ifdef MEMORY_ARENAS
  1931.     if ( EDT_IS_EDITOR(context) ) {
  1932.         eptr->lo_any.next = state->top_state->recycle_list;
  1933.         state->top_state->recycle_list = elements;
  1934.     }
  1935. #else
  1936.     eptr->lo_any.next = state->top_state->recycle_list;
  1937.     state->top_state->recycle_list = elements;
  1938. #endif /* MEMORY_ARENAS */
  1939. }
  1940.  
  1941.  
  1942. LO_Element *
  1943. lo_NewElement(MWContext *context, lo_DocState *state, intn type, 
  1944.         ED_Element *edit_element, intn edit_offset)
  1945. {
  1946.     LO_Element *eptr;
  1947.  
  1948. #ifdef MEMORY_ARENAS
  1949.     int32 size;
  1950.  
  1951.     switch(type)
  1952.     {
  1953.         case LO_TEXT:
  1954.             size = sizeof(LO_TextStruct);
  1955.             break;
  1956.         case LO_LINEFEED:
  1957.             size = sizeof(LO_LinefeedStruct);
  1958.             break;
  1959.         case LO_HRULE:
  1960.             size = sizeof(LO_HorizRuleStruct);
  1961.             break;
  1962.         case LO_IMAGE:
  1963.             size = sizeof(LO_ImageStruct);
  1964.             break;
  1965.         case LO_BULLET:
  1966.             size = sizeof(LO_BulletStruct);
  1967.             break;
  1968.         case LO_FORM_ELE:
  1969.             size = sizeof(LO_FormElementStruct);
  1970.             break;
  1971.         case LO_SUBDOC:
  1972.             size = sizeof(LO_SubDocStruct);
  1973.             break;
  1974.         case LO_TABLE:
  1975.             size = sizeof(LO_TableStruct);
  1976.             break;
  1977.         case LO_CELL:
  1978.             size = sizeof(LO_CellStruct);
  1979.             break;
  1980.         case LO_EMBED:
  1981.             size = sizeof(LO_EmbedStruct);
  1982.             break;
  1983. #ifdef JAVA
  1984.         case LO_JAVA:
  1985.             size = sizeof(LO_JavaAppStruct);
  1986.             break;
  1987. #endif
  1988.         case LO_EDGE:
  1989.             size = sizeof(LO_EdgeStruct);
  1990.             break;
  1991.         case LO_OBJECT:
  1992.             size = sizeof(LO_ObjectStruct);
  1993.             break;
  1994.         case LO_PARAGRAPH:
  1995.             size = sizeof(LO_ParagraphStruct);
  1996.             break;
  1997.         case LO_CENTER:
  1998.             size = sizeof(LO_CenterStruct);
  1999.             break;
  2000.         case LO_MULTICOLUMN:
  2001.             size = sizeof(LO_MulticolumnStruct);
  2002.             break;
  2003.         case LO_TEXTBLOCK:
  2004.             size = sizeof(LO_TextBlock);
  2005.             break;
  2006.         case LO_LIST:
  2007.             size = sizeof(LO_ListStruct);
  2008.             break;
  2009.         case LO_DESCTITLE:
  2010.             size = sizeof(LO_DescTitleStruct);
  2011.             break;
  2012.         case LO_DESCTEXT:
  2013.             size = sizeof(LO_DescTextStruct);
  2014.             break;
  2015.         case LO_BLOCKQUOTE:
  2016.             size = sizeof(LO_BlockQuoteStruct);
  2017.             break;
  2018.         case LO_LAYER:
  2019.             size = sizeof(LO_LayerStruct);
  2020.             break;
  2021.         case LO_SPACER:
  2022.             size = sizeof(LO_SpacerStruct);
  2023.             break;
  2024.         default:
  2025.             size = sizeof(LO_Any);
  2026.             break;
  2027.     }
  2028.     if ( ! EDT_IS_EDITOR(context) ) {
  2029.         eptr = (LO_Element *)lo_MemoryArenaAllocate(state->top_state, size);
  2030.     }
  2031.     else {
  2032.         if (state->top_state->recycle_list != NULL)
  2033.         {
  2034.             eptr = state->top_state->recycle_list;
  2035.             state->top_state->recycle_list = eptr->lo_any.next;
  2036.         }
  2037.         else
  2038.         {
  2039.             eptr = XP_NEW(LO_Element);
  2040.         }
  2041.     }
  2042. #else
  2043.  
  2044.     /* sorry about all the asserts, in my debug version somehow state
  2045.      * becomes nil after a malloc failure. */
  2046. #ifdef DEBUG
  2047.     assert (state);
  2048. #endif
  2049.     
  2050.     if (state->top_state->recycle_list != NULL)
  2051.     {
  2052.         eptr = state->top_state->recycle_list;
  2053.         state->top_state->recycle_list = eptr->lo_any.next;
  2054.     }
  2055.     else
  2056.     {
  2057.         eptr = XP_NEW(LO_Element);
  2058. #ifdef DEBUG
  2059.         assert (state);
  2060. #endif
  2061.     } 
  2062. #endif /* MEMORY_ARENAS */
  2063.     
  2064.     if (eptr == NULL)
  2065.     {
  2066. #ifdef DEBUG
  2067.         assert (state);
  2068. #endif
  2069.         state->top_state->out_of_memory = TRUE;
  2070.     }
  2071.     else
  2072.     {
  2073.         eptr->lo_any.next = NULL;
  2074.         eptr->lo_any.prev = NULL;
  2075. #ifdef EDITOR
  2076.         eptr->lo_any.edit_element = NULL;
  2077.         eptr->lo_any.edit_offset = 0;
  2078.  
  2079.         if( EDT_IS_EDITOR(context) )
  2080.         {
  2081.             if( lo_EditableElement( type ) )
  2082.             {
  2083.                 if( edit_element == 0 ){
  2084.                     edit_element = state->edit_current_element;
  2085.                     edit_offset = state->edit_current_offset;
  2086.                 }
  2087.                 EDT_SetLayoutElement( edit_element, 
  2088.                                         edit_offset,
  2089.                                         type,
  2090.                                         eptr );
  2091.             } else if( edit_element && (type == LO_TABLE || type == LO_CELL) )
  2092.             {
  2093.                 /* _TABLE_EXPERIMENT_  SAVE POINTER TO EDIT ELEMENT IN LO STRUCT */
  2094.                 eptr->lo_any.edit_element = edit_element;
  2095.  
  2096.             }
  2097.         }
  2098.         state->edit_force_offset = FALSE;
  2099. #endif
  2100.     }
  2101.  
  2102.     return(eptr);
  2103. }
  2104.  
  2105.  
  2106. /* Add a named anchor to the global list of named anchors.  This does not
  2107.    associate the anchor with a layout element.  lo_SetNamedAnchor should be
  2108.    followed by a call to lo_BindNamedAnchorToElement in order to associate
  2109.    the named anchor with a layout element. */
  2110. Bool
  2111. lo_SetNamedAnchor(lo_DocState *state, PA_Block name)
  2112. {
  2113.     lo_NameList *name_rec = NULL;
  2114.     lo_DocLists *doc_lists;
  2115.  
  2116.     /*
  2117.      * No named anchors are allowed within a
  2118.      * hacked scrolling content layout document.
  2119.      */
  2120.     if (state->top_state->scrolling_doc != FALSE)
  2121.     {
  2122.         if (name != NULL)
  2123.         {
  2124.             PA_FREE(name);
  2125.         }
  2126.         return FALSE;
  2127.     }
  2128.  
  2129.     doc_lists = lo_GetCurrentDocLists(state);
  2130.     
  2131. #ifdef MOCHA
  2132.     if (state->in_relayout) {
  2133.         /* Look for the old lo_NameList.  Its mocha_object is still valid. */
  2134.         lo_NameList *name_list = doc_lists->name_list;
  2135.         lo_NameList *prev;
  2136.         Bool no_match;
  2137.         char *s1, *s2;
  2138.         
  2139.         XP_ASSERT(name_list);   /* If in relayout, this cannot be empty. */
  2140.         
  2141.         prev = name_list;
  2142.         name_rec = name_list;
  2143.         while (name_rec != NULL) {
  2144.             PA_LOCK(s1, char*, name);
  2145.             PA_LOCK(s2, char*, name_rec->name);
  2146.             no_match = XP_STRCMP(s1, s2);
  2147.             PA_UNLOCK(name_rec->name);
  2148.             PA_UNLOCK(name);
  2149.             if (!no_match) {
  2150.                 if (name_rec == name_list)
  2151.                     doc_lists->name_list = name_list->next;
  2152.                 else
  2153.                     prev->next = name_rec->next;
  2154.                 PA_FREE(name_rec->name); /* No need for this, use new one. */
  2155.                 break;
  2156.             }
  2157.             prev = name_rec;
  2158.             name_rec = name_rec->next;
  2159.         }
  2160.     }
  2161.     if (!name_rec || !state->in_relayout) {
  2162. #endif /* MOCHA */
  2163.         name_rec = XP_NEW(lo_NameList);
  2164.         if (name_rec == NULL)
  2165.             {
  2166.                 state->top_state->out_of_memory = TRUE;
  2167.                 PA_FREE(name);
  2168.                 return FALSE;
  2169.             }
  2170. #ifdef MOCHA
  2171.         name_rec->mocha_object = NULL;
  2172.     }
  2173. #endif /* MOCHA */
  2174.     name_rec->x = 0;
  2175.     name_rec->y = 0;
  2176.     name_rec->name = name;
  2177.     name_rec->element = NULL;   /* Set by lo_BindNamedAnchorToElement. */
  2178.  
  2179.     name_rec->next = doc_lists->name_list;
  2180.     doc_lists->name_list = name_rec;
  2181.     return TRUE;
  2182. }
  2183.  
  2184. /* Associate a named anchor with a layout element.  The named anchor should
  2185.    be the first one in the list of named anchors.*/
  2186. Bool
  2187. lo_BindNamedAnchorToElement(lo_DocState *state, PA_Block name,
  2188.                            LO_Element *element)
  2189. {
  2190.     Bool no_match;
  2191.     LO_Element *eptr;
  2192.     lo_NameList *name_rec;
  2193.     char *s1, *s2;
  2194.     lo_DocLists *doc_lists;
  2195.  
  2196.     doc_lists = lo_GetCurrentDocLists(state);
  2197.     
  2198.     if (element == NULL)
  2199.     {
  2200.         if (state->line_list == NULL)
  2201.         {
  2202.             eptr = state->end_last_line;
  2203.         }
  2204.         else
  2205.         {
  2206.             eptr = state->line_list;
  2207.             while (eptr->lo_any.next != NULL)
  2208.             {
  2209.                 eptr = eptr->lo_any.next;
  2210.             }
  2211.         }
  2212.     }
  2213.     else
  2214.     {
  2215.         eptr = element;
  2216.     }
  2217.  
  2218.     /* Find the matching name_rec in the name_list */
  2219.     name_rec = doc_lists->name_list;
  2220.     PA_LOCK(s1, char*, name);
  2221.     while (name_rec != NULL)
  2222.     {
  2223.     PA_LOCK(s2, char*, name_rec->name);
  2224.     no_match = XP_STRCMP(s1, s2);
  2225.     PA_UNLOCK(name_rec->name);
  2226.     if (!no_match)
  2227.         break;
  2228.     name_rec = name_rec->next;
  2229.     }
  2230.     PA_UNLOCK(name);
  2231.     if (name_rec == NULL)
  2232.         return FALSE;
  2233.  
  2234.     if (eptr == NULL)
  2235.     {
  2236.         name_rec->x = 0;
  2237.         name_rec->y = 0;
  2238.     }
  2239.     else
  2240.     {
  2241.         name_rec->x = eptr->lo_any.x;
  2242.         name_rec->y = eptr->lo_any.y;
  2243.     }
  2244.  
  2245.     name_rec->element = eptr;
  2246.     return TRUE;
  2247. }
  2248.  
  2249.  
  2250. void
  2251. lo_AddNameList(lo_DocState *state, lo_DocState *old_state)
  2252. {
  2253. /*
  2254.  * Now named anchors are added directly to the
  2255.  * top_state (or layer's) name_list, so we don't have to push
  2256.  * them up. We do, however, need to update their positions, 
  2257.  * though it seems like this is done at the end of table 
  2258.  * processing. Hence this code is no longer necessary.
  2259.  */
  2260. #if 0
  2261.     lo_NameList *name_list;
  2262.     lo_NameList *nptr;
  2263.  
  2264.     name_list = old_state->name_list;
  2265.     while (name_list != NULL)
  2266.     {
  2267.         /*
  2268.          * Extract the current record from the list.
  2269.          */
  2270.         nptr = name_list;
  2271.         name_list = name_list->next;
  2272.  
  2273.         /*
  2274.          * The element almost certainly has been moved
  2275.          * from subdoc to main cell, correct its position.
  2276.          */
  2277.         if (nptr->element != NULL)
  2278.         {
  2279.             nptr->x = nptr->element->lo_any.x;
  2280.             nptr->y = nptr->element->lo_any.y;
  2281.         }
  2282.  
  2283.         /*
  2284.          * Stick it into the main name list.
  2285.          */
  2286.         nptr->next = state->name_list;
  2287.         state->name_list = nptr;
  2288.     }
  2289.     old_state->name_list = name_list;
  2290. #endif /* 0 */
  2291. }
  2292.  
  2293.  
  2294. void
  2295. lo_CheckNameList(MWContext *context, lo_DocState *state, int32 min_id)
  2296. {
  2297.     lo_NameList *nptr;
  2298.     lo_DocLists *doc_lists;
  2299.  
  2300.     /*
  2301.      * Positions of named elements are only accurate if
  2302.      * we are not in a nested subdoc.
  2303.      */
  2304.     if (state->is_a_subdoc != SUBDOC_NOT)
  2305.     {
  2306.         return;
  2307.     }
  2308.  
  2309.     doc_lists = lo_GetCurrentDocLists(state);
  2310.     
  2311.     nptr = doc_lists->name_list;
  2312.     while (nptr != NULL)
  2313.     {
  2314.         /*
  2315.          * If the element's id is greater
  2316.          * than the passed minimum, then
  2317.          * the element almost certainly has been moved
  2318.          * during table processing,
  2319.          * correct its position.
  2320.          */
  2321.         if ((nptr->element != NULL)&&
  2322.             (nptr->element->lo_any.ele_id > min_id))
  2323.         {
  2324.             nptr->x = nptr->element->lo_any.x;
  2325.             nptr->y = nptr->element->lo_any.y;
  2326.         }
  2327.  
  2328.         /*
  2329.          * If we are blocked on a named element.
  2330.          * Check if this name is one we are waiting on.
  2331.          */
  2332.         if ((state->display_blocking_element_id == -1)&&
  2333.             (nptr->name != NULL))
  2334.         {
  2335.             char *name;
  2336.  
  2337.             PA_LOCK(name, char *, nptr->name);
  2338.             if (XP_STRCMP(name,
  2339.                 (char *)(state->top_state->name_target + 1)) == 0)
  2340.             {
  2341.                 XP_FREE(state->top_state->name_target);
  2342.                 state->top_state->name_target = NULL;
  2343.                 if (nptr->element != NULL)
  2344.                 {
  2345.                     state->display_blocking_element_id =
  2346.                         nptr->element->lo_any.ele_id;
  2347.                 }
  2348.                 else
  2349.                 {
  2350.                     state->display_blocking_element_id =
  2351.                         state->top_state->element_id;
  2352.                 }
  2353.                 /*
  2354.                  * If the display is blocked for an element
  2355.                  * we havn't reached yet, check to see if
  2356.                  * it is in this line, and if so, save its
  2357.                  * y position.
  2358.                  */
  2359.                 if ((state->display_blocked != FALSE)&&
  2360.                     (state->is_a_subdoc == SUBDOC_NOT)&&
  2361.                     (state->display_blocking_element_y == 0)&&
  2362.                     (state->display_blocking_element_id != -1))
  2363.                 {
  2364.                     state->display_blocking_element_y = nptr->y;
  2365.                 }
  2366.                 PA_UNLOCK(nptr->name);
  2367.             }
  2368.             else
  2369.             {
  2370.                 PA_UNLOCK(nptr->name);
  2371.             }
  2372.         }
  2373.  
  2374.         nptr = nptr->next;
  2375.     }
  2376. }
  2377.  
  2378.  
  2379. void
  2380. lo_AppendToLineList(MWContext *context, lo_DocState *state,
  2381.     LO_Element *element, int32 baseline_inc)
  2382. {
  2383.     LO_Element *eptr;
  2384.  
  2385.     if (state->current_named_anchor != NULL) {
  2386.         if (!lo_BindNamedAnchorToElement(state, state->current_named_anchor,
  2387.                                          element)) {
  2388.             XP_ASSERT(FALSE);
  2389.         }
  2390.     state->current_named_anchor = NULL;
  2391.     }
  2392. #ifdef MOCHA
  2393.     else if (state->current_anchor) {
  2394.         state->current_anchor->element = element;
  2395.     }
  2396. #endif /* MOCHA */
  2397.  
  2398.     element->lo_any.next = NULL;
  2399.     element->lo_any.prev = NULL;
  2400.     eptr = state->line_list;
  2401.     if (eptr == NULL)
  2402.     {
  2403.         state->line_list = element;
  2404.     }
  2405.     else
  2406.     {
  2407.         while (eptr->lo_any.next != NULL)
  2408.         {
  2409.             eptr->lo_any.y_offset += baseline_inc;
  2410.             eptr = eptr->lo_any.next;
  2411.         }
  2412.         eptr->lo_any.y_offset += baseline_inc;
  2413.         eptr->lo_any.next = element;
  2414.         element->lo_any.prev = eptr;
  2415.     }
  2416. }
  2417.  
  2418. void
  2419. lo_SetLineArrayEntry(lo_DocState *state, LO_Element *eptr, int32 line)
  2420. {
  2421.     LO_Element **line_array;
  2422.  
  2423. #ifdef XP_WIN16
  2424.         intn a_size;
  2425.         intn a_indx;
  2426.         intn a_line;
  2427.         XP_Block *larray_array;
  2428. #endif /* XP_WIN16 */
  2429.  
  2430.     if ((line < 0) || (line >= (state->line_num - 1)))
  2431.     {
  2432.         return;
  2433.     }
  2434.  
  2435. #ifdef XP_WIN16
  2436.         a_size = SIZE_LIMIT / sizeof(LO_Element *);
  2437.         a_indx = (intn)(line / a_size);
  2438.         a_line = (intn)(line - (a_indx * a_size));
  2439.  
  2440.         XP_LOCK_BLOCK(larray_array, XP_Block *, state->larray_array);
  2441.         state->line_array = larray_array[a_indx];
  2442.         XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
  2443.     line_array[a_line] = eptr;
  2444.  
  2445.         XP_UNLOCK_BLOCK(state->line_array);
  2446.         XP_UNLOCK_BLOCK(state->larray_array);
  2447. #else
  2448.         XP_LOCK_BLOCK(line_array, LO_Element **, state->line_array);
  2449.     line_array[line] = eptr;
  2450.         XP_UNLOCK_BLOCK(state->line_array);
  2451. #endif /* XP_WIN16 */
  2452. }
  2453.  
  2454. #define POSITIVE_SCALE_FACTOR 1.10 /* 10% */
  2455. #define NEGATIVE_SCALE_FACTOR .90  /* 10% */
  2456.  
  2457.  
  2458. /*
  2459.  * Return the scaling percentage given a font scaler
  2460.  *
  2461.  */
  2462. double
  2463. LO_GetScalingFactor(int32 scaler)
  2464. {
  2465.     double scale=1.0;
  2466.     double mult;
  2467.     int32 count;
  2468.  
  2469.     if(scaler < 0)
  2470.     {
  2471.         count = -scaler;
  2472.         mult = NEGATIVE_SCALE_FACTOR;
  2473.     }
  2474.     else
  2475.     {
  2476.        count = scaler;
  2477.        mult = POSITIVE_SCALE_FACTOR;
  2478.     }
  2479.  
  2480.     /* use the percentage scaling factor to the power of the pref */
  2481.     while(count--)
  2482.         scale *= mult;
  2483.  
  2484.     return scale;
  2485. }
  2486.  
  2487.  
  2488. /*
  2489.  * Return the width of the window for this context in chars in the default
  2490.  * fixed width font.  Return -1 on error.
  2491.  */
  2492. int16
  2493. LO_WindowWidthInFixedChars(MWContext *context)
  2494. {
  2495.     int32 doc_id;
  2496.     lo_TopState *top_state;
  2497.     lo_DocState *state;
  2498.     LO_TextInfo tmp_info;
  2499.     LO_TextAttr tmp_attr;
  2500.     LO_TextStruct tmp_text;
  2501.     PA_Block buff;
  2502.     char *str;
  2503.     int32 width;
  2504.     int16 char_cnt;
  2505.  
  2506.     /*
  2507.      * Get the unique document ID, and retreive this
  2508.      * documents layout state.
  2509.      */
  2510.     doc_id = XP_DOCID(context);
  2511.     top_state = lo_FetchTopState(doc_id);
  2512.     if ((top_state == NULL)||(top_state->doc_state == NULL))
  2513.     {
  2514.         return((int16)-1);
  2515.     }
  2516.     state = top_state->doc_state;
  2517.  
  2518.     /*
  2519.      * Create a fake text buffer to measure an 'M'.
  2520.      */
  2521.     memset (&tmp_text, 0, sizeof (tmp_text));
  2522.     buff = PA_ALLOC(1);
  2523.     if (buff == NULL)
  2524.     {
  2525.         return((int16)-1);
  2526.     }
  2527.     PA_LOCK(str, char *, buff);
  2528.     str[0] = 'M';
  2529.     PA_UNLOCK(buff);
  2530.     tmp_text.text = buff;
  2531.     tmp_text.text_len = 1;
  2532.  
  2533.     /*
  2534.      * Fill in default fixed font information.
  2535.      */
  2536.     lo_SetDefaultFontAttr(state, &tmp_attr, context);
  2537.     tmp_attr.fontmask |= LO_FONT_FIXED;
  2538.     tmp_text.text_attr = &tmp_attr;
  2539.  
  2540.     /*
  2541.      * Get the width of that 'M'
  2542.      */
  2543.     FE_GetTextInfo(context, &tmp_text, &tmp_info);
  2544.     PA_FREE(buff);
  2545.  
  2546.     /*
  2547.      * Error if bad character width
  2548.      */
  2549.     if (tmp_info.max_width <= 0)
  2550.     {
  2551.         return((int16)-1);
  2552.     }
  2553.  
  2554.     width = state->win_width - state->win_left - state->win_right;
  2555.     char_cnt = (int16)(width / tmp_info.max_width);
  2556.     return(char_cnt);
  2557. }
  2558.  
  2559.  
  2560. LO_Element *
  2561. lo_FirstElementOfLine(MWContext *context, lo_DocState *state, int32 line)
  2562. {
  2563.     LO_Element *eptr;
  2564.     LO_Element **line_array;
  2565.  
  2566.     if ((line < 0)||(line > (state->line_num - 2)))
  2567.     {
  2568.         return(NULL);
  2569.     }
  2570.  
  2571. #ifdef XP_WIN16
  2572.     {
  2573.         intn a_size;
  2574.         intn a_indx;
  2575.         intn a_line;
  2576.         XP_Block *larray_array;
  2577.  
  2578.         a_size = SIZE_LIMIT / sizeof(LO_Element *);
  2579.         a_indx = (intn)(line / a_size);
  2580.         a_line = (intn)(line - (a_indx * a_size));
  2581.         XP_LOCK_BLOCK(larray_array, XP_Block *,
  2582.                 state->larray_array);
  2583.         state->line_array = larray_array[a_indx];
  2584.         XP_LOCK_BLOCK(line_array, LO_Element **,
  2585.                 state->line_array);
  2586.         eptr = line_array[a_line];
  2587.         XP_UNLOCK_BLOCK(state->line_array);
  2588.         XP_UNLOCK_BLOCK(state->larray_array);
  2589.     }
  2590. #else
  2591.     {
  2592.         XP_LOCK_BLOCK(line_array, LO_Element **,
  2593.                 state->line_array);
  2594.         eptr = line_array[line];
  2595.         XP_UNLOCK_BLOCK(state->line_array);
  2596.     }
  2597. #endif /* XP_WIN16 */
  2598.     return(eptr);
  2599. }
  2600.  
  2601.  
  2602. Bool
  2603. lo_FindMochaExpr(char *str, char **expr_start, char **expr_end)
  2604. {
  2605.     char *tptr;
  2606.     char *start;
  2607.     char *end;
  2608.  
  2609.     if (str == NULL)
  2610.     {
  2611.         return(FALSE);
  2612.     }
  2613.  
  2614.     start = NULL;
  2615.     end = NULL;
  2616.     tptr = str;
  2617.     while (*tptr != '\0')
  2618.     {
  2619.         if ((*tptr == '&')&&(*(char *)(tptr + 1) == '{'))
  2620.         {
  2621.             start = tptr;
  2622.             break;
  2623.         }
  2624.         tptr++;
  2625.     }
  2626.  
  2627.     if (start == NULL)
  2628.     {
  2629.         return(FALSE);
  2630.     }
  2631.  
  2632.     tptr = (char *)(start + 2);
  2633.     while (*tptr != '\0')
  2634.     {
  2635.         if ((*tptr == '}')&&(*(char *)(tptr + 1) == ';'))
  2636.         {
  2637.             end = tptr;
  2638.             break;
  2639.         }
  2640.         tptr++;
  2641.     }
  2642.  
  2643.     if (end == NULL)
  2644.     {
  2645.         return(FALSE);
  2646.     }
  2647.  
  2648.     end = (char *)(end + 1);
  2649.     *expr_start = start;
  2650.     *expr_end = end;
  2651.     return(TRUE);
  2652. }
  2653.  
  2654.  
  2655. static char *
  2656. lo_add_string(char *base, char *add)
  2657. {
  2658.     char *new;
  2659.     int32 base_len, add_len;
  2660.  
  2661.     if (add == NULL)
  2662.     {
  2663.         return(base);
  2664.     }
  2665.  
  2666.     if (base == NULL)
  2667.     {
  2668.         new = XP_STRDUP(add);
  2669.         return(new);
  2670.     }
  2671.  
  2672.     base_len = XP_STRLEN(base);
  2673.     add_len = XP_STRLEN(add);
  2674.     new = (char *)XP_ALLOC(base_len + add_len + 1);
  2675.     if (new == NULL)
  2676.     {
  2677.         return(base);
  2678.     }
  2679.  
  2680.     XP_STRCPY(new, base);
  2681.     XP_STRCAT(new, add);
  2682.     XP_FREE(base);
  2683.     return(new);
  2684. }
  2685.  
  2686.  
  2687. static char *
  2688. lo_eval_javascript_entities(MWContext *context, char *orig_value,
  2689.                             uint newline_count)
  2690. {
  2691.     char *tptr;
  2692.     char *str;
  2693.     char *new_str;
  2694.     int32 len;
  2695.     char tchar;
  2696.     Bool has_mocha;
  2697.     char *start, *end;
  2698.  
  2699.     if (orig_value == NULL)
  2700.     {
  2701.         return(NULL);
  2702.     }
  2703.  
  2704.     str = orig_value;
  2705.     len = XP_STRLEN(str);
  2706.  
  2707.     new_str = NULL;
  2708.     tptr = str;
  2709.     has_mocha = lo_FindMochaExpr(tptr, &start, &end);
  2710.     while (has_mocha != FALSE)
  2711.     {
  2712.         char *expr_start, *expr_end;
  2713.  
  2714.         if (start > tptr)
  2715.         {
  2716.             tchar = *start;
  2717.             *start = '\0';
  2718.             new_str = lo_add_string(new_str, tptr);
  2719.             *start = tchar;
  2720.         }
  2721.  
  2722.         expr_start = (char *)(start + 2);
  2723.         expr_end = (char *)(end - 1);
  2724.         if (expr_end > expr_start)
  2725.         {
  2726.             char *eval_str;
  2727.  
  2728.             tchar = *expr_end;
  2729.             *expr_end = '\0';
  2730.             eval_str = LM_EvaluateAttribute(context, expr_start,
  2731.                                             newline_count + 1);
  2732.             *expr_end = tchar;
  2733.             new_str = lo_add_string(new_str, eval_str);
  2734.             if (eval_str != NULL)
  2735.             {
  2736.                 XP_FREE(eval_str);
  2737.             }
  2738.         }
  2739.  
  2740.         tptr = (char *)(end + 1);
  2741.         has_mocha = lo_FindMochaExpr(tptr, &start, &end);
  2742.     }
  2743.     if (tptr != str)
  2744.     {
  2745.         new_str = lo_add_string(new_str, tptr);
  2746.     }
  2747.  
  2748.     if (new_str == NULL)
  2749.     {
  2750.         new_str = str;
  2751.     }
  2752.  
  2753.     return(new_str);
  2754. }
  2755.  
  2756.  
  2757. void
  2758. lo_ConvertAllValues(MWContext *context, char **value_list, int32 list_len,
  2759.                     uint newline_count)
  2760. {
  2761.     int32 i;
  2762.  
  2763.     if (LM_CanDoJS(context) == FALSE)
  2764.     {
  2765.         return;
  2766.     }
  2767.  
  2768.     for (i=0; i < list_len; i++)
  2769.     {
  2770.         char *str;
  2771.         char *new_str;
  2772.  
  2773.         str = value_list[i];
  2774.         if (str != NULL)
  2775.         {
  2776.             new_str = lo_eval_javascript_entities(context, str, newline_count);
  2777.             if (new_str != str)
  2778.             {
  2779.                 XP_FREE(str);
  2780.                 value_list[i] = new_str;
  2781.             }
  2782.         }
  2783.     }
  2784. }
  2785.  
  2786.  
  2787. PA_Block
  2788. lo_FetchParamValue(MWContext *context, PA_Tag *tag, char *param_name)
  2789. {
  2790.     PA_Block buff;
  2791.     INTL_CharSetInfo c = LO_GetDocumentCharacterSetInfo(context);
  2792.     buff = PA_FetchParamValue(tag, param_name, INTL_GetCSIWinCSID(c));
  2793.     return(buff);
  2794. }
  2795.  
  2796. #include "prthread.h"
  2797. #include "prmon.h"
  2798.  
  2799. static PRMonitor * layout_lock_monitor = NULL;
  2800. static PRThread  * layout_lock_owner = NULL;
  2801. static int layout_lock_count = 0;
  2802.  
  2803. /*
  2804.  * Grab the lock around layout so that we can delete things / manipulate
  2805.  *   layout owned data structures in a separate thread
  2806.  */
  2807. void
  2808. LO_LockLayout()
  2809. {
  2810.     if(!layout_lock_monitor)
  2811.     layout_lock_monitor = PR_NewNamedMonitor("layout-lock");
  2812.  
  2813.     PR_EnterMonitor(layout_lock_monitor);
  2814.  
  2815.     while(TRUE) {
  2816.  
  2817.     /* no current owner or owned by this thread */
  2818.     if(layout_lock_owner == NULL ||
  2819.        layout_lock_owner == PR_CurrentThread()) {
  2820.         layout_lock_owner = PR_CurrentThread();
  2821.         layout_lock_count++;
  2822.  
  2823.         PR_ExitMonitor(layout_lock_monitor);
  2824.         return;
  2825.     }
  2826.  
  2827.     /* owned by someone else -- wait till we can get it */
  2828.     PR_Wait(layout_lock_monitor, PR_INTERVAL_NO_TIMEOUT);
  2829.  
  2830.     }
  2831. }
  2832.  
  2833. /*
  2834.  * Release the lock and wake up anyone who was waiting to get it if
  2835.  *   we are the last release of the lock from this thread
  2836.  */
  2837. void
  2838. LO_UnlockLayout()
  2839. {
  2840.  
  2841.     PR_EnterMonitor(layout_lock_monitor);
  2842.  
  2843. #ifdef DEBUG
  2844.     /* make sure someone doesn't try to free a lock they don't own */
  2845.     XP_ASSERT(layout_lock_owner == PR_CurrentThread());
  2846. #endif
  2847.  
  2848.     layout_lock_count--;
  2849.  
  2850.     if(layout_lock_count == 0) {
  2851.     layout_lock_owner = NULL;
  2852.     PR_Notify(layout_lock_monitor);
  2853.     }
  2854.     PR_ExitMonitor(layout_lock_monitor);
  2855.  
  2856. }
  2857.  
  2858.  
  2859. /*
  2860.  * A (debugging) way to make sure the current thread doesn't have the
  2861.  *   layout lock
  2862.  */
  2863. Bool
  2864. LO_VerifyUnlockedLayout()
  2865. {
  2866. #ifdef DEBUG
  2867.     Bool bHolding = TRUE;
  2868.     
  2869.     if (layout_lock_monitor) {
  2870.     PR_EnterMonitor(layout_lock_monitor);
  2871.     bHolding = (layout_lock_owner != PR_CurrentThread());
  2872.     PR_ExitMonitor(layout_lock_monitor);
  2873.     }
  2874.  
  2875.     return bHolding;
  2876.  
  2877. #else
  2878.     return TRUE;
  2879. #endif
  2880. }
  2881.  
  2882.  
  2883. /*
  2884.  * The mocha lock has been released, flush the blockage to see if
  2885.  *   we can get our blocked entities evaluated now.
  2886.  */
  2887. static void
  2888. lo_JSLockReleased(void * data)
  2889. {
  2890.     MWContext * context = (MWContext *) data;
  2891.     lo_TopState * top_state;
  2892.  
  2893.     top_state = lo_FetchTopState(XP_DOCID(context));
  2894.     if (!top_state)
  2895.     return;
  2896.  
  2897.     /* free the fake element we created earlier */
  2898.     lo_FreeElement(context, top_state->layout_blocking_element, FALSE);
  2899.  
  2900.     /* flush the blockage */
  2901.     lo_UnblockLayout(context, top_state);
  2902. }
  2903.  
  2904. /* 
  2905.  * see if there are any &{} constructs for this tag.  If so,
  2906.  *   convert them now, if we can't convert them (since we couldn't
  2907.  *   get the mocha lock, for example) return FALSE
  2908.  */
  2909. Bool
  2910. lo_ConvertMochaEntities(MWContext * context, lo_DocState *state, PA_Tag * tag)
  2911. {
  2912.  
  2913.         char *tptr;
  2914.     char *str;
  2915.     char *new_str;
  2916.     int32 len;
  2917.     char tchar;
  2918.     Bool has_mocha;
  2919.     char *start, *end;
  2920.     int32 cur_layer_id;
  2921.  
  2922.     PA_LOCK(str, char *, tag->data);
  2923.     len = tag->data_len;
  2924.  
  2925.     if (LM_CanDoJS(context) == FALSE)
  2926.         return TRUE;
  2927.  
  2928.     new_str = NULL;
  2929.     tptr = str;
  2930.     has_mocha = lo_FindMochaExpr(tptr, &start, &end);
  2931.  
  2932.     if (has_mocha == FALSE)
  2933.         return TRUE;
  2934.  
  2935.     /* attempt to lock JS */
  2936.     if (!LM_AttemptLockJS(lo_JSLockReleased, context))
  2937.         return FALSE;
  2938.  
  2939.     /* 
  2940.      * Make sure that the current layer and all its ancestors have
  2941.      * been reflected and that the current layer has been set as the 
  2942.      * active layer, since we want to ensure correct scoping and there's 
  2943.      * no way to know that the reflect event has reached Mocha yet. 
  2944.      * Note that reflecting the object multiple times is safe, since the 
  2945.      * reflection code is idempotent.
  2946.      */
  2947.     cur_layer_id = lo_CurrentLayerId(state);
  2948.     if (cur_layer_id != LO_DOCUMENT_LAYER_ID) {
  2949.         CL_Layer *layer, *parent;
  2950.     int32 child_layer_id = cur_layer_id;
  2951.         int32 parent_layer_id;
  2952.         
  2953.     do {
  2954.         layer = LO_GetLayerFromId(context, child_layer_id);
  2955.         parent = CL_GetLayerParent(layer);
  2956.         parent_layer_id = LO_GetIdFromLayer(context, parent);
  2957.         LM_ReflectLayer(context, cur_layer_id, parent_layer_id, NULL);
  2958.         child_layer_id = parent_layer_id;
  2959.     } while (child_layer_id != LO_DOCUMENT_LAYER_ID);
  2960.  
  2961.     }
  2962.     LM_SetActiveLayer(context, cur_layer_id);
  2963.     while (has_mocha != FALSE)
  2964.     {
  2965.         char *expr_start, *expr_end;
  2966.  
  2967.         if (start > tptr)
  2968.         {
  2969.             tchar = *start;
  2970.             *start = '\0';
  2971.             new_str = lo_add_string(new_str, tptr);
  2972.             *start = tchar;
  2973.         }
  2974.  
  2975.         expr_start = (char *)(start + 2);
  2976.         expr_end = (char *)(end - 1);
  2977.         if (expr_end > expr_start)
  2978.         {
  2979.             char *eval_str;
  2980.  
  2981.             tchar = *expr_end;
  2982.             *expr_end = '\0';
  2983.             if (state->top_state && state->top_state->nurl) {
  2984.                 LM_SetDecoderStream(context, NULL, 
  2985.                                     state->top_state->nurl,
  2986.                                     JS_FALSE);
  2987.             }
  2988.             eval_str = LM_EvaluateAttribute(context, expr_start,
  2989.                             tag->newline_count + 1);
  2990.             *expr_end = tchar;
  2991.             new_str = lo_add_string(new_str, eval_str);
  2992.             if (eval_str != NULL)
  2993.             {
  2994.                 XP_FREE(eval_str);
  2995.             }
  2996.         }
  2997.  
  2998.         tptr = (char *)(end + 1);
  2999.         has_mocha = lo_FindMochaExpr(tptr, &start, &end);
  3000.     }
  3001.     if (tptr != str)
  3002.     {
  3003.         new_str = lo_add_string(new_str, tptr);
  3004.     }
  3005.  
  3006.     PA_FREE(tag->data);
  3007.     tag->data = (PA_Block) new_str;
  3008.     tag->data_len = XP_STRLEN((char *) tag->data);
  3009.     PA_UNLOCK(tag->data);
  3010.  
  3011.     LM_UnlockJS();
  3012.  
  3013.     return TRUE;
  3014.  
  3015. }
  3016.  
  3017. /* Called from front ends as a threadsafe way to update values of text fields. */
  3018. void
  3019. LO_UpdateTextData(lo_FormElementTextData * textData, const char * text) {
  3020.  
  3021.     LO_LockLayout();
  3022.  
  3023.     if(textData->current_text)
  3024.     XP_FREE(textData->current_text);
  3025.             
  3026.     textData->current_text = (PA_Block) XP_STRDUP(text);
  3027.  
  3028.     LO_UnlockLayout();
  3029. }
  3030.  
  3031. LO_TableStruct *lo_GetParentTable(MWContext *pContext, LO_Element *pElement)
  3032. {
  3033.     LO_Element *tptr;
  3034.     if( !pElement )
  3035.         return NULL;
  3036.  
  3037.     if( pElement->lo_any.type == LO_CELL )
  3038.     {
  3039.         /* Supplied element is already a cell, start table search with it */
  3040.         tptr = pElement;
  3041.     } else {
  3042.         if( !pContext )
  3043.             return NULL;
  3044.  
  3045.         /* First find the cell that contains the given element */
  3046.         tptr = (LO_Element*)lo_GetParentCell(pContext, pElement);
  3047.     }
  3048.  
  3049.     /* Simply search back from current cell to find table element */
  3050.     while( tptr )
  3051.     {
  3052.         if( tptr->lo_any.type == LO_TABLE )
  3053.         {
  3054.             return (LO_TableStruct*)tptr;
  3055.         }
  3056.         tptr = tptr->lo_any.prev;
  3057.     } 
  3058.     return NULL;
  3059. }
  3060.  
  3061.  
  3062. /* Recusively search for cell struct containing the given element 
  3063.  * If table is found, it searches into that as well
  3064.  */
  3065. LO_CellStruct *lo_GetCellContainingElement( LO_Element *pElement, LO_CellStruct *pFirstCell )
  3066. {
  3067.     LO_CellStruct *pNestedCell = NULL;
  3068.     LO_CellStruct *pFirstNestedCell;
  3069.     LO_Element    *cell_list_ptr;
  3070.     LO_CellStruct *pLoCell;
  3071.  
  3072.     pLoCell = pFirstCell;
  3073.     if( pLoCell == NULL )
  3074.         return NULL;
  3075.  
  3076.     do {
  3077.         cell_list_ptr = pLoCell->cell_list;
  3078.         while( cell_list_ptr )
  3079.         {
  3080.             if( cell_list_ptr == pElement )
  3081.             {
  3082.                 /* We found the element - return cell containing it */
  3083.                 return pLoCell;
  3084.             }
  3085.             if( cell_list_ptr->type == LO_TABLE )
  3086.             {
  3087.                 /* We found a nested table
  3088.                  * Get first cell in it and search through it
  3089.                 */
  3090.                 pFirstNestedCell = (LO_CellStruct*)cell_list_ptr->lo_any.next;
  3091.                 XP_ASSERT(pFirstNestedCell->type == LO_CELL);
  3092.                 pNestedCell = lo_GetCellContainingElement(pElement, pFirstNestedCell);
  3093.                 if( pNestedCell )
  3094.                 {
  3095.                    /* We found cell in nested table */
  3096.                    return pNestedCell;
  3097.                 }
  3098.             }
  3099.             cell_list_ptr = cell_list_ptr->lo_any.next;
  3100.         }
  3101.         pLoCell = (LO_CellStruct*)pLoCell->next;
  3102.     }  /* End when there's no more cells or we hit linefeed at end of line (top-level table)*/
  3103.     while (pLoCell && pLoCell->type == LO_CELL);
  3104.  
  3105.     return NULL;
  3106. }
  3107.  
  3108. /* Search algorithm is very similar to CEditBuffer::GetTableHitRegion()
  3109.  *   (which is similar to lo_XYtoDocumentElement except it finds only cells)
  3110.  * Search for the Cell that contains pElement
  3111. */
  3112. LO_CellStruct *lo_GetParentCell(MWContext * pContext, LO_Element *pElement)
  3113. {
  3114.     LO_Element *tptr;
  3115.     int32 doc_id;
  3116.     lo_TopState *top_state;
  3117.     lo_DocState *state;
  3118.     XP_Bool in_table;
  3119.     int32 line;
  3120.     LO_Element *end_ptr;
  3121.     LO_Element *tptrTable;
  3122.     int32 x, y, t_width, t_height;
  3123.  
  3124.     doc_id = XP_DOCID(pContext);
  3125.     top_state = lo_FetchTopState(doc_id);
  3126.  
  3127.     /* Supplied element is a cell - return it ??? */
  3128.     if( pElement && pElement->type == LO_CELL )
  3129.         return (LO_CellStruct*)pElement;
  3130.  
  3131.     if( pContext == NULL || pElement == NULL || top_state == NULL || top_state->doc_state == NULL )
  3132.         return NULL;
  3133.     
  3134.     state = top_state->doc_state;
  3135.     tptrTable = NULL;
  3136.     in_table = FALSE;
  3137.     
  3138.     /* Find the line that contains the supplied element
  3139.      * This defines the top-level table
  3140.     */
  3141.     x = pElement->lo_any.x+1;
  3142.     y = pElement->lo_any.y+1;
  3143.  
  3144.     line = lo_PointToLine(pContext, state, x, y);
  3145.     lo_GetLineEnds(pContext, state, line, &tptr, &end_ptr);
  3146.  
  3147.     while (tptr != end_ptr)
  3148.     {
  3149.            t_width = tptr->lo_any.width;
  3150.            t_height = tptr->lo_any.height;
  3151.  
  3152.         if (t_width <= 0)
  3153.         {
  3154.             t_width = 1;
  3155.         }
  3156.  
  3157.         if ((y >= tptr->lo_any.y) &&
  3158.             (y < tptr->lo_any.y + tptr->lo_any.y_offset + t_height) &&
  3159.             (x >= tptr->lo_any.x) &&
  3160.             (x < (tptr->lo_any.x + tptr->lo_any.x_offset + t_width)))
  3161.         {
  3162.             /* We are only interested in finding cells */
  3163.             if (tptr->type == LO_CELL)
  3164.             {
  3165.                 /* Search through the cell's element list,
  3166.                  * Including all nested tables in that cell
  3167.                 */
  3168.                 LO_CellStruct * pLoCell = lo_GetCellContainingElement(pElement, (LO_CellStruct*)tptr);
  3169.                 /* We found it - done */
  3170.                 if( pLoCell )
  3171.                     return pLoCell;
  3172.             }
  3173.         }
  3174.         tptr = tptr->lo_any.next;
  3175.     }
  3176.  
  3177.     /* Failed to find element */
  3178.     return NULL;
  3179. }
  3180.  
  3181.  
  3182. /* Find the first cell with with closest left border x-value <= than the given x
  3183.  * value or, if bGetColumn=FALSE, find the cell with closest top border 
  3184.  *   y-value <= than the given Y value. Also returns the pointer to the
  3185.  *    last LO element so we can search for other cells until pEndElement is reached.
  3186. */
  3187. LO_Element* lo_GetFirstCellInColumnOrRow(MWContext *pContext, LO_Element *pElement, int32 x, int32 y, XP_Bool bGetColumn, LO_Element **ppLastCellInTable)
  3188. {
  3189.     LO_Element *pFirstCell = NULL;
  3190.     LO_Element *pLastCellInTable = NULL;
  3191.     LO_Element *tptr = NULL;
  3192.     int32 closest = 0;
  3193.     lo_DocState *state;
  3194.  
  3195.  
  3196.     if( pElement->type == LO_TABLE )
  3197.     {
  3198.         /* Start at first element after the table */
  3199.         tptr = pElement->lo_any.next;
  3200.     } else {
  3201.     
  3202.         if( pElement->type == LO_CELL )
  3203.         {
  3204.             /* Element is a cell */
  3205.             tptr = pElement;
  3206.         } else {
  3207.             /* Get parent cell of supplied element */
  3208.             tptr = (LO_Element*)lo_GetParentCell(pContext, pElement);
  3209.         }
  3210.         if( !tptr )
  3211.             return NULL;
  3212.     
  3213.         /* Search back until we are at first cell in table */
  3214.         while ( (tptr->lo_any.prev)->type != LO_TABLE )
  3215.         {
  3216.             tptr = tptr->lo_any.prev;
  3217.         }
  3218.     }
  3219.     
  3220.     /* Scan all cells to find first and last */
  3221.     do {
  3222.         if( tptr->type == LO_CELL )
  3223.         {
  3224.             if( bGetColumn && tptr->lo_any.x <= x &&
  3225.                 tptr->lo_any.x > closest  )
  3226.             {
  3227.                 /* We found a cell candidate */
  3228.                 closest = tptr->lo_any.x;
  3229.                 pFirstCell = tptr;
  3230.             } else if( !bGetColumn && tptr->lo_any.y <= y &&
  3231.                        tptr->lo_any.y > closest )
  3232.             {
  3233.                 closest = tptr->lo_any.y;
  3234.                 pFirstCell = tptr;
  3235.             }
  3236.             pLastCellInTable = tptr;
  3237.         }
  3238.         tptr = tptr->lo_any.next;
  3239.  
  3240.        /* Table ends at linefeed (top level) or null element (nested table) */
  3241.     } while (tptr && tptr->type != LO_LINEFEED ); 
  3242.  
  3243.     /* Return last cell element encountered */
  3244.     if( ppLastCellInTable )
  3245.         *ppLastCellInTable = pLastCellInTable;
  3246.  
  3247.     return pFirstCell;    
  3248. }
  3249.  
  3250. /* Assumptions;
  3251.  * Given a LO_CellStruct, the table element defines the begining of table
  3252.  *   and the last cell is that whose "next" pointer is NULL (nested table)
  3253.  *   or a linefeed element (top-level table)
  3254. */
  3255. LO_Element *lo_GetFirstAndLastCellsInTable(MWContext *pContext, LO_Element *pElement, LO_Element **ppLastCell)
  3256. {
  3257.     LO_Element *tptr = NULL;
  3258.     LO_Element *pFirstCell = NULL;
  3259.     LO_Element *pLastCell = NULL;
  3260.     LO_Element *pCurrentCell = NULL;
  3261.  
  3262.     if(pContext == NULL || pElement == NULL )
  3263.         return NULL;
  3264.  
  3265.     if( pElement->type == LO_CELL )
  3266.     {
  3267.         pCurrentCell = pElement;
  3268.     }
  3269.     else if( pElement->type == LO_TABLE )
  3270.     {
  3271.         /* First cell SHOULD be next element, but let's be sure */
  3272.         pCurrentCell = pElement->lo_table.next;
  3273.         while(pCurrentCell->type != LO_CELL)
  3274.         {
  3275.             pCurrentCell = pCurrentCell->lo_any.next;
  3276.         }
  3277.     } else {
  3278.         pCurrentCell = (LO_Element*)lo_GetParentCell(pContext, pElement);
  3279.     }
  3280.  
  3281.     if( pCurrentCell == NULL )
  3282.         return NULL;
  3283.  
  3284.     /* Scan backwards until we hit the table element
  3285.      *  that's before all the cells
  3286.     */
  3287.     tptr = pCurrentCell;
  3288.     while (tptr && (tptr->lo_any.prev)->type != LO_TABLE )
  3289.     {
  3290.         tptr = tptr->lo_any.prev;
  3291.     }
  3292.     
  3293.     /* Scan forward to find last cell -- next is null or line-feed element */
  3294.     do {
  3295.         if( tptr->type == LO_CELL )
  3296.         {
  3297.             if( !pFirstCell )
  3298.                 pFirstCell = tptr;
  3299.  
  3300.             pLastCell = tptr;
  3301.         }
  3302.         tptr = tptr->lo_any.next;
  3303.     } while (tptr && tptr->type != LO_LINEFEED); 
  3304.  
  3305.     /* Return last cell element encountered */
  3306.     if( ppLastCell )
  3307.         *ppLastCell = pLastCell;
  3308.  
  3309.     return pFirstCell;    
  3310. }
  3311.  
  3312. LO_Element *lo_GetFirstAndLastCellsInColumnOrRow(LO_Element *pCellElement, LO_Element **ppLastCell, XP_Bool bInColumn )
  3313. {
  3314.     LO_Element *tptr = NULL;
  3315.     LO_Element *pFirstCell = NULL;
  3316.     LO_Element *pLastCell = NULL;
  3317.  
  3318.     if(pCellElement == NULL || pCellElement->type != LO_CELL)
  3319.         return NULL;
  3320.  
  3321.     /* Scan backwards until we hit the table element
  3322.      *  that's before all the cells
  3323.     */
  3324.     tptr = pCellElement;
  3325.     while (tptr && (tptr->lo_any.prev)->type != LO_TABLE )
  3326.     {
  3327.         tptr = tptr->lo_any.prev;
  3328.     }
  3329.     
  3330.     /* Scan forward to find first and last cells,
  3331.      *   based on sharing left edge (column) or top (row)
  3332.      */
  3333.     do {
  3334.         if( tptr->type == LO_CELL )
  3335.         {
  3336.             if( (bInColumn && pCellElement->lo_any.x == tptr->lo_any.x) ||
  3337.                 (!bInColumn && pCellElement->lo_any.y == tptr->lo_any.y) )
  3338.             {
  3339.                 if( !pFirstCell )
  3340.                     pFirstCell = tptr;
  3341.  
  3342.                 pLastCell = tptr;
  3343.             }
  3344.         }
  3345.         tptr = tptr->lo_any.next;
  3346.     } while (tptr && tptr->type != LO_LINEFEED); 
  3347.  
  3348.     /* Return last cell element encountered */
  3349.     if( ppLastCell )
  3350.         *ppLastCell = pLastCell;
  3351.  
  3352.     return pFirstCell;    
  3353. }
  3354.  
  3355. XP_Bool lo_AllCellsSelectedInColumnOrRow( LO_CellStruct *pCell, XP_Bool bInColumn )
  3356. {
  3357.     LO_Element *pFirstCell;
  3358.     LO_Element *pLastCell;
  3359.     LO_Element *tptr;
  3360.  
  3361.     /* Get first and last cells in row or column */
  3362.     pFirstCell = lo_GetFirstAndLastCellsInColumnOrRow( (LO_Element*)pCell, &pLastCell, bInColumn );
  3363.     if( !pFirstCell || !pLastCell )
  3364.         return FALSE;
  3365.  
  3366.     tptr = pFirstCell;
  3367.  
  3368.     do {
  3369.         if( tptr->type == LO_CELL )
  3370.         {
  3371.             if( (bInColumn && pCell->x == tptr->lo_any.x) ||
  3372.                 (!bInColumn && pCell->y == tptr->lo_any.y) )
  3373.             {
  3374.                 /* If any cell is not selected, return FALSE */
  3375.                 if( !(pCell->ele_attrmask & LO_ELE_SELECTED) )
  3376.                     return FALSE;
  3377.             }
  3378.         }
  3379.         tptr = tptr->lo_any.next;
  3380.     } while (tptr != pLastCell); 
  3381.  
  3382.     return TRUE;
  3383. }
  3384.  
  3385. int32 lo_GetNumberOfCellsInTable(LO_TableStruct *pTable )
  3386. {
  3387.     int32 iCount = 0;
  3388.     if( pTable )
  3389.     {
  3390.         LO_Element *tptr = (LO_Element*)pTable;
  3391.         while( tptr && tptr->type != LO_LINEFEED )
  3392.         {
  3393.             if( tptr->type == LO_CELL)
  3394.                 iCount++;
  3395.             
  3396.             tptr = tptr->lo_any.next;
  3397.         }
  3398.     }
  3399.     return iCount;
  3400. }
  3401.  
  3402. /* Subtract borders and inter-cell spacing to get the available table width
  3403.  *   to use when cell width in HTML is "percent of table"
  3404. */
  3405. int32 lo_CalcTableWidthForPercentMode(LO_Element *pCellElement)
  3406. {
  3407.     LO_Element     *pLastCell;
  3408.     LO_Element     *pFirstCell;
  3409.     LO_Element     *pCell;
  3410.     int32          iWidth;
  3411.     XP_Bool        bDone;
  3412.  
  3413.     /* Never return 0 to avoid divide by zero errors */
  3414.     if( !pCellElement || pCellElement->type != LO_CELL )
  3415.         return -1;
  3416.  
  3417.     iWidth = 0;
  3418.  
  3419.     /* We calculate the width by simply adding up widths of all cells in the row */
  3420.     pFirstCell = lo_GetFirstAndLastCellsInColumnOrRow(pCellElement, &pLastCell, FALSE );
  3421.     pCell = pFirstCell;
  3422.  
  3423.     if( pCell && pLastCell )
  3424.     {
  3425.         bDone = FALSE;
  3426.         while(!bDone) 
  3427.         {
  3428.             if( pCell == pLastCell )
  3429.                 bDone = TRUE;
  3430.  
  3431.             /* Add widths of all cells in the row (must have same top) */
  3432.             if( pCell->type == LO_CELL && 
  3433.                 (pCell->lo_any.y == pFirstCell->lo_any.y) )
  3434.             {
  3435.                 iWidth += pCell->lo_cell.width;            
  3436.             }
  3437.             pCell = pCell->lo_any.next;
  3438.         }
  3439.     }    
  3440.     return (iWidth > 0) ? iWidth : -1;
  3441. }
  3442.  
  3443. XP_Bool LO_IsEmptyCell(LO_CellStruct *cell)
  3444. {
  3445.     if ( cell )
  3446.     {
  3447.         LO_Element *element = cell->cell_list;
  3448.  
  3449.         /* Unlikely, but if nothing inside cell, we're empty! */
  3450.         if(element)
  3451.         {
  3452.             LO_Element *pNext = element->lo_any.next;
  3453.             while(element)
  3454.             {
  3455.                 /* Any non-text element except linefeed is not "empty"
  3456.                  *  and check for text length
  3457.                  * Length of any element is 1. Length of text = real length,
  3458.                  * (but we don't want to consider linefeeds)
  3459.                 */
  3460.                 if( element->type != LO_LINEFEED && lo_GetElementLength(element) > 0 )
  3461.                 {
  3462.                     return FALSE;
  3463.                 }
  3464.                 element = element->lo_any.next;
  3465.             }
  3466.         }
  3467.     }
  3468.     return TRUE;
  3469. }
  3470.  
  3471. LO_Element * lo_GetLastElementInList( LO_Element *eleList )
  3472. {
  3473.     LO_Element *retEle = NULL;
  3474.  
  3475.     if (eleList != NULL)
  3476.     {
  3477.         while (eleList->lo_any.next != NULL)
  3478.             eleList = eleList->lo_any.next;
  3479.  
  3480.         retEle = eleList;
  3481.     }
  3482.  
  3483.     return retEle;
  3484.         
  3485. }
  3486.  
  3487. #ifdef DOM
  3488. /* Checks the layout element to see if the element is enclosed within <SPAN> */
  3489. Bool LO_IsWithinSpan( LO_Element *ele )
  3490. {
  3491.     Bool isInSpan = FALSE;
  3492.  
  3493.     switch (ele->type) {
  3494.  
  3495.     case LO_TEXT:
  3496.         isInSpan = ele->lo_text.ele_attrmask & LO_ELE_IN_SPAN ? TRUE : FALSE;
  3497.         break;
  3498.     case LO_IMAGE:
  3499.         isInSpan = ele->lo_image.ele_attrmask & LO_ELE_IN_SPAN ? TRUE : FALSE;
  3500.         break;
  3501.     case LO_FORM_ELE:
  3502.         isInSpan = ele->lo_form.ele_attrmask & LO_ELE_IN_SPAN ? TRUE : FALSE;
  3503.         break;
  3504.     case LO_EMBED:
  3505.         isInSpan = ele->lo_embed.ele_attrmask & LO_ELE_IN_SPAN ? TRUE : FALSE;
  3506.         break;
  3507. #ifdef JAVA
  3508.     case LO_JAVA:
  3509.         isInSpan = ele->lo_java.ele_attrmask & LO_ELE_IN_SPAN ? TRUE : FALSE;
  3510.         break;
  3511. #endif
  3512.     }
  3513.  
  3514.     return isInSpan;
  3515. }
  3516. #endif
  3517.  
  3518. #ifdef PROFILE
  3519. #pragma profile off
  3520. #endif
  3521.