home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / layout / edtutil.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  194.5 KB  |  6,272 lines
  1. /* -*- Mode: C++; tab-width: 4; 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. // Public interface and shared subsystem data.
  22. //
  23.  
  24. #ifdef EDITOR
  25.  
  26. #include "editor.h"
  27.  
  28. typedef struct PA_AmpEsc_struct {
  29.         char *str;
  30.         char value;
  31.         intn len;
  32. } PA_AmpEsc;
  33.  
  34. #ifndef XP_MAC
  35. static PA_AmpEsc PA_AmpEscapes[] = {
  36.     {"lt", '<', 2},
  37.     {"LT", '<', 2},
  38.     {"gt", '>', 2},
  39.     {"GT", '>', 2},
  40.     {"amp", '&', 3},
  41.     {"AMP", '&', 3},
  42.     {"quot", '\"', 4},
  43.     {"QUOT", '\"', 4},
  44.     {"nbsp", '\240', 4},
  45.     {"reg", '\256', 3},
  46.     {"REG", '\256', 3},
  47.     {"copy", '\251', 4},
  48.     {"COPY", '\251', 4},
  49.  
  50.     {"iexcl", '\241', 5},
  51.     {"cent", '\242', 4},
  52.     {"pound", '\243', 5},
  53.     {"curren", '\244', 6},
  54.     {"yen", '\245', 3},
  55.     {"brvbar", '\246', 6},
  56.     {"sect", '\247', 4},
  57.  
  58.     {"uml", '\250', 3},
  59.     {"ordf", '\252', 4},
  60.     {"laquo", '\253', 5},
  61.     {"not", '\254', 3},
  62.     {"shy", '\255', 3},
  63.     {"macr", '\257', 4},
  64.  
  65.     {"deg", '\260', 3},
  66.     {"plusmn", '\261', 6},
  67.     {"sup2", '\262', 4},
  68.     {"sup3", '\263', 4},
  69.     {"acute", '\264', 5},
  70.     {"micro", '\265', 5},
  71.     {"para", '\266', 4},
  72.     {"middot", '\267', 6},
  73.  
  74.     {"cedil", '\270', 5},
  75.     {"sup1", '\271', 4},
  76.     {"ordm", '\272', 4},
  77.     {"raquo", '\273', 5},
  78.     {"frac14", '\274', 6},
  79.     {"frac12", '\275', 6},
  80.     {"frac34", '\276', 6},
  81.     {"iquest", '\277', 6},
  82.  
  83.     {"Agrave", '\300', 6},
  84.     {"Aacute", '\301', 6},
  85.     {"Acirc", '\302', 5},
  86.     {"Atilde", '\303', 6},
  87.     {"Auml", '\304', 4},
  88.     {"Aring", '\305', 5},
  89.     {"AElig", '\306', 5},
  90.     {"Ccedil", '\307', 6},
  91.  
  92.     {"Egrave", '\310', 6},
  93.     {"Eacute", '\311', 6},
  94.     {"Ecirc", '\312', 5},
  95.     {"Euml", '\313', 4},
  96.     {"Igrave", '\314', 6},
  97.     {"Iacute", '\315', 6},
  98.     {"Icirc", '\316', 5},
  99.     {"Iuml", '\317', 4},
  100.  
  101.     {"ETH", '\320', 3},
  102.     {"Ntilde", '\321', 6},
  103.     {"Ograve", '\322', 6},
  104.     {"Oacute", '\323', 6},
  105.     {"Ocirc", '\324', 5},
  106.     {"Otilde", '\325', 6},
  107.     {"Ouml", '\326', 4},
  108.     {"times", '\327', 5},
  109.  
  110.     {"Oslash", '\330', 6},
  111.     {"Ugrave", '\331', 6},
  112.     {"Uacute", '\332', 6},
  113.     {"Ucirc", '\333', 5},
  114.     {"Uuml", '\334', 4},
  115.     {"Yacute", '\335', 6},
  116.     {"THORN", '\336', 5},
  117.     {"szlig", '\337', 5},
  118.  
  119.     {"agrave", '\340', 6},
  120.     {"aacute", '\341', 6},
  121.     {"acirc", '\342', 5},
  122.     {"atilde", '\343', 6},
  123.     {"auml", '\344', 4},
  124.     {"aring", '\345', 5},
  125.     {"aelig", '\346', 5},
  126.     {"ccedil", '\347', 6},
  127.  
  128.     {"egrave", '\350', 6},
  129.     {"eacute", '\351', 6},
  130.     {"ecirc", '\352', 5},
  131.     {"euml", '\353', 4},
  132.     {"igrave", '\354', 6},
  133.     {"iacute", '\355', 6},
  134.     {"icirc", '\356', 5},
  135.     {"iuml", '\357', 4},
  136.  
  137.     {"eth", '\360', 3},
  138.     {"ntilde", '\361', 6},
  139.     {"ograve", '\362', 6},
  140.     {"oacute", '\363', 6},
  141.     {"ocirc", '\364', 5},
  142.     {"otilde", '\365', 6},
  143.     {"ouml", '\366', 4},
  144.     {"divide", '\367', 6},
  145.  
  146.     {"oslash", '\370', 6},
  147.     {"ugrave", '\371', 6},
  148.     {"uacute", '\372', 6},
  149.     {"ucirc", '\373', 5},
  150.     {"uuml", '\374', 4},
  151.     {"yacute", '\375', 6},
  152.     {"thorn", '\376', 5},
  153.     {"yuml", '\377', 4},
  154.  
  155.     {NULL, '\0', 0},
  156. };
  157. #else /* ! XP_MAC */
  158.                             /* Entities encoded in MacRoman.  */
  159. static PA_AmpEsc PA_AmpEscapes[] = {
  160.     {"lt", '<', 2},
  161.     {"LT", '<', 2},
  162.     {"gt", '>', 2},
  163.     {"GT", '>', 2},
  164.     {"amp", '&', 3},
  165.     {"AMP", '&', 3},
  166.     {"quot", '\"', 4},
  167.     {"QUOT", '\"', 4},
  168.     {"nbsp", '\007', 4},
  169.     {"reg", '\250', 3},
  170.     {"REG", '\250', 3},
  171.     {"copy", '\251', 4},
  172.     {"COPY", '\251', 4},
  173.  
  174.     {"iexcl", '\301', 5},
  175.     {"cent", '\242', 4},
  176.     {"pound", '\243', 5},
  177.     {"curren", '\333', 6},
  178.     {"yen", '\264', 3},
  179.  
  180.     /*
  181.      * Navigator Gold currently inverts this table in such a way that
  182.      * ASCII characters (less than 128) get converted to the names
  183.      * listed here.  For things like ampersand (&) this is the
  184.      * right thing to do, but for this one (brvbar), it isn't since
  185.      * both broken vertical bar and vertical bar are mapped to the same
  186.      * character by the Latin-1 to Mac Roman table.
  187.      *
  188.      * Punt for now. This needs to be fixed later. -- erik
  189.      */
  190.     /* {"brvbar", '\174', 6}, */
  191.  
  192.     {"sect", '\244', 4},
  193.  
  194.     {"uml", '\254', 3},
  195.     {"ordf", '\273', 4},
  196.     {"laquo", '\307', 5},
  197.     {"not", '\302', 3},
  198.     {"shy", '\320', 3},
  199.     {"macr", '\370', 4},
  200.  
  201.     {"deg", '\241', 3},
  202.     {"plusmn", '\261', 6},
  203.     /* {"sup2", '\62', 4}, see comment above */
  204.     /* {"sup3", '\63', 4}, see comment above */
  205.     {"acute", '\253', 5},
  206.     {"micro", '\265', 5},
  207.     {"para", '\246', 4},
  208.     {"middot", '\341', 6},
  209.  
  210.     {"cedil", '\374', 5},
  211.     /* {"sup1", '\61', 4}, see comment above */
  212.     {"ordm", '\274', 4},
  213.     {"raquo", '\310', 5},
  214.     {"frac14", '\271', 6},
  215.     {"frac12", '\270', 6},
  216.     {"frac34", '\262', 6},
  217.     {"iquest", '\300', 6},
  218.  
  219.     {"Agrave", '\313', 6},
  220.     {"Aacute", '\347', 6},
  221.     {"Acirc", '\345', 5},
  222.     {"Atilde", '\314', 6},
  223.     {"Auml", '\200', 4},
  224.     {"Aring", '\201', 5},
  225.     {"AElig", '\256', 5},
  226.     {"Ccedil", '\202', 6},
  227.  
  228.     {"Egrave", '\351', 6},
  229.     {"Eacute", '\203', 6},
  230.     {"Ecirc", '\346', 5},
  231.     {"Euml", '\350', 4},
  232.     {"Igrave", '\355', 6},
  233.     {"Iacute", '\352', 6},
  234.     {"Icirc", '\353', 5},
  235.     {"Iuml", '\354', 4},
  236.  
  237.     {"ETH", '\334', 3},            /* Icelandic MacRoman: ETH ('D' w/horiz bar) */
  238.     {"Ntilde", '\204', 6},
  239.     {"Ograve", '\361', 6},
  240.     {"Oacute", '\356', 6},
  241.     {"Ocirc", '\357', 5},
  242.     {"Otilde", '\315', 6},
  243.     {"Ouml", '\205', 4},
  244.     /* {"times", '\170', 5}, see comment above */
  245.  
  246.     {"Oslash", '\257', 6},
  247.     {"Ugrave", '\364', 6},
  248.     {"Uacute", '\362', 6},
  249.     {"Ucirc", '\363', 5},
  250.     {"Uuml", '\206', 4},
  251.     {"Yacute", '\240', 6},        /* Icelandic MacRoman: Yacute */
  252.     {"THORN", '\336', 5},        /* Icelandic MacRoman: THORN (kinda like 'P') */
  253.     {"szlig", '\247', 5},
  254.  
  255.     {"agrave", '\210', 6},
  256.     {"aacute", '\207', 6},
  257.     {"acirc", '\211', 5},
  258.     {"atilde", '\213', 6},
  259.     {"auml", '\212', 4},
  260.     {"aring", '\214', 5},
  261.     {"aelig", '\276', 5},
  262.     {"ccedil", '\215', 6},
  263.  
  264.     {"egrave", '\217', 6},
  265.     {"eacute", '\216', 6},
  266.     {"ecirc", '\220', 5},
  267.     {"euml", '\221', 4},
  268.     {"igrave", '\223', 6},
  269.     {"iacute", '\222', 6},
  270.     {"icirc", '\224', 5},
  271.     {"iuml", '\225', 4},
  272.  
  273.     {"eth", '\335', 3},        /* Icelandic MacRoman: eth ('d' w/horiz bar) */
  274.     {"ntilde", '\226', 6},
  275.     {"ograve", '\230', 6},
  276.     {"oacute", '\227', 6},
  277.     {"ocirc", '\231', 5},
  278.     {"otilde", '\233', 6},
  279.     {"ouml", '\232', 4},
  280.     {"divide", '\326', 6},
  281.  
  282.     {"oslash", '\277', 6},
  283.     {"ugrave", '\235', 6},
  284.     {"uacute", '\234', 6},
  285.     {"ucirc", '\236', 5},
  286.     {"uuml", '\237', 4},
  287.     {"yacute", '\340', 6},        /* Icelandic MacRoman: yacute */
  288.     {"thorn", '\337', 5},        /* Icelandic MacRoman: thorn (kinda like 'p') */
  289.     {"yuml", '\330', 4},
  290.  
  291.     {NULL, '\0', 0},
  292. };
  293.  
  294. #endif
  295.  
  296.  
  297. // For XP Strings
  298. extern "C" {
  299. #include "xpgetstr.h"
  300. #define WANT_ENUM_STRING_IDS
  301. #include "allxpstr.h"
  302. #undef WANT_ENUM_STRING_IDS
  303. }
  304. #include "prefapi.h"
  305. #include "secnav.h"
  306. #include "xp_str.h"
  307.  
  308. char* edt_CopyFromHuge(int16 /*csid*/, XP_HUGE_CHAR_PTR text, int32 length, int32* pOutLength){
  309.     int len2 = length;
  310.  
  311. #ifdef XP_WIN16
  312.     const int32 kMax = 65530;
  313.     XP_Bool bTruncated = FALSE;
  314.     if ( len2 > kMax ) {
  315.         XP_TRACE(("Truncating huge data. original size: %d bytes", len2));
  316.         bTruncated = TRUE;
  317.         len2 = kMax;
  318.     }
  319. #endif
  320.  
  321.     char* pData = (char*) XP_ALLOC(len2 + 1);
  322.     if ( pData == NULL ) return NULL;
  323.     for(int32 i = 0; i < len2; i++ ){
  324.         // No XP way of transfering from HUGE to normal
  325.         pData[i] = text[i];
  326.     }
  327.  
  328. #ifdef XP_WIN16
  329.     if ( bTruncated ) {
  330.         int nboc = INTL_NthByteOfChar(csid, pData, (int)(len2));
  331.         // nboc is one-based. Stupid!
  332.         if ( nboc > 1 ){
  333.             len2 -= (nboc - 1);
  334.         }
  335.         if ( len2 < 0 ) {
  336.             len2 = 0;
  337.         }
  338.         XP_TRACE(("Final size: %d bytes", len2));
  339.     }
  340. #endif
  341.  
  342.     pData[len2] = '\0';
  343.     if ( pOutLength ) {
  344.         *pOutLength = len2;
  345.     }
  346.     return pData;
  347. }
  348.  
  349. void edt_StripAtHashOrQuestionMark(char *pUrl)
  350. {
  351.     if( !pUrl )
  352.         return;
  353.  
  354.     char *pStart = XP_STRRCHR(pUrl, '/');
  355.  
  356.     if(!pStart)
  357.         pStart = pUrl;
  358.     
  359.     char * pSuffix = XP_STRCHR(pStart, '?');
  360.  
  361.     if(pSuffix)
  362.         *pSuffix = '\0';
  363.  
  364.     pSuffix = XP_STRRCHR(pStart, '#');
  365.     if(pSuffix)
  366.         *pSuffix = '\0';
  367. }
  368.  
  369. char *edt_StripUsernamePassword(char *pUrl) {
  370.   int iType = NET_URL_Type(pUrl);
  371.   if (iType != FTP_TYPE_URL &&
  372.       iType != HTTP_TYPE_URL &&
  373.       iType != SECURE_HTTP_TYPE_URL) {
  374.     return XP_STRDUP(pUrl);
  375.   }
  376.  
  377.   char *pRet = NULL;
  378.   if (NET_ParseUploadURL(pUrl,&pRet,NULL,NULL) && pRet) {
  379.     return pRet;
  380.   }
  381.   else {
  382.     return XP_STRDUP(pUrl);
  383.   }
  384. }
  385.  
  386.  
  387. // Always returns newly allocated memory or NULL.
  388. PRIVATE char *edt_remove_trailing_slash(const char *pStr) {
  389.   if (pStr) {
  390.     char *pNew = XP_STRDUP(pStr);
  391.     if (pNew && *pNew) {
  392.       // Only do strlen() if pNew is non-NULL.
  393.       int iLen = XP_STRLEN(pNew);
  394.  
  395.       // Kill trailing slash.
  396.       if (pNew[iLen-1] == '/') {
  397.         pNew[iLen-1] = '\0';
  398.       }
  399.     }
  400.     return pNew;
  401.   }
  402.   else {
  403.     return NULL;
  404.   }
  405. }
  406.  
  407.  
  408.  
  409. // Just wrappers around the XP_* functions.  The only difference is that
  410. // these functions will work if the directory ends in a trailing slash,
  411. // avoiding obscure bugs on Win16.
  412. XP_Dir edt_OpenDir(const char * name, XP_FileType type) {
  413.   XP_ASSERT(type == xpURL);
  414.   char *pNew = edt_remove_trailing_slash(name);
  415.   XP_Dir ret = XP_OpenDir(pNew,type);
  416.   XP_FREEIF(pNew);
  417.   return ret;
  418. }
  419.  
  420. int edt_MakeDirectory(const char* name, XP_FileType type) {
  421.   XP_ASSERT(type == xpURL);
  422.   char *pNew = edt_remove_trailing_slash(name);
  423.   int ret = XP_MakeDirectory(pNew,type);
  424.   XP_FREEIF(pNew);
  425.   return ret;
  426. }
  427.  
  428. int edt_RemoveDirectory(const char *name, XP_FileType type) {
  429.   XP_ASSERT(type == xpURL);
  430.   char *pNew = edt_remove_trailing_slash(name);
  431.   int ret = XP_RemoveDirectory(pNew,type);
  432.   XP_FREEIF(pNew);
  433.   return ret;
  434. }
  435.  
  436.  
  437.  
  438. // Recursively kill everything under pNameArg, which is in xpURL format.
  439. void edt_RemoveDirectoryR(char *pNameArg) {
  440.   // non-NULL and non-zero-length.
  441.   if (!(pNameArg && *pNameArg))
  442.     return;
  443.  
  444.   // Make sure name ends in slash.
  445.   char *pName = XP_STRDUP(pNameArg);
  446.   if (!pName) {
  447.     return; 
  448.   }
  449.   if (pName[XP_STRLEN(pName)-1] != '/') {
  450.     StrAllocCat(pName,"/");
  451.   }
  452.  
  453.  
  454.   XP_Dir dir = edt_OpenDir(pName, xpURL);
  455.   if (dir) {
  456.     XP_DirEntryStruct *entry = NULL;
  457.     for (entry = XP_ReadDir(dir); entry; entry = XP_ReadDir(dir)) {
  458.       // Don't touch "." or ".."
  459.       if (entry->d_name && XP_STRCMP(entry->d_name,".") && XP_STRCMP(entry->d_name,"..")) {
  460.  
  461.         // Create filename inside directory.
  462.         char *subName = XP_STRDUP(pName);
  463.         if (entry->d_name[0] == '/') {
  464.           // skip the slash.
  465.           StrAllocCat(subName,entry->d_name + 1);
  466.         }
  467.         else {
  468.           StrAllocCat(subName,entry->d_name);
  469.         }
  470.  
  471.         // Recurse, will do nothing if not a directory.
  472.         edt_RemoveDirectoryR(subName);
  473.         // If subName is a directory, it will already be gone, so this does nothing.
  474.         XP_FileRemove(subName,xpURL);
  475.  
  476.  
  477.         XP_FREEIF(subName);
  478.       }
  479.     }
  480.                 
  481.     XP_CloseDir(dir); 
  482.     edt_RemoveDirectory(pName,xpURL);
  483.   }  
  484.  
  485.  
  486.   XP_FREE(pName);
  487. }
  488.  
  489.  
  490. // Timer
  491.  
  492.  
  493. void CEditTimerCallback (void * closure){
  494.     if (closure) {
  495.         CEditTimer* pTimer = (CEditTimer*) closure;
  496.         pTimer->Callback();
  497.     }
  498. }
  499.  
  500. CEditTimer::CEditTimer(){
  501.     m_timeoutEnabled = FALSE;
  502.     m_timerID = NULL;
  503. }
  504.  
  505. CEditTimer::~CEditTimer(){
  506.     Cancel();
  507. }
  508.  
  509. void CEditTimer::Callback() {
  510.     m_timeoutEnabled = FALSE;
  511.     OnCallback();
  512. }
  513.  
  514. void CEditTimer::Cancel(){
  515.     if ( m_timeoutEnabled ) {
  516.         FE_ClearTimeout(m_timerID);
  517.         m_timeoutEnabled = FALSE;
  518.         m_timerID = NULL;
  519.     }
  520. }
  521.  
  522. void CEditTimer::OnCallback() {}
  523.  
  524. void CEditTimer::SetTimeout(uint32 msecs){
  525.     Cancel();
  526.     m_timerID = FE_SetTimeout(&CEditTimerCallback, this, msecs);
  527.     m_timeoutEnabled = TRUE;
  528. }
  529.  
  530. // Color with a defined/undefined boolean
  531.  
  532. ED_Color::ED_Color() {
  533.     m_bDefined = TRUE;
  534.     m_color.red = 0;
  535.     m_color.green = 0;
  536.     m_color.blue = 0;
  537. }
  538. ED_Color::ED_Color(LO_Color& pLoColor) {
  539.     m_bDefined = TRUE;
  540.     m_color = pLoColor;
  541. }
  542.  
  543. static int ED_Color_Clip(int c) {
  544.     if ( c < 0 ) {
  545.         XP_ASSERT(FALSE);
  546.         c = 0;
  547.     }
  548.     if ( c > 255 ) {
  549.         XP_ASSERT(FALSE);
  550.         c = 255;
  551.     }
  552.     return c;
  553. }
  554.  
  555. ED_Color::ED_Color(int r, int g, int b) {
  556.     m_bDefined = TRUE;
  557.     m_color.red = ED_Color_Clip(r);
  558.     m_color.green = ED_Color_Clip(g);
  559.     m_color.blue = ED_Color_Clip(b);
  560. }
  561.  
  562. ED_Color::ED_Color(int32 rgb) {
  563.     if ( rgb == -1 ) {
  564.         m_bDefined = FALSE;
  565.         m_color.red = 0;
  566.         m_color.green = 0;
  567.         m_color.blue = 0;
  568.     }
  569.     else {
  570.         m_bDefined = TRUE;
  571.         m_color.red = (rgb >> 16) & 255;
  572.         m_color.green = (rgb >> 8) & 255;
  573.         m_color.blue = rgb & 255;
  574.     }
  575. }
  576.  
  577. ED_Color::ED_Color(LO_Color* pLoColor) {
  578.     if ( pLoColor ) {
  579.         m_color.red = ED_Color_Clip(pLoColor->red);
  580.         m_color.green = ED_Color_Clip(pLoColor->green);
  581.         m_color.blue = ED_Color_Clip(pLoColor->blue);
  582.         m_bDefined = TRUE;
  583.     }
  584.     else {
  585.         m_bDefined = FALSE;
  586.     }
  587. }
  588.  
  589. XP_Bool ED_Color::operator==(const ED_Color& other) const {
  590.     return m_bDefined == other.m_bDefined &&
  591.         (!m_bDefined || m_color.red == other.m_color.red &&
  592.         m_color.green == other.m_color.green &&
  593.         m_color.blue == other.m_color.blue );
  594. }
  595.  
  596. XP_Bool ED_Color::operator!=(const ED_Color& other) const {
  597.     return ! operator==(other);
  598. }
  599.  
  600. XP_Bool ED_Color::IsDefined() { return m_bDefined; }
  601. int ED_Color::Red() { XP_ASSERT(m_bDefined); return m_color.red; }
  602. int ED_Color::Green() { XP_ASSERT(m_bDefined); return m_color.green; }
  603. int ED_Color::Blue() { XP_ASSERT(m_bDefined); return m_color.blue; }
  604. LO_Color ED_Color::GetLOColor() {XP_ASSERT(m_bDefined); return m_color; }
  605.  
  606. long ED_Color::GetAsLong() {
  607.     if ( ! m_bDefined ) return -1;
  608.     return (((long)m_color.red << 16) | ((long)m_color.green << 8) | (long)m_color.blue);
  609. }
  610.  
  611. void
  612. ED_Color::SetUndefined() {
  613.     m_bDefined = FALSE;
  614.     m_color.red = 0;
  615.     m_color.green = 0;
  616.     m_color.blue = 0;
  617. }
  618.  
  619. ED_Color 
  620. ED_Color::GetUndefined()
  621. {
  622.     ED_Color undef;
  623.     undef.SetUndefined();
  624.     return undef;
  625. }
  626.  
  627. //-----------------------------------------------------------------------------
  628. // Helper functions.
  629. //-----------------------------------------------------------------------------
  630.  
  631. //
  632. // Convert a tagtype to a string
  633. //
  634.  
  635. static char* TagString(int32 tagType)
  636. {
  637.     switch(tagType)
  638.     {
  639.         case P_UNKNOWN:
  640.             return "";
  641.         case P_TEXT:
  642.             return "text";
  643.         case P_TITLE:
  644.             return PT_TITLE;
  645.         case P_INDEX:
  646.             return PT_INDEX;
  647.         case P_BASE:
  648.             return PT_BASE;
  649.         case P_LINK:
  650.             return PT_LINK;
  651.         case P_HEADER_1:
  652.             return PT_HEADER_1;
  653.         case P_HEADER_2:
  654.             return PT_HEADER_2;
  655.         case P_HEADER_3:
  656.             return PT_HEADER_3;
  657.         case P_HEADER_4:
  658.             return PT_HEADER_4;
  659.         case P_HEADER_5:
  660.             return PT_HEADER_5;
  661.         case P_HEADER_6:
  662.             return PT_HEADER_6;
  663.         case P_ANCHOR:
  664.             return PT_ANCHOR;
  665.         case P_PARAGRAPH:
  666.             return PT_PARAGRAPH;
  667.         case P_ADDRESS:
  668.             return PT_ADDRESS;
  669.         case P_IMAGE:
  670.             return PT_IMAGE;
  671.         case P_NEW_IMAGE:
  672.             return PT_NEW_IMAGE;
  673.         case P_PLAIN_TEXT:
  674.             return PT_PLAIN_TEXT;
  675.         case P_PLAIN_PIECE:
  676.             return PT_PLAIN_PIECE;
  677.         case P_PREFORMAT:
  678.             return PT_PREFORMAT;
  679.         case P_LISTING_TEXT:
  680.             return PT_LISTING_TEXT;
  681.         case P_UNUM_LIST:
  682.             return PT_UNUM_LIST;
  683.         case P_NUM_LIST:
  684.             return PT_NUM_LIST;
  685.         case P_MENU:
  686.             return PT_MENU;
  687.         case P_DIRECTORY:
  688.             return PT_DIRECTORY;
  689.         case P_LIST_ITEM:
  690.             return PT_LIST_ITEM;
  691.         case P_DESC_LIST:
  692.             return PT_DESC_LIST;
  693.         case P_DESC_TITLE:
  694.             return PT_DESC_TITLE;
  695.         case P_DESC_TEXT:
  696.             return PT_DESC_TEXT;
  697.         case P_STRIKEOUT:
  698.             return PT_STRIKEOUT;
  699.         case P_STRIKE:
  700.             return PT_STRIKE;
  701.         case P_UNDERLINE:
  702.             return PT_UNDERLINE;
  703.         case P_FIXED:
  704.             return PT_FIXED;
  705.         case P_CENTER:
  706.             return PT_CENTER;
  707.         case P_EMBED:
  708.             return PT_EMBED;
  709.         case P_SUBDOC:
  710.             return PT_SUBDOC;
  711.         case P_CELL:
  712.             return PT_CELL;
  713.         case P_TABLE:
  714.             return PT_TABLE;
  715.         case P_CAPTION:
  716.             return PT_CAPTION;
  717.         case P_TABLE_ROW:
  718.             return PT_TABLE_ROW;
  719.         case P_TABLE_HEADER:
  720.             return PT_TABLE_HEADER;
  721.         case P_TABLE_DATA:
  722.             return PT_TABLE_DATA;
  723.         case P_BOLD:
  724.             return PT_BOLD;
  725.         case P_ITALIC:
  726.             return PT_ITALIC;
  727.         case P_EMPHASIZED:
  728.             return PT_EMPHASIZED;
  729.         case P_STRONG:
  730.             return PT_STRONG;
  731.         case P_CODE:
  732.             return PT_CODE;
  733.         case P_SAMPLE:
  734.             return PT_SAMPLE;
  735.         case P_KEYBOARD:
  736.             return PT_KEYBOARD;
  737.         case P_VARIABLE:
  738.             return PT_VARIABLE;
  739.         case P_CITATION:
  740.             return PT_CITATION;
  741.         case P_BLOCKQUOTE:
  742.             return PT_BLOCKQUOTE;
  743.         case P_FORM:
  744.             return PT_FORM;
  745.         case P_INPUT:
  746.             return PT_INPUT;
  747.         case P_SELECT:
  748.             return PT_SELECT;
  749.         case P_OPTION:
  750.             return PT_OPTION;
  751.         case P_TEXTAREA:
  752.             return PT_TEXTAREA;
  753.         case P_HRULE:
  754.             return PT_HRULE;
  755.         case P_BODY:
  756.             return PT_BODY;
  757.         case P_COLORMAP:
  758.             return PT_COLORMAP;
  759.         case P_HYPE:
  760.             return PT_HYPE;
  761.         case P_META:
  762.             return PT_META;
  763.         case P_LINEBREAK:
  764.             return PT_LINEBREAK;
  765.         case P_WORDBREAK:
  766.             return PT_WORDBREAK;
  767.         case P_NOBREAK:
  768.             return PT_NOBREAK;
  769.         case P_BASEFONT:
  770.             return PT_BASEFONT;
  771.         case P_FONT:
  772.             return PT_FONT;
  773.         case P_BLINK:
  774.             return PT_BLINK;
  775.         case P_BIG:
  776.             return PT_BIG;
  777.         case P_SMALL:
  778.             return PT_SMALL;
  779.         case P_SUPER:
  780.             return PT_SUPER;
  781.         case P_SUB:
  782.             return PT_SUB;
  783.         case P_GRID:
  784.             return PT_GRID;
  785.         case P_GRID_CELL:
  786.             return PT_GRID_CELL;
  787.         case P_NOGRIDS:
  788.             return PT_NOGRIDS;
  789.         case P_JAVA_APPLET:
  790.             return PT_JAVA_APPLET;
  791.         case P_MAP:
  792.             return PT_MAP;
  793.         case P_AREA:
  794.             return PT_AREA;
  795.         case P_DIVISION:
  796.             return PT_DIVISION;
  797.         case P_KEYGEN:
  798.             return PT_KEYGEN;
  799.         case P_MAX:
  800.             return "HTML";
  801.         case P_SCRIPT:
  802.             return PT_SCRIPT;
  803.         case P_NOEMBED:
  804.             return PT_NOEMBED;
  805.         case P_SERVER:
  806.             return PT_SERVER;
  807.         case P_PARAM:
  808.             return PT_PARAM;
  809.         case P_MULTICOLUMN:
  810.             return PT_MULTICOLUMN;
  811.         case P_SPACER:
  812.             return PT_SPACER;
  813.         case P_NOSCRIPT:
  814.             return PT_NOSCRIPT;
  815.         case P_HEAD:
  816.             return PT_HEAD;
  817.         case P_HTML:
  818.             return PT_HTML;
  819.         case P_CERTIFICATE:
  820.             return PT_CERTIFICATE;
  821.         case P_MQUOTE:
  822.             return PT_MQUOTE;
  823.         case P_STYLE:
  824.             return PT_STYLE;
  825.         case P_LAYER:
  826.             return PT_LAYER;
  827.         case P_ILAYER:
  828.             return PT_ILAYER;
  829.         case P_OBJECT:
  830.             return PT_OBJECT;
  831.         case P_SPAN:
  832.             return PT_SPAN;
  833.         case P_SPELL:
  834.             return PT_SPELL;
  835.         case P_INLINEINPUT:
  836.             return PT_INLINEINPUT;
  837.         case P_INLINEINPUTTHICK:
  838.             return PT_INLINEINPUTTHICK;
  839.         case P_INLINEINPUTDOTTED:
  840.             return PT_INLINEINPUTDOTTED;
  841.         case P_NSDT:
  842.             return PT_NSDT;
  843.         case P_NSCP_CLOSE:
  844.             return PT_NSCP_OPEN;
  845.         case P_NSCP_OPEN:
  846.             return PT_NSDT;
  847.         case P_NSCP_REBLOCK:
  848.             return PT_NSCP_REBLOCK;
  849.         case P_BLOCK:
  850.             return "block"; // PT_BLOCK 
  851.         case P_NOLAYER:
  852.             return PT_NOLAYER; // (?) jrm 97/03/08 according to instructions below.
  853.         default:
  854.             // If we get here, then it's a new tag that's been added to lib\libparse\pa_tags.h
  855.             // The fix is to add this new tag to the case statement above.
  856.             XP_ASSERT(FALSE);
  857.             return "UNKNOWN";
  858.     }
  859. }
  860.  
  861. const int kTagBufferSize = 40;
  862. static char tagBuffer[kTagBufferSize];
  863.  
  864. char* EDT_UpperCase(char* tagString)
  865. {
  866.     int i = 0;
  867.     if ( tagString ) {
  868.         for ( i = 0; i < kTagBufferSize-1 && tagString[i] != '\0'; i++ ) {
  869.             tagBuffer[i] = XP_TO_UPPER(tagString[i]);
  870.         }
  871.     }
  872.     tagBuffer[i] = '\0';
  873.     return tagBuffer;
  874. }
  875.  
  876. char *EDT_TagString(int32 tagType){
  877.     return EDT_UpperCase(TagString(tagType));
  878. }
  879.  
  880. char* EDT_AlignString(ED_Alignment align){
  881.     if ( align < ED_ALIGN_CENTER ) {
  882.         XP_ASSERT(FALSE);
  883.         align = ED_ALIGN_CENTER;
  884.     }
  885.     if ( align > ED_ALIGN_ABSTOP ) {
  886.         XP_ASSERT(FALSE);
  887.         align = ED_ALIGN_ABSTOP;
  888.     }
  889.     return EDT_UpperCase(lo_alignStrings[align]);
  890. }
  891.  
  892. ED_TextFormat edt_TagType2TextFormat( TagType t ){
  893.     switch(t){
  894.     case P_BOLD:
  895.     case P_STRONG:
  896.         return TF_BOLD;
  897.  
  898.     case P_ITALIC:
  899.     case P_EMPHASIZED:
  900.     case P_VARIABLE:
  901.     case P_CITATION:
  902.         return TF_ITALIC;
  903.  
  904.     case P_FIXED:
  905.     case P_CODE:
  906.     case P_KEYBOARD:
  907.     case P_SAMPLE:
  908.         return TF_FIXED;
  909.  
  910.     case P_SUPER:
  911.         return TF_SUPER;
  912.  
  913.     case P_SUB:
  914.         return TF_SUB;
  915.  
  916.     case P_NOBREAK:
  917.         return TF_NOBREAK;
  918.  
  919.     case P_STRIKEOUT:
  920.         return TF_STRIKEOUT;
  921.  
  922.     case P_UNDERLINE:
  923.         return TF_UNDERLINE;
  924.  
  925.     case P_BLINK:
  926.         return TF_BLINK;
  927.  
  928.     case P_SERVER:
  929.         return TF_SERVER;
  930.  
  931.     case P_SCRIPT:
  932.         return TF_SCRIPT;
  933.  
  934.     case P_STYLE:
  935.         return TF_STYLE;
  936.  
  937.     case P_SPELL:
  938.         return TF_SPELL;
  939.  
  940.     case P_INLINEINPUT:
  941.         return TF_INLINEINPUT;
  942.  
  943.     case P_INLINEINPUTTHICK:
  944.         return TF_INLINEINPUTTHICK;
  945.  
  946.     case P_INLINEINPUTDOTTED:
  947.         return TF_INLINEINPUTDOTTED;
  948.     }
  949.     return TF_NONE;
  950. }
  951.  
  952. static int workBufSize = 0;
  953. static char* workBuf = 0;
  954.  
  955. char *edt_WorkBuf( int iSize ){
  956.     if( iSize > workBufSize ){
  957.         if( workBuf != 0 ){
  958.             delete[] workBuf;
  959.         }
  960.         workBuf = new char[ iSize ];
  961.     }
  962.     return workBuf;
  963. }
  964.  
  965. char *edt_QuoteString( char* pString ){
  966.     int iLen = 0;
  967.     char *p = pString;
  968.     while( p && *p  ){
  969.         if( *p == '"' ){
  970.             iLen += 6;    // "
  971.         }
  972.         else {
  973.             iLen++;
  974.         }
  975.         p++;
  976.     }
  977.     iLen++;
  978.     
  979.     char *pRet = edt_WorkBuf( iLen+1 );
  980.     p = pRet;
  981.     while( pString && *pString ){
  982.         if( *pString == '"' ){
  983.             strcpy( p, """ );
  984.             p += 6;
  985.         }
  986.         else {
  987.             *p++ = *pString;
  988.         }
  989.         pString++;
  990.     }
  991.     *p = 0;
  992.     return pRet;
  993. }
  994.  
  995.  
  996. char *edt_MakeParamString( char* pString ){
  997.     int iLen = 0;
  998.     char *p = pString;
  999.     while( p && *p  ){
  1000.         if( *p == '"' ){
  1001.             iLen += 6;    // "
  1002.         }
  1003.         else {
  1004.             iLen++;
  1005.         }
  1006.         p++;
  1007.     }
  1008.     iLen += 3;      // the beginning and ending quote and the trailing 0.
  1009.     
  1010.     char *pRet = edt_WorkBuf( iLen+1 );
  1011.     p = pRet;
  1012.     if( pString && *pString == '`' ){
  1013.         do {
  1014.             *p++ = *pString++;
  1015.         } while( *pString && *pString != '`' );
  1016.         *p++ = '`';
  1017.         *p = 0;
  1018.     }
  1019.     else {
  1020.         *p = '"';
  1021.         p++;
  1022.         while( pString && *pString ){
  1023.             if( *pString == '"' ){
  1024.                 strcpy( p, """ );
  1025.                 p += 6;
  1026.             }
  1027.             else {
  1028.                 *p++ = *pString;
  1029.             }
  1030.             pString++;
  1031.         }
  1032.         *p++ = '"';
  1033.         *p = 0;
  1034.     }
  1035.     return pRet;
  1036. }
  1037.  
  1038. char *edt_FetchParamString( PA_Tag *pTag, char* param, int16 win_csid ){
  1039.     PA_Block buff;
  1040.     char *str;
  1041.     char *retVal = 0;
  1042.  
  1043.     buff = PA_FetchParamValue(pTag, param, win_csid);
  1044.     if (buff != NULL)
  1045.     {
  1046.         PA_LOCK(str, char *, buff);
  1047.         lo_StripTextWhitespace(str, XP_STRLEN(str));
  1048.         if( str ) {
  1049.             retVal = XP_STRDUP( str );
  1050.         }
  1051.         PA_UNLOCK(buff);
  1052.         PA_FREE(buff);
  1053.     }
  1054.     return retVal;
  1055. }
  1056.  
  1057. XP_Bool edt_FetchParamBoolExist( PA_Tag *pTag, char* param, int16 csid ){
  1058.     PA_Block buff;
  1059.  
  1060.     buff = PA_FetchParamValue(pTag, param, csid);
  1061.     if (buff != NULL){
  1062.         PA_FREE(buff);
  1063.         return TRUE;
  1064.     }
  1065.     else {
  1066.         return FALSE;
  1067.     }
  1068. }
  1069.  
  1070. XP_Bool edt_FetchDimension( PA_Tag *pTag, char* param, 
  1071.                          int32 *pValue, XP_Bool *pPercent,
  1072.                          int32 nDefaultValue, XP_Bool bDefaultPercent, int16 csid ){
  1073.     PA_Block buff;
  1074.     char *str;
  1075.     int32   value;
  1076.  
  1077.     // Fill in defaults
  1078.     *pValue = nDefaultValue;
  1079.     *pPercent = bDefaultPercent;
  1080.     
  1081.     buff = PA_FetchParamValue(pTag, param, csid);
  1082.     XP_Bool result = buff != NULL;
  1083.     if( buff != NULL )
  1084.     {
  1085.         PA_LOCK(str, char *, buff);
  1086.         if( str != 0 ){
  1087.             value = XP_ATOI(str);
  1088.             *pValue = value;
  1089.             *pPercent = (NULL != XP_STRCHR(str, '%'));
  1090.         }
  1091.         PA_UNLOCK(buff);
  1092.         PA_FREE(buff);
  1093.     }
  1094.     return result;
  1095. }
  1096.     
  1097. ED_Alignment edt_FetchParamAlignment( PA_Tag* pTag, ED_Alignment eDefault, XP_Bool bVAlign, int16 csid ){
  1098.     PA_Block buff;
  1099.     char *str;
  1100.     ED_Alignment retVal = eDefault;
  1101.  
  1102.     buff = PA_FetchParamValue(pTag, bVAlign ? PARAM_VALIGN : PARAM_ALIGN, csid);
  1103.     if (buff != NULL)
  1104.     {
  1105.         XP_Bool floating;
  1106.  
  1107.         floating = FALSE;
  1108.         PA_LOCK(str, char *, buff);
  1109.         lo_StripTextWhitespace(str, XP_STRLEN(str));
  1110.         // LTNOTE: this is a hack.  We should do a better job maping these
  1111.         //  could cause problems in the future.
  1112.         retVal = (ED_Alignment) lo_EvalAlignParam(str, &floating);
  1113.         PA_UNLOCK(buff);
  1114.         PA_FREE(buff);
  1115.     }
  1116.     return retVal;
  1117. }
  1118.  
  1119. int32 edt_FetchParamInt( PA_Tag *pTag, char* param, int32 defValue, int16 csid ){
  1120.     return edt_FetchParamInt(pTag, param, defValue, defValue, csid);
  1121. }
  1122.  
  1123. int32 edt_FetchParamInt( PA_Tag *pTag, char* param, int32 defValue, int32 defValueIfParamButNoValue, int16 csid ){
  1124.     PA_Block buff;
  1125.     char *str;
  1126.     int32 retVal = defValue;
  1127.  
  1128.     buff = PA_FetchParamValue(pTag, param, csid);
  1129.     if (buff != NULL)
  1130.     {
  1131.         PA_LOCK(str, char *, buff);
  1132.         if( str != 0 ){
  1133.             if ( *str == '\0' ) { /* They mentioned the param, but gave to value. */
  1134.                 retVal = defValueIfParamButNoValue;
  1135.             }
  1136.             else {
  1137.                 retVal = XP_ATOI(str);
  1138.             }
  1139.         }
  1140.         PA_UNLOCK(buff);
  1141.         PA_FREE(buff);
  1142.     }
  1143.     return retVal;
  1144. }
  1145.  
  1146. ED_Color edt_FetchParamColor( PA_Tag *pTag, char* param, int16 csid ){
  1147.     PA_Block buff = PA_FetchParamValue(pTag, param, csid);
  1148.     ED_Color retVal;
  1149.     retVal.SetUndefined();
  1150.     if (buff != NULL)
  1151.     {
  1152.         char *color_str;
  1153.         PA_LOCK(color_str, char *, buff);
  1154.         lo_StripTextWhitespace(color_str, XP_STRLEN(color_str));
  1155.         uint8 red, green, blue;
  1156.         LO_ParseRGB(color_str, &red, &green, &blue);
  1157.         retVal = EDT_RGB(red,green,blue);
  1158.         PA_UNLOCK(buff);
  1159.         PA_FREE(buff);
  1160.     }
  1161.     return retVal;
  1162. }
  1163.  
  1164. PRIVATE
  1165. XP_Bool edt_NameInList( char* pName, char** ppNameList ){
  1166.     int i = 0;
  1167.     while( ppNameList && ppNameList[i] ){
  1168.         if( XP_STRCASECMP( pName, ppNameList[i]) == 0 ){
  1169.             return TRUE;
  1170.         }
  1171.         i++;
  1172.     }
  1173.     return FALSE;
  1174. }
  1175.  
  1176. char* edt_FetchParamExtras( PA_Tag *pTag, char**ppKnownParams, int16 win_csid ){
  1177.     char** ppNames;
  1178.     char** ppValues;
  1179.     char* pRet = 0;
  1180.     int i = 0;
  1181.     char *pSpace = "";
  1182.     int iMax;
  1183.  
  1184.     iMax = PA_FetchAllNameValues( pTag, &ppNames, &ppValues, win_csid );
  1185.  
  1186.     while( i < iMax ){
  1187.         if( !edt_NameInList( ppNames[i], ppKnownParams ) ){
  1188.             if( ppValues[i] ){
  1189.                 pRet = PR_sprintf_append( pRet, "%s%s=%s",
  1190.                     pSpace, ppNames[i], edt_MakeParamString( ppValues[i] ) );
  1191.             }
  1192.             else {
  1193.                 pRet = PR_sprintf_append( pRet, "%s%s", pSpace, ppNames[i] );
  1194.             }
  1195.             pSpace = " ";
  1196.         }
  1197.         i++;
  1198.     }
  1199.  
  1200.     i = 0;
  1201.     while( i < iMax ){
  1202.         if( ppNames[i] ) XP_FREE( ppNames[i] );
  1203.         if( ppValues[i] ) XP_FREE( ppValues[i] );
  1204.         i++;
  1205.     }
  1206.  
  1207.     if( ppNames ) XP_FREE( ppNames );
  1208.     if( ppValues ) XP_FREE( ppValues );
  1209.  
  1210.     return pRet;
  1211. }
  1212.  
  1213. // Override existing.
  1214. void edt_FetchParamString2(PA_Tag* pTag, char* param, char*& data, int16 win_csid){
  1215.     char* result = edt_FetchParamString( pTag, param, win_csid );
  1216.     if ( result ) {
  1217.         if ( data ){
  1218.             XP_FREE(data);
  1219.         }
  1220.         data = result;
  1221.     }
  1222. }
  1223.  
  1224. // Override existing.
  1225. void edt_FetchParamColor2( PA_Tag *pTag, char* param, ED_Color& data, int16 csid ){
  1226.     ED_Color result = edt_FetchParamColor(pTag, param, csid);
  1227.     if ( result.IsDefined() ) {
  1228.         data = result;
  1229.     }
  1230. }
  1231.  
  1232. // Append to existing extras. To Do: Have new versions of a parameter overwrite the old ones.
  1233. void edt_FetchParamExtras2( PA_Tag *pTag, char**ppKnownParams, char*& data, int16 win_csid ){
  1234.     char* result = edt_FetchParamExtras( pTag, ppKnownParams, win_csid );
  1235.     if ( result ) {
  1236.         if ( data ) {
  1237.             data = PR_sprintf_append(data, " %s", result);
  1238.             XP_FREE(result);
  1239.         }
  1240.         else {
  1241.             data = result;
  1242.         }
  1243.     }
  1244. }
  1245.  
  1246. XP_Bool edt_ReplaceParamValue( PA_Tag *pTag, char * pName, char * pValue, int16 csid ){
  1247.     XP_ASSERT(pName);
  1248.     XP_ASSERT(pTag);
  1249.  
  1250.     char** ppNames;
  1251.     char** ppValues;
  1252.     char* pNew = 0;
  1253.     int i = 0;
  1254.     char *pSpace = "";
  1255.     int iMax;
  1256.     XP_Bool bFound = FALSE;
  1257.     
  1258.     iMax = PA_FetchAllNameValues( pTag, &ppNames, &ppValues, csid );
  1259.  
  1260.     while( i < iMax ){
  1261.         if( XP_STRCASECMP( pName, ppNames[i]) == 0 ){
  1262.             bFound = TRUE;
  1263.             if( pValue){
  1264.                 pNew = PR_sprintf_append( pNew, "%s%s=%s",
  1265.                     pSpace, pName, edt_MakeParamString( pValue ) );
  1266.             }
  1267.         } else {
  1268.             if( ppValues[i] ){
  1269.                 pNew = PR_sprintf_append( pNew, "%s%s=%s",
  1270.                     pSpace, ppNames[i], edt_MakeParamString( ppValues[i] ) );
  1271.             }
  1272.             else {
  1273.                 pNew = PR_sprintf_append( pNew, "%s%s", pSpace, ppNames[i] );
  1274.             }
  1275.             pSpace = " ";
  1276.         }
  1277.         i++;
  1278.     }
  1279.     // Add value at end if not found
  1280.     if( !bFound && pValue ){
  1281.         pNew = PR_sprintf_append( pNew, "%s%s=%s", pSpace, pName, pValue );
  1282.     }
  1283.     // Terminate
  1284.     pNew = PR_sprintf_append( pNew, "%s", ">" );
  1285.  
  1286.     // Cleanup memory
  1287.     i = 0;
  1288.     while( i < iMax ){
  1289.         if( ppNames[i] ) XP_FREE( ppNames[i] );
  1290.         if( ppValues[i] ) XP_FREE( ppValues[i] );
  1291.         i++;
  1292.     }
  1293.  
  1294.     if( ppNames ) XP_FREE( ppNames );
  1295.     if( ppValues ) XP_FREE( ppValues );
  1296.     
  1297.     // Now replace with new data
  1298.  
  1299.     PA_Block buff;
  1300.     char *locked_buff;
  1301.     int iLen;
  1302.  
  1303.     iLen = XP_STRLEN(pNew);
  1304.     buff = (PA_Block)PA_ALLOC((iLen+1) * sizeof(char));
  1305.     if (buff != NULL) {
  1306.         PA_LOCK(locked_buff, char *, buff);
  1307.         XP_BCOPY(pNew, locked_buff, iLen);
  1308.         locked_buff[iLen] = '\0';
  1309.         PA_UNLOCK(buff);
  1310.  
  1311.         if( pTag->data ) XP_FREE(pTag->data);
  1312.         pTag->data = buff;
  1313.         pTag->data_len = iLen;
  1314.     } else { 
  1315.         // LTNOTE: out of memory, should throw an exception
  1316.     }
  1317.     return bFound;
  1318. }
  1319.  
  1320. LO_Color* edt_MakeLoColor(ED_Color c) {
  1321.     if( !c.IsDefined()){
  1322.         return 0;
  1323.     }
  1324.     LO_Color *pColor = XP_NEW( LO_Color );
  1325.     pColor->red = EDT_RED(c);
  1326.     pColor->green = EDT_GREEN(c);
  1327.     pColor->blue = EDT_BLUE(c);
  1328.     return pColor;
  1329. }
  1330.  
  1331. void edt_SetLoColor( ED_Color c, LO_Color *pColor ){
  1332.     if( !c.IsDefined()){
  1333.         XP_ASSERT(FALSE);
  1334.         return;
  1335.     }
  1336.     pColor->red = EDT_RED(c);
  1337.     pColor->green = EDT_GREEN(c);
  1338.     pColor->blue = EDT_BLUE(c);
  1339. }
  1340.  
  1341.  
  1342. #define CHARSET_SIZE    256
  1343. static PA_AmpEsc *ed_escapes[CHARSET_SIZE];
  1344.  
  1345. void edt_InitEscapes(int16 /*csid*/, XP_Bool bQuoteHiBits){
  1346.     PA_AmpEsc *pEsc = PA_AmpEscapes;
  1347.  
  1348.     XP_BZERO( ed_escapes, CHARSET_SIZE * sizeof( PA_AmpEsc* ) );
  1349.  
  1350.     while( pEsc->value ){
  1351.         int ch = 0xff & (int) pEsc->value;
  1352.         if( ed_escapes[ ch ] == 0 ){
  1353.             if ( ch == '&' || ch == '<'
  1354.                 || (NON_BREAKING_SPACE == ((char) ch))            
  1355.                 || (ch > 128 && bQuoteHiBits ) ) {
  1356.                    ed_escapes[ ch ] = pEsc;
  1357.             }
  1358.         }
  1359.         pEsc++;
  1360.     }
  1361. }
  1362.  
  1363. void edt_PrintWithEscapes( CPrintState *ps, char *p, XP_Bool bBreakLines ){
  1364.     int csid = ps->m_pBuffer->GetRAMCharSetID();
  1365.     char *pBegin;
  1366.     PA_AmpEsc *pEsc;
  1367.  
  1368.     // break the lines after 70 characters if we can, but don't really do it 
  1369.     // in the formatted case.
  1370.     while( p && *p ){
  1371.         pBegin = p;
  1372.         while( *p && ps->m_iCharPos < 70 && ed_escapes[(unsigned char)*p] == 0
  1373.             && ((unsigned char) *p) != ((unsigned char) NON_BREAKING_SPACE) ){
  1374.             char* p2 = INTL_NextChar(csid, p);
  1375.             int charWidth = p2 - p;
  1376.             ps->m_iCharPos += charWidth;
  1377.             p = p2;
  1378.         }
  1379.         while( *p && *p != ' ' && ed_escapes[(unsigned char)*p] == 0
  1380.             && ((unsigned char) *p) != ((unsigned char) NON_BREAKING_SPACE)){
  1381.             char* p2 = INTL_NextChar(csid, p);
  1382.             int charWidth = p2 - p;
  1383.             ps->m_iCharPos += charWidth;
  1384.             p = p2;
  1385.         }
  1386.         ps->m_pOut->Write( pBegin, p-pBegin);
  1387.  
  1388.         if( *p && *p == ' ' && ps->m_iCharPos >= 70 ){
  1389.             if( bBreakLines ){
  1390.                 ps->m_pOut->Write( "\n", 1 );
  1391.             }
  1392.             else {
  1393.                 ps->m_pOut->Write( " ", 1 );
  1394.             }
  1395.             ps->m_iCharPos = 0;
  1396.         }
  1397.         else if( *p && (pEsc = ed_escapes[(unsigned char)*p]) != 0 ){
  1398.             ps->m_pOut->Write( "&",1 );
  1399.             ps->m_pOut->Write( pEsc->str, pEsc->len );
  1400.             ps->m_pOut->Write( ";",1 );
  1401.             ps->m_iCharPos += pEsc->len+2;
  1402.         }
  1403.         else if (((unsigned char) *p) == ((unsigned char) NON_BREAKING_SPACE) ){
  1404.             const char* nbsp = INTL_NonBreakingSpace(csid);
  1405.             int nbsp_len = XP_STRLEN(nbsp);
  1406.             ps->m_pOut->Write( (char*) nbsp, XP_STRLEN(nbsp));
  1407.         }
  1408.  
  1409.         // move past the space or special char
  1410.         if( *p ){
  1411.             p = INTL_NextChar(csid, p);
  1412.         }
  1413.     }
  1414. }
  1415.  
  1416. char *edt_LocalName( char *pURL ){
  1417.     char *pDest = FE_URLToLocalName( pURL );
  1418. #if 0
  1419.     if( pDest && FE_EditorPrefConvertFileCaseOnWrite( ) ){
  1420.         char *url_ptr = pDest;
  1421.         while ( *url_ptr != '\0' ){
  1422.             *url_ptr = XP_TO_LOWER(*url_ptr); 
  1423.             url_ptr++;
  1424.         }
  1425.     }
  1426. #endif
  1427.     return pDest;
  1428. }
  1429.  
  1430. PA_Block PA_strdup( char* s ){
  1431.     char *new_str;
  1432.     PA_Block new_buff;
  1433.  
  1434.     if( s == 0 ){
  1435.         return 0;
  1436.     }
  1437.  
  1438.     new_buff = (PA_Block)PA_ALLOC(XP_STRLEN(s) + 1);
  1439.     if (new_buff != NULL)
  1440.     {
  1441.         PA_LOCK(new_str, char *, new_buff);
  1442.         XP_STRCPY(new_str, s);
  1443.         PA_UNLOCK(new_buff);
  1444.     }
  1445.     return new_buff;
  1446. }
  1447.  
  1448. void edt_SetTagData( PA_Tag* pTag, char* pTagData){
  1449.     PA_Block buff;
  1450.     char *locked_buff;
  1451.     int iLen;
  1452.  
  1453.     iLen = XP_STRLEN(pTagData);
  1454.     buff = (PA_Block)PA_ALLOC((iLen+1) * sizeof(char));
  1455.     if (buff != NULL)
  1456.     {
  1457.         PA_LOCK(locked_buff, char *, buff);
  1458.         XP_BCOPY(pTagData, locked_buff, iLen);
  1459.         locked_buff[iLen] = '\0';
  1460.         PA_UNLOCK(buff);
  1461.     }
  1462.     else { 
  1463.         // LTNOTE: out of memory, should throw an exception
  1464.         return;
  1465.     }
  1466.     pTag->data = buff;
  1467.     pTag->data_len = iLen;
  1468.     pTag->next = NULL;
  1469.     return;
  1470. }
  1471.  
  1472. //
  1473. // Create a tag and add it to the list
  1474. //
  1475. void edt_AddTag( PA_Tag*& pStart, PA_Tag*& pEnd, TagType t, XP_Bool bIsEnd,
  1476.         char *pTagData  ){
  1477.     PA_Tag *pTag = XP_NEW( PA_Tag );
  1478.     XP_BZERO( pTag, sizeof( PA_Tag ) );
  1479.     pTag->type = t;
  1480.     pTag->is_end = bIsEnd;
  1481.     edt_SetTagData(pTag, pTagData ? pTagData : ">" );
  1482.     if( pStart == 0 ){
  1483.         pStart = pTag;
  1484.     }
  1485.     if( pEnd ){
  1486.         pEnd->next = pTag;
  1487.     }
  1488.     pEnd = pTag;
  1489. }
  1490.  
  1491.  
  1492.  
  1493. //-----------------------------------------------------------------------------
  1494. // CEditPosition
  1495. //-----------------------------------------------------------------------------
  1496.  
  1497. void CEditPositionComparable::CalcPosition( TXP_GrowableArray_int32* pA, 
  1498.             CEditPosition *pPos ){
  1499.  
  1500.     CEditElement *pElement, *pParent, *pSib;
  1501.     int i;
  1502.  
  1503.     pA->Empty();
  1504.     pA->Add( pPos->Offset() );
  1505.     pElement = pPos->Element();
  1506.     if( pElement ){
  1507.         while( (pParent = pElement->GetParent()) != NULL ){
  1508.             i = 0;
  1509.             pSib = pParent->GetChild();        
  1510.             while( pSib != pElement ){
  1511.                 pSib = pSib->GetNextSibling();
  1512.                 i++;
  1513.             }
  1514.             pA->Add(i);
  1515.             pElement = pParent;
  1516.         }
  1517.     }
  1518. }
  1519.  
  1520. int CEditPositionComparable::Compare( CEditPosition *pPos ){
  1521.     TXP_GrowableArray_int32 toArray;
  1522.  
  1523.     CalcPosition( &toArray, pPos );
  1524.  
  1525.     int32 i = m_Array.Size();
  1526.     int32 iTo = toArray.Size();
  1527.     int32 iDiff;
  1528.  
  1529.     while( i && iTo ){
  1530.         iDiff = toArray[--iTo] - m_Array[--i];
  1531.         if( iDiff != 0 ) {
  1532.             return (iDiff > 0 ? 1 : -1 );
  1533.         }
  1534.     }
  1535.     if( i == 0 && iTo == 0){
  1536.         return 0;
  1537.     }
  1538.     iDiff = iTo - i;
  1539.     return (iDiff > 0 ? 1 : -1 );
  1540. }
  1541.  
  1542.  
  1543. // CEditInsertPoint
  1544.  
  1545. CEditInsertPoint::CEditInsertPoint() {
  1546.     m_pElement = 0;
  1547.     m_iPos = 0;
  1548.     m_bStickyAfter = FALSE;
  1549. }
  1550.  
  1551. CEditInsertPoint::CEditInsertPoint(CEditLeafElement* pElement, ElementOffset iPos) {
  1552.     m_pElement = pElement;
  1553.     m_iPos = iPos;
  1554.     m_bStickyAfter = FALSE;
  1555. }
  1556.  
  1557. CEditInsertPoint::CEditInsertPoint(CEditElement* pElement, ElementOffset iPos){
  1558.     m_pElement = pElement->Leaf();
  1559.     m_iPos = iPos;
  1560.     m_bStickyAfter = FALSE;
  1561. }
  1562.  
  1563. CEditInsertPoint::CEditInsertPoint(CEditElement* pElement, ElementOffset iPos, XP_Bool bStickyAfter){
  1564.     m_pElement = pElement->Leaf();
  1565.     m_iPos = iPos;
  1566.     m_bStickyAfter = bStickyAfter;
  1567. }
  1568.  
  1569. XP_Bool CEditInsertPoint::operator==(const CEditInsertPoint& other ) {
  1570.     return m_pElement == other.m_pElement && m_iPos == other.m_iPos;
  1571. }
  1572.  
  1573. XP_Bool CEditInsertPoint::operator!=(const CEditInsertPoint& other ) {
  1574.     return ! (*this == other);
  1575. }
  1576.  
  1577. XP_Bool CEditInsertPoint::operator<(const CEditInsertPoint& other ) {
  1578.     return Compare(other) < 0;
  1579. }
  1580.  
  1581. XP_Bool CEditInsertPoint::operator<=(const CEditInsertPoint& other ) {
  1582.     return Compare(other) <= 0;
  1583. }
  1584.  
  1585. XP_Bool CEditInsertPoint::operator>=(const CEditInsertPoint& other ) {
  1586.     return Compare(other) >= 0;
  1587. }
  1588.  
  1589. XP_Bool CEditInsertPoint::operator>(const CEditInsertPoint& other ) {
  1590.     return Compare(other) > 0;
  1591. }
  1592.  
  1593. CEditElement* CEditInsertPoint::FindNonEmptyElement( CEditElement *pStartElement ){
  1594.     CEditElement* pOldElement = NULL;
  1595.     while ( pStartElement && pStartElement != pOldElement ) {
  1596.         pOldElement = pStartElement;
  1597.         if( !pStartElement->IsLeaf() ){
  1598.             pStartElement = pStartElement->PreviousLeaf();
  1599.         }
  1600.         else if( pStartElement->Leaf()->GetLayoutElement() == 0 ){
  1601.            pStartElement = pStartElement->PreviousLeaf();
  1602.         }
  1603.     }
  1604.     return pStartElement;
  1605. }
  1606.  
  1607. int CEditInsertPoint::Compare(const CEditInsertPoint& other ) {
  1608.     XP_Bool bAIsBreak = FALSE;
  1609.     LO_Element* pA = m_pElement->GetLayoutElement();
  1610.     if ( ! pA ) {
  1611.         bAIsBreak = TRUE;
  1612.         pA = FindNonEmptyElement(m_pElement)->Leaf()->GetLayoutElement();
  1613.     }
  1614.     XP_Bool bBIsBreak = FALSE;
  1615.     LO_Element* pB = other.m_pElement->GetLayoutElement();
  1616.     if ( ! pB ) {
  1617.         bBIsBreak = TRUE;
  1618.         pB = FindNonEmptyElement(other.m_pElement)->Leaf()->GetLayoutElement();
  1619.     }
  1620.     if ( !pA || !pB ) {
  1621.         XP_ASSERT(FALSE); // Phantom insert points.
  1622.         return 0;
  1623.     }
  1624.     int32 aIndex = pA->lo_any.ele_id;
  1625.     int32 bIndex = pB->lo_any.ele_id;
  1626.     if ( aIndex < bIndex ) {
  1627.         return -1;
  1628.     }
  1629.     else if ( aIndex == bIndex ) {
  1630.         // Same element. Compare positions.
  1631.         if ( m_iPos < other.m_iPos ) {
  1632.             return -1;
  1633.         }
  1634.         else if ( m_iPos == other.m_iPos ) {
  1635.             if ( bAIsBreak < bBIsBreak ) {
  1636.                 return -1;
  1637.             }
  1638.             else if ( bAIsBreak == bBIsBreak ) {
  1639.                 return 0;
  1640.             }
  1641.             else {
  1642.                 return 1;
  1643.             }
  1644.         }
  1645.         else {
  1646.             return 1;
  1647.         }
  1648.     }
  1649.     else {
  1650.         return 1;
  1651.     }
  1652. }
  1653.  
  1654. XP_Bool CEditInsertPoint::IsDenormalizedVersionOf(const CEditInsertPoint& other){
  1655.     return other.m_iPos == 0 &&
  1656.         m_iPos == m_pElement->GetLen() &&
  1657.         m_pElement->NextLeaf() == other.m_pElement;
  1658. }
  1659.  
  1660. XP_Bool CEditInsertPoint::IsStartOfElement() {
  1661.     return m_iPos <= 0;
  1662. }
  1663.  
  1664. XP_Bool CEditInsertPoint::IsEndOfElement() {
  1665.     return m_iPos >= m_pElement->GetLen();
  1666. }
  1667.  
  1668. XP_Bool CEditInsertPoint::IsStartOfContainer() {
  1669.     return IsStartOfElement()
  1670.         && m_pElement->PreviousLeafInContainer() == NULL;
  1671. }
  1672.  
  1673. XP_Bool CEditInsertPoint::IsEndOfContainer() {
  1674.     return IsEndOfElement()
  1675.         && m_pElement->LeafInContainerAfter() == NULL;
  1676. }
  1677.  
  1678. XP_Bool CEditInsertPoint::IsStartOfDocument(){
  1679.     return IsStartOfElement() &&
  1680.         m_pElement->PreviousLeaf() == NULL;
  1681. }
  1682.  
  1683. XP_Bool CEditInsertPoint::IsEndOfDocument(){
  1684.     return m_pElement->IsEndOfDocument();
  1685. }
  1686.  
  1687. XP_Bool CEditInsertPoint::GapWithBothSidesAllowed(){
  1688.     XP_Bool bResult = FALSE;
  1689.     XP_Bool bAllowBothSidesOfGap = m_pElement->AllowBothSidesOfGap();
  1690.     if ( bAllowBothSidesOfGap
  1691.             && IsEndOfElement()
  1692.             && !IsEndOfContainer() ) {
  1693.         bResult = TRUE;
  1694.     }
  1695.     else if ( IsStartOfElement() && ! IsStartOfContainer() ) {
  1696.         if ( bAllowBothSidesOfGap ) {
  1697.             bResult = TRUE;
  1698.         }
  1699.         else {
  1700.             CEditLeafElement* pPrev = m_pElement->PreviousLeaf();
  1701.             if ( pPrev && pPrev->AllowBothSidesOfGap() ) {
  1702.                 bResult = TRUE;
  1703.             }
  1704.         }
  1705.     }
  1706.     return bResult;
  1707. }
  1708.  
  1709. XP_Bool CEditInsertPoint::IsLineBreak(){
  1710.     return IsHardLineBreak() || IsSoftLineBreak();
  1711. }
  1712.  
  1713. XP_Bool CEditInsertPoint::IsSoftLineBreak(){
  1714.     XP_Bool result = FALSE;
  1715.     CEditTextElement* pText = CEditTextElement::Cast(m_pElement);
  1716.     if ( pText ){
  1717.         int iOffset;
  1718.         LO_Element* pLOElement;
  1719.         if ( pText->GetLOElementAndOffset(m_iPos, m_bStickyAfter,
  1720.                 pLOElement, iOffset) ){
  1721.             if ( pLOElement->type == LO_LINEFEED ){
  1722.                 result = TRUE;
  1723.             }
  1724.         }
  1725.     }
  1726.     return result;
  1727. }
  1728.  
  1729. XP_Bool CEditInsertPoint::IsHardLineBreak(){
  1730.     return IsStartOfElement() && m_pElement->CausesBreakBefore()
  1731.         || IsEndOfElement() && m_pElement->CausesBreakAfter();
  1732. }
  1733.  
  1734. XP_Bool CEditInsertPoint::IsSpace() {
  1735.     XP_Bool result = FALSE;
  1736.     if ( m_pElement->IsA(P_TEXT) ) {
  1737.         if ( m_iPos == m_pElement->GetLen() ){
  1738.             CEditLeafElement *pNext = m_pElement->TextInContainerAfter();
  1739.             if( pNext
  1740.                 && pNext->IsA(P_TEXT)
  1741.                 && pNext->Text()->GetLen() != 0
  1742.                 && pNext->Text()->GetText()[0] == ' ') {
  1743.                 result = TRUE;
  1744.             }
  1745.         }
  1746.         else if ( m_pElement->Text()->GetText()[m_iPos] == ' ' ) {
  1747.             result = TRUE;
  1748.         }
  1749.     }
  1750.     return result;
  1751. }
  1752.  
  1753. XP_Bool CEditInsertPoint::IsSpaceBeforeOrAfter() {
  1754.     XP_Bool result = IsSpace();
  1755.     if ( !result ) {
  1756.         CEditInsertPoint before = PreviousPosition();
  1757.         if ( before != *this ) {
  1758.             result = before.IsSpace();
  1759.         }
  1760.     }
  1761.     return result;
  1762. }
  1763.  
  1764. CEditInsertPoint CEditInsertPoint::NextPosition(){
  1765.     CEditInsertPoint result;
  1766.     m_pElement->NextPosition(m_iPos, result.m_pElement, result.m_iPos);
  1767.     return result;
  1768. }
  1769.  
  1770. CEditInsertPoint CEditInsertPoint::PreviousPosition(){
  1771.     CEditInsertPoint result;
  1772.     m_pElement->PrevPosition(m_iPos, result.m_pElement, result.m_iPos);
  1773.     // Work around what is probably a bug in PrevPosition.
  1774.     if ( m_iPos == 0 && result.m_iPos == result.m_pElement->GetLen() ) {
  1775.         result.m_pElement->PrevPosition(result.m_iPos, result.m_pElement, result.m_iPos);
  1776.     }
  1777.     return result;
  1778. }
  1779.  
  1780. #ifdef DEBUG
  1781. void CEditInsertPoint::Print(IStreamOut& stream) {
  1782.     stream.Printf("0x%08lx.%d%s", m_pElement, m_iPos, m_bStickyAfter ? "+" : "" );
  1783. }
  1784. #endif
  1785.  
  1786.  
  1787.  
  1788. // CEditSelection
  1789.  
  1790. CEditSelection::CEditSelection(){
  1791.     m_bFromStart = FALSE;
  1792. }
  1793.  
  1794. CEditSelection::CEditSelection(CEditElement* pStart, intn iStartPos,
  1795.     CEditElement* pEnd, intn iEndPos, XP_Bool fromStart)
  1796.     : m_start(pStart, iStartPos), m_end(pEnd, iEndPos), m_bFromStart(fromStart)
  1797. {
  1798. }
  1799.  
  1800. CEditSelection::CEditSelection(const CEditInsertPoint& start,
  1801.     const CEditInsertPoint& end, XP_Bool fromStart)
  1802.     : m_start(start), m_end(end), m_bFromStart(fromStart)
  1803. {
  1804. }
  1805.  
  1806. XP_Bool CEditSelection::operator==(const CEditSelection& other ){
  1807.     return m_start == other.m_start &&
  1808.     m_end == other.m_end && m_bFromStart == other.m_bFromStart;
  1809. }
  1810.  
  1811. XP_Bool CEditSelection::operator!=(const CEditSelection& other ){
  1812.     return ! (*this == other);
  1813. }
  1814.  
  1815. XP_Bool CEditSelection::EqualRange(CEditSelection& other){
  1816.     return m_start == other.m_start && m_end == other.m_end;
  1817. }
  1818.  
  1819. XP_Bool CEditSelection::IsInsertPoint() {
  1820.     /* It's an insert point if the two edges are equal, OR if the
  1821.      * start is at the end of an element, and the
  1822.      * end is at the start of an element, and
  1823.      * the two elements are next to each other,
  1824.      * and they're in the same container. (Whew!)
  1825.      */
  1826.     return m_start == m_end ||
  1827.         ( m_start.IsEndOfElement() &&
  1828.           m_end.IsStartOfElement() &&
  1829.           m_start.m_pElement->LeafInContainerAfter() == m_end.m_pElement
  1830.         );
  1831. }
  1832.  
  1833. CEditInsertPoint* CEditSelection::GetEdge(XP_Bool bEnd){
  1834.     if ( bEnd ) return &m_end;
  1835.     else return &m_start;
  1836. }
  1837.  
  1838. CEditInsertPoint* CEditSelection::GetActiveEdge(){
  1839.      return GetEdge(!m_bFromStart);
  1840. }
  1841.  
  1842. CEditInsertPoint* CEditSelection::GetAnchorEdge(){
  1843.     return GetEdge(m_bFromStart);
  1844. }
  1845.  
  1846. XP_Bool CEditSelection::Intersects(CEditSelection& other) {
  1847.     return m_start < other.m_end && other.m_start < m_end;
  1848. }
  1849.  
  1850. XP_Bool CEditSelection::Contains(CEditInsertPoint& point) {
  1851.     return m_start <= point && point < m_end;
  1852. }
  1853.  
  1854. XP_Bool CEditSelection::Contains(CEditSelection& other) {
  1855.     return ContainsStart(other) && other.m_end <= m_end;
  1856. }
  1857.  
  1858. XP_Bool CEditSelection::ContainsStart(CEditSelection& other) {
  1859.     return Contains(other.m_start);
  1860. }
  1861.  
  1862. XP_Bool CEditSelection::ContainsEnd(CEditSelection& other) {
  1863.     return Contains(other.m_end) || other.m_end == m_end;
  1864. }
  1865.  
  1866. XP_Bool CEditSelection::ContainsEdge(CEditSelection& other, XP_Bool bEnd){
  1867.     if ( bEnd )
  1868.         return ContainsEnd(other);
  1869.     else
  1870.         return ContainsStart(other);
  1871. }
  1872.  
  1873. XP_Bool CEditSelection::CrossesOver(CEditSelection& other) {
  1874.     XP_Bool bContainsStart = ContainsStart(other);
  1875.     XP_Bool bContainsEnd = ContainsEnd(other);
  1876.     return bContainsStart ^ bContainsEnd;
  1877. }
  1878.  
  1879. XP_Bool CEditSelection::ClipTo(CEditSelection& other) {
  1880.     // True if the result is defined. No change to this if it isn't
  1881.     XP_Bool intersects = Intersects(other);
  1882.     if ( intersects ) {
  1883.         if ( m_start < other.m_start ) {
  1884.             m_start = other.m_start;
  1885.         }
  1886.         if ( other.m_end < m_end ) {
  1887.             m_end = other.m_end;
  1888.         }
  1889.     }
  1890.     return intersects;
  1891. }
  1892.  
  1893. CEditElement* CEditSelection::GetCommonAncestor(){
  1894.     return m_start.m_pElement->GetCommonAncestor(m_end.m_pElement);
  1895. }
  1896.  
  1897. XP_Bool CEditSelection::CrossesSubDocBoundary(){
  1898.     // The intent of this method is "If this selection were cut, would the
  1899.     // document become malformed?"
  1900.  
  1901.     // A document could be malformed if the selection crosses the table
  1902.     // boundary, or if it would leave a table without it's protective
  1903.     // buffer of containers.
  1904.  
  1905.     XP_Bool result = FALSE;
  1906.     if ( ! IsInsertPoint() ){
  1907.         CEditElement* pStartCell = m_start.m_pElement->GetSubDocOrLayerSkipRoot();
  1908.         CEditElement* pEndCell = m_end.m_pElement->GetSubDocOrLayerSkipRoot();
  1909.         CEditElement* pClosedEndCell = GetClosedEndContainer()->GetSubDocOrLayerSkipRoot();
  1910.         result = pStartCell != pEndCell || pStartCell != pClosedEndCell;
  1911.         if ( result ) {
  1912.             // This is only OK if the selection spans an entire table.
  1913.             Bool bStartBad = FALSE;
  1914.             Bool bEndBad = FALSE;
  1915.             if ( pStartCell ) {
  1916.                 CEditSelection all;
  1917.                 pStartCell->GetTableOrLayerIgnoreSubdoc()->GetAll(all);
  1918.                 bStartBad = ! Contains(all);
  1919.             }
  1920.  
  1921.             if ( pEndCell ) {
  1922.                 CEditSelection all;
  1923.                 pEndCell->GetTableOrLayerIgnoreSubdoc()->GetAll(all);
  1924.                 bEndBad = ! Contains(all);
  1925.             }
  1926.             result = bStartBad || bEndBad;
  1927.         }
  1928.         else if ( pStartCell && pEndCell != pClosedEndCell ) {
  1929.             // If the selection spans an entire cell, but not an entire table, that's bad
  1930.             CEditSelection all;
  1931.             pStartCell->GetTableOrLayerIgnoreSubdoc()->GetAll(all);
  1932.             result = *this != all;
  1933.         }
  1934.         else {
  1935.             // One further check: If the selection starts at the start of
  1936.             // a paragraph, and the selection ends at the end of a paragraph
  1937.             // and the previous item is a table, and the
  1938.             // next item is not a container, then we can't cut. The reason is
  1939.             // that tables need to have containers after them.
  1940.  
  1941.             // Note that m_end is one more than is selected.
  1942.             if ( m_start.IsStartOfContainer() &&
  1943.                 m_end.IsStartOfContainer() ) {
  1944.                 // The selection spans whole containers.
  1945.                 CEditContainerElement* pStartContainer = GetStartContainer();
  1946.                 CEditElement* pPreviousSib = pStartContainer->GetPreviousSibling();
  1947.                 
  1948.                 if ( pPreviousSib && pPreviousSib->IsTable() ) {
  1949.                     CEditContainerElement* pEndContainer = GetClosedEndContainer();
  1950.                     CEditElement* pNextSib = pEndContainer->GetNextSibling();
  1951.                     if ( !pNextSib || pNextSib->IsEndContainer() || pNextSib->IsTable() ) {
  1952.                         result = TRUE;
  1953.                     }
  1954.                 }
  1955.             }
  1956.         }
  1957.     }
  1958.     return result;
  1959. }
  1960.  
  1961. CEditSubDocElement* CEditSelection::GetEffectiveSubDoc(XP_Bool bEnd){
  1962.     CEditInsertPoint* pEdge = GetEdge(bEnd);
  1963.     CEditSubDocElement* pSubDoc = pEdge->m_pElement->GetSubDoc();
  1964.     while ( pSubDoc ) {
  1965.         // If the edge is actually the edge of a subdoc, skip out of the subdoc.
  1966.         CEditSelection wholeSubDoc;
  1967.         pSubDoc->GetAll(wholeSubDoc);
  1968.         // If this is a wholeSubDoc Selection, bump up
  1969.         if ( *this != wholeSubDoc ) {
  1970.             if ( *pEdge != *wholeSubDoc.GetEdge(bEnd) )
  1971.                 break;
  1972.             // If the other end of the selection is is in this same subdoc, stop
  1973.             if ( wholeSubDoc.ContainsEdge(*this, !bEnd) )
  1974.                 break;
  1975.         }
  1976.         CEditElement* pSubDocParent = pSubDoc->GetParent();
  1977.         if ( !pSubDocParent )
  1978.             break;
  1979.         CEditSubDocElement* pParentSubDoc = pSubDocParent->GetSubDoc();
  1980.         if ( ! pParentSubDoc )
  1981.             break;
  1982.         pSubDoc = pParentSubDoc;
  1983.     }
  1984.     return pSubDoc;
  1985. }
  1986.  
  1987. XP_Bool CEditSelection::ExpandToNotCrossStructures(){
  1988.     XP_Bool bChanged = FALSE;
  1989.     if ( ! IsInsertPoint() ){
  1990.         CEditElement* pGrandfatherStart = m_start.m_pElement->GetParent()->GetParent();
  1991.         CEditElement* pGrandfatherEnd;
  1992.         CEditElement* pEffectiveEndContianer;
  1993.         if ( m_end.IsEndOfDocument() || EndsAtStartOfContainer()) {
  1994.             pEffectiveEndContianer = m_end.m_pElement->PreviousLeaf()->GetParent();
  1995.         }
  1996.         else {
  1997.             pEffectiveEndContianer = m_end.m_pElement->GetParent();
  1998.         }
  1999.         pGrandfatherEnd = pEffectiveEndContianer->GetParent();
  2000.         if ( pGrandfatherStart != pGrandfatherEnd ){
  2001.             bChanged = TRUE;
  2002.             CEditElement* pAncestor = pGrandfatherStart->GetCommonAncestor(pGrandfatherEnd);
  2003.             if ( ! pAncestor ) {
  2004.                 XP_ASSERT(FALSE);
  2005.                 return FALSE;
  2006.             }
  2007.             // If we're in a table, we need to return the whole table.
  2008.             if ( pAncestor->IsTableRow() ) {
  2009.                 pAncestor = pAncestor->GetTable();
  2010.                 if ( ! pAncestor ) {
  2011.                     XP_ASSERT(FALSE);
  2012.                     return FALSE;
  2013.                 }
  2014.             }
  2015.             if ( pAncestor->IsTable() ) {
  2016.                 pAncestor->GetAll(*this);
  2017.                 return TRUE;
  2018.             }
  2019.             CEditLeafElement* pCleanStart = pAncestor->GetChildContaining(m_start.m_pElement)->GetFirstMostChild()->Leaf();
  2020.             CEditLeafElement* pCleanEnd = pAncestor->GetChildContaining(pEffectiveEndContianer)->GetLastMostChild()->NextLeaf();
  2021.             m_start.m_pElement = pCleanStart;
  2022.             m_start.m_iPos = 0;
  2023.             if ( pCleanEnd ) {
  2024.                 m_end.m_pElement = pCleanEnd;
  2025.                 m_end.m_iPos = 0;
  2026.             }
  2027.             else {
  2028.                 XP_ASSERT(FALSE);   // Somehow we've lost the end of the document element.
  2029.                 pCleanEnd = m_end.m_pElement->GetParent()->GetLastMostChild()->Leaf();
  2030.                 m_end.m_pElement = pCleanEnd;
  2031.                 m_end.m_iPos = pCleanEnd->Leaf()->GetLen();
  2032.             }
  2033.         }
  2034.     }
  2035.     return bChanged;
  2036. }
  2037.  
  2038. void CEditSelection::ExpandToBeCutable(){
  2039.     // Very similar to ExpandToNotCrossDocumentStructures, except that
  2040.     // the result is always Cutable.
  2041.     if ( ! IsInsertPoint() ){
  2042.         CEditElement* pGrandfatherStart = m_start.m_pElement->GetParent()->GetParent();
  2043.         CEditElement* pGrandfatherEnd;
  2044.         CEditElement* pEffectiveEndContianer;
  2045.         if ( m_end.IsEndOfDocument()) {
  2046.             pEffectiveEndContianer = m_end.m_pElement->PreviousLeaf()->GetParent();
  2047.         }
  2048.         else {
  2049.             pEffectiveEndContianer = m_end.m_pElement->GetParent();
  2050.         }
  2051.         pGrandfatherEnd = pEffectiveEndContianer->GetParent();
  2052.         if ( pGrandfatherStart != pGrandfatherEnd ){
  2053.             CEditElement* pAncestor = pGrandfatherStart->GetCommonAncestor(pGrandfatherEnd);
  2054.             if ( ! pAncestor ) {
  2055.                 XP_ASSERT(FALSE);
  2056.                 return;
  2057.             }
  2058.             // If we're in a table, we need to return the whole table.
  2059.             if ( pAncestor->IsTableRow() ) {
  2060.                 pAncestor = pAncestor->GetTable();
  2061.                 if ( ! pAncestor ) {
  2062.                     XP_ASSERT(FALSE);
  2063.                     return;
  2064.                 }
  2065.             }
  2066.             if ( pAncestor->IsTable() ) {
  2067.                 pAncestor->GetAll(*this);
  2068.                 return;
  2069.             }
  2070.             CEditLeafElement* pCleanStart = pAncestor->GetChildContaining(m_start.m_pElement)->GetFirstMostChild()->Leaf();
  2071.             CEditLeafElement* pCleanEnd = pAncestor->GetChildContaining(pEffectiveEndContianer)->GetLastMostChild()->NextLeaf();
  2072.             m_start.m_pElement = pCleanStart;
  2073.             m_start.m_iPos = 0;
  2074.             if ( pCleanEnd ) {
  2075.                 m_end.m_pElement = pCleanEnd;
  2076.                 m_end.m_iPos = 0;
  2077.             }
  2078.             else {
  2079.                 XP_ASSERT(FALSE);   // Somehow we've lost the end of the document element.
  2080.                 pCleanEnd = m_end.m_pElement->GetParent()->GetLastMostChild()->Leaf();
  2081.                 m_end.m_pElement = pCleanEnd;
  2082.                 m_end.m_iPos = pCleanEnd->Leaf()->GetLen();
  2083.             }
  2084.         }
  2085.     }
  2086. }
  2087.  
  2088. void CEditSelection::ExpandToIncludeFragileSpaces() {
  2089.     // Expand the selection to include spaces that will be
  2090.     // trimmed if we did a cut of the original selection.
  2091.     if ( ! IsInsertPoint() ){
  2092.         CEditInsertPoint before = m_start.PreviousPosition();
  2093.         // Either we backed up one position, or we hit the beginning
  2094.         // of the document.
  2095.         if ( before == m_start || before.IsSpace() ) {
  2096.             if ( m_end.IsSpace() ) {
  2097.                 if ( ! m_end.m_pElement->InFormattedText() ) {
  2098.                     m_end = m_end.NextPosition();
  2099.                 }
  2100.             }
  2101.         }
  2102.     }
  2103. }
  2104.  
  2105. void CEditSelection::ExpandToEncloseWholeContainers(){
  2106.     XP_Bool bWasInsertPoint = IsInsertPoint();
  2107.     CEditLeafElement* pCleanStart = m_start.m_pElement->GetParent()->GetFirstMostChild()->Leaf();
  2108.     m_start.m_pElement = pCleanStart;
  2109.     m_start.m_iPos = 0;
  2110.     if ( !m_end.IsStartOfContainer() || bWasInsertPoint ) {
  2111.         CEditLeafElement* pCleanEnd = m_end.m_pElement->GetParent()->GetLastMostChild()->NextLeaf();
  2112.         if ( pCleanEnd ) {
  2113.             m_end.m_pElement = pCleanEnd;
  2114.             m_end.m_iPos = 0;
  2115.         }
  2116.         else {
  2117.             XP_ASSERT(FALSE);   // Somehow we've lost the end of the document element.
  2118.             pCleanEnd = m_end.m_pElement->GetParent()->GetLastMostChild()->Leaf();
  2119.             m_end.m_pElement = pCleanEnd;
  2120.             m_end.m_iPos = pCleanEnd->Leaf()->GetLen();
  2121.         }
  2122.     }
  2123. }
  2124.  
  2125.  
  2126. XP_Bool CEditSelection::EndsAtStartOfContainer() {
  2127.     return m_end.IsStartOfContainer();
  2128. }
  2129.  
  2130. XP_Bool CEditSelection::StartsAtEndOfContainer() {
  2131.     return m_start.IsEndOfContainer();
  2132. }
  2133.  
  2134. XP_Bool CEditSelection::AnyLeavesSelected(){
  2135.     // FALSE if insert point or container end.
  2136.     return ! (IsInsertPoint() || IsContainerEnd());
  2137. }
  2138.  
  2139. XP_Bool CEditSelection::IsContainerEnd(){
  2140.     XP_Bool result = FALSE;
  2141.     if ( ! IsInsertPoint() && EndsAtStartOfContainer()
  2142.         && StartsAtEndOfContainer() ) {
  2143.         CEditContainerElement* pStartContainer = m_start.m_pElement->FindContainer();
  2144.         CEditContainerElement* pEndContainer = m_end.m_pElement->FindContainer();
  2145.         if ( pStartContainer && pEndContainer ) {
  2146.             CEditContainerElement* pNextContainer =
  2147.                 CEditContainerElement::Cast(pStartContainer->FindNextElement(&CEditElement::FindContainer, 0));
  2148.             if ( pNextContainer == pEndContainer) {
  2149.                 result = TRUE;
  2150.             }
  2151.         }
  2152.     }
  2153.     return result;
  2154. }
  2155.  
  2156. void CEditSelection::ExcludeLastDocumentContainerEnd() {
  2157.     // Useful for cut & delete, where you don't replace the final container mark
  2158.     if ( ContainsLastDocumentContainerEnd() ){
  2159.         CEditLeafElement* pEnd = m_end.m_pElement;
  2160.         pEnd = pEnd->PreviousLeaf();
  2161.         if ( pEnd ) {
  2162.             m_end.m_pElement = pEnd;
  2163.             m_end.m_iPos = pEnd->Leaf()->GetLen();
  2164.             if ( m_start > m_end ) {
  2165.                 m_start = m_end;
  2166.             }
  2167.         }
  2168.     }
  2169. }
  2170.  
  2171. XP_Bool CEditSelection::ContainsLastDocumentContainerEnd() {
  2172.     // Useful for cut & delete, where you don't replace the final container mark
  2173.     XP_Bool bResult = FALSE;
  2174.     CEditLeafElement* pEnd = m_end.m_pElement;
  2175.     if ( pEnd && pEnd->GetElementType() == eEndElement ){
  2176.         bResult = TRUE;
  2177.     }
  2178.     return bResult;
  2179. }
  2180.  
  2181. CEditContainerElement* CEditSelection::GetStartContainer() {
  2182.     CEditElement* pParent = m_start.m_pElement->GetParent();
  2183.     if ( pParent && pParent->IsContainer() ) return pParent->Container();
  2184.     else return NULL;
  2185. }
  2186.  
  2187. CEditContainerElement* CEditSelection::GetClosedEndContainer() {
  2188.     CEditElement* pEnd = m_end.m_pElement;
  2189.     if ( m_end.IsStartOfContainer() ) {
  2190.         // Back up one
  2191.         CEditElement* pPrev = pEnd->PreviousLeaf();
  2192.         if ( pPrev ) {
  2193.             pEnd = pPrev;
  2194.         }
  2195.         else pEnd = m_start.m_pElement;
  2196.     }
  2197.     CEditElement* pParent = pEnd->GetParent();
  2198.     if ( pParent && pParent->IsContainer() ) return pParent->Container();
  2199.     else return NULL;
  2200. }
  2201.  
  2202. #ifdef DEBUG
  2203. void CEditSelection::Print(IStreamOut& stream){
  2204.     stream.Printf("start ");
  2205.     m_start.Print(stream);
  2206.     stream.Printf(" end ");
  2207.     m_end.Print(stream);
  2208.     stream.Printf(" FromStart %ld", (long)m_bFromStart);
  2209. }
  2210. #endif
  2211.  
  2212. // Persistent selections
  2213. CPersistentEditInsertPoint::CPersistentEditInsertPoint()
  2214. {
  2215.     m_index = -1;
  2216.     m_bStickyAfter = TRUE;
  2217. }
  2218.  
  2219. CPersistentEditInsertPoint::CPersistentEditInsertPoint(ElementIndex index)
  2220.     : m_index(index), m_bStickyAfter(TRUE)
  2221. {}
  2222.  
  2223. CPersistentEditInsertPoint::CPersistentEditInsertPoint(ElementIndex index, XP_Bool bStickyAfter)
  2224.     : m_index(index), m_bStickyAfter(bStickyAfter)
  2225. {
  2226. }
  2227.  
  2228. XP_Bool CPersistentEditInsertPoint::operator==(const CPersistentEditInsertPoint& other ) {
  2229.     return m_index == other.m_index;
  2230. }
  2231.  
  2232. XP_Bool CPersistentEditInsertPoint::operator!=(const CPersistentEditInsertPoint& other ) {
  2233.     return ! (*this == other);
  2234. }
  2235.  
  2236. XP_Bool CPersistentEditInsertPoint::operator<(const CPersistentEditInsertPoint& other ) {
  2237.     return m_index < other.m_index;
  2238. }
  2239.  
  2240. XP_Bool CPersistentEditInsertPoint::operator<=(const CPersistentEditInsertPoint& other ) {
  2241.     return *this < other || *this == other;
  2242. }
  2243.  
  2244. XP_Bool CPersistentEditInsertPoint::operator>=(const CPersistentEditInsertPoint& other ) {
  2245.     return ! (*this < other);
  2246. }
  2247.  
  2248. XP_Bool CPersistentEditInsertPoint::operator>(const CPersistentEditInsertPoint& other ) {
  2249.     return ! (*this <= other);
  2250. }
  2251.  
  2252. #ifdef DEBUG
  2253. void CPersistentEditInsertPoint::Print(IStreamOut& stream) {
  2254.     stream.Printf("%ld%s", (long)m_index, m_bStickyAfter ? "+" : "" );
  2255. }
  2256. #endif
  2257.  
  2258. void CPersistentEditInsertPoint::ComputeDifference(
  2259.     CPersistentEditInsertPoint& other, CPersistentEditInsertPoint& delta){
  2260.     // delta = this - other;
  2261.     delta.m_index = m_index - other.m_index;
  2262. }
  2263.  
  2264. void CPersistentEditInsertPoint::AddRelative(
  2265.     CPersistentEditInsertPoint& delta, CPersistentEditInsertPoint& result){
  2266.     // result = this + delta;
  2267.     result.m_index = m_index + delta.m_index;
  2268. }
  2269.  
  2270. XP_Bool CPersistentEditInsertPoint::IsEqualUI(
  2271.     const CPersistentEditInsertPoint& other ) {
  2272.     return m_index == other.m_index && m_bStickyAfter == other.m_bStickyAfter;
  2273. }
  2274.  
  2275. // class CPersistentEditSelection
  2276.  
  2277. CPersistentEditSelection::CPersistentEditSelection()
  2278. {
  2279.     m_bFromStart = FALSE;
  2280. }
  2281.  
  2282. CPersistentEditSelection::CPersistentEditSelection(const CPersistentEditInsertPoint& start, const CPersistentEditInsertPoint& end)
  2283.     : m_start(start), m_end(end)
  2284. {
  2285.     m_bFromStart = FALSE;
  2286. }
  2287.  
  2288. ElementIndex CPersistentEditSelection::GetCount() {
  2289.     return m_end.m_index - m_start.m_index;
  2290. }
  2291.  
  2292. XP_Bool CPersistentEditSelection::IsInsertPoint(){
  2293.     return m_start == m_end;
  2294. }
  2295.  
  2296. XP_Bool CPersistentEditSelection::operator==(const CPersistentEditSelection& other ) {
  2297.     return SelectedRangeEqual(other) && m_bFromStart == other.m_bFromStart;
  2298. }
  2299.  
  2300. XP_Bool CPersistentEditSelection::operator!=(const CPersistentEditSelection& other ) {
  2301.     return ! ( *this == other );
  2302. }
  2303.  
  2304. XP_Bool CPersistentEditSelection::SelectedRangeEqual(const CPersistentEditSelection& other ) {
  2305.     return m_start == other.m_start && m_end == other.m_end;
  2306. }
  2307.  
  2308. CPersistentEditInsertPoint* CPersistentEditSelection::GetEdge(XP_Bool bEnd){
  2309.     return bEnd ? &m_end : &m_start;
  2310. } 
  2311.  
  2312. #ifdef DEBUG
  2313. void CPersistentEditSelection::Print(IStreamOut& stream) {
  2314.     stream.Printf("start ");
  2315.     m_start.Print(stream);
  2316.     stream.Printf(" end ");
  2317.     m_end.Print(stream);
  2318.     stream.Printf(" FromStart %ld", (long)m_bFromStart);
  2319. }
  2320. #endif
  2321.  
  2322. // Used for undo
  2323. // change this by the same way that original was changed into modified.
  2324. void CPersistentEditSelection::Map(CPersistentEditSelection& original,
  2325.     CPersistentEditSelection& modified){
  2326.     CPersistentEditSelection delta;
  2327.     CPersistentEditSelection result;
  2328.     modified.m_start.ComputeDifference(original.m_start, delta.m_start);
  2329.     modified.m_end.ComputeDifference(original.m_end, delta.m_end);
  2330.     m_start.AddRelative(delta.m_start, result.m_start);
  2331.     m_end.AddRelative(delta.m_end, result.m_end);
  2332.     *this = result;
  2333. }
  2334.  
  2335. //
  2336. //  Call this constructor with a maximum number, a series of bits and 
  2337. //  BIT_ARRAY_END for example: CBitArray a(100, 1 ,4 9 ,7, BIT_ARRAY_END);
  2338. // 
  2339. CBitArray::CBitArray(long n, int iFirst, ...) {
  2340.  
  2341.     m_Bits = 0;
  2342.     size = 0;
  2343.  
  2344.     int i;
  2345.  
  2346.     if( n ) {
  2347.       SetSize(n);
  2348.     }
  2349.     va_list stack;
  2350. #ifdef OSF1
  2351.     va_start( stack, n );
  2352. #else
  2353.     va_start( stack, iFirst );
  2354.  
  2355.     (*this)[iFirst] = 1;
  2356. #endif
  2357.  
  2358.     while( (i = va_arg(stack,int)) != BIT_ARRAY_END ){
  2359.        (*this)[i] = 1;
  2360.     }
  2361. }
  2362.  
  2363. void CBitArray::SetSize(long n){
  2364.     // On Win16 we can't have a size larger that int.
  2365.   XP_ASSERT(size < (1L << (16 + 3)));
  2366.   uint8 *oldBits = m_Bits;
  2367.   m_Bits = new uint8[n/8+1];
  2368.   memset(m_Bits,0,(int) (n/8+1));
  2369.   if(oldBits){
  2370.      memcpy(m_Bits,oldBits,(int) (min(n,size)/8+1));
  2371.      delete oldBits;
  2372.   }
  2373.   size = n;
  2374. }
  2375.  
  2376. void CBitArray::ClearAll(){
  2377.   memset(m_Bits,0, (int) (size/8+1) );
  2378. }
  2379.  
  2380. /* CLM: Helper to gray UI items not allowed when inside Java Script
  2381.  * Note that the return value is FALSE if partial selection, 
  2382.  *   allowing the non-script text to be changed
  2383.  * Current Font Size, Color, and Character attributes will suppress
  2384.  *   setting other attributes, so it is OK to call these when mixed
  2385. */
  2386. #ifdef USE_SCRIPT
  2387.  
  2388. XP_Bool EDT_IsJavaScript(MWContext * pMWContext)
  2389. {
  2390.     if(!pMWContext) return FALSE;
  2391.     XP_Bool bRetVal = FALSE;
  2392.     EDT_CharacterData * pData = EDT_GetCharacterData(pMWContext);
  2393.     if( pData) {
  2394.         bRetVal = ( (0 != (pData->mask & TF_SERVER)) &&
  2395.                     (0 != (pData->values & TF_SERVER)) ) ||
  2396.                   ( (0 != (pData->mask & TF_STYLE)) &&
  2397.                     (0 != (pData->values & TF_STYLE)) ) ||
  2398.                   ( (0 != (pData->mask & TF_SCRIPT )) &&
  2399.                     (0 != (pData->values & TF_SCRIPT)) );
  2400.         EDT_FreeCharacterData(pData);
  2401.     }
  2402.     return bRetVal;
  2403. }
  2404.  
  2405. #else
  2406.  
  2407. XP_Bool EDT_IsJavaScript(MWContext *)
  2408. {
  2409.     return FALSE;
  2410. }
  2411.  
  2412. #endif
  2413.  
  2414. /* Helper to use for enabling Character properties 
  2415.  * (Bold, Italic, etc., but DONT use for clearing (TF_NONE)
  2416.  *  or setting Java Script (Server or Client)
  2417.  * Tests for:
  2418.  *   1. Good edit buffer and not blocked because of some action,
  2419.  *   2. Caret or selection is NOT entirely within Java Script, 
  2420.  *   3. Caret or selection has some text or is mixed selection
  2421.  *      (thus FALSE if single non-text object is selected)
  2422. */
  2423. XP_Bool EDT_CanSetCharacterAttribute(MWContext * pMWContext)
  2424. {
  2425.     if( !pMWContext || pMWContext->waitingMode || EDT_IsBlocked(pMWContext) ){
  2426.         return FALSE;
  2427.     }
  2428.     ED_ElementType type = EDT_GetCurrentElementType(pMWContext);
  2429.     return ( (type == ED_ELEMENT_TEXT || type == ED_ELEMENT_SELECTION ||
  2430.               type >= ED_ELEMENT_TABLE) && !EDT_IsJavaScript(pMWContext) );
  2431. }
  2432.  
  2433. // XP string defines for FontFaces
  2434.  
  2435. extern "C" {
  2436. #include "xpgetstr.h"
  2437. #define WANT_ENUM_STRING_IDS
  2438. #include "allxpstr.h"
  2439. #undef WANT_ENUM_STRING_IDS
  2440. }
  2441.  
  2442. int iFontFaces[] = {
  2443.     XP_NSFONT_DEFAULT,
  2444.     XP_NSFONT_FIXED,
  2445.     XP_NSFONT_ARIAL,
  2446.     XP_NSFONT_TIMES,
  2447.     XP_NSFONT_COURIER
  2448. };
  2449.  
  2450. // IDs for the list of fonts written to the tags
  2451. // MUST CORRESPOND IN NUMBER AND LOCATION TO iFontFaces!
  2452. int iFontFaceTags[] = {
  2453.     0, 0,
  2454.     XP_NSFONTLIST_ARIAL,
  2455.     XP_NSFONTLIST_TIMES,
  2456.     XP_NSFONTLIST_COURIER
  2457. };
  2458. #define ED_NSFONT_MAX ((sizeof(iFontFaceTags))/sizeof(int))
  2459.  
  2460. // Cache the lists of font faces that we show to user
  2461. //  and list of tags (no shown to user)
  2462. static char * pFontFaces = NULL;
  2463. static char * pFontFaceTags = NULL;
  2464.  
  2465. char *EDT_GetFontFaces()
  2466. {
  2467.     if( pFontFaces ){
  2468.         return pFontFaces;
  2469.     }
  2470.     intn iSize = 512;
  2471.     int iCur = 0;
  2472.     pFontFaces = (char*)XP_ALLOC( iSize );
  2473.  
  2474.     if( !pFontFaces )
  2475.         return NULL;
  2476.  
  2477.     pFontFaces[0] = 0;
  2478.     pFontFaces[1] = 0;
  2479.     
  2480.     for( int i = 0; i < ED_NSFONT_MAX; i++ ){
  2481.         char *pFont = XP_GetString(iFontFaces[i]);
  2482.  
  2483.         if( pFont && *pFont ){
  2484.             int iLen = XP_STRLEN( pFont );
  2485.             if( iCur + iLen + 2 > iSize ){
  2486.                 iSize += 512;
  2487.                 pFontFaces = (char*)XP_REALLOC( pFontFaces, iSize );
  2488.  
  2489.                 if( ! pFontFaces ){
  2490.                     return NULL;
  2491.                 }
  2492.             }
  2493.             XP_STRCPY( &pFontFaces[iCur], pFont );
  2494.             iCur += iLen+1;
  2495.         }
  2496.     }
  2497.     // Append extra '\0' at end
  2498.     pFontFaces[iCur] = 0;
  2499.  
  2500.     return pFontFaces;
  2501. }
  2502.  
  2503. char *EDT_GetFontFaceTags()
  2504. {
  2505.     if( pFontFaceTags ){
  2506.         return pFontFaceTags;
  2507.     }
  2508.     intn iSize = 2024;
  2509.     pFontFaceTags = (char*)XP_ALLOC( iSize );
  2510.  
  2511.     if( !pFontFaceTags )
  2512.         return NULL;
  2513.  
  2514.     // First 2 strings are ignored - map to default proportional and fixed
  2515.     XP_STRCPY(pFontFaceTags, " ");
  2516.     XP_STRCPY(&pFontFaceTags[2], " ");
  2517.     int iCur = 4; // Start at 4th character - after above strings
  2518.     pFontFaceTags[5] = 0; // Add extra 0 in case there are no more strings
  2519.  
  2520.     for( int i = 2; i < ED_NSFONT_MAX; i++ ){
  2521.         char *pFont = XP_GetString(iFontFaceTags[i]);
  2522.  
  2523.         if( pFont && *pFont ){
  2524.             int iLen = XP_STRLEN( pFont );
  2525.             if( iCur + iLen + 2 > iSize ){
  2526.                 iSize += 2024;
  2527.                 pFontFaceTags = (char*)XP_REALLOC( pFontFaceTags, iSize );
  2528.  
  2529.                 if( ! pFontFaceTags ){
  2530.                     return NULL;
  2531.                 }
  2532.             }
  2533.             XP_STRCPY( &pFontFaceTags[iCur], pFont );
  2534.             iCur += iLen+1;
  2535.         }
  2536.     }
  2537.     // Append extra '\0' at end
  2538.     pFontFaceTags[iCur] = 0;
  2539.  
  2540.     return pFontFaceTags;
  2541. }
  2542.  
  2543. #define EDT_CLEAR_BIT(x,tf) x &= ~tf
  2544. #define EDT_SET_BIT(x,tf)   x |= tf
  2545.  
  2546. void EDT_SetFontFace(MWContext * pMWContext, EDT_CharacterData * pCharacterData,
  2547.                      int iFontIndex, char * pFontFace )
  2548. {
  2549.     // Must have one or the other
  2550.     if( pMWContext == NULL && pCharacterData == NULL )
  2551.         return;
  2552. #if defined(XP_WIN) || defined(XP_OS2)
  2553.     // Windows may give us this if click off of the font combobox
  2554.     if( (long)pFontFace == -1L )
  2555.         return;
  2556. #endif
  2557.  
  2558.     EDT_CharacterData * pData;
  2559.     XP_Bool bCanCopy;
  2560.     XP_Bool bHaveData;
  2561.  
  2562.     // Only 0 and 1 have any meaning now that XP groups are "automatic"
  2563.     if( iFontIndex < 0 || iFontIndex > 1 ){
  2564.         iFontIndex = -1;
  2565.     }
  2566.     if( pCharacterData ){
  2567.         // Use supplied structure
  2568.         pData = pCharacterData;
  2569.         bHaveData = TRUE;
  2570.         // If pointer to existing data is same as new, don't copy it
  2571.         bCanCopy = pData->pFontFace != pFontFace;
  2572.         // We will respect the TF_FONT_FACE bit in existing data,
  2573.         //  but we are also interested in FIXED if we are doing
  2574.         if( pData->mask & TF_FONT_FACE ){
  2575.             EDT_SET_BIT(pData->mask, TF_FIXED);
  2576.         }
  2577.     } else {
  2578.         // No data supplied, get from current selection or at caret
  2579.         bHaveData = FALSE;
  2580.         pData = EDT_GetCharacterData(pMWContext);
  2581.         if( !pData )
  2582.             return;
  2583.         bCanCopy = TRUE;
  2584.         // Set the bit to tell that we are interested in font face
  2585.         //  and fixed width
  2586.         pData->mask = TF_FONT_FACE | TF_FIXED;
  2587.     }
  2588.  
  2589.     // Remove any existing font face data if not same as new data
  2590.     if( pData->pFontFace && bCanCopy){
  2591.         XP_FREEIF(pData->pFontFace);
  2592.     }
  2593.  
  2594.     // This will force using whatever user string was supplied
  2595.     if( pFontFace ){
  2596.         // So it will be skipped in test below
  2597.         iFontIndex = -1;
  2598.         if( bCanCopy) {
  2599.             // Translate into XP font "group" if face is found in any group
  2600.             char *pTranslated = EDT_TranslateToXPFontFace(pFontFace);
  2601.             if( *pTranslated == '_' ){
  2602.                 // First character may have signal for separator - skip over it
  2603.                 pTranslated++;
  2604.             }            
  2605.             // Detect the 1st two items -- the Default Variable and Fixed Width fonts
  2606.             if( 0 == XP_STRCMP(pTranslated, XP_GetString(iFontFaces[0])) ){
  2607.                 iFontIndex = 0;
  2608.             } else if( 0 == XP_STRCMP(pTranslated,  XP_GetString(iFontFaces[1])) ){
  2609.                 iFontIndex = 1;
  2610.             } else {
  2611.                 // Copy the font face - either same as pFontFace or the entire group if translated
  2612.                 pData->pFontFace = XP_STRDUP(pTranslated);
  2613.                 // Set font face tag - note that it is set
  2614.                 EDT_SET_BIT(pData->values, TF_FONT_FACE);
  2615.                 // We can't be fixed width if here
  2616.                 EDT_CLEAR_BIT(pData->values, TF_FIXED);
  2617.             }
  2618.         }
  2619.     } 
  2620.  
  2621.     if( iFontIndex == 0 || iFontIndex == 1 ){
  2622.         // No font face tag will be set
  2623.         EDT_CLEAR_BIT(pData->values, TF_FONT_FACE);
  2624.         
  2625.         if( iFontIndex == 1){
  2626.             // Fixed Width
  2627.             EDT_SET_BIT(pData->values, TF_FIXED);
  2628.         } else {
  2629.             // Default proportional font
  2630.             EDT_CLEAR_BIT(pData->values, TF_FIXED);
  2631.         }
  2632.     }
  2633.  
  2634.     if( pMWContext ){
  2635.         EDT_SetCharacterData(pMWContext, pData);
  2636.     }
  2637.     // Free only the data we obtained
  2638.     if( !bHaveData ){
  2639.         EDT_FreeCharacterData(pData);
  2640.     }
  2641. }
  2642.  
  2643. char * EDT_TranslateToXPFontFace( char * pFontFace )
  2644. {
  2645.     char * pFontFaceTags = EDT_GetFontFaceTags();
  2646.     if( pFontFaceTags ){
  2647.         char * pFace = pFontFace;
  2648.         // Skip over initial separator signal
  2649.         if( *pFace == '_' ){
  2650.             pFace++;
  2651.         }
  2652.         // Skip over first two strings (each contains " ")
  2653.         char * pTag = pFontFaceTags+4;
  2654.         int iLen;    
  2655.         int i = 0;
  2656.         while( (iLen = XP_STRLEN(pTag)) > 0 ) {
  2657.             char * pComma;
  2658.             char * pTagFace = pTag;
  2659.             // Scan for comma separating the next font in group
  2660.             while( (pComma = XP_STRCHR(pTagFace,',')) != 0 ){
  2661.                 *pComma = '\0';
  2662.                 int iFaceLen = XP_STRLEN(pTagFace);
  2663.                 XP_Bool bFound = (0 == XP_STRCMP(pTagFace, pFace));
  2664.                 *pComma = ',';
  2665.                 if( bFound ){
  2666.                     // We found the font in the list - we're done
  2667.                     return pTag;
  2668.                 }
  2669.                 pTagFace += iFaceLen+1;
  2670.             }
  2671.             // Check one more time - either no commas found or 
  2672.             //  pFace is on the last font in the group
  2673.             if( 0 == XP_STRCMP(pTagFace, pFace) ){
  2674.                 return pTag;
  2675.             }
  2676.     
  2677.             pTag += iLen+1;
  2678.             i++;
  2679.         }
  2680.     }
  2681.     // Return exactly what we were passed if not found in font groups    
  2682.     return pFontFace;
  2683. }
  2684.  
  2685.  
  2686. // Cache the list of colors that we show to user
  2687. //static char * pFontColors = NULL;
  2688.  
  2689. // Use this array instead of pFontColor list
  2690. // This replaces the XP_Strings colors
  2691. uint8 NSColors[MAX_NS_COLORS][3] = 
  2692. { { 255,255,255 },
  2693.   { 204,204,204 },
  2694.   { 192,192,192 },
  2695.   { 153,153,153 },
  2696.   { 102,102,102 },
  2697.   { 51,51,51 },   
  2698.   { 0,0,0 },      
  2699.   { 255,204,204 },
  2700.   { 255,102,102 },
  2701.   { 255,0,0 },    
  2702.   { 204,0,0 },    
  2703.   { 153,0,0 },    
  2704.   { 102,0,0 },    
  2705.   { 51,0,0 },     
  2706.   { 255,204,153 },
  2707.   { 255,204,51 }, 
  2708.   { 255,153,0 },  
  2709.   { 255,102,0 },  
  2710.   { 204,102,0 },  
  2711.   { 153,51,0 },   
  2712.   { 102,51,0 },   
  2713.   { 255,255,153 },
  2714.   { 255,255,102 },
  2715.   { 255,204,102 },
  2716.   { 255,204,51 }, 
  2717.   { 204,153,51 }, 
  2718.   { 153,102,51 }, 
  2719.   { 102,51,51 },  
  2720.   { 255,255,204 },
  2721.   { 255,255,153 },
  2722.   { 255,255,0 },  
  2723.   { 255,204,0 },  
  2724.   { 153,153,0 },  
  2725.   { 102,102,0 },  
  2726.   { 51,51,0 },    
  2727.   { 153,255,153 },
  2728.   { 102,255,153 },
  2729.   { 51,255,51 },  
  2730.   { 0,204,0 },    
  2731.   { 0,153,0 },    
  2732.   { 0,102,0 },    
  2733.   { 0,51,0 },     
  2734.   { 153,255,255 },
  2735.   { 51,255,255 }, 
  2736.   { 102,204,204 },
  2737.   { 0,204,204 },  
  2738.   { 51,153,153 }, 
  2739.   { 51,102,102 }, 
  2740.   { 0,51,51 },    
  2741.   { 204,255,255 },
  2742.   { 102,255,255 },
  2743.   { 51,204,255 }, 
  2744.   { 51,102,255 }, 
  2745.   { 51,51,255 },  
  2746.   { 0,0,153 },    
  2747.   { 0,0,102 },    
  2748.   { 204,204,255 },
  2749.   { 153,153,204 },
  2750.   { 102,102,204 },
  2751.   { 102,51,255 }, 
  2752.   { 102,0,204 },  
  2753.   { 51,51,153 },  
  2754.   { 51,0,153 },   
  2755.   { 255,204,255 },
  2756.   { 255,153,255 },
  2757.   { 204,102,204 },
  2758.   { 204,51,204 }, 
  2759.   { 153,51,102 }, 
  2760.   { 102,51,102 }, 
  2761.   { 51,0,51 } };    
  2762.  
  2763. void EDT_GetNSColor(intn iIndex, LO_Color * pLoColor)
  2764. {
  2765.     if( pLoColor && iIndex < MAX_NS_COLORS )
  2766.     {
  2767.         pLoColor->red = NSColors[iIndex][0];
  2768.         pLoColor->green = NSColors[iIndex][1];
  2769.         pLoColor->blue = NSColors[iIndex][2];
  2770.     }
  2771. }
  2772.  
  2773. /* Return list of font colors in format: "r,g,b,ColorName" where colors for r,g,b
  2774.  *  are decimal strings in range 0-255
  2775. */
  2776. #if defined(XP_UNIX)
  2777. char *EDT_GetFontColors()
  2778. {
  2779.     return NULL;
  2780.  
  2781. #if 0
  2782.     if( pFontColors )
  2783.         return pFontColors;
  2784.  
  2785.     intn iSize = 512;
  2786.     int iCur = 0;
  2787.     pFontColors = (char*)XP_ALLOC( iSize );
  2788.  
  2789.     if( !pFontColors )
  2790.         return NULL;
  2791.  
  2792.     pFontColors[0] = 0;
  2793.     pFontColors[1] = 0;
  2794.     
  2795.     int nIDColor = XP_NSCOLOR_BASE;
  2796.     while( nIDColor < XP_NSCOLOR_END){
  2797.         char *pColor = XP_GetString(nIDColor);
  2798.  
  2799.         if( pColor && *pColor ){
  2800.             int iLen = XP_STRLEN( pColor );
  2801.             if( iCur + iLen + 2 > iSize ){
  2802.                 iSize += 512;
  2803.                 pFontColors = (char*)XP_REALLOC( pFontColors, iSize );
  2804.  
  2805.                 if( ! pFontColors ){
  2806.                     return NULL;
  2807.                 }
  2808.             }
  2809.             XP_STRCPY( &pFontColors[iCur], pColor );
  2810.             iCur += iLen+1;
  2811.         }
  2812.         // Next color ID
  2813.         nIDColor++;
  2814.     }
  2815.     // Append extra '\0' at end
  2816.     pFontColors[iCur] = 0;
  2817.     return pFontColors;
  2818. #endif
  2819. }
  2820. #endif
  2821.  
  2822. char * EDT_ParseColorString(LO_Color * pLoColor, char * pColorString)
  2823. {
  2824.     XP_ASSERT(pLoColor);
  2825.     XP_ASSERT(pColorString);
  2826.  
  2827.     char *pComma = XP_STRCHR(pColorString, ',');
  2828.     if(!pComma) return pColorString;
  2829.  
  2830.     *pComma = '\0';
  2831.     pLoColor->red = (uint8)atoi(pColorString);
  2832.     *pComma = ',';
  2833.     char *pColor = pComma+1;
  2834.  
  2835.     pComma = XP_STRCHR(pColor, ',');
  2836.     if(!pComma) return pColor;
  2837.     *pComma = '\0';
  2838.     pLoColor->green = (uint8)atoi(pColor);
  2839.     *pComma = ',';
  2840.     pColor = pComma+1;
  2841.  
  2842.     pComma = XP_STRCHR(pColor, ',');
  2843.     // If no comma found, assume color string
  2844.     //  doesn't have HTML-HEX format and 
  2845.     //  all thats left is the blue value
  2846.     if(pComma) 
  2847.         *pComma = '\0';
  2848.     pLoColor->blue = (uint8)atoi(pColor);
  2849.     if(pComma) 
  2850.     {
  2851.         *pComma = ',';
  2852.         pColor = pComma+1;
  2853.         // Return rest of string, assumned to be Hex representation
  2854.         return pColor;
  2855.     }
  2856.  
  2857.     // Supply a hex translation
  2858.     static char pHexColor[16];
  2859.     XP_SPRINTF(pHexColor, "#%02X%02X%02X", pLoColor->red, pLoColor->green, pLoColor->blue);
  2860.     return pHexColor;
  2861. }
  2862.  
  2863. /* Scan our list of colors and return index of matching color
  2864.  *   or -1 if no match found. We NEVER return 0 (default color)
  2865. */
  2866. int EDT_GetMatchingFontColorIndex(LO_Color * pLOColor)
  2867. {
  2868.     for( intn i = 0; i < MAX_NS_COLORS; i++ )
  2869.     {
  2870.         if( NSColors[i][0] == pLOColor->red &&
  2871.             NSColors[i][1] == pLOColor->green &&
  2872.             NSColors[i][2] == pLOColor->blue ){
  2873.             return (i+1);
  2874.         }
  2875.     }
  2876.     return -1;
  2877. }
  2878.  
  2879.  
  2880. #ifdef DEBUG
  2881.  
  2882. // Automated test routine hook
  2883.  
  2884. const char* CEditTestManager::m_kTrigger = "$$$Test";
  2885.  
  2886. CEditTestManager::CEditTestManager(CEditBuffer* pBuffer)
  2887.     : m_pBuffer(pBuffer),
  2888.       m_bTesting(FALSE),
  2889.       m_iTriggerIndex(0),
  2890.       m_pSaveBuffer(0),
  2891.       m_pTempFileURL(0)
  2892. {
  2893. #ifdef XP_WIN32
  2894.     _CrtMemCheckpoint( &m_state ); // In theorey, avoid measuring the data before we were created.
  2895. #endif
  2896.  
  2897.     PowerOnTest();
  2898. }
  2899.  
  2900. void CEditTestManager::DumpMemoryDelta() {
  2901.     m_pBuffer->Trim(); // Clear out undo/redo log to simplify memory statistics.
  2902. #ifdef XP_WIN32
  2903.     _CrtMemDumpAllObjectsSince( &m_state );
  2904.     _CrtMemCheckpoint( &m_state );
  2905. #else
  2906.     XP_TRACE(("Not supported on this OS.\n"));
  2907. #endif
  2908. }
  2909.  
  2910. XP_Bool CEditTestManager::Key(char key) {
  2911.     XP_Bool result = m_bTesting;
  2912.     if ( ! m_bTesting ){
  2913.         if ( key == m_kTrigger[m_iTriggerIndex] ) {
  2914.             m_iTriggerIndex++;
  2915.             if ( m_kTrigger[m_iTriggerIndex] == '\0' ) {
  2916.                 m_bTesting = TRUE;
  2917.                 XP_TRACE(("Testing on! Type # of test, or Q to quit."));
  2918.             }
  2919.         }
  2920.         else {
  2921.             m_iTriggerIndex = 0;
  2922.         }
  2923.     }
  2924.     else {
  2925.         int bQuitTesting = FALSE;
  2926.         m_bTesting = FALSE; // So when the tests type, it doesn't cause a recursion into the test code.
  2927.         intn bTestResult = -1;
  2928.         if ( key >= 'A' && key <= 'Z' ) key = key + ('a' - 'A');
  2929.         switch (key) {
  2930.             case 'q':
  2931.                 bQuitTesting = TRUE;
  2932.                 XP_TRACE(("Quitting test mode."));
  2933.                 break;
  2934.             case 'a':
  2935.                 DumpLoElements();
  2936.                 break;
  2937.             case 'b':
  2938.                 VerifyLoElements();
  2939.                 break;
  2940.             case 'c':
  2941.                 DumpDocumentContents();
  2942.                 break;
  2943.             case 'd':
  2944.                 DumpMemoryDelta();
  2945.                 break;
  2946.             case 'g':
  2947.                 GetDocTempDir();
  2948.                 break;            
  2949.             case '!':
  2950.                 PasteINTL();
  2951.                 break;
  2952.             case 'w':
  2953.                 PasteINTLText();
  2954.                 break;
  2955.  
  2956.             case 'x':
  2957.                 CopyDocumentToBuffer();
  2958.                 break;
  2959.             case 'y':
  2960.                 CopyBufferToDocument();
  2961.                 break;
  2962. #ifdef EDITOR_JAVA
  2963.             case 'j':
  2964.                 DumpPlugins();
  2965.                 break;
  2966.             case 'k':
  2967.                 PerformFirstPlugin();
  2968.                 break;
  2969.             case 'l':
  2970.                 PerformPluginByName();
  2971.                 break;
  2972.             case 'm':
  2973.                 PerformFirstEncoder();
  2974.                 break;
  2975.             case 'n':
  2976.                 PerformPreOpen();
  2977.                 break;
  2978. #endif
  2979.             case 's':
  2980.                 SaveToTempFile();
  2981.                 break;
  2982.             case 't':
  2983.                 RemoveTempFile();
  2984.                 break;
  2985.             case 'v':
  2986.                 TestHTMLPaste();
  2987.                 break;
  2988.             case '0':
  2989.                 bTestResult = EveryNavigationKeyEverywhereTest();
  2990.                 break;
  2991.             case '1':
  2992.                 bTestResult = ArrowTest();
  2993.                 break;
  2994.             case '2':
  2995.                 bTestResult = BackspaceKeyTest();
  2996.                 break;
  2997.             case '3':
  2998.                 bTestResult = DeleteKeyTest();
  2999.                 break;
  3000.             case '4':
  3001.                 bTestResult = ZeroDocumentCursorTest();
  3002.                 break;
  3003.             case '5':
  3004.                 bTestResult = OneCharDocumentCursorTest();
  3005.                 break;
  3006.             case '6':
  3007.                 bTestResult = BoldTest(10); // OneDayTest(1);
  3008.                 break;
  3009.             case '7':
  3010.                     m_pBuffer->m_bSkipValidation = TRUE;
  3011.                     bTestResult = OneDayTest(100);
  3012.                     m_pBuffer->m_bSkipValidation = FALSE;
  3013.                 break;
  3014.            case '8':
  3015.                 bTestResult = TextFETest();
  3016.                 break;
  3017.              case '?':
  3018.                  XP_TRACE(("? - type this help\n"
  3019.                     "Q - quit.\n"
  3020.                     "a - print lo-elements.\n"
  3021.                     "b - verify lo-elements.\n"
  3022.                     "c - print document contents (elements, undo history, etc.)\n"
  3023.                     "d - dump memory usage delta.\n"
  3024.                     "g - get doc temp directory. \n"
  3025.                     ));
  3026. #ifdef EDITOR_JAVA
  3027.                  XP_TRACE(("j - show Composer Plugin and Image Encoder information.\n"
  3028.                      "k - run the first composer plugin.\n"
  3029.                      "l - run a composer plugin by name.\n"
  3030.                      "m - run the first image encoder.\n"
  3031.                      "n - test the EDT_PreOpen call.\n"
  3032.                     ));
  3033. #endif
  3034.                  XP_TRACE(("q - test HTML Paste Quoted.\n"
  3035.                     ));
  3036.                  XP_TRACE(("s - save doc to temporary file.\n"
  3037.                     ));
  3038.                  XP_TRACE(("t - remove saved temporary file.\n"
  3039.                     ));
  3040.                  XP_TRACE(("x - save document state.\n"
  3041.                     "y - restore document state.\n"
  3042.                     ));
  3043.                  XP_TRACE((
  3044.                     "0 - navigation key crash test.\n"
  3045.                     "1 - arrow completeness test.\n"
  3046.                     "2 - destructive backspace test.\n"
  3047.                     "3 - destructive delete test.\n"
  3048.                     "4 - empty document cursor test.\n"
  3049.                     "5 - one character document cursor test.\n"
  3050.                     "6 - one day document test - simulate editing for one whole day 1 cycle.\n"
  3051.                     "7 - one day document test - simulate editing for one whole day 500 cycle.\n"
  3052.                      "8 - write buffer to out.txt as plain text.\n"
  3053.                    ));
  3054.                break;
  3055.             default:
  3056.                  XP_TRACE(("Type ? for help, Type # of test, or Q to quit."));
  3057.                  break;
  3058.         }
  3059.         if ( ! bQuitTesting )
  3060.         {
  3061.             m_bTesting = TRUE;
  3062.         }
  3063.         if ( bTestResult >= 0 ){
  3064.             XP_TRACE(("Test %s", bTestResult ? "Passed": "Failed"));
  3065.         }
  3066.     }
  3067.     return result;
  3068. }
  3069.  
  3070. void CEditTestManager::PowerOnTest() {
  3071.     // Test some things that have to be tested by code. This method is
  3072.     // called whenever the editor starts up in debug mode. Don't take too long.
  3073.     
  3074.     // Test that we know about all the existing tags.
  3075.     for(int i = 0; i < P_MAX; i++ ){
  3076.         EDT_TagString(i);
  3077.     }
  3078. }
  3079.  
  3080. void CEditTestManager::DumpLoElements() {
  3081.     lo_PrintLayout(m_pBuffer->m_pContext);
  3082. }
  3083.  
  3084. void CEditTestManager::VerifyLoElements() {
  3085.     lo_VerifyLayout(m_pBuffer->m_pContext);
  3086. }
  3087.  
  3088. void CEditTestManager::DumpDocumentContents(){
  3089.     CStreamOutMemory buffer;
  3090.     m_pBuffer->printState.Reset( &buffer, m_pBuffer );
  3091.     m_pBuffer->DebugPrintTree( m_pBuffer->m_pRoot );
  3092.     m_pBuffer->DebugPrintState(buffer);
  3093.     TraceLargeString(buffer.GetText());
  3094. }
  3095.  
  3096. void TraceLargeString(char* b){
  3097.     // have to dump one line at a time. XP_TRACE has a 512 char limit on Windows.
  3098.     while ( *b != '\0' ) {
  3099.         char* b2 = b;
  3100.         while ( *b2 != '\0' && *b2 != '\n'){
  3101.             b2++;
  3102.         }
  3103.         char old = *b2;
  3104.         *b2 = '\0';
  3105.         XP_TRACE(("%s", b));
  3106.         *b2 = old;
  3107.         b = b2 + 1;
  3108.         if ( old == '\0' ) break;
  3109.     }
  3110. }
  3111.  
  3112. void CEditTestManager::PasteINTL(){
  3113.     unsigned char testStringJIS[] = {'J','I','S',' ','[',27,'$','B',30,21,']',' ',0};
  3114.     unsigned char testStringEUC1[] = {'E','U','C',' ','[', 0xb0, 0};
  3115.     unsigned char tesrStringEUC2[] = {0xa1,']',' ',0};
  3116.     unsigned char testStringSJIS[] = {'S','J','I','S',' ','[',0x88,0x9f,']',0};
  3117.     
  3118.     MWContext* pContext = m_pBuffer->m_pContext;
  3119.     EDT_PasteQuoteBegin(pContext, TRUE);
  3120.     EDT_PasteQuoteINTL(pContext, (char*) testStringJIS, CS_JIS);
  3121.     EDT_PasteQuoteINTL(pContext, (char*) testStringEUC1, CS_EUCJP);
  3122.     EDT_PasteQuoteINTL(pContext, (char*) tesrStringEUC2, CS_EUCJP);
  3123.     EDT_PasteQuoteINTL(pContext, (char*) testStringSJIS, CS_SJIS);
  3124.     EDT_PasteQuoteEnd(pContext);
  3125. }
  3126.  
  3127. void CEditTestManager::PasteINTLText(){
  3128.     unsigned char testStringJIS[] = {'J','I','S',' ','[',27,'$','B',30,21,']',' ',0};
  3129.     unsigned char testStringEUC[] = {'E','U','C',' ','[', 0xb0, 0xa1,']',' ',0};
  3130.     unsigned char testStringSJIS[] = {'S','J','I','S',' ','[',0x88,0x9f,']',0};
  3131.     
  3132.     MWContext* pContext = m_pBuffer->m_pContext;
  3133.     EDT_PasteQuoteBegin(pContext, FALSE);
  3134.     EDT_PasteQuoteINTL(pContext, (char*) testStringJIS, CS_JIS);
  3135.     EDT_PasteQuoteINTL(pContext, (char*) testStringEUC, CS_EUCJP);
  3136.     EDT_PasteQuoteINTL(pContext, (char*) testStringSJIS, CS_SJIS);
  3137.     EDT_PasteQuoteEnd(pContext);
  3138. }
  3139.  
  3140. void CEditTestManager::CopyDocumentToBuffer(){
  3141.     if ( m_pSaveBuffer){
  3142.         delete[] m_pSaveBuffer;
  3143.         m_pSaveBuffer = 0;
  3144.     }
  3145.     m_pBuffer->WriteToBuffer(&m_pSaveBuffer, TRUE);
  3146.     XP_TRACE(("Buffer size: %d bytes", XP_STRLEN(m_pSaveBuffer)));
  3147. }
  3148.  
  3149. void CEditTestManager::CopyBufferToDocument(){
  3150.     if ( m_pSaveBuffer == NULL ) {
  3151.         XP_TRACE(("The save buffer is empty."));
  3152.     }
  3153.     else {
  3154.         m_pBuffer->ReadFromBuffer(m_pSaveBuffer);
  3155.     }
  3156. }
  3157.  
  3158. static const char* kChunkName[EDT_NA_COUNT] = {
  3159.     "character", "word", "line edge", "document", "updown"
  3160. };
  3161.  
  3162. XP_Bool CEditTestManager::ZeroDocumentCursorTest(){
  3163.     XP_TRACE(("ZeroDocumentCursorTest"));
  3164.     // [selection][chunk][direction][edge]
  3165.     const ElementIndex kExpectedResults[2][EDT_NA_COUNT][2][2] =
  3166.     {   // no selection
  3167.         {
  3168.             {{ 0, 0}, {0, 0} }, // EDT_NA_CHARACTER
  3169.             {{ 0, 0}, {0, 0} }, // EDT_NA_WORD
  3170.             {{ 0, 0}, {0, 0} }, // EDT_NA_LINEEDGE
  3171.             {{ 0, 0}, {0, 0} }, // EDT_NA_DOCUMENT
  3172.             {{ 0, 0}, {0, 0} }  // EDT_NA_UPDOWN
  3173.         },
  3174.         // selection
  3175.         {
  3176.             {{ 0, 0}, {0, 1} }, // EDT_NA_CHARACTER
  3177.             {{ 0, 0}, {0, 1} }, // EDT_NA_WORD
  3178.             {{ 0, 0}, {0, 1} }, // EDT_NA_LINEEDGE
  3179.             {{ 0, 0}, {0, 1} }, // EDT_NA_DOCUMENT
  3180.             {{ 0, 0}, {0, 1} }  // EDT_NA_UPDOWN
  3181.         }
  3182.     };
  3183.  
  3184.     XP_Bool result = TRUE;
  3185.     // Clear everything from existing document
  3186.     EDT_SelectAll(m_pBuffer->m_pContext);
  3187.     EDT_DeleteChar(m_pBuffer->m_pContext);
  3188.     CPersistentEditInsertPoint zero(0,FALSE);
  3189.     // Verify the cursor does the right thing for every possible cursor
  3190.     for ( int select = 0; select < 2; select++ ) {
  3191.         for ( int chunk = 0; chunk < EDT_NA_COUNT; chunk++ ) {
  3192.             for ( int direction = 0; direction < 2; direction++ ) {
  3193.                 m_pBuffer->SetInsertPoint(zero);
  3194.                 m_pBuffer->NavigateChunk(select, chunk, direction);
  3195.                 CPersistentEditSelection selection;
  3196.                 m_pBuffer->GetSelection(selection);
  3197.                 for ( int edge = 0; edge < 2; edge++ ) {
  3198.                     ElementIndex expected = kExpectedResults[select][chunk][direction][edge];
  3199.                     ElementIndex actual = selection.GetEdge(edge)->m_index;
  3200.                     if ( expected != actual ){
  3201.                         result = FALSE;
  3202.                         XP_TRACE(("selection: %s chunk: %s direction: %s edge: %s. Expected %d got %d",
  3203.                             select ? "TRUE" : "FALSE",
  3204.                             kChunkName[chunk],
  3205.                             direction ? "forward" : "back",
  3206.                             edge ? "end" : "start",
  3207.                             expected,
  3208.                             actual));
  3209.                     }
  3210.                 }
  3211.             }
  3212.         }
  3213.     }
  3214.     return result;
  3215. }
  3216.  
  3217.  
  3218. XP_Bool CEditTestManager::OneCharDocumentCursorTest(){
  3219.     XP_TRACE(("OneCharDocumentCursorTest"));
  3220.     // [startPos][selection][chunk][direction][edge]
  3221.     const ElementIndex kExpectedResults[2][2][EDT_NA_COUNT][2][2] =
  3222.     {
  3223.         // position 0
  3224.         {   // no selection
  3225.             {
  3226.                 {{ 0, 0}, {1, 1} }, // EDT_NA_CHARACTER
  3227.                 {{ 0, 0}, {1, 1} }, // EDT_NA_WORD
  3228.                 {{ 0, 0}, {1, 1} }, // EDT_NA_LINEEDGE
  3229.                 {{ 0, 0}, {1, 1} }, // EDT_NA_DOCUMENT
  3230.                 {{ 0, 0}, {0, 0} }  // EDT_NA_UPDOWN
  3231.             },
  3232.             // selection
  3233.             {
  3234.                 {{ 0, 0}, {0, 1} }, // EDT_NA_CHARACTER
  3235.                 {{ 0, 0}, {0, 1} }, // EDT_NA_WORD
  3236.                 {{ 0, 0}, {0, 2} }, // EDT_NA_LINEEDGE
  3237.                 {{ 0, 0}, {0, 2} }, // EDT_NA_DOCUMENT
  3238.                 {{ 0, 0}, {0, 2} }  // EDT_NA_UPDOWN
  3239.             }
  3240.         },
  3241.         // position 1
  3242.         {   // no selection
  3243.             {
  3244.                 {{ 0, 0}, {1, 1} }, // EDT_NA_CHARACTER
  3245.                 {{ 0, 0}, {1, 1} }, // EDT_NA_WORD
  3246.                 {{ 0, 0}, {1, 1} }, // EDT_NA_LINEEDGE
  3247.                 {{ 0, 0}, {1, 1} }, // EDT_NA_DOCUMENT
  3248.                 {{ 1, 1}, {1, 1} }  // EDT_NA_UPDOWN
  3249.             },
  3250.             // selection
  3251.             {
  3252.                 {{ 0, 1}, {1, 2} }, // EDT_NA_CHARACTER
  3253.                 {{ 0, 1}, {1, 2} }, // EDT_NA_WORD
  3254.                 {{ 0, 1}, {1, 2} }, // EDT_NA_LINEEDGE
  3255.                 {{ 0, 1}, {1, 2} }, // EDT_NA_DOCUMENT
  3256.                 {{ 0, 1}, {1, 2} }  // EDT_NA_UPDOWN
  3257.             }
  3258.         }
  3259.     };
  3260.  
  3261.     XP_Bool result = TRUE;
  3262.     // Clear everything from existing document
  3263.     EDT_SelectAll(m_pBuffer->m_pContext);
  3264.     EDT_DeleteChar(m_pBuffer->m_pContext);
  3265.     m_pBuffer->InsertChar( 'X', FALSE );
  3266.     // Verify the cursor does the right thing for every possible cursor
  3267.     for ( int startPos = 0; startPos < 2; startPos++ ){
  3268.         CPersistentEditInsertPoint p(startPos,FALSE);
  3269.         for ( int select = 0; select < 2; select++ ) {
  3270.             for ( int chunk = 0; chunk < EDT_NA_COUNT; chunk++ ) {
  3271.                 for ( int direction = 0; direction < 2; direction++ ) {
  3272.                     m_pBuffer->SetInsertPoint(p);
  3273.                     m_pBuffer->NavigateChunk(select, chunk, direction);
  3274.                     CPersistentEditSelection selection;
  3275.                     m_pBuffer->GetSelection(selection);
  3276.                     for ( int edge = 0; edge < 2; edge++ ) {
  3277.                         ElementIndex expected = kExpectedResults[startPos][select][chunk][direction][edge];
  3278.                         ElementIndex actual = selection.GetEdge(edge)->m_index;
  3279.                         if ( expected != actual ){
  3280.                             result = FALSE;
  3281.                             XP_TRACE(("position: %d selection: %s chunk: %s direction: %s edge: %s. Expected %d got %d",
  3282.                                 startPos,
  3283.                                 select ? "TRUE" : "FALSE",
  3284.                                 kChunkName[chunk],
  3285.                                 direction ? "forward" : "back",
  3286.                                 edge ? "end" : "start",
  3287.                                 expected,
  3288.                                 actual));
  3289.                         }
  3290.                     }
  3291.                 }
  3292.             }
  3293.         }
  3294.     }
  3295.     return result;
  3296. }
  3297.  
  3298. XP_Bool CEditTestManager::OneDayTest(int32 rounds) {
  3299.     char* kTitle = "One Day Test\n";
  3300.     XP_TRACE(("%s", kTitle));
  3301.     EDT_SelectAll(m_pBuffer->m_pContext);
  3302.     EDT_DeleteChar(m_pBuffer->m_pContext);
  3303.     EDT_PasteText(m_pBuffer->m_pContext, kTitle);
  3304.     for( int32 i = 0; i < rounds; i++ ) {
  3305.         XP_TRACE(("Round %d", i));
  3306.         const char* kTestString = "All work and no play makes Jack a dull boy.\nRedrum.\n";
  3307.         char c;
  3308.         for ( int j = 0;
  3309.               (c = kTestString[j]) != '\0';
  3310.             j++ ) {
  3311.             if ( c == '\n' || c == '\r') {
  3312.                 EDT_ReturnKey(m_pBuffer->m_pContext);
  3313.             }
  3314.             else {
  3315.                 EDT_KeyDown(m_pBuffer->m_pContext, c,0,0);
  3316.             }
  3317.         }
  3318.         // And delete a little.
  3319.         for ( int k = 0; k < 8; k++ ) {
  3320.             EDT_DeletePreviousChar(m_pBuffer->m_pContext);
  3321.         }
  3322.     }
  3323.     XP_TRACE(("End of %s.", kTitle));
  3324.     return TRUE;
  3325. }
  3326.  
  3327. static void TextFETestDone(PrintSetup *setup) {
  3328.     XP_FileClose(setup->out);
  3329.     XP_TRACE(("Finished TextFETest."));
  3330. }
  3331.  
  3332.  
  3333. XP_Bool CEditTestManager::TextFETest() {
  3334.     PrintSetup setup;
  3335.     char *_srcName = 0;
  3336.     char *srcName = 0;
  3337.     char *srcURL = 0;
  3338.     char *destName = 0;
  3339.     XP_File destFile = 0;
  3340.     URL_Struct *srcURLS = 0;
  3341.     XP_Bool ret = FALSE;
  3342.     ED_FileError result;
  3343.  
  3344.     ////  Write the edit buffer to a temporary file as HTML.
  3345.     // Get the filename of a temporary file.
  3346. #ifdef XP_MAC
  3347.     _srcName = WH_TempName(xpFileToPost,"ns");
  3348. #else
  3349.     _srcName = WH_TempName(xpTemporary,"ns");
  3350. #endif
  3351.     if (!_srcName)
  3352.         goto CLEAN_UP;
  3353.  
  3354.     // Is this necessary for some Mac magic to work?
  3355.     srcName = WH_FilePlatformName(_srcName);
  3356.     if (!srcName)
  3357.         goto CLEAN_UP;
  3358.  
  3359.     srcURL = XP_PlatformFileToURL(srcName);
  3360.     if (!srcURL)
  3361.         goto CLEAN_UP;
  3362.  
  3363.     result = EDT_SaveFile(m_pBuffer->m_pContext,
  3364.                                         srcURL,srcURL,
  3365.                                         FALSE,FALSE,FALSE);
  3366.     if (result != ED_ERROR_NONE)
  3367.         goto CLEAN_UP;
  3368.     XP_TRACE(("Created %s",srcURL));
  3369.  
  3370.  
  3371.     // The converted plain text will go to "out.txt".
  3372.     destName = XP_STRDUP("out.txt");
  3373.     if (!destName)
  3374.         goto CLEAN_UP;
  3375.  
  3376.     destFile = XP_FileOpen(destName,xpFileToPost,XP_FILE_WRITE_BIN);
  3377.     if (!destFile)
  3378.         goto CLEAN_UP;
  3379.  
  3380.  
  3381.     //// Call XL_Translate text to convert src to dest, TextFETestDone will be called on
  3382.     // completion.
  3383.     srcURLS = NET_CreateURLStruct(srcURL,NET_DONT_RELOAD);
  3384.     if (!srcURLS) {
  3385.         XP_FileClose(destFile);
  3386.         goto CLEAN_UP;
  3387.     }
  3388.  
  3389.     XL_InitializeTextSetup(&setup);
  3390.     setup.url = srcURLS;
  3391.     setup.completion = TextFETestDone;
  3392.     setup.out = destFile;
  3393.  
  3394.     // Seems that passed in MWcontext is only used to copy some info when making the
  3395.     // temporary text context.
  3396.     XL_TranslateText(m_pBuffer->m_pContext,srcURLS,&setup);
  3397.     ret = TRUE;
  3398.  
  3399.  
  3400. // Nasty, a goto.
  3401. CLEAN_UP:
  3402.     if (_srcName)
  3403.         XP_FREE(_srcName);
  3404.     if (srcName)
  3405.         XP_FREE(srcName);
  3406.     if (srcURL)
  3407.         XP_FREE(srcURL);
  3408.     if (destName)
  3409.         XP_FREE(destName);
  3410.  
  3411.     return ret;
  3412. }
  3413.  
  3414. XP_Bool CEditTestManager::BoldTest(int32 rounds) {
  3415.     char* kTitle = "Bold Test\n";
  3416.     XP_TRACE(("%s", kTitle));
  3417.     EDT_SelectAll(m_pBuffer->m_pContext);
  3418.     EDT_DeleteChar(m_pBuffer->m_pContext);
  3419.     EDT_PasteText(m_pBuffer->m_pContext, kTitle);
  3420.     EDT_SelectAll(m_pBuffer->m_pContext);
  3421.     for( int32 i = 0; i < rounds; i++ ) {
  3422.         XP_TRACE(("Round %d", i));
  3423.         EDT_CharacterData* normal = EDT_GetCharacterData( m_pBuffer->m_pContext );
  3424.         EDT_CharacterData* bold = EDT_GetCharacterData( m_pBuffer->m_pContext );
  3425.         bold->mask = TF_BOLD;
  3426.         bold->values = TF_BOLD;
  3427.         EDT_SetCharacterData(m_pBuffer->m_pContext, bold);
  3428.         EDT_SetCharacterData(m_pBuffer->m_pContext, normal);
  3429.         EDT_FreeCharacterData(normal);
  3430.         EDT_FreeCharacterData(bold);
  3431.     }
  3432.     XP_TRACE(("End of %s.", kTitle));
  3433.     return TRUE;
  3434. }
  3435.  
  3436. XP_Bool CEditTestManager::EveryNavigationKeyEverywhereTest() {
  3437.     // Does navigation work from every position?
  3438.     XP_Bool result;
  3439.     result = NavigateChunkCrashTest() && UArrowTest(FALSE) && UArrowTest(TRUE) 
  3440.                 && DArrowTest(FALSE) && DArrowTest(TRUE);
  3441.     XP_TRACE(("Done.\n"));
  3442.     return result;
  3443. }
  3444.  
  3445. XP_Bool CEditTestManager::ArrowTest() {
  3446.     // Does the navigation move smoothly through the document?
  3447.     XP_Bool result;
  3448.     result = LArrowTest(FALSE) || LArrowTest(TRUE) || RArrowTest(FALSE)
  3449.                 || RArrowTest(TRUE) || UArrowTest(TRUE) || DArrowTest(TRUE);
  3450. #if 0
  3451.     // Too many false positives -- need to know about up/down at first/last line
  3452.     result |= UArrowTest(FALSE);
  3453.     result |= DArrowTest(FALSE);
  3454. #endif
  3455.     XP_TRACE(("Done.\n"));
  3456.     return result;
  3457. }
  3458.  
  3459. void CEditTestManager::GetWholeDocumentSelection(CPersistentEditSelection& selection){
  3460.     CEditSelection wholeDocument;
  3461.     m_pBuffer->m_pRoot->GetAll(wholeDocument);
  3462.     selection = m_pBuffer->EphemeralToPersistent(wholeDocument);
  3463.     // Ignore the last 2 positions -- it's the EOF marker
  3464.     selection.m_end.m_index -= 2;
  3465. }
  3466.  
  3467. XP_Bool CEditTestManager::NavigateChunkCrashTest(){
  3468.     for ( int select = 0; select < 2; select++ ) {
  3469.         for ( int chunk = 0; chunk < EDT_NA_COUNT; chunk++ ) {
  3470.             for ( int direction = 0; direction < 2; direction++ ) {
  3471.                 if ( !NavChunkCrashTest(select, chunk, direction) )
  3472.                     return FALSE;
  3473.             }
  3474.         }
  3475.     }
  3476.     return TRUE;
  3477. }
  3478.  
  3479. XP_Bool CEditTestManager::NavChunkCrashTest(XP_Bool bSelect, int chunk, XP_Bool bDirection){
  3480.     XP_Bool bResult = TRUE;
  3481.     CPersistentEditSelection w;
  3482.     GetWholeDocumentSelection(w);
  3483.     CPersistentEditInsertPoint p;
  3484.     XP_TRACE(("NavChunkCrashTest bSelect = %d chunk = %d bDirection = %d\n", bSelect, chunk, bDirection));
  3485.  
  3486.     for ( p = w.m_start;
  3487.         p.m_index < w.m_end.m_index;
  3488.         p.m_index++ ) {
  3489.         m_pBuffer->SetInsertPoint(p);
  3490.         m_pBuffer->NavigateChunk(bSelect, chunk, bDirection);
  3491.     }
  3492.     return bResult;
  3493. }
  3494.  
  3495. XP_Bool CEditTestManager::RArrowTest(XP_Bool bSelect){
  3496.     XP_Bool result = TRUE;
  3497.     CPersistentEditSelection w;
  3498.     GetWholeDocumentSelection(w);
  3499.     CPersistentEditInsertPoint p;
  3500.     XP_TRACE(("Right Arrow%s\n", bSelect ? " with shift key" : ""));
  3501.  
  3502.     for ( p = w.m_start;
  3503.         p.m_index < w.m_end.m_index;
  3504.         p.m_index++ ) {
  3505.         m_pBuffer->SetInsertPoint(p);
  3506.         m_pBuffer->NavigateChunk(bSelect, LO_NA_CHARACTER, TRUE);
  3507.         CPersistentEditSelection s2;
  3508.         m_pBuffer->GetSelection(s2);
  3509.         if ( (bSelect == s2.IsInsertPoint()) ||
  3510.             s2.m_end.m_index != p.m_index + 1 ) {
  3511.             XP_TRACE(("%d should be %d was %d\n", p.m_index,
  3512.                 p.m_index + 1, s2.m_end.m_index));
  3513.             result = FALSE;
  3514.         }
  3515.     }
  3516.     return result;
  3517. }
  3518.  
  3519. XP_Bool CEditTestManager::LArrowTest(XP_Bool bSelect){
  3520.     XP_Bool result = TRUE;
  3521.     CPersistentEditSelection w;
  3522.     GetWholeDocumentSelection(w);
  3523.     CPersistentEditInsertPoint p(0,TRUE);
  3524.     XP_TRACE(("Left Arrow Test%s\n", bSelect ? " with shift key" : ""));
  3525.  
  3526.     for ( p.m_index = w.m_end.m_index - 1;
  3527.         p.m_index > w.m_start.m_index;
  3528.         p.m_index-- ) {
  3529.  
  3530.         CEditSelection startSelection;
  3531.         CPersistentEditSelection s2;
  3532.  
  3533.         p.m_bStickyAfter = TRUE;
  3534.         m_pBuffer->SetInsertPoint(p);
  3535.  
  3536.         m_pBuffer->GetSelection(startSelection);
  3537.         if ( startSelection.m_start.GapWithBothSidesAllowed() && ! bSelect ) {
  3538.             // XP_TRACE(("%d - gap with both sides allowed.", p.m_index));
  3539.             // Test that SetInsertPoint did the right thing.
  3540.             m_pBuffer->GetSelection(s2);
  3541.             if ( ! s2.IsInsertPoint() || !s2.m_start.IsEqualUI(p) ) {
  3542.                 XP_TRACE(("SetInsertPoint at %d should be %d.%d was %d.%d\n", p.m_index,
  3543.                     p.m_index, p.m_bStickyAfter,
  3544.                     s2.m_start.m_index, s2.m_start.m_bStickyAfter));
  3545.                 result = FALSE;
  3546.             }
  3547.             // Test hump over soft break
  3548.             m_pBuffer->NavigateChunk(bSelect, LO_NA_CHARACTER, FALSE);
  3549.             m_pBuffer->GetSelection(s2);
  3550.             CPersistentEditInsertPoint expected = p;
  3551.             expected.m_bStickyAfter = FALSE;
  3552.             if ( ! s2.IsInsertPoint() || !s2.m_start.IsEqualUI(expected) ) {
  3553.                 XP_TRACE(("gap at %d should be %d.%d was %d.%d\n", p.m_index,
  3554.                     expected.m_index, expected.m_bStickyAfter,
  3555.                     s2.m_start.m_index, s2.m_start.m_bStickyAfter));
  3556.                 result = FALSE;
  3557.             }
  3558.             p.m_bStickyAfter = FALSE;
  3559.             m_pBuffer->SetInsertPoint(p);
  3560.         }
  3561.         m_pBuffer->NavigateChunk(bSelect, LO_NA_CHARACTER, FALSE);
  3562.         m_pBuffer->GetSelection(s2);
  3563.         if ( bSelect == s2.IsInsertPoint() ) {
  3564.             XP_TRACE(("%d Wrong type of selection. Expected %d.%d was %d.%d\n", p.m_index,
  3565.                 p.m_index, p.m_bStickyAfter,
  3566.                 s2.m_start.m_index, s2.m_start.m_bStickyAfter));
  3567.             result = FALSE;
  3568.         }
  3569.         else if ( s2.m_start.m_index != p.m_index - 1 ) {
  3570.             XP_TRACE(("%d wrong edge position. Should be %d.%d was %d.%d\n", p.m_index,
  3571.                 p.m_index-1, p.m_bStickyAfter,
  3572.                 s2.m_start.m_index, s2.m_start.m_bStickyAfter));
  3573.             result = FALSE;
  3574.         }
  3575.     }
  3576.     return result;
  3577. }
  3578.  
  3579. XP_Bool CEditTestManager::UArrowTest(XP_Bool bSelect){
  3580.     XP_Bool result = TRUE;
  3581.     CPersistentEditSelection w;
  3582.     GetWholeDocumentSelection(w);
  3583.     CPersistentEditInsertPoint p;
  3584.     XP_TRACE(("Up Arrow Test%s\n", bSelect ? " with shift key" : ""));
  3585.  
  3586.     for ( p = w.m_end.m_index - 1;
  3587.         p.m_index > w.m_start.m_index;
  3588.         p.m_index-- ) {
  3589.         m_pBuffer->SetInsertPoint(p);
  3590.         CPersistentEditSelection s;
  3591.         m_pBuffer->GetSelection(s);
  3592.         m_pBuffer->ClearMove();
  3593.         m_pBuffer->UpDown(bSelect, FALSE);
  3594.         CPersistentEditSelection s2;
  3595.         m_pBuffer->GetSelection(s2);
  3596.         if ( s2 == s ) {
  3597.             XP_TRACE(("%d didn't change selection\n", p.m_index));
  3598.             result = FALSE;
  3599.         }
  3600.     }
  3601.     return result;
  3602. }
  3603.  
  3604.  
  3605. XP_Bool CEditTestManager::DArrowTest(XP_Bool bSelect){
  3606.     XP_Bool result = TRUE;
  3607.     CPersistentEditSelection w;
  3608.     GetWholeDocumentSelection(w);
  3609.     CPersistentEditInsertPoint p;
  3610.     XP_TRACE(("Down Arrow Test%s\n", bSelect ? " with shift key" : ""));
  3611.  
  3612.     for ( p = w.m_start.m_index;
  3613.         p.m_index < w.m_end.m_index;
  3614.         p.m_index++ ) {
  3615.         m_pBuffer->SetInsertPoint(p);
  3616.         CPersistentEditSelection s;
  3617.         m_pBuffer->GetSelection(s);
  3618.         m_pBuffer->ClearMove();
  3619.         m_pBuffer->UpDown(bSelect, TRUE);
  3620.         CPersistentEditSelection s2;
  3621.         m_pBuffer->GetSelection(s2);
  3622.         if ( s2 == s ) {
  3623.             XP_TRACE(("%d didn't change selection\n", p.m_index));
  3624.             result = FALSE;
  3625.         }
  3626.     }
  3627.     return result;
  3628. }
  3629.  
  3630. XP_Bool CEditTestManager::BackspaceKeyTest(){
  3631.     XP_Bool result = TRUE;
  3632.     CPersistentEditSelection w;
  3633.     GetWholeDocumentSelection(w);
  3634.     CPersistentEditInsertPoint p;
  3635.     XP_TRACE(("DeleteKeyTest"));
  3636.     p = w.m_end;
  3637.     p.m_index--;
  3638.     m_pBuffer->SetInsertPoint(p);
  3639.     for ( p = w.m_start.m_index;
  3640.         p.m_index < w.m_end.m_index;
  3641.         p.m_index++ ) {
  3642.         m_pBuffer->DeletePreviousChar();
  3643.     }
  3644.     return result;
  3645. }
  3646.  
  3647. XP_Bool CEditTestManager::DeleteKeyTest(){
  3648.     XP_Bool result = TRUE;
  3649.     CPersistentEditSelection w;
  3650.     GetWholeDocumentSelection(w);
  3651.     CPersistentEditInsertPoint p;
  3652.     XP_TRACE(("DeleteKeyTest"));
  3653.  
  3654.     m_pBuffer->SetInsertPoint(w.m_start);
  3655.     for ( p = w.m_start.m_index;
  3656.         p.m_index < w.m_end.m_index;
  3657.         p.m_index++ ) {
  3658.         m_pBuffer->DeleteNextChar();
  3659.     }
  3660.     return result;
  3661. }
  3662.  
  3663. XP_Bool CEditTestManager::Backspace() {
  3664.     if ( ! m_bTesting ){
  3665.         m_iTriggerIndex--;
  3666.         if (m_iTriggerIndex < 0 ) m_iTriggerIndex = 0;
  3667.     }
  3668.     return m_bTesting;
  3669. }
  3670.  
  3671. XP_Bool CEditTestManager::ReturnKey() {
  3672.     if ( ! m_bTesting ){
  3673.         m_iTriggerIndex = 0;
  3674.     }
  3675.     return m_bTesting;
  3676. }
  3677.  
  3678. #ifdef EDITOR_JAVA
  3679.  
  3680. void CEditTestManager::DumpPlugins(){
  3681.     XP_TRACE(("Dump Plugin database."));
  3682.     int32 numCategories = EDT_NumberOfPluginCategories();
  3683.     XP_TRACE(("EDT_NumberOfPluginCategories: %d", numCategories));
  3684.     for(int category = 0; category < numCategories; category++ ) {
  3685.         char* pcsCategoryName = EDT_GetPluginCategoryName(category);
  3686.         XP_TRACE(("EDT_GetPluginCategoryName(%d) = \"%s\"", category, pcsCategoryName));
  3687.         int plugins = EDT_NumberOfPlugins(category);
  3688.         XP_TRACE(("EDT_NumberOfPlugins(%d) = %d", category, plugins));
  3689.         for(int plugin = 0; plugin < plugins; plugin++){
  3690.             char* pcsPluginName = EDT_GetPluginName(category, plugin);
  3691.             XP_TRACE(("EDT_GetPluginName(%d, %d) = \"%s\"", category, plugin, pcsPluginName));
  3692.             char* pcsPluginMenuHelp = EDT_GetPluginMenuHelp(category, plugin);
  3693.             XP_TRACE(("EDT_GetPluginMenuHelp(%d, %d) = \"%s\"", category, plugin, pcsPluginMenuHelp));
  3694.         }
  3695.     }
  3696.     XP_TRACE(("Dump Image Encoder database."));
  3697.     int encoders = EDT_NumberOfEncoders();
  3698.     XP_TRACE(("EDT_NumberOfEncoders() = %d", encoders));
  3699.     for(int encoder = 0; encoder < encoders; encoder++){
  3700.         char* pcsEncoderName = EDT_GetEncoderName(encoder);
  3701.         XP_TRACE(("EDT_GetEncoderName(%d) = \"%s\"", encoder, pcsEncoderName));
  3702.  
  3703.         char* pcsEncoderFileExtension = EDT_GetEncoderFileExtension(encoder);
  3704.         XP_TRACE(("EDT_GetEncoderFileExtension(%d) = \"%s\"", encoder, pcsEncoderFileExtension));
  3705.  
  3706.         char* pcsEncoderFileType = EDT_GetEncoderFileType(encoder);
  3707.         XP_TRACE(("EDT_GetEncoderFileType(%d) = \"%s\"", encoder, pcsEncoderFileType));
  3708.  
  3709.         XP_TRACE(("EDT_GetEncoderNeedsQuantizedSource(%d) = \"%d\"", encoder, EDT_GetEncoderNeedsQuantizedSource(encoder)));
  3710.  
  3711.         char* pcsEncoderMenuHelp = EDT_GetEncoderMenuHelp(encoder);
  3712.         XP_TRACE(("EDT_GetEncoderMenuHelp(%d) = \"%s\"", encoder, pcsEncoderMenuHelp));
  3713.  
  3714.     }
  3715. }
  3716.  
  3717. #ifndef XP_OS2
  3718. static 
  3719. #else
  3720. extern "OPTLINK"
  3721. #endif
  3722. void edt_TestImageEncoderCallbackFn(EDT_ImageEncoderStatus status, void* hook) {
  3723.     XP_TRACE(("edt_TestImageEncoderCallbackFn Status: %d hook: %08x", status, hook));
  3724. }
  3725.  
  3726. void CEditTestManager::PerformFirstPlugin(){
  3727.     if ( EDT_NumberOfPluginCategories() <= 0 ) {
  3728.         XP_TRACE(("EDT_NumberOfPluginCategories: %d", EDT_NumberOfPluginCategories()));
  3729.         return;
  3730.     }
  3731.     if ( EDT_NumberOfPlugins(0) <= 0 ) {
  3732.         XP_TRACE(("EDT_NumberOfPlugins(0): %d", EDT_NumberOfPlugins(0)));
  3733.         return;
  3734.     }
  3735.     XP_Bool bItem = EDT_PerformPlugin(m_pBuffer->m_pContext, 0, 0, edt_TestImageEncoderCallbackFn, (void*) 0x1234);
  3736.     XP_TRACE(("EDT_PerformPlugin: returned %d\n", bItem));
  3737. }
  3738.  
  3739. void CEditTestManager::PerformPluginByName(){
  3740.     XP_TRACE(("Calling dummyPlugin.does.not.exist"));
  3741.     XP_Bool bResult = EDT_PerformPluginByClassName(m_pBuffer->m_pContext, "dummyPlugin.does.not.exist",
  3742.         edt_TestImageEncoderCallbackFn, (void*) 12);
  3743.     XP_TRACE(("EDT_PerformPluginByClassName returned %d\n", bResult));
  3744.     XP_TRACE(("Calling netscape.test.plugin.composer.EditRaw"));
  3745.     bResult = EDT_PerformPluginByClassName(m_pBuffer->m_pContext, "netscape.test.plugin.composer.EditRaw",
  3746.          edt_TestImageEncoderCallbackFn, (void*) 13);
  3747.     XP_TRACE(("EDT_PerformPluginByClassName returned %d\n", bResult));
  3748. }
  3749.  
  3750. void CEditTestManager::PerformFirstEncoder(){
  3751.     if ( EDT_NumberOfEncoders() <= 0 ) {
  3752.         XP_TRACE(("EDT_NumberOfEncoders: %d", EDT_NumberOfEncoders()));
  3753.         return;
  3754.     }
  3755.     char** ppPixels = (char**) XP_ALLOC(sizeof(char*));
  3756.     char* pPixels = (char*) XP_ALLOC(3);
  3757.     ppPixels[0] = pPixels;
  3758.     pPixels[0] = 1;
  3759.     pPixels[1] = 2;
  3760.     pPixels[2] = 3;
  3761.     XP_TRACE(("EDT_StartEncoder: starting\n"));
  3762.     XP_Bool bItem = EDT_StartEncoder(m_pBuffer->m_pContext, 0, 1, 1, ppPixels,
  3763.         "C:\\junk.txt", edt_TestImageEncoderCallbackFn, (void*) 0xfeedface);
  3764.     XP_TRACE(("EDT_StartEncoder: returned %d\n", bItem));
  3765.     XP_FREE(pPixels);
  3766.     XP_FREE(ppPixels);
  3767. }
  3768.  
  3769. #ifndef XP_OS2
  3770. static 
  3771. #else
  3772. extern "OPTLINK"
  3773. #endif
  3774. void edt_TestPreOpenCallbackFn(XP_Bool bUserCancled, char* pURL, void* hook) {
  3775.     XP_TRACE(("edt_TestPreOpenCallbackFn bUserCancled: %s url: %s hook: %08x", bUserCancled ? "TRUE" : "FALSE",
  3776.         pURL ? pURL : "null", hook));
  3777. }
  3778.  
  3779. void CEditTestManager::PerformPreOpen(){
  3780.     XP_TRACE(("Calling preOpen."));
  3781.     EDT_PreOpen(m_pBuffer->m_pContext,"http://PerformPreOpen",
  3782.         edt_TestPreOpenCallbackFn, (void*) 13);
  3783. }
  3784.  
  3785. #endif // EDITOR_JAVA
  3786.  
  3787. void CEditTestManager::TestHTMLPaste(){
  3788.     EDT_PasteQuoteBegin(m_pBuffer->m_pContext, TRUE);
  3789.     EDT_PasteQuote(m_pBuffer->m_pContext, "<b>This is bold.</b>");
  3790.     EDT_PasteQuote(m_pBuffer->m_pContext, "<i>This is italic.</i>");
  3791.     EDT_PasteQuoteEnd(m_pBuffer->m_pContext);
  3792. }
  3793.  
  3794. void CEditTestManager::SaveToTempFile() {
  3795.   EDT_SaveToTempFile(m_pBuffer->m_pContext,(EDT_SaveToTempCallbackFn) SaveToTempFileCB,(void *)m_pBuffer->m_pContext);
  3796. }
  3797.  
  3798. void CEditTestManager::SaveToTempFileCB(char *pFileURL,void *hook) {
  3799.   XP_ASSERT(hook);
  3800.   MWContext *pContext = (MWContext *)hook;
  3801.   GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  3802.  
  3803.   CEditTestManager *pManager = pEditBuffer->m_pTestManager;
  3804.   if (!pManager) {
  3805.     XP_ASSERT(0);
  3806.     return;
  3807.   }
  3808.   XP_FREEIF(pManager->m_pTempFileURL);
  3809.   if (pFileURL) {
  3810.     pManager->m_pTempFileURL = XP_STRDUP(pFileURL);
  3811.     XP_TRACE(("Wrote to temp file %s",pFileURL));
  3812.   }
  3813.   else 
  3814.   {
  3815.     XP_TRACE(("Failed to write temp file."));
  3816.   }
  3817. }
  3818.  
  3819. void CEditTestManager::RemoveTempFile() {
  3820.   if (m_pTempFileURL) {
  3821.     XP_TRACE(("Removing file %s",m_pTempFileURL));
  3822.     EDT_RemoveTempFile(m_pBuffer->m_pContext,m_pTempFileURL);
  3823.     XP_FREEIF(m_pTempFileURL);
  3824.   }
  3825.   else {
  3826.     XP_TRACE(("No temp file has been saved"));
  3827.   }
  3828. }
  3829.  
  3830. void CEditTestManager::GetDocTempDir() {
  3831.   CEditCommandLog *pLog = CGlobalHistoryGroup::GetGlobalHistoryGroup()->GetLog(m_pBuffer);
  3832.   if (!pLog) {
  3833.     return;
  3834.   }
  3835.  
  3836.   char *pFile = pLog->GetDocTempDir();
  3837.   if (pFile) {
  3838.     XP_TRACE(("DocTempDir is %s",pFile));
  3839.     XP_FREE(pFile);
  3840.   }
  3841.   else {
  3842.     XP_TRACE(("No document temp dir was created."));
  3843.   }
  3844. }
  3845. #endif // DEBUG
  3846.  
  3847. //-----------------------------------------------------------------------------
  3848. // CParseState / CPrintState
  3849. //-----------------------------------------------------------------------------
  3850. #define PRE_BODY 0
  3851. #define IN_BODY 1
  3852. #define POST_BODY 2
  3853.  
  3854. CParseState::CParseState()
  3855.     :m_bInTitle(FALSE),
  3856.     m_iDocPart(0),
  3857.     m_inJavaScript(0),
  3858.     m_baseFontSize(0),
  3859.     m_pNextText(0),
  3860.     m_pJavaScript(0),
  3861.     m_pPostBody(0){
  3862. }
  3863.  
  3864. XP_Bool CParseState::InBody(){
  3865.     return m_iDocPart == IN_BODY;
  3866. }
  3867.  
  3868. void CParseState::StartBody(){
  3869.     m_iDocPart = IN_BODY;
  3870. }
  3871.  
  3872. void CParseState::EndBody(){
  3873.     m_iDocPart = POST_BODY;
  3874. }
  3875.  
  3876. CStreamOutMemory* CParseState::GetStream(){
  3877.     if ( m_iDocPart < POST_BODY ) {
  3878.         // m_pJavaScript is mis-named. It's actually
  3879.         // a bag we hold all our unprocessed head tags in.
  3880.         if( m_pJavaScript == 0 ){
  3881.             m_pJavaScript = new CStreamOutMemory();
  3882.         }
  3883.         return m_pJavaScript;
  3884.     }
  3885.     else {
  3886.         if( m_pPostBody == 0 ){
  3887.             m_pPostBody = new CStreamOutMemory();
  3888.         }
  3889.         return m_pPostBody;
  3890.     }
  3891. }
  3892.  
  3893. CParseState::~CParseState() {
  3894.     Free(m_pJavaScript);
  3895.     Free(m_pPostBody);
  3896.     delete m_pNextText;
  3897. }
  3898.  
  3899. void CParseState::Free(CStreamOutMemory*& pStream){
  3900.     if ( pStream ) {
  3901.         // COutMemoryStreams don't delete their text.
  3902.         XP_HUGE_CHAR_PTR pData = pStream->GetText();
  3903.         if ( pData ) {
  3904.             XP_HUGE_FREE(pData);
  3905.         }
  3906.         delete pStream;
  3907.         pStream = NULL;
  3908.     }
  3909. }
  3910.  
  3911. void CParseState::Reset(){
  3912.     bLastWasSpace = TRUE;               // at the beginning of the document
  3913.                                         //  we should ignore leading spaces
  3914.     m_baseFontSize = 3;
  3915.     m_formatTypeStack.Reset();
  3916.     m_formatTextStack.Reset();
  3917.     m_iDocPart = 0;
  3918.     m_bInTitle = FALSE;
  3919.     m_inJavaScript = 0;
  3920.     m_pJavaScript = 0;
  3921.     delete m_pNextText;
  3922.     // force the compiler to use the non-stream constructor
  3923.     m_pNextText = new CEditTextElement((CEditElement*)0,0);
  3924. }
  3925.  
  3926. //-----------------------------------------------------------------------------
  3927. //  CPrintState
  3928. //-----------------------------------------------------------------------------
  3929. void CPrintState::Reset( IStreamOut* pOut, CEditBuffer *pBuffer ){
  3930.     m_pOut = pOut;
  3931.     m_iCharPos = 0;
  3932.     m_bTextLast = FALSE;
  3933.     m_iLevel = 0;
  3934.     m_pBuffer = pBuffer;
  3935.     m_bEncodeSelectionAsComment = FALSE;
  3936. }
  3937.  
  3938. void CPrintState::PrintSelectionComment(XP_Bool bEnd, XP_Bool bStickyAfter){
  3939.     if ( !bEnd ) {
  3940.         m_pBuffer->PasteHTMLHook(this);
  3941.     }
  3942.     m_pOut->Printf("<!-- %s%s -->", bEnd ? EDT_SELECTION_END_COMMENT : EDT_SELECTION_START_COMMENT,
  3943.         bStickyAfter ? "+" : "");
  3944. }
  3945.  
  3946. XP_Bool CPrintState::ShouldPrintSelectionComments(CEditLeafElement* pElement){
  3947.     return m_bEncodeSelectionAsComment && (
  3948.         ShouldPrintSelectionComment(pElement, FALSE)
  3949.             || ShouldPrintSelectionComment(pElement, TRUE));
  3950. }
  3951.  
  3952. XP_Bool CPrintState::ShouldPrintSelectionComment(CEditLeafElement* pElement, XP_Bool bEnd){
  3953.     return m_bEncodeSelectionAsComment && m_selection.GetEdge(bEnd)->m_pElement == pElement;
  3954. }
  3955.  
  3956. //-----------------------------------------------------------------------------
  3957. // CEditLinkManager
  3958. //-----------------------------------------------------------------------------
  3959. EDT_HREFData* ED_Link::GetData(){
  3960.     EDT_HREFData* pData = EDT_NewHREFData();
  3961.     pData->pURL = XP_STRDUP( hrefStr );
  3962.     if( pExtra ){
  3963.         pData->pExtra = XP_STRDUP( pExtra );
  3964.     }
  3965.     else {
  3966.         pData->pExtra = 0;
  3967.     }
  3968.     return pData;
  3969. }
  3970.  
  3971. CEditLinkManager::CEditLinkManager(){
  3972. }
  3973.  
  3974. ED_Link* CEditLinkManager::MakeLink( char *pHREF, char *pExtra, intn iRefCount ){
  3975.  
  3976.     ED_Link *pNewLink = XP_NEW( ED_Link );
  3977.     pNewLink->iRefCount = iRefCount;
  3978.     pNewLink->pLinkManager = this;
  3979.     pNewLink->hrefStr = XP_STRDUP( pHREF );
  3980.     pNewLink->bAdjusted = FALSE;
  3981.     if( pExtra ){
  3982.         pNewLink->pExtra = XP_STRDUP( pExtra );
  3983.     }
  3984.     else {
  3985.         pNewLink->pExtra = 0;
  3986.     }
  3987.     return pNewLink;
  3988. }
  3989.  
  3990. void CEditLinkManager::AdjustAllLinks( char *pOldURL, char* pNewURL, ED_HREFList *badLinks ){
  3991.     int i;
  3992.     for (i = 0; i < m_links.Size(); i++ ){
  3993.         ED_Link *pLink;
  3994.         if( (pLink = m_links[i]) != 0 ){
  3995.             AdjustLink(&pLink->hrefStr,pOldURL,pNewURL,badLinks);
  3996.         }
  3997.     }
  3998. }
  3999.  
  4000. // Used for adjusting links, images, etc.
  4001. // pNewBase can be NULL, the other args shouldn't be.
  4002. //
  4003. // Change  *ppURL so that the URL will still point to the same location
  4004. // after changing the base URL.
  4005. // If there is no way to adjust ppURL, ppURL will not change and we add it to badLinks.
  4006. // E.g. if ppURL relative to pOldBase points to a local file and
  4007. // pNewBase is a remote site, we can't adjust the URL.
  4008. void CEditLinkManager::AdjustLink(char **ppURL,char *pOldBase, char *pNewBase, ED_HREFList *badLinks){
  4009.  
  4010.   if (!ppURL || !*ppURL) {
  4011.     return;
  4012.   }
  4013.  
  4014.   if ((*ppURL)[0] == '#' || (*ppURL)[0] == '`') {
  4015.     // do nothing, but not an error.
  4016.     return;
  4017.   }
  4018.  
  4019.   // Will make url
  4020.   // absolute if the source and dest are on the same machine, just different
  4021.   // drives.  If on the same drive, will make a relative URL.
  4022.   // If on different drives or different machine, leave URL alone, return FALSE.
  4023.  
  4024.   // Make absolute relative to source URL
  4025.   char *pAbsURL = NET_MakeAbsoluteURL( pOldBase, *ppURL );
  4026.   if (!pAbsURL) {
  4027.     // Add to list of bad links.
  4028.     AddHREFUnique(badLinks,*ppURL);
  4029.     return;
  4030.   }
  4031.   char *pNewURL = NULL;
  4032.  
  4033.   if( pNewBase ){
  4034.     // Try to make relative to dest URL.
  4035.     int result = NET_MakeRelativeURL( pNewBase, pAbsURL, &pNewURL );
  4036.  
  4037.     // If we can't make it relative.
  4038.     if (result != NET_URL_SAME_DIRECTORY &&
  4039.         result != NET_URL_SAME_DEVICE) {
  4040.  
  4041.       if (NET_URL_Type(pAbsURL) == FILE_TYPE_URL &&
  4042.           NET_URL_Type(pNewBase) != FILE_TYPE_URL) {
  4043.         // No point in adjusting URL or making relative, local file is not
  4044.         // visible to a remote machine.  So don't change anything.
  4045.         XP_FREEIF(pAbsURL);
  4046.         XP_FREEIF(pNewURL);
  4047.   
  4048.         // Add to list of bad links.
  4049.         AddHREFUnique(badLinks,*ppURL);
  4050.         return;
  4051.       }
  4052.       // else pNewURL will be a copy of pAbsURL, so just continue.
  4053.       // I.e. we have made the URL absolute.
  4054.     }
  4055.     // result is same directory or same device.
  4056.     else if (result == NET_URL_SAME_DEVICE && (*ppURL)[0] == '/') {
  4057.       // Absolute pathing.  Don't force it to be relative.  It'll work in the 
  4058.       // new location.
  4059.       XP_FREEIF(pAbsURL);
  4060.       XP_FREEIF(pNewURL);
  4061.       return;
  4062.     }
  4063.     // More aggressive absolute pathing.  If the new relative url goes all the
  4064.     // way up to the root, just make it start from the root instead of having a 
  4065.     // bunch of ../../../   Bug 50500.
  4066.     // E.g. pAbsURL  = http://host/images/bob.gif,
  4067.     //      pNewBase = http://host/dir1/dir2/dir3/doc.html
  4068.     // instead of setting pNewURL to 
  4069.     //                 ../../../images/bob.gif, use
  4070.     //                 /images/bob.gif
  4071.     else if (result == NET_URL_SAME_DEVICE) {
  4072.       // Count sets of ../ at the beginning of pNewURL.
  4073.       int dotDotCount = 0;
  4074.       char *pSeek = pNewURL;
  4075.       while (pSeek && *pSeek && !XP_STRNCMP(pSeek,"../",3)) {
  4076.         dotDotCount++;
  4077.         pSeek +=3;
  4078.       }
  4079.  
  4080.       char *basePath = NET_ParseURL(pNewBase,GET_PATH_PART);
  4081.       if (!basePath) {
  4082.         XP_ASSERT(0);
  4083.         return; 
  4084.       }
  4085.  
  4086.       /* Find location of drive separator */
  4087.       char *basePtr = (char*) XP_STRCHR(basePath, '|');
  4088.       if (!basePtr) {
  4089.         basePtr = basePath;
  4090.         // basePtr now points to first '/' in pNewBase before directories
  4091.  
  4092.         // Count number of subdirectories in pNewBase.
  4093.         int subDirCount = -1; // Don't count first slash.
  4094.         while (basePtr && *basePtr) {
  4095.           if (*basePtr == '/') {
  4096.             subDirCount++;
  4097.           }
  4098.           basePtr++;
  4099.         }
  4100.         XP_FREE(basePath);
  4101.  
  4102.         if (dotDotCount >= subDirCount && dotDotCount > 0) {
  4103.           if (dotDotCount > subDirCount) {
  4104.             // Error, Net_MakeRelativeURL added too many ../
  4105.             XP_ASSERT(0);
  4106.           }
  4107.  
  4108.           // pSeek is pointing to first char after all the ../ 
  4109.           char *pTemp = XP_STRDUP(pSeek - 1); // Move back to get the slash.
  4110.           XP_FREE(pNewURL);
  4111.           pNewURL = pTemp;
  4112.         }
  4113.       }
  4114.       else {
  4115.       // there is a drive separator, so this trick won't work.  
  4116.       // use pNewURL as is.
  4117.         XP_FREE(basePath);
  4118.       }
  4119.     }
  4120.   } else {
  4121.     // No new base is supplied - so we just return absolute URL
  4122.     XP_FREEIF(*ppURL);
  4123.     *ppURL = pAbsURL;
  4124.     return;
  4125.   }
  4126.   
  4127.   // else pNewURL is a correct relative URL.  Or an absolute URL if result == NET_URL_FAIL.
  4128.   
  4129.   XP_FREEIF( pAbsURL );
  4130.   XP_FREEIF(*ppURL);
  4131.   *ppURL = pNewURL;
  4132. }
  4133.  
  4134. ED_LinkId CEditLinkManager::Add( char *pHREF, char *pExtra ){
  4135.     int i = 0;
  4136.     int lastFree = -1;
  4137.     while( i < m_links.Size() ){
  4138.         ED_Link* pLink = m_links[i];
  4139.         if( pLink != 0 ){
  4140.             // need a more intelegent way of comparing HREFs
  4141.             if( XP_STRCMP( pLink->hrefStr, pHREF) == 0 ) {
  4142.                 // Links the same. How about pExtra ?
  4143.                 if ( (!!pExtra == !!pLink->pExtra)
  4144.                     && ((pExtra &&
  4145.                             XP_STRCMP( pExtra, pLink->pExtra ) == 0 )
  4146.                        || pExtra == 0 ) ){
  4147.                     pLink->iRefCount++;
  4148.                     return pLink;
  4149.                 }
  4150.             }
  4151.         }
  4152.         else {
  4153.             lastFree = i;
  4154.         }
  4155.         i++;
  4156.     }
  4157.  
  4158.     ED_Link *pNewLink = MakeLink( pHREF, pExtra );
  4159.  
  4160.     //
  4161.     // Store it.
  4162.     //
  4163.     if( lastFree != -1 ){
  4164.         m_links[lastFree] = pNewLink;
  4165.     }
  4166.     else {
  4167.         lastFree = m_links.Add( pNewLink );
  4168.     }
  4169.     pNewLink->linkOffset = lastFree;
  4170.     return pNewLink;
  4171. }
  4172.  
  4173. void CEditLinkManager::Free(ED_LinkId id){
  4174.     if( --id->iRefCount == 0 ){
  4175.         m_links[ id->linkOffset ] = 0;
  4176.         XP_FREEIF( id->pExtra );
  4177.         XP_FREEIF( id->hrefStr );
  4178.         XP_FREE( id );
  4179.     }
  4180. }
  4181.  
  4182. void CEditLinkManager::AddHREFUnique(ED_HREFList *badLinks,char *pURL) {
  4183.   for (int n = 0; n < badLinks->Size(); n++) {
  4184.     // Just comparing links for equality by string comparison.
  4185.     if (!XP_STRCMP((*badLinks)[n],pURL)) {
  4186.       // Already in list.
  4187.       return;
  4188.     }
  4189.   }
  4190.   badLinks->Add(XP_STRDUP(pURL));
  4191. }
  4192.  
  4193. XP_Bool EDT_SelectTableElement(MWContext  *pMWContext, int32 x, int32 y, 
  4194.                                LO_Element *pLoElement, 
  4195.                                ED_HitType  iHitType, 
  4196.                                XP_Bool     bModifierKeyPressed,
  4197.                                XP_Bool     bExtendSelection)
  4198. {
  4199.     GET_EDIT_BUF_OR_RETURN(pMWContext, pEditBuffer) 0;
  4200.     return pEditBuffer->SelectTableElement(x, y, pLoElement, iHitType, 
  4201.                                            bModifierKeyPressed, bExtendSelection);
  4202. }
  4203.  
  4204. ED_HitType EDT_ExtendTableCellSelection(MWContext *pMWContext, int32 x, int32 y)
  4205. {
  4206.     GET_EDIT_BUF_OR_RETURN(pMWContext, pEditBuffer) ED_HIT_NONE;
  4207.     return pEditBuffer->ExtendTableCellSelection(x, y);
  4208. }
  4209.  
  4210. // Dynamic Sizing Object
  4211.  
  4212. CSizingObject::CSizingObject() :
  4213.         m_pBuffer(0),
  4214.         m_pLoElement(0),
  4215.         m_iStyle(0),
  4216.         m_iXOrigin(0),
  4217.         m_iYOrigin(0),
  4218.         m_iStartWidth(0),
  4219.         m_iStartHeight(0),
  4220.         m_iViewWidth(0),
  4221.         m_iViewHeight(0),
  4222.         m_bWidthPercent(0),
  4223.         m_bHeightPercent(0),
  4224.         m_bPercentOriginal(0),
  4225.         m_iAddCols(0),
  4226.         m_iAddRows(0)
  4227. {
  4228. }
  4229.  
  4230. XP_Bool CSizingObject::Create(CEditBuffer *pBuffer,
  4231.                               LO_Element *pLoElement,
  4232.                               int iSizingStyle,
  4233.                               int32 xVal, int32 yVal,
  4234.                               XP_Bool /*bLockAspect*/, XP_Rect *pRect){
  4235.     XP_ASSERT(pBuffer);
  4236.     XP_ASSERT(pRect);
  4237.     XP_ASSERT(iSizingStyle);
  4238.     m_pBuffer = pBuffer;
  4239.     m_pLoElement = pLoElement;
  4240.     m_iStyle = iSizingStyle;
  4241.  
  4242.     if( !pLoElement )
  4243.     {
  4244. #ifdef LAYERS
  4245.         pLoElement = LO_XYToElement(pBuffer->m_pContext, xVal, yVal, 0);
  4246. #else
  4247.         pLoElement = LO_XYToElement(pBuffer->m_pContext, xVal, yVal);
  4248. #endif
  4249.     }
  4250.     if( !pLoElement )
  4251.     {
  4252.         return FALSE;
  4253.     }
  4254.  
  4255.     // Get view window size for "100%" sizing
  4256.     FE_GetDocAndWindowPosition(pBuffer->m_pContext, &m_iXOrigin, &m_iYOrigin, &m_iViewWidth, &m_iViewHeight);
  4257.     if( !m_iViewWidth || !m_iViewHeight )
  4258.     {
  4259.         return FALSE;
  4260.     }
  4261.     // Get extra margin
  4262.     int32 iMarginWidth;
  4263.     int32 iMarginHeight;
  4264.     LO_GetDocumentMargins(pBuffer->m_pContext, &iMarginWidth, &iMarginHeight);
  4265.     m_iViewWidth -= 2 * iMarginWidth;
  4266.     m_iViewHeight -= 2 * iMarginHeight;
  4267.     LO_Any *pAny = &(pLoElement->lo_any);
  4268.     int32 iSelectX = pAny->x + pAny->x_offset;
  4269.     int32 iSelectY = pAny->y + pAny->y_offset;
  4270.  
  4271.     m_iParentWidth = 0;
  4272.     // Check for sizing of table cell or nested table
  4273.     if( pAny->type == LO_TABLE )
  4274.     {
  4275.         // Check for possible nested table by finding if it has a parent cell
  4276.         LO_CellStruct *pParentCell = lo_GetParentCell(m_pBuffer->m_pContext, pLoElement); 
  4277.         if( pParentCell )
  4278.         {
  4279.             // Width = that of cell containing table
  4280.             m_iParentWidth = pParentCell->width;
  4281.             m_iWidthMsgID = XP_EDT_PERCENT_CELL;
  4282.         }
  4283.         iSelectX = pAny->x;
  4284.         iSelectY = pAny->y;
  4285.     } 
  4286.     else if( pAny->type == LO_CELL )
  4287.     {
  4288.         // 
  4289.         LO_TableStruct *pParentTable = lo_GetParentTable(m_pBuffer->m_pContext, pLoElement);
  4290.         if( pParentTable )
  4291.         {
  4292.             // Get the width usable for percent calculation (minus borders and cell spacing)
  4293.             m_iParentWidth = lo_CalcTableWidthForPercentMode(pLoElement);
  4294.             m_iWidthMsgID = XP_EDT_PERCENT_TABLE;
  4295.         }
  4296.         iSelectX = pAny->x;
  4297.         iSelectY = pAny->y;
  4298.     } else {
  4299.         // If not a table or cell, 
  4300.         //   select the item of interest to make it the current element
  4301.         // Select at its CENTER to avoid setting caret
  4302.         //   if real X,Y is near the left or right edge
  4303.         iSelectX += pAny->width/2;
  4304.         iSelectY += pAny->height/2;
  4305.     }
  4306.     
  4307.     if( m_iParentWidth == 0 )
  4308.     {
  4309.         m_iParentWidth = m_iViewWidth;
  4310.         m_iWidthMsgID = XP_EDT_PERCENT_WINDOW;
  4311.     }
  4312.     
  4313.     //m_pBuffer->MoveAndHideCaretInTable(pLoElement);
  4314.  
  4315.     // Calculate the rect in View's coordinates;
  4316.     // ASSUMES PIXELS ONLY -- NO CONVERSION DONE
  4317.     m_Rect.left = pAny->x + pAny->x_offset - m_iXOrigin;
  4318.     m_Rect.top = pAny->y + pAny->y_offset - m_iYOrigin;
  4319.  
  4320.     // Recent default value of flag used
  4321.     //  for image status string, e.g.: (% of original width)
  4322.     m_bPercentOriginal = FALSE;
  4323.  
  4324.     // Get percent-mode flag for edit element and adjust table/cell data
  4325.     switch ( m_pLoElement->type )
  4326.     {
  4327.         case LO_IMAGE:
  4328.         {
  4329.             // Get the edit element
  4330.             CEditElement * pElement = m_pLoElement->lo_any.edit_element;
  4331.             if( !pElement ) return FALSE;
  4332.  
  4333.             if( pElement->IsIcon() )
  4334.             {
  4335.                 // All "unknown" tags are handled here
  4336.                 pElement->GetWidth(&m_bWidthPercent, &m_iStartWidth);
  4337.                 pElement->GetHeight(&m_bHeightPercent, &m_iStartHeight);
  4338.             } else if( pElement->IsImage() )
  4339.             {
  4340.                 EDT_ImageData * pImageData = pElement->Image()->GetImageData();
  4341.                 //pBuffer->GetImageData();
  4342.                 if( pImageData )
  4343.                 {
  4344.                     m_bWidthPercent = pImageData->bWidthPercent;
  4345.                     m_bHeightPercent = pImageData->bHeightPercent;
  4346.  
  4347.                     // Save the original height and width of the image
  4348.                     //  if we have it
  4349.                     if( pImageData->iOriginalWidth )
  4350.                     {
  4351.                         m_iStartWidth = pImageData->iOriginalWidth;
  4352.                         m_iStartHeight = pImageData->iOriginalHeight;
  4353.                         // Constrain relative to "original" dimensions
  4354.                         m_bPercentOriginal = TRUE;
  4355.                     }
  4356.                     EDT_FreeImageData(pImageData);
  4357.                 }
  4358.                 // LO_ImageStruct includes border -- adjust
  4359.                 m_Rect.left += ((LO_ImageStruct*)pAny)->border_width;
  4360.                 m_Rect.top += ((LO_ImageStruct*)pAny)->border_width;
  4361.             }
  4362.             break;
  4363.         }
  4364.         case LO_HRULE: 
  4365.         {
  4366.             // Get the edit element
  4367.             CEditElement * pElement = m_pLoElement->lo_any.edit_element;
  4368.             if( !pElement ) return FALSE;
  4369.  
  4370.             EDT_HorizRuleData * pHData = pElement->HorizRule()->GetData(); //pBuffer->GetHorizRuleData();
  4371.             if( pHData )
  4372.             {
  4373.                 m_bWidthPercent = pHData->bWidthPercent;
  4374.                 //Note: we will get width and "size" (height) in pixels below
  4375.                 m_iStartHeight = pHData->size;
  4376.                 EDT_FreeHorizRuleData(pHData);
  4377.             }
  4378.             break;
  4379.         }
  4380.         case LO_TABLE:
  4381.         {
  4382.             CEditTableElement *pTable = 
  4383.                 (CEditTableElement*)m_pBuffer->GetTableElementFromLO_Element( m_pLoElement, LO_TABLE );
  4384.             if( pTable )
  4385.             {
  4386.                 EDT_TableData *pTableData = pTable->GetData();
  4387.                 if( pTableData )
  4388.                 {
  4389.                     switch( iSizingStyle )
  4390.                     {
  4391.                         case ED_SIZE_RIGHT:
  4392.                             // Use width determined by layout
  4393.                             m_bWidthPercent = pTableData->bWidthPercent;
  4394.                             if( m_bWidthPercent )
  4395.                             {
  4396.                                 m_iStartWidth = (pAny->width * 100) / m_iParentWidth;
  4397.                             } else {
  4398.                                 m_iStartWidth = pAny->width;
  4399.                             }
  4400.                             break;
  4401.                         case ED_SIZE_BOTTOM:
  4402.                             // Use Height determined by layout
  4403.                             m_bHeightPercent = pTableData->bHeightPercent;
  4404.                             if( m_bHeightPercent )
  4405.                             {
  4406.                                 m_iStartHeight = (pAny->height * 100) / m_iViewHeight;
  4407.                             } else {
  4408.                                 m_iStartHeight = pAny->height;
  4409.                             }
  4410.                             break;
  4411.                         case ED_SIZE_ADD_COLS:
  4412.                             // When adding columns, show selection only
  4413.                             //  around "new" columns, so rect.left = table->right
  4414.                             m_Rect.left += pAny->width;
  4415.                             m_Rect.right = m_Rect.left + 1;
  4416.                             m_Rect.bottom = m_Rect.top + pAny->height;
  4417.                             m_iStartHeight = pAny->height;
  4418.                             break;
  4419.  
  4420.                         case ED_SIZE_ADD_ROWS:
  4421.                             // As with columns, rect is around "new" rows
  4422.                             m_Rect.top += pAny->height;
  4423.                             m_Rect.bottom = m_Rect.top + 1;
  4424.                             m_Rect.right = m_Rect.left + pAny->width;
  4425.                             m_iStartWidth = pAny->width;
  4426.                             break;
  4427.                     }
  4428.                     EDT_FreeTableData(pTableData);
  4429.                 }
  4430.             }
  4431.             break;
  4432.         }
  4433.         case LO_CELL:
  4434.         {
  4435.             CEditTableCellElement *pCell = 
  4436.                 (CEditTableCellElement*)m_pBuffer->GetTableElementFromLO_Element( m_pLoElement, LO_CELL );
  4437.             if( pCell )
  4438.             {
  4439.                 EDT_TableCellData * pCellData = pCell->GetData(0);
  4440.                 if( pCellData )
  4441.                 {
  4442.                     m_bWidthPercent = pCellData->bWidthPercent;
  4443.                     m_bHeightPercent = pCellData->bHeightPercent;
  4444.                     EDT_FreeTableCellData(pCellData);
  4445.  
  4446.                     if( iSizingStyle == ED_SIZE_RIGHT )
  4447.                     {
  4448.                         if( m_bWidthPercent )
  4449.                         {
  4450.                             m_iStartWidth = (pAny->width * 100) / m_iParentWidth;
  4451.                         } else {
  4452.                             // Use width determined by layout
  4453.                             m_iStartWidth = pAny->width; // pCellData->iWidth;
  4454.                         }
  4455.                     } 
  4456.                     else 
  4457.                     {
  4458.                         if( m_bHeightPercent )
  4459.                         {
  4460.                             m_iStartHeight = (pAny->height * 100) / m_iViewHeight;
  4461.                         } else {
  4462.                             m_iStartHeight = pAny->height;
  4463.                         }
  4464.                     }                
  4465.  
  4466.                     // We will select the entire row or column, so get size of table
  4467.                     LO_TableStruct * pLoTable = lo_GetParentTable(pBuffer->m_pContext, m_pLoElement);
  4468.                     if( pLoTable )
  4469.                     {
  4470.                         int32 iAdjust = min(pLoTable->border_width, 4 - pLoTable->inter_cell_space);
  4471.                         if( iSizingStyle == ED_SIZE_RIGHT )
  4472.                         {
  4473.                             // Prefered top and bottom is just inside table border
  4474.                             m_Rect.top = pLoTable->y + pLoTable->y_offset - m_iYOrigin + pLoTable->border_width;
  4475.                             m_Rect.bottom = m_Rect.top + pLoTable->height - 2*pLoTable->border_width;
  4476.                     
  4477.                             // Back off top and bottom if intercell space is too small
  4478.                             if( pLoTable->inter_cell_space < 4 && iAdjust > 0 )
  4479.                             {
  4480.                                 m_Rect.top -= iAdjust;
  4481.                                 m_Rect.bottom += iAdjust;
  4482.                             }
  4483.                             m_Rect.right = m_Rect.left + pAny->width;
  4484.                         } 
  4485.                         else 
  4486.                         {
  4487.                             // Prefered left and right is just inside table border
  4488.                             m_Rect.left = pLoTable->x + pLoTable->x_offset - m_iXOrigin + pLoTable->border_width;
  4489.                             m_Rect.right = m_Rect.left + pLoTable->width - 2*pLoTable->border_width;
  4490.                     
  4491.                             // Back off if intercell space is too small
  4492.                             if( pLoTable->inter_cell_space < 4 && iAdjust > 0 )
  4493.                             {
  4494.                                 m_Rect.left -= iAdjust;
  4495.                                 m_Rect.right += iAdjust;
  4496.                             }
  4497.                             m_Rect.bottom = m_Rect.top + pAny->height;
  4498.                         }
  4499.                     }
  4500.                 }
  4501.             }
  4502.             break;
  4503.         }
  4504.     }
  4505.  
  4506.     XP_TRACE(("Start Sizing: m_iStartWidth = %d", m_iStartWidth));
  4507.  
  4508.     if( !m_bWidthPercent )
  4509.     {
  4510.         // We aren't doing percent, so set message ID for pixels
  4511.         m_iWidthMsgID = XP_EDT_PIXELS;
  4512.     }
  4513.  
  4514.     // Finish calculating object rect if not set for table sizing above
  4515.     if( iSizingStyle != ED_SIZE_ADD_COLS && iSizingStyle != ED_SIZE_ADD_ROWS &&
  4516.         m_pLoElement->type != LO_CELL )
  4517.     {
  4518.         m_Rect.right = m_Rect.left + pAny->width;
  4519.         m_Rect.bottom = m_Rect.top + pAny->height;
  4520.     }
  4521.     *pRect = m_Rect;
  4522.  
  4523.     // If we didn't set above, use current size or minimum of 1
  4524.     if( m_iStartWidth == 0 )
  4525.     {
  4526.         m_iStartWidth = max(1, pAny->width);
  4527.     }
  4528.     if( m_iStartHeight == 0 )
  4529.     {
  4530.         m_iStartHeight = max(1, pAny->height);
  4531.     }
  4532.     return TRUE;
  4533. }
  4534.  
  4535. #define  EDT_NEW_ROW_HEIGHT  24
  4536. #define  EDT_NEW_COL_WIDTH   24
  4537.  
  4538. PRIVATE
  4539. void CalcAddRowRect(int32 iRows, XP_Rect *pTableRect, XP_Rect *pRect)
  4540. {
  4541.     pRect->left = pTableRect->left + 6;
  4542.     pRect->right = pTableRect->right - 6;
  4543.     pRect->top = pTableRect->top + (iRows * EDT_NEW_ROW_HEIGHT) + 2;
  4544.     pRect->bottom = pRect->top;
  4545. }
  4546.  
  4547. PRIVATE
  4548. void CalcAddColRect(int32 iCols, XP_Rect *pTableRect, XP_Rect *pRect)
  4549. {
  4550.     pRect->top = pTableRect->top + 6;
  4551.     pRect->bottom = pTableRect->bottom - 6;
  4552.     pRect->left = pTableRect->left + (iCols * EDT_NEW_COL_WIDTH) + 2;
  4553.     pRect->right = pRect->left;
  4554. }
  4555.  
  4556. // Corner must be > any single side value
  4557. #define  EDT_IS_SIZING_CORNER(style)   (style == ED_SIZE_TOP_LEFT || \
  4558.                                         style == ED_SIZE_TOP_RIGHT || \
  4559.                                         style == ED_SIZE_BOTTOM_LEFT || \
  4560.                                         style == ED_SIZE_BOTTOM_RIGHT )
  4561.  
  4562. XP_Bool CSizingObject::GetSizingRect(int32 xVal, int32 yVal, XP_Bool bLockAspect, XP_Rect *pRect)
  4563. {
  4564.     XP_ASSERT(pRect);
  4565.     int i;
  4566.     XP_Bool bLockAspectRatio = EDT_IS_SIZING_CORNER(m_iStyle) && bLockAspect;
  4567.  
  4568.     int32 iViewX = xVal - m_iXOrigin;
  4569.     int32 iViewY = yVal - m_iYOrigin;
  4570.  
  4571.     // Calculate the new rectangle
  4572.     // And don't allow dragging past opposite side:
  4573.     XP_Rect new_rect = m_Rect;
  4574.  
  4575.     if( m_bWidthPercent )
  4576.     {
  4577.         // In % mode, limit largest value to get 100% of width or height
  4578.         // Calc. the pixel value corresponding to just under 101% width or height,
  4579.         //  so roundoff will always allow achieving 100%
  4580.         int32 iFullWidth = ((101 * m_iParentWidth) / 100) - 1;
  4581.         int32 iFullHeight = ((101 * m_iViewHeight) / 100) - 1;
  4582.  
  4583.         if( m_iStyle & ED_SIZE_TOP )
  4584.         {
  4585.             new_rect.top = min(m_Rect.bottom, max(iViewY,m_Rect.bottom-iFullHeight));
  4586.         }
  4587.         if( m_iStyle & ED_SIZE_BOTTOM )
  4588.         {
  4589.             new_rect.bottom = max(m_Rect.top, min(iViewY,m_Rect.top+iFullHeight));
  4590.         }
  4591.         if( m_iStyle & ED_SIZE_LEFT )
  4592.         {
  4593.             new_rect.left = min(m_Rect.right, max(iViewX,m_Rect.right-iFullWidth));
  4594.         }
  4595.         if( m_iStyle & ED_SIZE_RIGHT )
  4596.         {
  4597.             new_rect.right = max(m_Rect.left, iViewX); //(m_pLoElement->type == LO_CELL) ? iViewX : min(iViewX,m_Rect.left+iFullWidth));
  4598.         }
  4599.     } else {
  4600.         if( m_iStyle & ED_SIZE_TOP )
  4601.         {
  4602.             new_rect.top = min(m_Rect.bottom, iViewY);
  4603.         }
  4604.         if( m_iStyle & ED_SIZE_BOTTOM || m_iStyle == ED_SIZE_ADD_ROWS )
  4605.         {
  4606.             new_rect.bottom = max(m_Rect.top, iViewY);
  4607.         }
  4608.         if( m_iStyle & ED_SIZE_LEFT )
  4609.         {
  4610.             new_rect.left = min(m_Rect.right, iViewX);
  4611.         }
  4612.         if( m_iStyle & ED_SIZE_RIGHT  || m_iStyle == ED_SIZE_ADD_COLS )
  4613.         {
  4614.             new_rect.right = max(m_Rect.left, iViewX);
  4615.         }
  4616.     }
  4617.     int iNewWidth = new_rect.right - new_rect.left;
  4618.     int iNewHeight = new_rect.bottom - new_rect.top;
  4619.  
  4620.     // When sizing both width and height,
  4621.     //   fixup coordinates to lock aspect ratio
  4622.     //
  4623.     if(bLockAspectRatio)
  4624.     {
  4625.         int iLockedWidth = (iNewHeight * m_iStartWidth) / m_iStartHeight;
  4626.         int iLockedHeight = (iNewWidth * m_iStartHeight) / m_iStartWidth;
  4627.  
  4628.         if( iNewWidth < iLockedWidth )
  4629.         {
  4630.             // New width is too small to match new height - adjust
  4631.             if( m_iStyle & ED_SIZE_LEFT ){
  4632.                 new_rect.left = new_rect.right - iLockedWidth;
  4633.             } else {
  4634.                 new_rect.right = new_rect.left + iLockedWidth;
  4635.             }
  4636.         } else if( iNewHeight < iLockedHeight )
  4637.         {
  4638.             // New height is too small to match new width
  4639.             if( m_iStyle & ED_SIZE_TOP )
  4640.             {
  4641.                 new_rect.top = new_rect.bottom - iLockedHeight;
  4642.             } else {
  4643.                 new_rect.bottom = new_rect.top + iLockedHeight;
  4644.             }
  4645.         }
  4646.     }
  4647.  
  4648.     // Return new rect to caller
  4649.     *pRect = new_rect;
  4650.  
  4651.     // Check if rect is different from last rect requested
  4652.     if( new_rect.top != m_Rect.top ||
  4653.         new_rect.bottom != m_Rect.bottom ||
  4654.         new_rect.left != m_Rect.left ||
  4655.         new_rect.right != m_Rect.right )
  4656.     {
  4657.         m_Rect = new_rect;
  4658.  
  4659.         // Display status message with data for user:
  4660.         char   pMsg[512] = "";
  4661.         char   pPercentOfWhat[256] = "";
  4662.         int32  iWidth = m_Rect.right - m_Rect.left;
  4663.         int32  iHeight = m_Rect.bottom - m_Rect.top;
  4664.         int32  iPercent;
  4665.  
  4666.         XP_Bool bDoWidth = (m_iStyle & ED_SIZE_LEFT) || (m_iStyle & ED_SIZE_RIGHT);
  4667.         XP_Bool bDoHeight = (m_iStyle & ED_SIZE_TOP) || (m_iStyle & ED_SIZE_BOTTOM);
  4668.  
  4669.         // Show only dimension(s) for whats changing: (Width vs. Height vs both)
  4670.         // First part of status shows: "Width = xx[pixesl|%of window width]"
  4671.         //  and/or similar string for Height.
  4672.         //
  4673.         if( bDoWidth )
  4674.         {
  4675.             if(m_bWidthPercent)
  4676.             {
  4677.                 // Convert to % format
  4678.                 iWidth = (iWidth * 100) / m_iParentWidth;
  4679.             }
  4680.             iPercent = (iWidth * 100 ) / m_iStartWidth;
  4681.  
  4682.             // "Width = x"
  4683.             PR_snprintf(pMsg, 128, XP_GetString(XP_EDT_WIDTH_EQUALS), iWidth);
  4684.             // "pixels" or "% of window"
  4685.  
  4686.             strcat(pMsg, XP_GetString(m_iWidthMsgID));
  4687.  
  4688.             // The % of original [width] and/or [height] string
  4689.             // Current logic assumes constaining aspect ratio when sizing corners,
  4690.             //   so separate Width, Height percentages are not shown
  4691.             XP_STRCPY(pPercentOfWhat, XP_GetString(XP_EDT_WIDTH));
  4692.         }
  4693.         if( bDoHeight )
  4694.         {
  4695.             if(m_bHeightPercent)
  4696.             {
  4697.                 iHeight = (iHeight * 100) / m_iViewHeight;
  4698.             }
  4699.             // Since corners are constrained to aspect ratio,
  4700.             //  just use Width's calculation if already done
  4701.             if( !bDoWidth )
  4702.             {
  4703.                 iPercent = (iHeight * 100 ) / m_iStartHeight;
  4704.             }
  4705.  
  4706.             // "Height = x"
  4707.             PR_snprintf(pMsg+XP_STRLEN(pMsg), 128,
  4708.                         XP_GetString(XP_EDT_HEIGHT_EQUALS), iHeight);
  4709.             // "pixels" or "% of window"
  4710.             strcat(pMsg, XP_GetString(m_bHeightPercent ? (int)XP_EDT_PERCENT_WINDOW :
  4711.                                                          (int)XP_EDT_PIXELS));
  4712.  
  4713.             if( bDoWidth )
  4714.             {
  4715.                 strcat(pPercentOfWhat, XP_GetString(XP_EDT_AND));
  4716.             }
  4717.             strcat(pPercentOfWhat, XP_GetString(XP_EDT_HEIGHT));
  4718.         }
  4719.         if( bDoWidth || bDoHeight )
  4720.         {
  4721.             // Build string to report relative size change:
  4722.             //  (% of [original|previous] [width | height | width and height])
  4723.             PR_snprintf(pMsg+XP_STRLEN(pMsg), 128,
  4724.                         XP_GetString(m_bPercentOriginal ? (int)XP_EDT_PERCENT_ORIGINAL :
  4725.                                                           (int)XP_EDT_PERCENT_PREVIOUS),
  4726.                         iPercent, pPercentOfWhat);
  4727.         } else if( m_iStyle == ED_SIZE_ADD_COLS )
  4728.         {
  4729.             int iAddCols = iNewWidth / EDT_NEW_COL_WIDTH;
  4730.             PR_snprintf(pMsg, 128, XP_GetString(XP_EDT_ADD_COLUMNS), iAddCols);
  4731.             XP_Rect rect;
  4732.  
  4733.             // Erase all existing lines
  4734.             // NOTE: We can't draw/erase just the "new" line because 
  4735.             //   we may skip lines if mouse is moved fast, causing a mess
  4736.             for( i=1; i< m_iAddCols; i++ )
  4737.             {
  4738.                 CalcAddColRect(i, &new_rect, &rect);
  4739.                 FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, TRUE);
  4740.             }
  4741.             // Draw all new lines based on new number of columns
  4742.             for( i=1; i< iAddCols; i++ )
  4743.             {
  4744.                 CalcAddColRect(i, &new_rect, &rect);
  4745.                 FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, FALSE);
  4746.             }
  4747.             m_iAddCols = iAddCols;
  4748.         } else if(  m_iStyle == ED_SIZE_ADD_ROWS )
  4749.         {
  4750.             int iAddRows = iNewHeight / EDT_NEW_ROW_HEIGHT;
  4751.             PR_snprintf(pMsg, 128, XP_GetString(XP_EDT_ADD_ROWS), iAddRows);
  4752.             XP_Rect rect;
  4753.             
  4754.             // Erase all existing lines
  4755.             for( i=1; i< m_iAddRows; i++ )
  4756.             {
  4757.                 CalcAddRowRect(i, &new_rect, &rect);
  4758.                 FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, TRUE);
  4759.             }
  4760.             // Draw all new lines based on new number of columns
  4761.             for( i=1; i< iAddRows; i++ )
  4762.             {
  4763.                 CalcAddRowRect(i, &new_rect, &rect);
  4764.                 FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, FALSE);
  4765.             }
  4766.             m_iAddRows = iAddRows;
  4767.         }
  4768.  
  4769.         FE_Progress(m_pBuffer->m_pContext, pMsg);
  4770.  
  4771.         // Indicate that rect changed
  4772.         return TRUE;
  4773.     }
  4774.     // Rect is same as last time
  4775.     return FALSE;
  4776. }
  4777.  
  4778. void CSizingObject::ResizeObject()
  4779. {
  4780.     // Erase visual feedback when adding rows or columns
  4781.     EraseAddRowsOrCols();
  4782.     int32 iWidth, iWidthPixels, iHeight;
  4783.  
  4784.     // Get the element being sized (except table or cell - obtained below)
  4785.     CEditLeafElement *pElement = (CEditLeafElement*)(m_pLoElement->lo_any.edit_element);
  4786.  
  4787.     if( !(m_iStyle == ED_SIZE_ADD_ROWS || m_iStyle == ED_SIZE_ADD_COLS) )
  4788.     {
  4789.  
  4790.         iWidthPixels = m_Rect.right - m_Rect.left;
  4791.         iHeight = m_Rect.bottom - m_Rect.top;
  4792.  
  4793.         // Convert to percent if that's what we are using
  4794.         // Note that we do not change that mode when returning new size
  4795.         if( m_bWidthPercent )
  4796.         {
  4797.             iWidth = (iWidthPixels * 100) / m_iParentWidth;
  4798.         } else {
  4799.             iWidth = iWidthPixels;        
  4800.         }
  4801.         if( m_bHeightPercent )
  4802.         {
  4803.             iHeight = (iHeight * 100) / m_iViewHeight;
  4804.         }
  4805.     }
  4806.  
  4807.     // Change the appropriate element's width and/or height
  4808.     switch ( m_pLoElement->type )
  4809.     {
  4810.         case LO_IMAGE:
  4811.         {
  4812.             if( pElement && pElement->IsIcon() )
  4813.             {
  4814.                 // TODO: ALL "UNKNOWN" TAGS ARE HANDLED HERE
  4815.                 // Only change dimension if we were sizing it
  4816.                 if( !(m_iStyle & ED_SIZE_LEFT ||
  4817.                       m_iStyle & ED_SIZE_RIGHT) )
  4818.                 {
  4819.                     iWidth = 0; // Signal to not change width...
  4820.                 }
  4821.                 if( !(m_iStyle & ED_SIZE_TOP ||
  4822.                       m_iStyle & ED_SIZE_BOTTOM) )
  4823.                 {
  4824.                     iHeight = 0; // ...or height
  4825.                 }
  4826.                 if( iWidth > 0 || iHeight > 0 )
  4827.                 {
  4828.                     m_pBuffer->BeginBatchChanges(kSetUnknownTagDataCommandID);
  4829.                     pElement->SetSize(m_bWidthPercent, iWidth, m_bHeightPercent, iHeight);
  4830.                     m_pBuffer->EndBatchChanges();
  4831.                 }
  4832.                 m_pBuffer->Relayout(pElement, 0);
  4833.             } else if( pElement && pElement->IsImage() )
  4834.             {
  4835.                 EDT_ImageData * pImageData = pElement->Image()->GetImageData();
  4836.                 if( pImageData )
  4837.                 {
  4838.  
  4839.                     // Only change dimension if we were sizing it
  4840.                     if( m_iStyle & ED_SIZE_TOP ||
  4841.                         m_iStyle & ED_SIZE_BOTTOM )
  4842.                     {
  4843.                         pImageData->iHeight = iHeight;
  4844.                     }
  4845.                     if( m_iStyle & ED_SIZE_LEFT ||
  4846.                         m_iStyle & ED_SIZE_RIGHT )
  4847.                     {
  4848.                         pImageData->iWidth = iWidth;
  4849.                     }
  4850.                     m_pBuffer->BeginBatchChanges(kSetImageDataCommandID);
  4851.                     // We are not changing image URL, so third param
  4852.                     //   (keep-images-with-doc) shouldn't matter
  4853.                     pElement->Image()->SetImageData(pImageData);
  4854.                     edt_FreeImageData(pImageData);
  4855.                     m_pBuffer->Relayout(pElement,0);
  4856.                     m_pBuffer->EndBatchChanges();
  4857.                }
  4858.             }
  4859.             break;
  4860.         }
  4861.         case LO_HRULE:
  4862.         {
  4863.             if( pElement )
  4864.             {
  4865.                 EDT_HorizRuleData * pHData = pElement->HorizRule()->GetData(); //m_pBuffer->GetHorizRuleData();
  4866.                 if( pHData )
  4867.                 {
  4868.                     // Only change dimension if we were sizing it
  4869.                     if( m_iStyle & ED_SIZE_TOP ||
  4870.                         m_iStyle & ED_SIZE_BOTTOM )
  4871.                     {
  4872.                         pHData->size = iHeight;
  4873.                     }
  4874.                     if( m_iStyle & ED_SIZE_LEFT ||
  4875.                         m_iStyle & ED_SIZE_RIGHT )
  4876.                     {
  4877.                         pHData->iWidth = iWidth;
  4878.                     }
  4879.                     m_pBuffer->BeginBatchChanges(kSetHorizRuleDataCommandID);
  4880.                     pElement->HorizRule()->SetData(pHData);
  4881.                     EDT_FreeHorizRuleData(pHData);
  4882.                     m_pBuffer->Relayout(pElement,0);
  4883.                     m_pBuffer->EndBatchChanges();
  4884.                 }
  4885.             }
  4886.             break;
  4887.         }
  4888.         case LO_TABLE:
  4889.         {
  4890.             CEditTableElement *pTable = 
  4891.                 (CEditTableElement*)m_pBuffer->GetTableElementFromLO_Element( m_pLoElement, LO_TABLE );
  4892.             if( pTable )
  4893.             {
  4894.                 if( m_iStyle == ED_SIZE_ADD_ROWS ||
  4895.                     m_iStyle == ED_SIZE_ADD_COLS )
  4896.                 {
  4897.                     // Be sure caret is already in the table,
  4898.                     //  but don't show caret or scroll window
  4899.                     m_pBuffer->MoveAndHideCaretInTable(m_pLoElement);
  4900.  
  4901.                     // Move to last cell of table
  4902.                     // (1ST param unused, 2nd = Forward, 3rd = NextRow index ptr
  4903.                     while(m_pBuffer->NextTableCell(FALSE, TRUE, 0))
  4904.                         ;
  4905.                     // Note: These functions handles Begin/EndBatchChanges
  4906.                     // TODO: CHANGE THIS???
  4907.                     if( m_iStyle == ED_SIZE_ADD_ROWS )
  4908.                         m_pBuffer->InsertTableRows(NULL, TRUE, m_iAddRows);
  4909.                     else
  4910.                         m_pBuffer->InsertTableColumns(NULL, TRUE, m_iAddCols);
  4911.                     
  4912.                     // InsertTable... will relayout
  4913.                     //m_pBuffer->Relayout(pTable, 0);
  4914.                 }
  4915.                 else
  4916.                 {
  4917.                     // Sizing table width
  4918.                     EDT_TableData * pTableData = pTable->GetData();
  4919.                     if( pTableData && iWidth != m_iStartWidth )
  4920.                     {
  4921.                         pTableData->bWidthDefined = TRUE;
  4922.                         pTableData->iWidth = iWidth;
  4923.                         pTableData->iWidthPixels = iWidthPixels;
  4924.                         m_pBuffer->BeginBatchChanges(kSetTableDataCommandID);
  4925.                         pTable->SetData(pTableData);
  4926.                         EDT_FreeTableData(pTableData);
  4927.                         m_pBuffer->Relayout(pTable, 0);
  4928.                         m_pBuffer->EndBatchChanges();
  4929.  
  4930. XP_TRACE(("End Sizing: iWidth = %d", iWidth));
  4931.                     }
  4932.                 }
  4933.             }
  4934.             break;
  4935.         }
  4936.         case LO_CELL:
  4937.         {
  4938.             CEditTableCellElement *pCell = 
  4939.                 (CEditTableCellElement*)m_pBuffer->GetTableElementFromLO_Element( m_pLoElement, LO_CELL );
  4940.             if( pCell )
  4941.             {
  4942.                 EDT_TableCellData * pCellData = pCell->GetData(0);
  4943.                 if( pCellData && iWidth != m_iStartWidth )
  4944.                 {
  4945.                     pCellData->bWidthDefined = TRUE;
  4946.                     pCellData->iWidth = iWidth;
  4947.                     pCellData->iWidthPixels = iWidthPixels;
  4948.                     m_pBuffer->BeginBatchChanges(kSetTableCellDataCommandID);
  4949.                     pCell->SetData(pCellData);
  4950.                     EDT_FreeTableCellData(pCellData);
  4951.  
  4952.                     // Get change in pixels: + means we increased width
  4953.                     int32 iDelta = iWidthPixels - m_pLoElement->lo_any.width;
  4954.                     int32 iNewWidth;
  4955.  
  4956.                     // Column sizing is complicated by the fact that first cell in column
  4957.                     //  may not be in the 1st row because of COLSPAN.
  4958.                     //  We must be sure 1st cell sharing RIGHT edge is resized as well,
  4959.                     LO_TableStruct *pLoTable = lo_GetParentTable(NULL, m_pLoElement);
  4960.                     LO_Element *pLoElement = (LO_Element*)pLoTable;
  4961.  
  4962.                     // Stop when we reach the cell we were sizing
  4963.                     while (pLoElement && pLoElement != m_pLoElement)
  4964.                     {
  4965.                         if( pLoElement->type == LO_CELL &&
  4966.                             ((pLoElement->lo_cell.x + pLoElement->lo_cell.width) ==
  4967.                              (m_pLoElement->lo_cell.x + m_pLoElement->lo_cell.width)) )
  4968.                         {
  4969.                             // We found a different cell in first row - get Edit element
  4970.                             CEditTableCellElement *pFirstCell = 
  4971.                                 (CEditTableCellElement*)m_pBuffer->GetTableElementFromLO_Element( pLoElement, LO_CELL );
  4972.                             if( pFirstCell )
  4973.                             {
  4974.                                 pCellData = pFirstCell->GetData(0);
  4975.                                 if( pCellData )
  4976.                                 {
  4977.                                     iNewWidth = pLoElement->lo_cell.width + iDelta;
  4978.                                     if( pCellData->bWidthPercent )
  4979.                                     {
  4980.                                         int32 iTableWidth = lo_CalcTableWidthForPercentMode(pLoElement);
  4981.                                         pCellData->iWidth = (iNewWidth * 100) / iTableWidth;                                
  4982.                                     } else {
  4983.                                         pCellData->iWidth = iNewWidth;
  4984.                                     }
  4985.                                     pCellData->iWidthPixels = iNewWidth;
  4986.                                     
  4987.                                     pCellData->bWidthDefined = TRUE;
  4988.                                     pFirstCell->SetData(pCellData);
  4989.                                     EDT_FreeTableCellData(pCellData);
  4990.                                     //Note: We don't need to change width in pLoElement
  4991.                                     //  since we will relayout entire table, where new widths are determined
  4992.                                 }
  4993.                             }
  4994.                             break;
  4995.                         }
  4996.                         pLoElement = pLoElement->lo_any.next;
  4997.                     }
  4998.                    
  4999.                     // Also adjust width of entire table by same amount,
  5000.                     //   else changing columns "fights" the user
  5001.                     CEditTableElement *pTable = pCell->GetParentTable();
  5002.  
  5003.                     if( pLoTable && pTable )
  5004.                     {
  5005.                         EDT_TableData * pTableData = pTable->GetData();
  5006.                         if( pTableData )
  5007.                         {
  5008.                             pTableData->bWidthDefined = TRUE;
  5009.                             iNewWidth = pLoTable->width + iDelta;
  5010.  
  5011.                             if( pTableData->bWidthPercent )
  5012.                             {
  5013.                                 // This may be > 100 %, but layout will redistibute sizes correctly
  5014.                                 // TODO: Should we warn the user and convert to "pixel" mode?
  5015.                                 //       or just convert to pixel mode automatically?
  5016.                                 pTableData->iWidth = (iNewWidth * 100) / pLoTable->width;
  5017.  
  5018.                                 // Automatically convert to ABSOLUTE PIXELS if new % is > 100%
  5019.                                 if( pTableData->iWidth > 100 )
  5020.                                 {
  5021.                                     pTableData->iWidth = iNewWidth;
  5022.                                     pTableData->bWidthPercent = FALSE;   
  5023.                                 }
  5024.                             } else {
  5025.                                 pTableData->iWidth = iNewWidth;
  5026.                             }
  5027.                             pTableData->iWidthPixels = iNewWidth;
  5028.                             pTable->SetData(pTableData);
  5029.                             EDT_FreeTableData(pTableData);
  5030.                         }
  5031.                     }
  5032.  
  5033.                     // Relayout the entire table
  5034.                     m_pBuffer->Relayout(pTable, 0);
  5035.                     m_pBuffer->EndBatchChanges();
  5036.                 }
  5037.             }
  5038.             break;
  5039.         }
  5040.     }
  5041. }
  5042.  
  5043. void CSizingObject::EraseAddRowsOrCols()
  5044. {
  5045.     int i;
  5046.     XP_Rect rect;
  5047.     if( m_iStyle == ED_SIZE_ADD_COLS )
  5048.     {
  5049.         // Erase all existing lines
  5050.         // NOTE: We can't draw/erase just the "new" line because 
  5051.         //   we may skip lines if mouse is moved fast, causing a mess
  5052.         for( i=1; i< m_iAddCols; i++ )
  5053.         {
  5054.             CalcAddColRect(i, &m_Rect, &rect);
  5055.             FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, TRUE);
  5056.         }
  5057.     } else if(  m_iStyle == ED_SIZE_ADD_ROWS )
  5058.     {
  5059.         // Erase all existing lines
  5060.         for( i=1; i< m_iAddRows; i++ )
  5061.         {
  5062.             CalcAddRowRect(i, &m_Rect, &rect);
  5063.             FE_DisplayAddRowOrColBorder(m_pBuffer->m_pContext, &rect, TRUE);
  5064.         }
  5065.     }
  5066. }
  5067.  
  5068. CSizingObject::~CSizingObject()
  5069. {
  5070.     // Assure that next comparison to a new rect
  5071.     //   will be different
  5072.     m_Rect.left = -1;
  5073.     FE_Progress(m_pBuffer->m_pContext, "");
  5074.  
  5075.     // Don't leave object in selected state
  5076.     m_pBuffer->ClearSelection(TRUE, FALSE);
  5077. }
  5078. ///////////////////////////////////////////////////
  5079.  
  5080. // Relayout timer ... doesn't quite work perfectly.
  5081.  
  5082. CRelayoutTimer::CRelayoutTimer(){
  5083.     m_pBuffer = NULL;
  5084. }
  5085.  
  5086. void CRelayoutTimer::SetEditBuffer(CEditBuffer* pBuffer){
  5087.     m_pBuffer = pBuffer;
  5088. }
  5089.  
  5090. void CRelayoutTimer::OnCallback() {
  5091.     m_pBuffer->Relayout(m_pStartElement, m_iOffset);
  5092. }
  5093.  
  5094. void CRelayoutTimer::Flush() {
  5095.     if (IsTimeoutEnabled() ) {
  5096.         Cancel();
  5097.         OnCallback();
  5098.     }
  5099. }
  5100.  
  5101. void CRelayoutTimer::Relayout( CEditElement *pStartElement, int iOffset)
  5102. {
  5103.     const uint32 kRelayoutDelay = 50;
  5104.     XP_Bool bSetValues = TRUE;
  5105.     XP_Bool bInTable = pStartElement->GetTableIgnoreSubdoc() != NULL;
  5106.  
  5107.     if ( ! bInTable ) {
  5108.         Flush();
  5109.         m_pBuffer->Relayout(pStartElement, iOffset);
  5110.         return;
  5111.     }
  5112.     if ( IsTimeoutEnabled() ) {
  5113.         Cancel();
  5114.         if ( pStartElement != m_pStartElement ) {
  5115.             OnCallback(); // Do saved relayout now.
  5116.         }
  5117.         else {
  5118.             bSetValues = FALSE;
  5119.         }
  5120.     }
  5121.     if ( bSetValues) {
  5122.         m_pStartElement = pStartElement;
  5123.         m_iOffset = iOffset;
  5124.     }
  5125.  
  5126.     // Put the character into the LO_Element string so that the two data structures are consistent.
  5127.     if (pStartElement->IsText() ){
  5128.         CEditTextElement* pTextElement = pStartElement->Text();
  5129.         LO_TextStruct* pLoText = NULL;
  5130.         int iLoOffset = 0;
  5131.         if ( pTextElement->GetLOTextAndOffset(iOffset, FALSE, pLoText, iLoOffset) ) {
  5132.             if ( pLoText ) {
  5133.                 int32 textLen = pLoText->text_len;
  5134.                 char *pText;
  5135.                 if (textLen <= 0 ){
  5136.                     PA_FREE(pLoText->text);
  5137.                     pLoText->text = (PA_Block) PA_ALLOC(2); // char plus zero terminated.
  5138.                 }
  5139.                 else {
  5140.                     pLoText->text = (PA_Block) PA_REALLOC(pLoText->text, textLen + 2);
  5141.                 }
  5142.                 PA_LOCK(pText, char *, pLoText->text);
  5143.                 int32 bytesToMove = textLen - iLoOffset;
  5144.                 if ( bytesToMove > 0){
  5145.                     XP_MEMMOVE(pText + iLoOffset +1, pText + iLoOffset, bytesToMove);
  5146.                 }
  5147.                 pText[iLoOffset] = pTextElement->GetText()[iOffset];
  5148.                 pText[textLen+1] = '\0';
  5149.                 // XP_TRACE(("pText=%08x %s %d\n", pText, pText, textLen));
  5150.                 PA_UNLOCK(pLoText->text);
  5151.                 textLen++;
  5152.                 pLoText->text_len = (int16) textLen;
  5153.             }
  5154.         }
  5155.     }
  5156.     SetTimeout(kRelayoutDelay);
  5157. }
  5158.  
  5159. CAutoSaveTimer::CAutoSaveTimer() {
  5160.      m_pBuffer = NULL;
  5161.      m_iMinutes = 0;
  5162.      m_bSuspended = FALSE;
  5163.      m_bCalledWhileSuspended = FALSE;
  5164. }
  5165.  
  5166. void CAutoSaveTimer::SetEditBuffer(CEditBuffer* pBuffer){
  5167.     m_pBuffer = pBuffer;
  5168.     // Sanity check, is this an OK Buffer?
  5169.     XP_ASSERT(m_pBuffer->m_pRoot);
  5170. }
  5171.  
  5172. void CAutoSaveTimer::OnCallback() {
  5173.     if( m_bSuspended ){
  5174.         m_bCalledWhileSuspended = TRUE;
  5175.     } else {
  5176.         // Sanity check -- is this an OK Buffer?
  5177.         if ( ! m_pBuffer || ! m_pBuffer->m_pRoot ) {
  5178.             XP_ASSERT(FALSE);
  5179.             return;
  5180.         }
  5181.         // Skip autosave if currently suspended
  5182.         m_pBuffer->AutoSaveCallback();
  5183.         Restart();
  5184.     }
  5185. }
  5186.  
  5187. void CAutoSaveTimer::Restart() {
  5188. #ifdef DEBUG_AUTO_SAVE
  5189.     const int32 kMillisecondsPerMinute = 6000L; //60000L; // * 1000 / 10;
  5190. #else
  5191.     const int32 kMillisecondsPerMinute = 60000L;
  5192. #endif
  5193.     if ( m_iMinutes > 0 ) {
  5194.         SetTimeout(m_iMinutes * kMillisecondsPerMinute);
  5195.     }
  5196. }
  5197.  
  5198. void CAutoSaveTimer::SetPeriod(int32 minutes){
  5199.     Cancel();
  5200.     m_iMinutes = minutes;
  5201.     Restart();
  5202. }
  5203.  
  5204. int32 CAutoSaveTimer::GetPeriod(){
  5205.     return m_iMinutes;
  5206. }
  5207.  
  5208. void CAutoSaveTimer::Suspend(){
  5209.     m_bSuspended = TRUE;
  5210. }
  5211.  
  5212. void CAutoSaveTimer::Resume(){
  5213.     m_bSuspended = FALSE;
  5214.     // We need to restart the timer ONLY
  5215.     //  if we were called during a suspended period
  5216.     if( m_bCalledWhileSuspended ){
  5217.         m_bCalledWhileSuspended = FALSE;
  5218.     } else {
  5219.         Restart();
  5220.     }
  5221. }
  5222.  
  5223. CEditDocState::CEditDocState() {
  5224.   m_pBuffer = NULL;
  5225.   m_version = 0;
  5226. }
  5227.  
  5228. CEditDocState::~CEditDocState() {
  5229.   if (m_pBuffer) {
  5230.     XP_HUGE_FREE(m_pBuffer);
  5231.   }
  5232. }
  5233.  
  5234. #ifdef DEBUG
  5235. void CEditDocState::Print(IStreamOut& stream) {
  5236.   if (!m_pBuffer) return;
  5237.  
  5238.   stream.Printf("%d bytes", XP_STRLEN(m_pBuffer));
  5239.   // have to dump one line at a time. XP_TRACE has a 512 char limit on Windows.
  5240.   char* b = m_pBuffer;
  5241.   while ( *b != '\0' ) {
  5242.       char* b2 = b;
  5243.       while ( *b2 != '\0' && *b2 != '\n'){
  5244.           b2++;
  5245.       }
  5246.       char old = *b2;
  5247.       *b2 = '\0';
  5248.       stream.Printf("%s\n", b);
  5249.       *b2 = old;
  5250.       b = b2 + 1;
  5251.       if ( old == '\0' ) break;
  5252.   }
  5253. }
  5254. #endif
  5255.  
  5256.  
  5257.  
  5258. /* Take the document for current context and change appropriate
  5259.  *   params to make it look like a "Untitled" new document
  5260.  * Allows loading any document as a "Template"
  5261.  */
  5262. void EDT_ConvertCurrentDocToNewDoc(MWContext * pMWContext)
  5263. {
  5264.     XP_ASSERT(pMWContext);
  5265.     if( !pMWContext ){
  5266.         return;
  5267.     }
  5268.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pMWContext, pEditBuffer);
  5269.  
  5270.     char * pUntitled = XP_GetString(XP_EDIT_NEW_DOC_NAME);
  5271.  
  5272.     // Traverse all links and images and change URLs to absolute
  5273.     //   since we will be destroying our current base doc URL
  5274.     EDT_ImageData *pImageData;
  5275.     char *pAbsolute = NULL;
  5276.     EDT_PageData *pPageData = pEditBuffer->GetPageData();
  5277.     if( !pPageData){
  5278.         return;
  5279.     }
  5280.     
  5281.     // Should be the same as pEntry->Address???
  5282.     char *pBaseURL = LO_GetBaseURL(pMWContext);
  5283.  
  5284.     // Call Java Plugin hook for pages to be closed,
  5285.     //  BUT only if it really was an lockable source
  5286.     int iType = NET_URL_Type(pBaseURL);
  5287.     if( iType == FTP_TYPE_URL ||
  5288.         iType == HTTP_TYPE_URL ||
  5289.         iType == SECURE_HTTP_TYPE_URL ||
  5290.         iType == FILE_TYPE_URL ){
  5291.         EDT_PreClose(pMWContext, pBaseURL, NULL, NULL);
  5292.     }
  5293.  
  5294.     // Walk the tree and find all HREFs.
  5295.     CEditElement *pLeaf = pEditBuffer->m_pRoot->FindNextElement( 
  5296.                                   &CEditElement::FindLeafAll,0 );
  5297.     // First sweep, mark all HREFs as not adjusted.
  5298.     while (pLeaf) {
  5299.         pEditBuffer->linkManager.SetAdjusted(pLeaf->Leaf()->GetHREF(),FALSE);
  5300.         pLeaf = pLeaf->FindNextElement(&CEditElement::FindLeafAll,0 );
  5301.     }
  5302.     // Second sweep, actually adjust the HREFs.
  5303.     pLeaf = pEditBuffer->m_pRoot->FindNextElement( 
  5304.             &CEditElement::FindLeafAll,0 );
  5305.     while (pLeaf) {
  5306.         ED_LinkId linkId = pLeaf->Leaf()->GetHREF();
  5307.         if (linkId && !pEditBuffer->linkManager.GetAdjusted(linkId)) {
  5308.             pEditBuffer->linkManager.AdjustLink(linkId, pBaseURL, NULL, NULL);          
  5309.             pEditBuffer->linkManager.SetAdjusted(linkId,TRUE);
  5310.         }
  5311.         pLeaf = pLeaf->FindNextElement(&CEditElement::FindLeafAll,0 );
  5312.     }
  5313.  
  5314.     // Regular images.
  5315.     CEditElement *pImage = pEditBuffer->m_pRoot->FindNextElement( 
  5316.                                    &CEditElement::FindImage, 0 );
  5317.     while( pImage ){
  5318.         pImageData = pImage->Image()->GetImageData();
  5319.         if( pImageData ){
  5320.             if( pImageData->pSrc && *pImageData->pSrc ){
  5321.                 char * pOld = XP_STRDUP(pImageData->pSrc);
  5322.                 pAbsolute = NET_MakeAbsoluteURL( pBaseURL, pImageData->pSrc );
  5323.                 if( pAbsolute ){
  5324.                     XP_FREE(pImageData->pSrc);
  5325.                     pImageData->pSrc = pAbsolute;
  5326.                 }
  5327.              }
  5328.              if( pImageData->pLowSrc && *pImageData->pLowSrc){
  5329.                 pAbsolute = NET_MakeAbsoluteURL( pBaseURL, pImageData->pLowSrc );
  5330.                 if( pAbsolute ){
  5331.                     XP_FREE(pImageData->pLowSrc);
  5332.                     pImageData->pLowSrc = pAbsolute;
  5333.                 }
  5334.             }    
  5335.             pImage->Image()->SetImageData( pImageData );
  5336.             edt_FreeImageData( pImageData );
  5337.         }
  5338.         pImage = pImage->FindNextElement( &CEditElement::FindImage, 0 );
  5339.     }
  5340.  
  5341.     // If there is a background Image, make it absolute also
  5342.     if( pPageData->pBackgroundImage && *pPageData->pBackgroundImage){
  5343.         pAbsolute = NET_MakeAbsoluteURL( pBaseURL, pPageData->pBackgroundImage );
  5344.         if( pAbsolute ){
  5345.             XP_FREE(pPageData->pBackgroundImage);
  5346.             pPageData->pBackgroundImage = pAbsolute;
  5347.         }
  5348.     }
  5349.  
  5350.     // Change context's "title" string
  5351.     XP_FREEIF(pMWContext->title);
  5352.     pMWContext->title = NULL;
  5353.     pMWContext->is_new_document = TRUE;
  5354.  
  5355.     // Change the history entry data
  5356.     History_entry * pEntry = SHIST_GetCurrent(&(pMWContext->hist));
  5357.     if(pEntry ){
  5358.         XP_FREEIF(pEntry->address);
  5359.         pEntry->address = XP_STRDUP(pUntitled);
  5360.         XP_FREEIF(pEntry->title);
  5361.     }
  5362.     // Layout uses this as the base URL for all links and images
  5363.     LO_SetBaseURL( pMWContext, pUntitled );
  5364.  
  5365.     // Cleat the old title in page data
  5366.     XP_FREEIF(pPageData->pTitle); 
  5367.  
  5368.     // This will set new background image,
  5369.     //   call FE_SetDocTitle() with new "file://Untitled" string,
  5370.     //   and refresh the layout of entire doc
  5371.     pEditBuffer->SetPageData(pPageData);
  5372.  
  5373.     pEditBuffer->FreePageData(pPageData);
  5374. }
  5375.  
  5376. char * EDT_GetFilename(char * pURL, XP_Bool bMustHaveExtension)
  5377. {
  5378.     // No string or its empty
  5379.     if( !pURL || !*pURL ){
  5380.         return NULL;
  5381.     }
  5382.     
  5383.     // Isolate just the filename of source URL
  5384.     char * pFilename = XP_STRRCHR(pURL, '/');
  5385.  
  5386.     // Maybe its a local filename?
  5387.     if(!pFilename){
  5388.         pFilename = XP_STRRCHR(pURL, '\\');
  5389.     }
  5390.  
  5391.     // Or just after host or drive letter?
  5392.     if(!pFilename){
  5393.         pFilename = XP_STRCHR(pURL, ':');
  5394.     }
  5395.  
  5396.     if(pFilename){
  5397.         // Filename starts just after "/"
  5398.         pFilename++;
  5399.     } else {
  5400.         // Use what we have - maybe not a full URL spec?
  5401.         pFilename = pURL;
  5402.     }
  5403.     char * pResult = NULL;
  5404.  
  5405.     if( pFilename && *pFilename ){
  5406.         // Don't include any stuff after filename
  5407.         char * ques = XP_STRCHR(pFilename, '?');
  5408.         char * hash = XP_STRCHR(pFilename, '#');
  5409.         if(ques){
  5410.             *ques = '\0';
  5411.         }
  5412.         if(hash){
  5413.             *hash = '\0';
  5414.         }
  5415.  
  5416.         // Check if we must have a period to be considered a filename
  5417.         // This allow text without "." to be considered a subdirectory, not filename
  5418.         if( *pFilename ){
  5419.             if( !bMustHaveExtension || 
  5420.                  (bMustHaveExtension && XP_STRCHR(pFilename, '.')) ){
  5421.                 // Copy just the filename if we have one
  5422.                 pResult = XP_STRDUP(pFilename);
  5423.             }
  5424.         }
  5425.  
  5426.         // set the values back 
  5427.         if(ques){
  5428.             *ques = '?';
  5429.         }
  5430.         if(hash){
  5431.             *hash = '#';
  5432.         }
  5433.     }    
  5434.     return pResult;
  5435. }
  5436.  
  5437.  char * EDT_ReplaceFilename(char * pBaseURL, char * pURL, XP_Bool bMustHaveExtension)
  5438. {
  5439.     char * pResult = NULL;
  5440.     if( !pBaseURL || !*pBaseURL ){
  5441.         return NULL;
  5442.     }
  5443.     // Find the start of filename in base - 
  5444.     // copy to new string
  5445.     // **** We overload the meaning of bMustHaveExtension to 
  5446.     //      also cause any filename on the base to have an extension,
  5447.     //      else any name without trailing slash, such as //chainsaw/mydir",
  5448.     //      will be "corrected" by adding trailing slash
  5449.     if( bMustHaveExtension ){
  5450.         char * pBaseFilename = EDT_GetFilename(pBaseURL, bMustHaveExtension);
  5451.         int iLen = XP_STRLEN(pBaseURL);
  5452.         if( !pBaseFilename && pBaseURL[iLen-1] != '/' ){
  5453.             // No trailing slash found, copy string and append one
  5454.             pResult = (char*)XP_ALLOC(iLen+1);
  5455.             if( !pResult ){
  5456.                 return NULL;
  5457.             }
  5458.             XP_STRCPY(pResult, pBaseURL);
  5459.             pResult[iLen] = '/';
  5460.             pResult[iLen+1] = '\0';
  5461.         }
  5462.         XP_FREEIF(pBaseFilename);
  5463.     }
  5464.     if( !pResult ){
  5465.         char * pBaseEnd = XP_STRRCHR(pBaseURL, '/');
  5466.  
  5467.         if( !pBaseEnd )
  5468.             pBaseEnd = XP_STRCHR(pBaseURL, ':');
  5469.         if( !pBaseEnd )
  5470.             return NULL;
  5471.  
  5472.         pBaseEnd++;
  5473.         char save_char = *pBaseEnd;
  5474.         *pBaseEnd = '\0';
  5475.  
  5476.         // Allocate result and copy the base part
  5477.         StrAllocCat(pResult, pBaseURL);
  5478.  
  5479.         // Restore character
  5480.         *pBaseEnd = save_char;
  5481.     }
  5482.     if( pResult && pURL ){
  5483.         // Get just the filename of source URL
  5484.         char * pFilename = EDT_GetFilename(pURL, bMustHaveExtension);
  5485.         if( pFilename ){
  5486.             // Append the filename to the base
  5487.             StrAllocCat(pResult, pFilename);
  5488.             XP_FREE(pFilename);
  5489.         }
  5490.     }
  5491.  
  5492.     //Note: If no pURL, pBaseURL is returned stripped of its filename
  5493.     return pResult;        
  5494. }
  5495.  
  5496. char * EDT_GetDefaultPublishURL(MWContext * pMWContext, char **ppFilename, char **ppUserName, char **ppPassword)
  5497. {
  5498.     XP_ASSERT(pMWContext);
  5499.     char * pURL = LO_GetBaseURL(pMWContext);
  5500.     if( !pURL ){
  5501.         return NULL;
  5502.     }
  5503.     XP_Bool bLastPublishFailed = EDT_IsSameURL(CEditSaveObject::m_pFailedPublishUrl, pURL, NULL, NULL);
  5504.  
  5505.     if( ppFilename ){
  5506.         if( EDT_IS_NEW_DOCUMENT(pMWContext) ){
  5507.             // New page: empty filename
  5508.             *ppFilename = NULL;
  5509.         } else {
  5510.             // Extract current filename part
  5511.             *ppFilename = EDT_GetFilename(pURL, TRUE);
  5512.  
  5513.             // On win16 force to lower case.
  5514. #ifdef XP_WIN16
  5515.             char *pConvert = *ppFilename;
  5516.             while (pConvert && *pConvert) {
  5517.               *pConvert = XP_TO_LOWER(*pConvert);
  5518.               pConvert++;
  5519.             }
  5520. #endif
  5521.         }
  5522.     }
  5523.     // Default: Clear password
  5524.     if( ppPassword ){
  5525.         *ppPassword = NULL;
  5526.     }
  5527.  
  5528.     if( !bLastPublishFailed && !EDT_IS_NEW_DOCUMENT(pMWContext) ){
  5529.         int iType = NET_URL_Type(pURL);
  5530.         if( iType == FTP_TYPE_URL ||
  5531.             iType == HTTP_TYPE_URL ||
  5532.             iType == SECURE_HTTP_TYPE_URL ) {
  5533.             // We are editing a remote page, so try to return it to that location
  5534.             // (We don't know the password)
  5535.             // Truncate current URL at the filename
  5536.             return EDT_ReplaceFilename(pURL, NULL, TRUE);
  5537.         }
  5538.     }
  5539.  
  5540.     char *pPrefURL = NULL;
  5541.     XP_Bool bUseDefault = FALSE;
  5542.  
  5543.     if( bLastPublishFailed ){
  5544.         // The publish destination should be saved to this at start of publishing (thus may not be "correct")
  5545.         // The destination should also be saved to the first history pref (editor.publish_history_0) 
  5546.         //  but only if publishing succeeded
  5547.         PREF_CopyCharPref("editor.publish_last_loc", &pPrefURL);
  5548.     } else {
  5549.         // Use the last successfully-used location saved in preferences
  5550.         PREF_CopyCharPref("editor.publish_history_0", &pPrefURL);
  5551.     }
  5552.     // Be sure to check for empty pref string
  5553.     if( !pPrefURL || !*pPrefURL ){
  5554.         XP_FREEIF(pPrefURL);
  5555.         // No last-used location -- use the default location
  5556.         PREF_CopyCharPref("editor.publish_location", &pPrefURL);
  5557.         bUseDefault = TRUE;
  5558.     }   
  5559.  
  5560.     char * pLocation = 0;
  5561.     char * pUserName = ppUserName ? *ppUserName : 0;
  5562.     
  5563.     // Parse the preference string to extract Username
  5564.     //  (password is separate for security munging)
  5565.     NET_ParseUploadURL( pPrefURL, &pLocation, &pUserName, NULL );
  5566.  
  5567.     if (ppUserName)
  5568.         *ppUserName = pUserName;
  5569.  
  5570.     if( ppPassword ){
  5571.         // Get the corrsponding password saved
  5572.         char * pPassword = NULL;
  5573.         if( bLastPublishFailed ){
  5574.         } else if( bUseDefault ){
  5575.             PREF_CopyCharPref("editor.publish_password", &pPassword);
  5576.         } else {
  5577.             PREF_CopyCharPref("editor.publish_password_0", &pPassword);
  5578.         }
  5579.  
  5580.         if( pPassword && *pPassword ){
  5581.             *ppPassword = SECNAV_UnMungeString(pPassword);
  5582.             XP_FREE(pPassword);
  5583.         }
  5584.     }
  5585.     XP_FREEIF(pPrefURL);
  5586.  
  5587.     return pLocation;
  5588. }
  5589.  
  5590. //
  5591. //    Keep this localized here. These two functions are the only ones
  5592. //    that need to know this value.
  5593. //    NOTE: CALLER MUST FREE THE RETURNED STRINGS
  5594. #define MAX_PUBLISH_LOCATIONS 20
  5595.  
  5596. XP_Bool
  5597. EDT_GetPublishingHistory(unsigned n,
  5598.                          char** location_r,
  5599.                          char** username_r,
  5600.                          char** password_r)
  5601. {
  5602.     char  prefname[32];
  5603.     char* prefvalue = NULL;
  5604.  
  5605.     if (n >= MAX_PUBLISH_LOCATIONS)
  5606.         return FALSE;
  5607.  
  5608.     XP_SPRINTF(prefname, "editor.publish_history_%d", n);
  5609.  
  5610.     if( PREF_CopyCharPref(prefname, &prefvalue) == -1 ||
  5611.         prefvalue == NULL || prefvalue[0] == '\0')
  5612.         return FALSE;
  5613.  
  5614.     if (location_r != NULL)
  5615.         *location_r = NULL; /* else NET_ParseUploadURL() will try to free! */
  5616.     if (username_r != NULL)
  5617.         *username_r = NULL;
  5618.  
  5619.     XP_Bool return_value;
  5620.     return_value = NET_ParseUploadURL(prefvalue, location_r, username_r, NULL);
  5621.     XP_FREE(prefvalue); // done with this now.
  5622.  
  5623.     if (!return_value)
  5624.         return FALSE;
  5625.  
  5626.     if (password_r != NULL) {
  5627.         XP_SPRINTF(prefname, "editor.publish_password_%d", n);
  5628.  
  5629.         if (PREF_CopyCharPref(prefname, &prefvalue) != -1 && prefvalue && *prefvalue) {
  5630.             *password_r = SECNAV_UnMungeString(prefvalue);
  5631.         } else {
  5632.             *password_r = NULL;
  5633.         }
  5634.         if (prefvalue != NULL)
  5635.             XP_FREE(prefvalue);
  5636.     }
  5637.     return TRUE;
  5638. }
  5639.  
  5640. void
  5641. EDT_SyncPublishingHistory()
  5642. {
  5643.     char  prefname[32];
  5644.     char* prefvalue = NULL;
  5645.     char* pLastLoc = NULL;
  5646.     char* pLastPass = NULL;
  5647.     int   i;
  5648.     
  5649.     /*
  5650.      *    Last location should be set when you start a publish.
  5651.      *    Now copy this to the top (first) of the history.
  5652.      *    Abort if pref doesn't exist or is empty
  5653.      */
  5654.     if( PREF_CopyCharPref("editor.publish_last_loc", &pLastLoc) == -1 ||
  5655.         !pLastLoc || !*pLastLoc )
  5656.         return;
  5657.     PREF_CopyCharPref("editor.publish_last_pass", &pLastPass);
  5658.     
  5659.     /*
  5660.      *    First scan the list to find pref that matches new item
  5661.      */
  5662.     for (i = 0; i < (MAX_PUBLISH_LOCATIONS - 1); i++) {
  5663.         XP_SPRINTF(prefname, "editor.publish_history_%d", i);
  5664.         if( PREF_CopyCharPref(prefname, &prefvalue) == -1 ||
  5665.             !prefvalue || !*prefvalue ||
  5666.             XP_STRCMP(prefvalue, pLastLoc) == 0) {
  5667.             //
  5668.             //    No history or this history matches the last publish location.
  5669.             //
  5670.             break;
  5671.         }
  5672.         XP_FREEIF(prefvalue);
  5673.     }
  5674.     XP_FREEIF(prefvalue);
  5675.     
  5676.     /*
  5677.      *    Now shift everything up a slot.
  5678.      */
  5679.     for (; i > 0; i--) {
  5680.         XP_SPRINTF(prefname, "editor.publish_history_%d", i-1);
  5681.         PREF_CopyCharPref(prefname, &prefvalue);
  5682.         XP_SPRINTF(prefname, "editor.publish_history_%d", i);
  5683.         PREF_SetCharPref(prefname, prefvalue);
  5684.         XP_FREEIF(prefvalue);
  5685.         
  5686.         XP_SPRINTF(prefname, "editor.publish_password_%d", i-1);
  5687.         PREF_CopyCharPref(prefname, &prefvalue);
  5688.         XP_SPRINTF(prefname, "editor.publish_password_%d", i);
  5689.         PREF_SetCharPref(prefname, prefvalue);
  5690.         XP_FREEIF(prefvalue);
  5691.     }
  5692.     
  5693.     /*
  5694.      *    Now set the zero'th one.
  5695.      */
  5696.     PREF_SetCharPref("editor.publish_history_0", pLastLoc);
  5697.     PREF_SetCharPref("editor.publish_password_0", pLastPass);
  5698.     
  5699.     XP_FREEIF(pLastLoc);
  5700.     XP_FREEIF(pLastPass);
  5701. }
  5702.  
  5703. //
  5704. // This was placed in EDT.H so front ends can use it as well
  5705. // #define MAX_EDIT_HISTORY_LOCATIONS 10 
  5706.  
  5707. // Cache the Edit History data
  5708. static char** ppEditHistoryURLs = NULL;
  5709. static char** ppEditHistoryTitles = NULL;
  5710.  
  5711. //    NOTE: Caller must NOT free the returned strings - they are locally cached
  5712. XP_Bool
  5713. EDT_GetEditHistory(MWContext * pMWContext, unsigned n,
  5714.                    char** ppUrl, char** ppTitle)
  5715. {
  5716.     char  prefname[32];
  5717.     unsigned i;
  5718.     
  5719.     // if context is NULL, bail!
  5720.     if( !pMWContext )
  5721.         return FALSE;
  5722.     
  5723.     // Initialize list if not done so already
  5724.     if( !ppEditHistoryURLs )
  5725.         EDT_SyncEditHistory(pMWContext);
  5726.  
  5727.     // Check if current URL is matches the requested or more recent items in the list
  5728.     if( pMWContext )
  5729.     {
  5730.         History_entry * pEntry = SHIST_GetCurrent(&(pMWContext->hist));
  5731.         if( pEntry && pEntry->address )
  5732.         {
  5733.             for( i = 0; i <= n; i++ ){
  5734.                 XP_SPRINTF(prefname, "editor.url_history.URL_%d", i);
  5735.                 if( ppEditHistoryURLs[i] && 
  5736.                     EDT_IsSameURL(pEntry->address, ppEditHistoryURLs[i], 0, 0) )
  5737.                 {
  5738.                     // The current doc was found, so skip over it
  5739.                     n++;
  5740.                     break;
  5741.                 }        
  5742.             }
  5743.         }
  5744.     }
  5745.     // Default in case we don't set the location
  5746.     if( ppUrl )
  5747.         *ppUrl = NULL;
  5748.     
  5749.     if( n >= MAX_EDIT_HISTORY_LOCATIONS )
  5750.         return FALSE;
  5751.  
  5752.     if( !ppEditHistoryURLs[n] )
  5753.         return FALSE;
  5754.  
  5755.     // Return URL and Title to caller
  5756.     if( ppUrl )
  5757.         *ppUrl = ppEditHistoryURLs[n];
  5758.  
  5759.     if( ppTitle )
  5760.         *ppTitle = ppEditHistoryTitles[n];
  5761.  
  5762.     return TRUE;
  5763. }
  5764.  
  5765. static char  pEmpty[] = ""; 
  5766.  
  5767. void
  5768. EDT_SyncEditHistory(MWContext * pMWContext)
  5769. {
  5770.     char  prefname[32];
  5771.     char* prefvalue = NULL;
  5772.     char* pTitle = pEmpty;
  5773.     int   i;
  5774.     
  5775.     if(!pMWContext)
  5776.         return;
  5777.  
  5778.     // Initialize the local arrays from the current preference list
  5779.     if( !ppEditHistoryURLs )
  5780.     {
  5781.         ppEditHistoryURLs = (char**)XP_ALLOC( MAX_EDIT_HISTORY_LOCATIONS * sizeof(char*) );
  5782.         if( !ppEditHistoryURLs )
  5783.             return;
  5784.  
  5785.         ppEditHistoryTitles = (char**)XP_ALLOC( MAX_EDIT_HISTORY_LOCATIONS * sizeof(char*) );
  5786.         if( !ppEditHistoryTitles )
  5787.         {
  5788.             XP_FREEIF(ppEditHistoryURLs);
  5789.             return;
  5790.         }
  5791.  
  5792.         for( i = 0; i < MAX_EDIT_HISTORY_LOCATIONS; i++ )
  5793.         {
  5794.             XP_SPRINTF(prefname, "editor.url_history.URL_%d", i);
  5795.             if(PREF_CopyCharPref(prefname, &prefvalue) != -1 &&
  5796.                prefvalue && *prefvalue )
  5797.             {
  5798.                 ppEditHistoryURLs[i] = prefvalue;
  5799.                 prefvalue = NULL;
  5800.  
  5801.             } else {
  5802.                 ppEditHistoryURLs[i] = NULL;
  5803.                 XP_FREEIF(prefvalue);
  5804.             }
  5805.  
  5806.             XP_SPRINTF(prefname, "editor.url_history.TITLE_%d", i);
  5807.             if(PREF_CopyCharPref(prefname, &prefvalue) != -1 &&
  5808.                prefvalue && *prefvalue )
  5809.             {
  5810.                 ppEditHistoryTitles[i] = prefvalue;
  5811.                 prefvalue = NULL;
  5812.             } else {
  5813.                 ppEditHistoryTitles[i] = NULL;
  5814.                 XP_FREEIF(prefvalue);
  5815.             }
  5816.         }
  5817.     }
  5818.  
  5819.     History_entry * pEntry = SHIST_GetCurrent(&(pMWContext->hist));
  5820.     if(pEntry )
  5821.     {
  5822.         // Must have an address
  5823.         if( !pEntry->address || !*pEntry->address )
  5824.             return;
  5825.  
  5826.         // Test for new document URL: file://Untitled and ignore it
  5827.         if( !XP_STRCMP(XP_GetString(XP_EDIT_NEW_DOC_NAME), pEntry->address) ||
  5828.             !XP_STRCMP(XP_GetString(XP_EDIT_NEW_DOC_URL), pEntry->address))
  5829.         {
  5830.             return;
  5831.         }
  5832.  
  5833.         if( pEntry->title && *pEntry->title ){
  5834.             pTitle = pEntry->title;
  5835.         }
  5836.     }
  5837.  
  5838.     /*
  5839.      *    First scan the list to find pref URL that matches current page
  5840.      */
  5841.     for (i = 0; i < (MAX_EDIT_HISTORY_LOCATIONS - 1); i++)
  5842.     {
  5843.         XP_SPRINTF(prefname, "editor.url_history.URL_%d", i);
  5844.         if( !ppEditHistoryURLs[i] ||
  5845.             EDT_IsSameURL(ppEditHistoryURLs[i], pEntry->address, 0, 0) ) {
  5846.             //
  5847.             //    No history or this history matches the current last-edited URL
  5848.             //
  5849.             break;
  5850.         }
  5851.     }
  5852.     // Now i = the index to last-edited URL or last possible URL in the list
  5853.     if( i == (MAX_EDIT_HISTORY_LOCATIONS-1) )
  5854.     {
  5855.         // We will be replacing the last item, so delete it
  5856.         //   so delete it
  5857.         XP_FREEIF(ppEditHistoryURLs[i]);
  5858.         XP_FREEIF(ppEditHistoryTitles[i]);
  5859.     }
  5860.     
  5861.     /*
  5862.      *    Now shift everything one item.
  5863.      */
  5864.     for (; i > 0; i--)
  5865.     {
  5866.         XP_SPRINTF(prefname, "editor.url_history.URL_%d", i);
  5867.         // Not sure if this can handle null string, so lets not try!
  5868.         PREF_SetCharPref(prefname, ppEditHistoryURLs[i-1] ? ppEditHistoryURLs[i-1] : pEmpty);
  5869.         
  5870.         ppEditHistoryURLs[i] = ppEditHistoryURLs[i-1];        
  5871.  
  5872.         XP_SPRINTF(prefname, "editor.url_history.TITLE_%d", i);
  5873.         PREF_SetCharPref(prefname, ppEditHistoryTitles[i-1] ? ppEditHistoryTitles[i-1] : pEmpty);
  5874.  
  5875.         ppEditHistoryTitles[i] = ppEditHistoryTitles[i-1];        
  5876.     }
  5877.     
  5878.     /*
  5879.      *    Now set the zero'th one -- the current URL
  5880.      */
  5881.     PREF_SetCharPref("editor.url_history.URL_0", pEntry->address);
  5882.     PREF_SetCharPref("editor.url_history.TITLE_0", pTitle);
  5883.  
  5884.     ppEditHistoryURLs[0] = XP_STRDUP(pEntry->address);        
  5885.  
  5886.  
  5887.     if( pTitle && *pTitle )
  5888.     {
  5889.         ppEditHistoryTitles[0] = XP_STRDUP(pTitle);
  5890.     } else {
  5891.         ppEditHistoryTitles[0] = NULL;
  5892.     }        
  5893. }
  5894.  
  5895. void edt_UpdateEditHistoryTitle(MWContext * pMWContext, char * pTitle)
  5896. {
  5897.     if( pMWContext )
  5898.     {
  5899.         History_entry * pEntry = SHIST_GetCurrent(&(pMWContext->hist));
  5900.         if(pEntry && pEntry->address && !*pEntry->address)
  5901.         {
  5902.             for (int i = 0; i < MAX_EDIT_HISTORY_LOCATIONS; i++)
  5903.             {
  5904.                 char  prefname[32];
  5905.                 XP_SPRINTF(prefname, "editor.url_history.URL_%d", i);
  5906.                 if( ppEditHistoryURLs[i] &&
  5907.                     EDT_IsSameURL(ppEditHistoryURLs[i], pEntry->address, 0, 0) )
  5908.                 {
  5909.                     XP_FREEIF(ppEditHistoryTitles[i]);
  5910.                     if( pTitle )
  5911.                         ppEditHistoryTitles[i] = pTitle;
  5912.  
  5913.                     // Also update the preference value
  5914.                     char  prefname[32];
  5915.                     XP_SPRINTF(prefname, "editor.url_history.TITLE_%d", i);
  5916.                 
  5917.                     // Not sure if this can handle null string, so lets not try!
  5918.                     PREF_SetCharPref(prefname, pTitle ? pTitle : pEmpty);
  5919.                     return;
  5920.                 }
  5921.             }
  5922.         }
  5923.     }
  5924. }
  5925.  
  5926. char * EDT_GetPageTitleFromFilename(char * pFilename)
  5927. {
  5928.     char * pTitle = NULL;
  5929.     if( pFilename ){
  5930.         // Get Full "filename" and we don't need an extension
  5931.         pTitle = EDT_GetFilename(pFilename, FALSE);
  5932.     
  5933.         if( pTitle ){
  5934.             // Don't include extension
  5935.             char * period = XP_STRCHR(pTitle, '.');
  5936.             if(period){
  5937.                 // Truncate at the beginning of extension
  5938.                 *period = '\0';
  5939.             }
  5940.         }
  5941.     }
  5942.     return pTitle;
  5943. }
  5944.  
  5945. // True if both urls are the same, ignores any username/password
  5946. // information.  Does caseless comparison for file:// URLs 
  5947. // on windows and mac.
  5948. // url1 and url2 are relative to base1 and base2, respectively.
  5949. // If url1 or url2 is already absolute, base1 or base2 can 
  5950. // be passed in as NULL.
  5951. XP_Bool EDT_IsSameURL(char *url1,char *url2,char *base1,char *base2) {
  5952.   // Check for NULL or empty strings.
  5953.   if (!url1 || !url2 || !*url1 || !*url2) {
  5954.     return FALSE;
  5955.   }
  5956.  
  5957.   // Used passed in base URLs if provided.
  5958.   char *pAbs1 = NULL;
  5959.   char *pAbs2 = NULL;
  5960.   if (base1) {
  5961.     pAbs1 = NET_MakeAbsoluteURL(base1,url1);
  5962.   }
  5963.   if (base2) {
  5964.     pAbs2 = NET_MakeAbsoluteURL(base2,url2);
  5965.   }
  5966.   // Strip any username/password info from urls in making comparison if
  5967.   // they are http, https, or ftp.
  5968.   char *pUrl1 = edt_StripUsernamePassword(pAbs1 ? pAbs1 : url1);
  5969.   char *pUrl2 = edt_StripUsernamePassword(pAbs2 ? pAbs2 : url2);
  5970.   edt_StripAtHashOrQuestionMark(pUrl1);
  5971.   edt_StripAtHashOrQuestionMark(pUrl2);
  5972.  
  5973.   XP_Bool bRetVal = FALSE;
  5974.   if (pUrl1 && pUrl2) {
  5975.     char *pBaseUrl1 = NET_ParseURL(pUrl1, GET_PATH_PART);
  5976.     char *pBaseUrl2 = NET_ParseURL(pUrl2, GET_PATH_PART);
  5977. #if defined(XP_WIN) || defined(XP_MAC) || defined(XP_OS2)
  5978.     // Strip off Target (named Anchors)
  5979.     // Local file URLs are equivalent if they differ only 
  5980.     // by case.
  5981.     if (NET_URL_Type(pUrl1) == FILE_TYPE_URL) {
  5982.       bRetVal = (XP_STRCASECMP( pUrl1, pUrl2 ) == 0);
  5983.     }
  5984.     else {
  5985.       bRetVal = (XP_STRCMP( pUrl1, pUrl2 ) == 0 );
  5986.     }
  5987. #else
  5988.     // Use regular strcmp.
  5989.     bRetVal = (XP_STRCMP( pUrl1, pUrl2 ) == 0 );
  5990. #endif
  5991.   }
  5992.   
  5993.   XP_FREEIF(pUrl1);
  5994.   XP_FREEIF(pUrl2);
  5995.   XP_FREEIF(pAbs1);
  5996.   XP_FREEIF(pAbs2);
  5997.   return bRetVal;
  5998. }
  5999.  
  6000. // Replace the current selection with supplied text
  6001. void EDT_ReplaceText(MWContext *pContext, char * pReplaceText, XP_Bool bReplaceAll,
  6002.                     char *pTextToLookFor, XP_Bool bCaseless, XP_Bool bBackward, XP_Bool bDoWrap)
  6003. {
  6004.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6005.     pEditBuffer->ReplaceLoop( pReplaceText, bReplaceAll, 
  6006.                               pTextToLookFor, bCaseless, bBackward, bDoWrap );
  6007. }
  6008.  
  6009. // Block of functions moved from EDITOR.CPP for Win16 Build
  6010. // NOT USED???
  6011. #ifdef FIND_REPLACE
  6012.  
  6013. XP_Bool EDT_FindAndReplace(MWContext *pContext,
  6014.                 EDT_FindAndReplaceData *pData ){
  6015.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6016.     return pEditBuffer->FindAndReplace( pData );
  6017.  
  6018. }
  6019. #endif  // FIND_REPLACE
  6020.  
  6021. // Table Sizing, Selection, Add Row/Col interface
  6022. ED_HitType EDT_GetTableHitRegion(MWContext *pContext, int32 xVal, int32 yVal, 
  6023.                                  LO_Element **ppElement, XP_Bool bModifierKeyPressed)
  6024. {
  6025.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) ED_HIT_NONE;
  6026.     return pEditBuffer->GetTableHitRegion(xVal, yVal, ppElement, bModifierKeyPressed);
  6027. }
  6028.  
  6029. ED_HitType EDT_GetSelectedTableElement(MWContext *pContext, LO_Element **ppElement){
  6030.     return EDT_GetTableHitRegion(pContext, 0, 0, ppElement, FALSE);
  6031. }
  6032.  
  6033. // Object Sizer
  6034. ED_SizeStyle EDT_CanSizeObject(MWContext *pContext, LO_Element *pElement,
  6035.                       int32 xVal, int32 yVal){
  6036.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) 0;
  6037.     return pEditBuffer->CanSizeObject(pElement, xVal, yVal);
  6038. }
  6039.  
  6040. XP_Bool EDT_IsSizing(MWContext *pContext){
  6041.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6042.     return pEditBuffer->IsSizing();
  6043. }
  6044.  
  6045. ED_SizeStyle EDT_StartSizing(MWContext *pContext, LO_Element *pElement, int32 xVal, int32 yVal,
  6046.                  XP_Bool bLockAspect, XP_Rect *pRect){
  6047.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) 0;
  6048.     return pEditBuffer->StartSizing(pElement, xVal, yVal, bLockAspect, pRect);
  6049. }
  6050.  
  6051. XP_Bool EDT_GetSizingRect(MWContext *pContext, int32 xVal, int32 yVal,
  6052.                        XP_Bool bLockAspect, XP_Rect *pRect){
  6053.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6054.     return pEditBuffer->GetSizingRect(xVal, yVal, bLockAspect, pRect);
  6055. }
  6056.  
  6057. void EDT_EndSizing(MWContext *pContext){
  6058.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6059.     pEditBuffer->EndSizing();
  6060. }
  6061.  
  6062. void EDT_CancelSizing(MWContext *pContext){
  6063.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6064.     pEditBuffer->CancelSizing();
  6065. }
  6066.  
  6067. ED_BufferOffset EDT_GetInsertPointOffset( MWContext *pContext ){
  6068.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) 0;
  6069.     CPersistentEditInsertPoint p;
  6070.     pEditBuffer->GetInsertPoint( p );
  6071.     return (ED_BufferOffset) p.m_index;
  6072. }
  6073.  
  6074. void EDT_SetInsertPointToOffset( MWContext *pContext, ED_BufferOffset i,
  6075.         int32 iLen ){
  6076.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6077.     CPersistentEditInsertPoint p((ElementIndex)i);
  6078.  
  6079.     if( iLen != 0 ){
  6080.         CPersistentEditInsertPoint p1((ElementIndex)i+iLen);
  6081.         CPersistentEditSelection perSel;
  6082.         perSel = CPersistentEditSelection( p, p1 );
  6083.         CEditSelection sel = pEditBuffer->PersistentToEphemeral( perSel );
  6084.         pEditBuffer->SetSelection( sel );
  6085.     }
  6086.     else {
  6087.         pEditBuffer->SetInsertPoint( p  );
  6088.     }
  6089. }
  6090.  
  6091. void EDT_OffsetToLayoutElement( MWContext *pContext, ED_BufferOffset i,
  6092.         LO_Element * *element, int32 *caretPos){
  6093.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6094.     CPersistentEditInsertPoint p((ElementIndex)i);
  6095.  
  6096.     CEditInsertPoint eP = pEditBuffer->PersistentToEphemeral(p);
  6097.     *element = eP.m_pElement->GetLayoutElement();
  6098.     *caretPos = eP.m_iPos;
  6099. }
  6100.  
  6101. ED_BufferOffset EDT_LayoutElementToOffset( MWContext *pContext,
  6102.         LO_Element *element, int32 caretPos){
  6103.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) -1;
  6104.     
  6105.     if (element->type != LO_TEXT)
  6106.         return -1;
  6107.         
  6108.     CEditInsertPoint insertPoint(element->lo_text.edit_element, caretPos);
  6109.     
  6110.     CPersistentEditInsertPoint p = pEditBuffer->EphemeralToPersistent(insertPoint);
  6111.     
  6112.     return p.m_index;
  6113. }
  6114.  
  6115. LO_TextBlock* EDT_GetTextBlock(MWContext *, LO_Element *le)
  6116. {
  6117.     LO_TextBlock *block;
  6118.     CEditTextElement *pText;
  6119.     
  6120.     block = NULL;
  6121.     
  6122.     if( ( le->type == LO_TEXT ) && ( le->lo_any.edit_element != NULL )
  6123.             && le->lo_any.edit_element->IsA( P_TEXT ) ){
  6124.         pText = le->lo_any.edit_element->Text();
  6125.         block = pText->GetTextBlock();
  6126.     }
  6127.     
  6128.     return block;
  6129. }
  6130.  
  6131. void EDT_GetSelectionOffsets(MWContext *pContext, ED_BufferOffset* pStart, ED_BufferOffset* pEnd){
  6132.     if ( ! pStart || !pEnd ) {
  6133.         XP_ASSERT(FALSE);
  6134.         return;
  6135.     }
  6136.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6137.     CPersistentEditSelection s;
  6138.     pEditBuffer->GetSelection( s );
  6139.     *pStart = (ED_BufferOffset) s.m_start.m_index;
  6140.     *pEnd = (ED_BufferOffset) s.m_end.m_index;
  6141. }
  6142.  
  6143. XP_Bool EDT_SelectFirstMisspelledWord( MWContext *pContext ){
  6144.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6145.     return pEditBuffer->FindNextMisspelledWord( TRUE, TRUE, 0 );
  6146. }
  6147.  
  6148. XP_Bool EDT_SelectNextMisspelledWord( MWContext *pContext ){
  6149.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6150.     return pEditBuffer->FindNextMisspelledWord( FALSE, TRUE, 0 );
  6151. }
  6152.  
  6153. void EDT_ReplaceMisspelledWord( MWContext *pContext, char* pOldWord, 
  6154.         char*pNewWord, XP_Bool bAll ){
  6155.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6156.     pEditBuffer->BeginBatchChanges(kPasteTextCommandID);
  6157.     pEditBuffer->IterateMisspelledWords( CEditBuffer::EMSW_REPLACE, 
  6158.             pOldWord, pNewWord, bAll );
  6159.     pEditBuffer->EndBatchChanges();
  6160. }
  6161.  
  6162. void EDT_IgnoreMisspelledWord( MWContext *pContext, char* pOldWord, 
  6163.         XP_Bool bAll ){
  6164.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6165.     pEditBuffer->IterateMisspelledWords( CEditBuffer::EMSW_IGNORE, 
  6166.             pOldWord, 0, bAll );
  6167. }
  6168.  
  6169.  
  6170. XP_HUGE_CHAR_PTR EDT_GetPositionalText( MWContext* pContext ){
  6171.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) 0;
  6172.     return pEditBuffer->GetPositionalText();
  6173. }
  6174.  
  6175. void EDT_SetCharacterDataAtOffset( MWContext *pContext, EDT_CharacterData *pData,
  6176.         ED_BufferOffset iBufOffset, int32 iLen ){
  6177.     GET_WRITABLE_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6178.     pEditBuffer->SetCharacterDataAtOffset(pData, iBufOffset, iLen );
  6179. }
  6180.  
  6181. void EDT_SetRefresh( MWContext* pContext, XP_Bool bRefreshOn ){
  6182.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer);
  6183.     pEditBuffer->SetRefresh( bRefreshOn );
  6184. }
  6185.  
  6186.  
  6187. // Warning this deletes (and recreates) the CEditBuffer.
  6188. XP_Bool EDT_SetEncoding(MWContext* pContext, int16 csid){
  6189.     GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) FALSE;
  6190.     XP_Bool bDoIt = TRUE;
  6191. //  if ( pEditBuffer->HasEncoding() ) {
  6192.     char* pMessage = XP_GetString(XP_EDT_I18N_HAS_CHARSET);
  6193.     if ( pMessage ) {
  6194.         bDoIt = FE_Confirm(pContext, pMessage);
  6195.     }
  6196.     else {
  6197.         XP_ASSERT(0);
  6198.     }
  6199.  
  6200.     if ( bDoIt ) {
  6201.         pEditBuffer->ChangeEncoding(csid);
  6202.     }
  6203.     return bDoIt;
  6204. }
  6205. // End of Block of functions moved from EDITOR.CPP for Win16 Build
  6206.  
  6207. /*
  6208.  * Extract the Extra HTML string from the ED_Element pointer in an image struct
  6209.  * (ED_Element is a void* to external users)
  6210.  * Caller must XP_FREE result
  6211.  */
  6212. char * EDT_GetExtraHTML_FromImage(LO_ImageStruct *pImage){
  6213.     if( pImage ){
  6214.         if( pImage->edit_element == 0 ){
  6215.             // We don't have an edit element - must be from Navigator,
  6216.             // so we have to pick out stuff that would end up in CEditImageElement's extra data
  6217.             // BUT the original PA_TAG data is no longer around.
  6218.             // The only item we will grab is the USEMAP data
  6219.             // TODO: Get other associated data such as JavaScript?
  6220.             //       To do that, we need a new function to reconstruct a tag from LO_ImageStruct
  6221.  
  6222.             if ( pImage->image_attr && pImage->image_attr->usemap_name ){
  6223.                 char * pRet = 0;
  6224.                 pRet = PR_sprintf_append( pRet, "USEMAP=");
  6225.                 pRet = PR_sprintf_append( pRet, pImage->image_attr->usemap_name);
  6226.                 return pRet;
  6227.             }
  6228.         }else if( pImage->edit_element->IsImage() ){
  6229.             EDT_ImageData * pImageData = ((CEditImageElement*)pImage->edit_element)->GetImageData();
  6230.             if( pImageData->pExtra && *pImageData->pExtra ){
  6231.                 return XP_STRDUP(pImageData->pExtra);
  6232.             }
  6233.             EDT_FreeImageData(pImageData);
  6234.         }
  6235.     }
  6236.     return NULL;
  6237. }
  6238.  
  6239. PRBool EDT_EncryptState( MWContext *pContext ){
  6240.     CEditBuffer *pEditBuffer = LO_GetEDBuffer( pContext );
  6241.  
  6242.     if (pEditBuffer == NULL) return PR_FALSE;
  6243.  
  6244.     return pEditBuffer->m_bEncrypt;
  6245. }
  6246.  
  6247. void EDT_EncryptToggle( MWContext *pContext ){
  6248.     CEditBuffer *pEditBuffer = LO_GetEDBuffer( pContext );
  6249.  
  6250.     if (pEditBuffer == NULL) return;
  6251.  
  6252.      pEditBuffer->m_bEncrypt = pEditBuffer->m_bEncrypt ? PR_FALSE :  PR_TRUE;
  6253. }
  6254.  
  6255. void EDT_EncryptSet( MWContext *pContext ){
  6256.     CEditBuffer *pEditBuffer = LO_GetEDBuffer( pContext );
  6257.  
  6258.     if (pEditBuffer == NULL) return;
  6259.  
  6260.     pEditBuffer->m_bEncrypt = PR_TRUE;
  6261. }
  6262.  
  6263. void EDT_EncryptReset( MWContext *pContext ){
  6264.     CEditBuffer *pEditBuffer = LO_GetEDBuffer( pContext );
  6265.  
  6266.     if (pEditBuffer == NULL) return;
  6267.  
  6268.     pEditBuffer->m_bEncrypt = PR_FALSE;
  6269. }
  6270.  
  6271. #endif // EDITOR
  6272.