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