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   if (type==nTypeOrClass)
  48     return TRUE;
  49   if (nTypeOrClass==diRunOrParagraph && (type==diRun || type==diParagraph))
  50     return TRUE;
  51   if (nTypeOrClass==diRunOrStartRow && (type==diRun || type==diStartRow))
  52     return TRUE;
  53   if (nTypeOrClass==diParagraphOrEnd && (type==diTextEnd || type==diParagraph))
  54     return TRUE;
  55   if (nTypeOrClass==diStartRowOrParagraph && (type==diStartRow || type==diParagraph))
  56     return TRUE;
  57   if (nTypeOrClass==diStartRowOrParagraphOrEnd
  58     && (type==diStartRow || type==diParagraph || type==diTextEnd))
  59     return TRUE;
  60   if (nTypeOrClass==diRunOrParagraphOrEnd
  61     && (type==diRun || type==diParagraph || type==diTextEnd))
  62     return TRUE;
  63   return FALSE;
  64 }
  65
  66 ME_DisplayItem *ME_FindItemBack(ME_DisplayItem *di, ME_DIType nTypeOrClass)
  67 {
  68   if (!di)
  69     return NULL;
  70   di = di->prev;
  71   while(di!=NULL) {
  72     if (ME_DITypesEqual(di->type, nTypeOrClass))
  73       return di;
  74     di = di->prev;
  75   }
  76   return NULL;
  77 }
  78
  79 ME_DisplayItem *ME_FindItemBackOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
  80 {
  81   while(di!=NULL) {
  82     if (ME_DITypesEqual(di->type, nTypeOrClass))
  83       return di;
  84     di = di->prev;
  85   }
  86   return NULL;
  87 }
  88
  89 ME_DisplayItem *ME_FindItemFwd(ME_DisplayItem *di, ME_DIType nTypeOrClass)
  90 {
  91   if (!di) return NULL;
  92   di = di->next;
  93   while(di!=NULL) {
  94     if (ME_DITypesEqual(di->type, nTypeOrClass))
  95       return di;
  96     di = di->next;
  97   }
  98   return NULL;
  99 }
 100
 101 ME_DisplayItem *ME_FindItemFwdOrHere(ME_DisplayItem *di, ME_DIType nTypeOrClass)
 102 {
 103   while(di!=NULL) {
 104     if (ME_DITypesEqual(di->type, nTypeOrClass))
 105       return di;
 106     di = di->next;
 107   }
 108   return NULL;
 109 }
 110
 111 void ME_DestroyDisplayItem(ME_DisplayItem *item) {
 112 /*  TRACE("type=%s\n", ME_GetDITypeName(item->type)); */
 113   if (item->type==diParagraph || item->type == diUndoSetParagraphFormat) {
 114     FREE_OBJ(item->member.para.pFmt);
 115   }
 116   if (item->type==diRun || item->type == diUndoInsertRun) {
 117     if (item->member.run.ole_obj) ME_DeleteReObject(item->member.run.ole_obj);
 118     ME_ReleaseStyle(item->member.run.style);
 119     ME_DestroyString(item->member.run.strText);
 120   }
 121   if (item->type==diUndoSetCharFormat) {
 122     ME_ReleaseStyle(item->member.ustyle);
 123   }
 124   if (item->type==diUndoSplitParagraph) {
 125      FREE_OBJ(item->member.para.pFmt);
 126      FREE_OBJ(item->member.para.pCell);
 127   }
 128   FREE_OBJ(item);
 129 }
 130
 131 ME_DisplayItem *ME_MakeDI(ME_DIType type) {
 132   ME_DisplayItem *item = ALLOC_OBJ(ME_DisplayItem);
 133   ZeroMemory(item, sizeof(ME_DisplayItem));
 134   item->type = type;
 135   item->prev = item->next = NULL;
 136   if (type == diParagraph || type == diUndoSplitParagraph) {
 137     item->member.para.pFmt = ALLOC_OBJ(PARAFORMAT2);
 138     ME_SetDefaultParaFormat(item->member.para.pFmt);
 139     item->member.para.nFlags = MEPF_REWRAP;
 140   }
 141
 142   return item;
 143 }
 144
 145 const char *ME_GetDITypeName(ME_DIType type)
 146 {
 147   switch(type)
 148   {
 149     case diParagraph: return "diParagraph";
 150     case diRun: return "diRun";
 151     case diCell: return "diCell";
 152     case diTextStart: return "diTextStart";
 153     case diTextEnd: return "diTextEnd";
 154     case diStartRow: return "diStartRow";
 155     case diUndoEndTransaction: return "diUndoEndTransaction";
 156     case diUndoPotentialEndTransaction: return "diUndoPotentialEndTransaction";
 157     case diUndoSetParagraphFormat: return "diUndoSetParagraphFormat";
 158     case diUndoSetCharFormat: return "diUndoSetCharFormat";
 159     case diUndoInsertRun: return "diUndoInsertRun";
 160     case diUndoDeleteRun: return "diUndoDeleteRun";
 161     case diUndoJoinParagraphs: return "diJoinParagraphs";
 162     case diUndoSplitParagraph: return "diSplitParagraph";
 163     default: return "?";
 164   }
 165 }
 166
 167 void ME_DumpDocument(ME_TextBuffer *buffer)
 168 {
 169   /* FIXME this is useless, */
 170   ME_DisplayItem *pItem = buffer->pFirst;
 171   TRACE("DOCUMENT DUMP START\n");
 172   while(pItem) {
 173     switch(pItem->type)
 174     {
 175       case diTextStart:
 176         TRACE("Start\n");
 177         break;
 178       case diCell:
 179         TRACE("Cell(level=%d%s)\n", pItem->member.cell.nNestingLevel,
 180               !pItem->member.cell.next_cell ? ", END" :
 181                 (!pItem->member.cell.prev_cell ? ", START" :""));
 182         break;
 183       case diParagraph:
 184         TRACE("Paragraph(ofs=%d)\n", pItem->member.para.nCharOfs);
 185         if (pItem->member.para.nFlags & MEPF_ROWSTART)
 186           TRACE(" - (Table Row Start)\n");
 187         if (pItem->member.para.nFlags & MEPF_ROWEND)
 188           TRACE(" - (Table Row End)\n");
 189         break;
 190       case diStartRow:
 191         TRACE(" - StartRow\n");
 192         break;
 193       case diRun:
 194         TRACE(" - Run(\"%s\", %d, flags=%x)\n", debugstr_w(pItem->member.run.strText->szData),
 195           pItem->member.run.nCharOfs, pItem->member.run.nFlags);
 196         break;
 197       case diTextEnd:
 198         TRACE("End(ofs=%d)\n", pItem->member.para.nCharOfs);
 199         break;
 200       default:
 201         break;
 202     }
 203     pItem = pItem->next;
 204   }
 205   TRACE("DOCUMENT DUMP END\n");
 206 }