dlls/riched20/list.c

   1 /*
   2  * RichEdit - Basic operations on double linked lists.
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21
  22 #include "editor.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(richedit_lists);
  25
  26 void ME_InsertBefore(ME_DisplayItem *diWhere, ME_DisplayItem *diWhat)
  27 {
  28   diWhat->next = diWhere;
  29   diWhat->prev = diWhere->prev;
  30
  31   diWhere->prev->next = diWhat;
  32   diWhat->next->prev = diWhat;
  33 }
  34
  35 void ME_Remove(ME_DisplayItem *diWhere)
  36 {
  37   ME_DisplayItem *diNext = diWhere->next;
  38   ME_DisplayItem *diPrev = diWhere->prev;
  39   assert(diNext);
  40   assert(diPrev);
  41   diPrev->next = diNext;
  42   diNext->prev = diPrev;
  43 }
  44
  45 static BOOL ME_DITypesEqual(ME_DIType type, ME_DIType nTypeOrClass)
  46 {
  47   switch (nTypeOrClass)
  48   {
  49     case diRunOrParagraph:
  50       return type == diRun || type == diParagraph;
  51     case diRunOrStartRow:
  52       return type == diRun || type == diStartRow;
  53     case diParagraphOrEnd:
  54       return type == diTextEnd || type == diParagraph;
  55     case diStartRowOrParagraph:
  56       return type == diStartRow || type == diParagraph;
  57     case diStartRowOrParagraphOrEnd:
  58       return type == diStartRow || type == diParagraph || type == diTextEnd;
  59     case diRunOrParagraphOrEnd:
  60       return type == diRun || type == diParagraph || type == diTextEnd;
  61     default:
  62       return type == nTypeOrClass;
  63   }
  64 }
  65
  66 /* Modifies run pointer to point to the next run, and modify the
  67  * paragraph pointer if moving into the next paragraph.
  68  *
  69  * Returns TRUE if next run is found, otherwise returns FALSE. */
  70 BOOL ME_NextRun(ME_DisplayItem **para, ME_DisplayItem **run)
  71 {
  72   ME_DisplayItem *p = (*run)->next;
  73   while (p->type != diTextEnd)
  74   {
  75     if (p->type == diParagraph) {
  76       *para = p;
  77     } else if (p->type == diRun) {
  78       *run = p;
  79       return TRUE;
  80     }
  81     p = p->next;
  82   }
  83   return FALSE;
  84 }
  85
  86 /* Modifies run pointer to point to the previous run, and modify the
  87  * paragraph pointer if moving into the previous paragraph.
  88  *
  89  * Returns TRUE if previous run is found, otherwise returns FALSE. */
  90 BOOL ME_PrevRun(ME_DisplayItem **para, ME_DisplayItem **run)
  91 {
  92   ME_DisplayItem *p = (*run)->prev;
  93   while (p->type != diTextStart)
  94   {
  95     if (p->type == diParagraph) {
  96       if (p->member.para.prev_para->type == diParagraph)
  97         *para = p->member.para.prev_para;
  98     } else if (p->type == diRun) {
  99       *run = p;
 100       return TRUE;
 101     }
 102     p = p->prev;
 103   }
 104   return FALSE;
 105 }
 106
 107 ME_DisplayItem *ME_FindItemBack(ME_DisplayItem *di, ME_DIType nTypeOrClass)
 108 {
 109   if (!di)
 110     return NULL;
 111   di = di->prev;
 112   while(di!=NULL) {
 113     if (ME_DITypesEqual(di->type, nTypeOrClass))
 114       return di;
 115     di = di->prev;
 116   }
 117   return NULL;
 118 }
 119
 120 ME_DisplayItem *ME_FindItemBackOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
 121 {
 122   while(di!=NULL) {
 123     if (ME_DITypesEqual(di->type, nTypeOrClass))
 124       return di;
 125     di = di->prev;
 126   }
 127   return NULL;
 128 }
 129
 130 ME_DisplayItem *ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass)
 131 {
 132   if (!di) return NULL;
 133   di = di->next;
 134   while(di!=NULL) {
 135     if (ME_DITypesEqual(di->type, nTypeOrClass))
 136       return di;
 137     di = di->next;
 138   }
 139   return NULL;
 140 }
 141
 142 void ME_DestroyDisplayItem(ME_DisplayItem *item) {
 143 /*  TRACE("type=%s\n", ME_GetDITypeName(item->type)); */
 144   if (item->type==diParagraph || item->type == diUndoSetParagraphFormat) {
 145     FREE_OBJ(item->member.para.pFmt);
 146   }
 147   if (item->type==diRun || item->type == diUndoInsertRun) {
 148     if (item->member.run.ole_obj) ME_DeleteReObject(item->member.run.ole_obj);
 149     ME_ReleaseStyle(item->member.run.style);
 150     ME_DestroyString(item->member.run.strText);
 151   }
 152   if (item->type==diUndoSetCharFormat) {
 153     ME_ReleaseStyle(item->member.ustyle);
 154   }
 155   if (item->type==diUndoSplitParagraph) {
 156      FREE_OBJ(item->member.para.pFmt);
 157      FREE_OBJ(item->member.para.pCell);
 158   }
 159   FREE_OBJ(item);
 160 }
 161
 162 ME_DisplayItem *ME_MakeDI(ME_DIType type) {
 163   ME_DisplayItem *item = ALLOC_OBJ(ME_DisplayItem);
 164   ZeroMemory(item, sizeof(ME_DisplayItem));
 165   item->type = type;
 166   item->prev = item->next = NULL;
 167   if (type == diParagraph || type == diUndoSplitParagraph) {
 168     item->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
 169     ME_SetDefaultParaFormat(item->member.para.pFmt);
 170     item->member.para.nFlags = MEPF_REWRAP;
 171   }
 172
 173   return item;
 174 }
 175
 176 const char *ME_GetDITypeName(ME_DIType type)
 177 {
 178   switch(type)
 179   {
 180     case diParagraph: return "diParagraph";
 181     case diRun: return "diRun";
 182     case diCell: return "diCell";
 183     case diTextStart: return "diTextStart";
 184     case diTextEnd: return "diTextEnd";
 185     case diStartRow: return "diStartRow";
 186     case diUndoEndTransaction: return "diUndoEndTransaction";
 187     case diUndoPotentialEndTransaction: return "diUndoPotentialEndTransaction";
 188     case diUndoSetParagraphFormat: return "diUndoSetParagraphFormat";
 189     case diUndoSetCharFormat: return "diUndoSetCharFormat";
 190     case diUndoInsertRun: return "diUndoInsertRun";
 191     case diUndoDeleteRun: return "diUndoDeleteRun";
 192     case diUndoJoinParagraphs: return "diJoinParagraphs";
 193     case diUndoSplitParagraph: return "diSplitParagraph";
 194     default: return "?";
 195   }
 196 }
 197
 198 void ME_DumpDocument(ME_TextBuffer *buffer)
 199 {
 200   /* FIXME this is useless, */
 201   ME_DisplayItem *pItem = buffer->pFirst;
 202   TRACE("DOCUMENT DUMP START\n");
 203   while(pItem) {
 204     switch(pItem->type)
 205     {
 206       case diTextStart:
 207         TRACE("Start\n");
 208         break;
 209       case diCell:
 210         TRACE("Cell(level=%d%s)\n", pItem->member.cell.nNestingLevel,
 211               !pItem->member.cell.next_cell ? ", END" :
 212                 (!pItem->member.cell.prev_cell ? ", START" :""));
 213         break;
 214       case diParagraph:
 215         TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
 216         if (pItem->member.para.nFlags & MEPF_ROWSTART)
 217           TRACE(" - (Table Row Start)\n");
 218         if (pItem->member.para.nFlags & MEPF_ROWEND)
 219           TRACE(" - (Table Row End)\n");
 220         break;
 221       case diStartRow:
 222         TRACE(" - StartRow\n");
 223         break;
 224       case diRun:
 225         TRACE(" - Run(\"%s\", %d, flags=%x)\n", debugstr_w(pItem->member.run.strText->szData),
 226           pItem->member.run.nCharOfs, pItem->member.run.nFlags);
 227         break;
 228       case diTextEnd:
 229         TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
 230         break;
 231       default:
 232         break;
 233     }
 234     pItem = pItem->next;
 235   }
 236   TRACE("DOCUMENT DUMP END\n");
 237 }