Jean-Claude Batista

dlls/richedit/Makefile.in

@@ -4,13 +4,15 @@ SRCDIR    = @srcdir@
 VPATH     = @srcdir@
 MODULE    = riched32
 SOVERSION = 1.0
-IMPORTS   = 
 WRCEXTRA  = -s -p$(MODULE)
 
 SPEC_SRCS = riched32.spec
 
 C_SRCS = \
-	riched32_main.c
+	charlist.c \
+	reader.c \
+	text-writer.c \
+	richedit.c
 
 @MAKE_DLL_RULES@
 

dlls/richedit/ansi_gen.h

+/*
+ RTF ANSI character set (\ansi) general map
+ These are taken from the ISO-Latin-1 (ISO-8859-1) encodings, with
+ a few additions
+
+ Field 1 is the standard character name which the character value in
+ field 2 maps onto.  (It doesn't mean "to produce the character in field 1,
+ use the value in field 2.)
+
+ The character value may be given either as a single character (which will be
+ converted to the ASCII value of the character), or in numeric format, either
+ in decimal or 0xyy as hex yy.  Single or double quotes may be used to quote
+ characters.*/
+
+int ansi_gen[] = 
+{
+  rtfSC_formula 	 ,0x06,
+  rtfSC_nobrkhyphen	 ,0x1e,
+  rtfSC_opthyphen	 ,0x1f,
+  rtfSC_space		 ,' ',
+  rtfSC_exclam  	 ,'!',
+  rtfSC_quotedbl	 ,'"',
+  rtfSC_numbersign	 ,'#',
+  rtfSC_dollar  	 ,'$',
+  rtfSC_percent 	 ,'%',
+  rtfSC_ampersand	 ,'&',
+  rtfSC_quoteright	 ,'\\',
+  rtfSC_parenleft	 ,'(',
+  rtfSC_parenright	 ,')',
+  rtfSC_asterisk	 ,'*',
+  rtfSC_plus		 ,'+',
+  rtfSC_comma		 ,',',
+  rtfSC_hyphen  	 ,'-',
+  rtfSC_period  	 ,'.',
+  rtfSC_slash		 ,'/',
+  rtfSC_zero		 ,'0',
+  rtfSC_one		 ,'1',
+  rtfSC_two		 ,'2',
+  rtfSC_three		 ,'3',
+  rtfSC_four		 ,'4',
+  rtfSC_five		 ,'5',
+  rtfSC_six		 ,'6',
+  rtfSC_seven		 ,'7',
+  rtfSC_eight		 ,'8',
+  rtfSC_nine		 ,'9',
+  rtfSC_colon		 ,':',
+  rtfSC_semicolon	 ,';',
+  rtfSC_less		 ,'<',
+  rtfSC_equal		 ,'=',
+  rtfSC_greater 	 ,'>',
+  rtfSC_question	 ,'?',
+  rtfSC_at		 ,'@',
+  rtfSC_A		 ,'A',
+  rtfSC_B		 ,'B',
+  rtfSC_C		 ,'C',
+  rtfSC_D		 ,'D',
+  rtfSC_E		 ,'E',
+  rtfSC_F		 ,'F',
+  rtfSC_G		 ,'G',
+  rtfSC_H		 ,'H',
+  rtfSC_I		 ,'I',
+  rtfSC_J		 ,'J',
+  rtfSC_K		 ,'K',
+  rtfSC_L		 ,'L',
+  rtfSC_M		 ,'M',
+  rtfSC_N		 ,'N',
+  rtfSC_O		 ,'O',
+  rtfSC_P		 ,'P',
+  rtfSC_Q		 ,'Q',
+  rtfSC_R		 ,'R',
+  rtfSC_S		 ,'S',
+  rtfSC_T		 ,'T',
+  rtfSC_U		 ,'U',
+  rtfSC_V		 ,'V',
+  rtfSC_W		 ,'W',
+  rtfSC_X		 ,'X',
+  rtfSC_Y		 ,'Y',
+  rtfSC_Z		 ,'Z',
+  rtfSC_bracketleft	 ,'[',
+  rtfSC_backslash	 ,'\\',
+  rtfSC_bracketright	 ,']',
+  rtfSC_asciicircum	 ,'^',
+  rtfSC_underscore	 ,'_',
+  rtfSC_quoteleft	 ,'`',
+  rtfSC_a		 ,'a',
+  rtfSC_b		 ,'b',
+  rtfSC_c		 ,'c',
+  rtfSC_d		 ,'d',
+  rtfSC_e		 ,'e',
+  rtfSC_f		 ,'f',
+  rtfSC_g		 ,'g',
+  rtfSC_h		 ,'h',
+  rtfSC_i		 ,'i',
+  rtfSC_j		 ,'j',
+  rtfSC_k		 ,'k',
+  rtfSC_l		 ,'l',
+  rtfSC_m		 ,'m',
+  rtfSC_n		 ,'n',
+  rtfSC_o		 ,'o',
+  rtfSC_p		 ,'p',
+  rtfSC_q		 ,'q',
+  rtfSC_r		 ,'r',
+  rtfSC_s		 ,'s',
+  rtfSC_t		 ,'t',
+  rtfSC_u		 ,'u',
+  rtfSC_v		 ,'v',
+  rtfSC_w		 ,'w',
+  rtfSC_x		 ,'x',
+  rtfSC_y		 ,'y',
+  rtfSC_z		 ,'z',
+  rtfSC_braceleft	 ,'{',
+  rtfSC_bar		 ,'|',
+  rtfSC_braceright	 ,'}',
+  rtfSC_asciitilde	 ,'~',
+  rtfSC_nobrkspace	 ,0xa0,
+  rtfSC_exclamdown	 ,0xa1,
+  rtfSC_cent		 ,0xa2,
+  rtfSC_sterling	 ,0xa3,
+  rtfSC_currency	 ,0xa4,
+  rtfSC_yen		 ,0xa5,
+  rtfSC_brokenbar	 ,0xa6,
+  rtfSC_section 	 ,0xa7,
+  rtfSC_dieresis	 ,0xa8,
+  rtfSC_copyright	 ,0xa9,
+  rtfSC_ordfeminine	 ,0xaa,
+  rtfSC_guillemotleft	 ,0xab,
+  rtfSC_logicalnot	 ,0xac,
+  rtfSC_opthyphen	 ,0xad,
+  rtfSC_registered	 ,0xae,
+  rtfSC_macron  	 ,0xaf,
+  rtfSC_degree  	 ,0xb0,
+  rtfSC_plusminus	 ,0xb1,
+  rtfSC_twosuperior	 ,0xb2,
+  rtfSC_threesuperior	 ,0xb3,
+  rtfSC_acute		 ,0xb4,
+  rtfSC_mu		 ,0xb5,
+  rtfSC_paragraph	 ,0xb6,
+  rtfSC_periodcentered   ,0xb7,
+  rtfSC_cedilla 	 ,0xb8,
+  rtfSC_onesuperior	 ,0xb9,
+  rtfSC_ordmasculine	 ,0xba,
+  rtfSC_guillemotright   ,0xbb,
+  rtfSC_onequarter	 ,0xbc,
+  rtfSC_onehalf 	 ,0xbd,
+  rtfSC_threequarters	 ,0xbe,
+  rtfSC_questiondown	 ,0xbf,
+  rtfSC_Agrave  	 ,0xc0,
+  rtfSC_Aacute  	 ,0xc1,
+  rtfSC_Acircumflex	 ,0xc2,
+  rtfSC_Atilde  	 ,0xc3,
+  rtfSC_Adieresis	 ,0xc4,
+  rtfSC_Aring		 ,0xc5,
+  rtfSC_AE		 ,0xc6,
+  rtfSC_Ccedilla	 ,0xc7,
+  rtfSC_Egrave  	 ,0xc8,
+  rtfSC_Eacute  	 ,0xc9,
+  rtfSC_Ecircumflex	 ,0xca,
+  rtfSC_Edieresis	 ,0xcb,
+  rtfSC_Igrave  	 ,0xcc,
+  rtfSC_Iacute  	 ,0xcd,
+  rtfSC_Icircumflex	 ,0xce,
+  rtfSC_Idieresis	 ,0xcf,
+  rtfSC_Eth		 ,0xd0,
+  rtfSC_Ntilde  	 ,0xd1,
+  rtfSC_Ograve  	 ,0xd2,
+  rtfSC_Oacute  	 ,0xd3,
+  rtfSC_Ocircumflex	 ,0xd4,
+  rtfSC_Otilde  	 ,0xd5,
+  rtfSC_Odieresis	 ,0xd6,
+  rtfSC_multiply	 ,0xd7,
+  rtfSC_Oslash  	 ,0xd8,
+  rtfSC_Ugrave  	 ,0xd9,
+  rtfSC_Uacute  	 ,0xda,
+  rtfSC_Ucircumflex	 ,0xdb,
+  rtfSC_Udieresis	 ,0xdc,
+  rtfSC_Yacute  	 ,0xdd,
+  rtfSC_Thorn		 ,0xde,
+  rtfSC_germandbls	 ,0xdf,
+  rtfSC_agrave  	 ,0xe0,
+  rtfSC_aacute  	 ,0xe1,
+  rtfSC_acircumflex	 ,0xe2,
+  rtfSC_atilde  	 ,0xe3,
+  rtfSC_adieresis	 ,0xe4,
+  rtfSC_aring		 ,0xe5,
+  rtfSC_ae		 ,0xe6,
+  rtfSC_ccedilla	 ,0xe7,
+  rtfSC_egrave  	 ,0xe8,
+  rtfSC_eacute  	 ,0xe9,
+  rtfSC_ecircumflex	 ,0xea,
+  rtfSC_edieresis	 ,0xeb,
+  rtfSC_igrave  	 ,0xec,
+  rtfSC_iacute  	 ,0xed,
+  rtfSC_icircumflex	 ,0xee,
+  rtfSC_idieresis	 ,0xef,
+  rtfSC_eth		 ,0xf0,
+  rtfSC_ntilde  	 ,0xf1,
+  rtfSC_ograve  	 ,0xf2,
+  rtfSC_oacute  	 ,0xf3,
+  rtfSC_ocircumflex	 ,0xf4,
+  rtfSC_otilde  	 ,0xf5,
+  rtfSC_odieresis	 ,0xf6,
+  rtfSC_divide  	 ,0xf7,
+  rtfSC_oslash  	 ,0xf8,
+  rtfSC_ugrave  	 ,0xf9,
+  rtfSC_uacute  	 ,0xfa,
+  rtfSC_ucircumflex	 ,0xfb,
+  rtfSC_udieresis	 ,0xfc,
+  rtfSC_yacute  	 ,0xfd,
+  rtfSC_thorn		 ,0xfe,
+  rtfSC_ydieresis	 ,0xff
+};

dlls/richedit/ansi_sym.h

+/*
+ * RTF ANSI character set (\ansi) Symbol font map
+ * 
+ * Field 1 is the standard character name which the character value in
+ * field 2 maps onto.  (It doesn't mean "to produce the character in field 1,
+ * use the value in field 2.)
+ * 
+ * The character value may be given either as a single character (which will be
+ * converted to the ASCII value of the character), or in numeric format, either
+ * in decimal or 0xyy as hex yy.  Single or double quotes may be used to quote
+ * characters.
+ * 
+ */
+ 
+int ansi_sym[] =
+{
+  rtfSC_formula        ,0x06,
+  rtfSC_nobrkhyphen    ,0x1e,
+  rtfSC_opthyphen      ,0x1f,
+  rtfSC_space	       ,' ',
+  rtfSC_exclam         ,'!',
+  rtfSC_universal      ,'"',
+  rtfSC_mathnumbersign ,'#',
+  rtfSC_existential    ,'$',
+  rtfSC_percent        ,'%',
+  rtfSC_ampersand      ,'&',
+  rtfSC_suchthat       ,'\\',
+  rtfSC_parenleft      ,'(',
+  rtfSC_parenright     ,')',
+  rtfSC_mathasterisk   ,'*',
+  rtfSC_mathplus       ,'+',
+  rtfSC_comma	       ,',',
+  rtfSC_mathminus      ,'-',
+  rtfSC_period         ,'.',
+  rtfSC_slash	       ,'/',
+  rtfSC_zero	       ,'0',
+  rtfSC_one	       ,'1',
+  rtfSC_two	       ,'2',
+  rtfSC_three	       ,'3',
+  rtfSC_four	       ,'4',
+  rtfSC_five	       ,'5',
+  rtfSC_six	       ,'6',
+  rtfSC_seven	       ,'7',
+  rtfSC_eight	       ,'8',
+  rtfSC_nine	       ,'9',
+  rtfSC_colon	       ,':',
+  rtfSC_semicolon      ,';',
+  rtfSC_less	       ,'<',
+  rtfSC_mathequal      ,'=',
+  rtfSC_greater        ,'>',
+  rtfSC_question       ,'?',
+  rtfSC_congruent      ,'@',
+  rtfSC_Alpha	       ,'A',
+  rtfSC_Beta	       ,'B',
+  rtfSC_Chi	       ,'C',
+  rtfSC_Delta	       ,'D',
+  rtfSC_Epsilon        ,'E',
+  rtfSC_Phi	       ,'F',
+  rtfSC_Gamma	       ,'G',
+  rtfSC_Eta	       ,'H',
+  rtfSC_Iota	       ,'I',
+  rtfSC_Kappa	       ,'K',
+  rtfSC_Lambda         ,'L',
+  rtfSC_Mu	       ,'M',
+  rtfSC_Nu	       ,'N',
+  rtfSC_Omicron        ,'O',
+  rtfSC_Pi	       ,'P',
+  rtfSC_Theta	       ,'Q',
+  rtfSC_Rho	       ,'R',
+  rtfSC_Sigma	       ,'S',
+  rtfSC_Tau	       ,'T',
+  rtfSC_Upsilon        ,'U',
+  rtfSC_varsigma       ,'V',
+  rtfSC_Omega	       ,'W',
+  rtfSC_Xi	       ,'X',
+  rtfSC_Psi	       ,'Y',
+  rtfSC_Zeta	       ,'Z',
+  rtfSC_bracketleft    ,'[',
+  rtfSC_backslash      ,'\\',
+  rtfSC_bracketright   ,']',
+  rtfSC_asciicircum    ,'^',
+  rtfSC_underscore     ,'_',
+  rtfSC_quoteleft      ,'`',
+  rtfSC_alpha	       ,'a',
+  rtfSC_beta	       ,'b',
+  rtfSC_chi	       ,'c',
+  rtfSC_delta	       ,'d',
+  rtfSC_epsilon        ,'e',
+  rtfSC_phi	       ,'f',
+  rtfSC_gamma	       ,'g',
+  rtfSC_eta	       ,'h',
+  rtfSC_iota	       ,'i',
+  rtfSC_kappa	       ,'k',
+  rtfSC_lambda         ,'l',
+  rtfSC_mu	       ,'m',
+  rtfSC_nu	       ,'n',
+  rtfSC_omicron        ,'o',
+  rtfSC_pi	       ,'p',
+  rtfSC_theta	       ,'q',
+  rtfSC_rho	       ,'r',
+  rtfSC_sigma	       ,'s',
+  rtfSC_tau	       ,'t',
+  rtfSC_upsilon        ,'u',
+  rtfSC_omega	       ,'w',
+  rtfSC_xi	       ,'x',
+  rtfSC_psi	       ,'y',
+  rtfSC_zeta	       ,'z',
+  rtfSC_braceleft      ,'{',
+  rtfSC_bar	       ,'|',
+  rtfSC_braceright     ,'}',
+  rtfSC_mathtilde      ,'~'
+};

dlls/richedit/charlist.c

+/*
+ * 
+ *  Character List
+ * 
+ *  Copyright (c) 2000 by Jean-Claude Batista
+ *  
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include "charlist.h"
+#include "windows.h"
+
+extern HANDLE RICHED32_hHeap;
+
+void CHARLIST_Enqueue( CHARLIST* pCharList, char myChar )
+{   
+    CHARLISTENTRY* pNewEntry = HeapAlloc(RICHED32_hHeap, 0,sizeof(CHARLISTENTRY));
+    pNewEntry->pNext = NULL;
+    pNewEntry->myChar = myChar;
+    
+    if(pCharList->pTail == NULL)
+    {
+         pCharList->pHead = pCharList->pTail = pNewEntry;
+    }
+    else
+    {
+         CHARLISTENTRY* pCurrent = pCharList->pTail;         
+         pCharList->pTail = pCurrent->pNext = pNewEntry;
+    }
+
+    pCharList->nCount++;
+}
+
+void CHARLIST_Push( CHARLIST* pCharList, char myChar)
+{   
+    CHARLISTENTRY* pNewEntry = malloc(sizeof(CHARLISTENTRY));
+    
+    pNewEntry->myChar = myChar;
+    
+    if(pCharList->pHead == NULL)
+    {
+         pCharList->pHead = pCharList->pTail = pNewEntry;
+         pNewEntry->pNext = NULL;
+
+    }
+    else
+    {
+         pNewEntry->pNext = pCharList->pHead;
+         pCharList->pHead = pNewEntry;
+    }
+
+    pCharList->nCount++;
+}
+
+char CHARLIST_Dequeue(CHARLIST* pCharList)
+{
+    CHARLISTENTRY* pCurrent;
+    char myChar;
+
+    if(pCharList->nCount == 0) 
+      return 0;
+    
+    pCharList->nCount--;
+    myChar = pCharList->pHead->myChar;
+    pCurrent = pCharList->pHead->pNext;
+    HeapFree(RICHED32_hHeap, 0,pCharList->pHead);
+ 
+    if(pCharList->nCount == 0)
+    {
+        pCharList->pHead = pCharList->pTail = NULL;
+    }
+    else
+    {
+        pCharList->pHead = pCurrent;
+    }
+
+    return myChar;   
+}
+
+int CHARLIST_GetNbItems(CHARLIST* pCharList)
+{
+    return pCharList->nCount;
+}
+
+void CHARLIST_FreeList(CHARLIST* pCharList){
+    while(pCharList->nCount)
+        CHARLIST_Dequeue(pCharList);       
+}
+
+/* this function count the number of occurences of a caracter */
+int CHARLIST_CountChar(CHARLIST* pCharList, char myChar)
+{
+    CHARLISTENTRY *pCurrent;
+    int nCount = 0;
+    
+    for(pCurrent =pCharList->pHead ;pCurrent;pCurrent=pCurrent->pNext)
+    	if(pCurrent->myChar == myChar)
+	    nCount++;
+    
+    return nCount;
+}
+
+int CHARLIST_toBuffer(CHARLIST* pCharList, char* pBuffer, int nBufferSize)
+{
+   
+   /* we add one to store a NULL caracter */
+   if(nBufferSize < pCharList->nCount + 1) 
+        return pCharList->nCount;
+  
+   for(;pCharList->nCount;pBuffer++)
+       *pBuffer = CHARLIST_Dequeue(pCharList);
+   
+   *pBuffer = '\0';
+
+   return 0;
+}
+

dlls/richedit/charlist.h

+#ifndef _CHARLIST
+#define _CHARLIST
+
+typedef struct _tagCHARLISTENTRY
+{
+    struct _tagCHARLISTENTRY *pNext;
+    char   myChar;
+} CHARLISTENTRY;
+
+typedef struct _tagCHARLIST
+{
+    unsigned int nCount; // Entries Count;
+    CHARLISTENTRY *pHead;
+    CHARLISTENTRY *pTail;
+} CHARLIST;
+
+
+void CHARLIST_Enqueue( CHARLIST* pCharList, char myChar);
+void CHARLIST_Push( CHARLIST* pCharList, char myChar);
+char CHARLIST_Dequeue(CHARLIST* pCharList);
+int CHARLIST_GetNbItems(CHARLIST* pCharList);
+void CHARLIST_FreeList(CHARLIST* pCharList);
+int CHARLIST_CountChar(CHARLIST* pCharList, char myChar);
+int CHARLIST_toBuffer(CHARLIST* pCharList, char* pBuffer, int nBufferSize);
+
+#endif
\ No newline at end of file

dlls/richedit/riched32.h

+/*
+ * Ritch Edit 32 class extra info
+ *
+ * Copyright 2000 Jean-Clauyde Batista
+ *
+ */
+
+#ifndef __WINE_RICHED32_H
+#define __WINE_RICHED32_H
+
+#include "richedit.h"
+
+extern HMODULE RICHED32_hModule;
+extern VOID RICHED32_Register (VOID);
+extern VOID RICHED32_Unregister (VOID);
+
+#endif  /* __WINE_RICHED32_H */

dlls/richedit/riched32.spec

 name	riched32
 type	win32
-init	RICHED32_Init
+init	RICHED32_LibMain
+
+2 stdcall DllGetVersion (ptr) RICHED32_DllGetVersion

dlls/richedit/riched32_main.c

-/*
- * Win32 Richedit control
- *
- * Copyright (C) 2000 Hidenori Takeshima <hidenori@a2.ctktv.ne.jp>
- */
-
-#include "winbase.h"
-#include "debugtools.h"
-/*#include "richedit.h"*/
-
-
-DEFAULT_DEBUG_CHANNEL(richedit);
-
-/******************************************************************************
- *
- * RICHED32_Register [Internal]
- *
- */
-static BOOL
-RICHED32_Register( void )
-{
-    FIXME( "stub\n" );
-
-    return FALSE;
-}
-
-/******************************************************************************
- *
- * RICHED32_Unregister
- *
- */
-static void
-RICHED32_Unregister( void )
-{
-}
-
-/******************************************************************************
- *
- * RICHED32_Init [Internal]
- *
- */
-
-BOOL WINAPI
-RICHED32_Init( HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpvReserved )
-{
-    switch ( fdwReason )
-    {
-    case DLL_PROCESS_ATTACH:
-        if ( !RICHED32_Register() )
-            return FALSE;
-        break;
-    case DLL_PROCESS_DETACH:
-        RICHED32_Unregister();
-        break;
-    }
-
-    return TRUE;
-}
-

dlls/richedit/richedit.c

+/*
+ * RichEdit32  functions
+ *
+ * This module is a simple wrap-arround the edit controls.
+ * At the point, it is good only for application who use the RICHEDIT control to 
+ * display RTF text.
+ *
+ * Copyright 2000 by Jean-Claude Batista
+ * 
+ */
+ 
+#include "windows.h"
+#include "winbase.h"
+#include "heap.h"
+#include "debugtools.h"
+#include "winerror.h"
+#include "riched32.h"
+#include "richedit.h"
+#include "charlist.h"
+
+#include "rtf.h"
+#include "rtf2text.h"
+
+#define ID_EDIT      1
+
+DEFAULT_DEBUG_CHANNEL(richedit)
+
+HANDLE RICHED32_hHeap = (HANDLE)NULL;
+DWORD  RICHED32_dwProcessesAttached = 0;
+/* LPSTR  RICHED32_aSubclass = (LPSTR)NULL; */
+HMODULE RICHED32_hModule = 0;
+
+/*
+ * RICHED32_LibMain [Internal] Initializes the internal 'RICHED32.DLL'.
+ *
+ * PARAMS
+ *     hinstDLL    [I] handle to the 'dlls' instance
+ *     fdwReason   [I]
+ *     lpvReserved [I] reserverd, must be NULL
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+
+BOOL WINAPI
+RICHED32_LibMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+        
+    switch (fdwReason) {
+	    case DLL_PROCESS_ATTACH:
+
+            if (RICHED32_dwProcessesAttached == 0) {
+
+		    /* This will be wrong for any other process attching in this address-space! */
+	            RICHED32_hModule = (HMODULE)hinstDLL;
+
+		        /* create private heap */
+		        RICHED32_hHeap = HeapCreate (0, 0x10000, 0);
+
+	        }
+		
+	        /* register the Rich Edit class */
+	        RICHED32_Register ();
+
+	        RICHED32_dwProcessesAttached++;
+	        break;
+
+	    case DLL_PROCESS_DETACH:
+	        RICHED32_dwProcessesAttached--;
+
+	        /* unregister all common control classes */      
+	        RICHED32_Unregister ();
+
+	        if (RICHED32_dwProcessesAttached == 0) {
+		    HeapDestroy (RICHED32_hHeap);
+		    RICHED32_hHeap = (HANDLE)NULL;
+                }
+		break;	    
+    }
+
+    return TRUE;
+}
+
+/*
+ *
+ * DESCRIPTION:
+ * Window procedure of the RichEdit control.
+ *
+ */
+static LRESULT WINAPI RICHED32_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
+                                   LPARAM lParam)
+{
+    int RTFToBuffer(char* pBuffer, int nBufferSize);
+    LONG newstyle = 0;
+    LONG style = 0;  
+
+    static HWND hwndEdit;
+    static char* rtfBuffer;
+    int rtfBufferSize;
+    
+    switch (uMsg)
+    {
+ 
+    case WM_CREATE :           
+            
+	    /* remove SCROLLBARS from the current window style */
+	    newstyle = style = ((LPCREATESTRUCTA) lParam)->style;
+            newstyle &= ~WS_HSCROLL;
+            newstyle &= ~WS_VSCROLL;
+            newstyle &= ~ES_AUTOHSCROLL;
+            newstyle &= ~ES_AUTOVSCROLL;
+                                  
+            hwndEdit = CreateWindowA ("edit", ((LPCREATESTRUCTA) lParam)->lpszName,
+                                   style, 0, 0, 0, 0,
+                                   hwnd, (HMENU) ID_EDIT,
+                                   ((LPCREATESTRUCTA) lParam)->hInstance, NULL) ;
+	
+	    SetWindowLongA(hwnd,GWL_STYLE, newstyle); 		   
+            return 0 ;
+          
+    case WM_SETFOCUS :            
+            SetFocus (hwndEdit) ;
+            return 0 ;
+          
+    case WM_SIZE :             
+            MoveWindow (hwndEdit, 0, 0, LOWORD (lParam), HIWORD (lParam), TRUE) ;
+            return 0 ;
+          
+    case WM_COMMAND :
+            if (LOWORD (wParam) == ID_EDIT)
+                 if (HIWORD (wParam) == EN_ERRSPACE || 
+                           HIWORD (wParam) == EN_MAXTEXT)
+
+                      MessageBoxA (hwnd, "RichEdit control out of space.",
+                                  "ERROR", MB_OK | MB_ICONSTOP) ;
+            return 0 ;
+     
+    case EM_STREAMIN:                               
+            
+	    /* setup the RTF parser */
+	    RTFSetEditStream(( EDITSTREAM*)lParam);
+	    WriterInit();
+	    RTFInit ();
+	    BeginFile();	    
+
+	    /* do the parsing */
+	    RTFRead ();
+            
+	    rtfBufferSize = RTFToBuffer(NULL, 0);
+	    rtfBuffer = HeapAlloc(RICHED32_hHeap, 0,rtfBufferSize*sizeof(char));
+	    if(rtfBuffer)
+	    {
+	    	RTFToBuffer(rtfBuffer, rtfBufferSize);
+            	SetWindowTextA(hwndEdit,rtfBuffer);
+	    	HeapFree(RICHED32_hHeap, 0,rtfBuffer);
+	    }
+	    else
+		WARN("Not enough memory for a allocating rtfBuffer\n");
+		
+            return 0;   
+    }
+    /*return SendMessageA( hwndEdit,uMsg,wParam,lParam);*/
+    return DefWindowProcA( hwnd,uMsg,wParam,lParam);
+}
+
+/*
+ * DllGetVersion [COMCTL32.25]
+ *
+ * Retrieves version information of the 'COMCTL32.DLL'
+ *
+ * PARAMS
+ *     pdvi [O] pointer to version information structure.
+ *
+ * RETURNS
+ *     Success: S_OK
+ *     Failure: E_INVALIDARG
+ *
+ * NOTES
+ *     Returns version of a comctl32.dll from IE4.01 SP1.
+ */
+
+HRESULT WINAPI
+RICHED32_DllGetVersion (DLLVERSIONINFO *pdvi)
+{
+    if (pdvi->cbSize != sizeof(DLLVERSIONINFO)) {
+ 
+	return E_INVALIDARG;
+    }
+
+    pdvi->dwMajorVersion = 4;
+    pdvi->dwMinorVersion = 0;
+    pdvi->dwBuildNumber = 0;
+    pdvi->dwPlatformID = 0;
+
+    return S_OK;
+}
+
+/***
+ * DESCRIPTION:
+ * Registers the window class.
+ * 
+ * PARAMETER(S):
+ * None
+ *
+ * RETURN:
+ * None
+ */
+VOID RICHED32_Register(void)
+{
+    WNDCLASSA wndClass; 
+
+    ZeroMemory(&wndClass, sizeof(WNDCLASSA));
+    wndClass.style = CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
+    wndClass.lpfnWndProc = (WNDPROC)RICHED32_WindowProc;
+    wndClass.cbClsExtra = 0;
+    wndClass.cbWndExtra = 0; /*(sizeof(RICHED32_INFO *);*/
+    wndClass.hCursor = LoadCursorA(0, IDC_ARROWA);
+    wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+    wndClass.lpszClassName = RICHEDIT_CLASS10A;//WC_RICHED32A;
+
+    RegisterClassA (&wndClass);
+}
+
+/***
+ * DESCRIPTION:
+ * Unregisters the window class.
+ * 
+ * PARAMETER(S):
+ * None
+ *
+ * RETURN:
+ * None
+ */
+VOID RICHED32_Unregister(void)
+{
+    UnregisterClassA(RICHEDIT_CLASS10A, (HINSTANCE)NULL);
+}

dlls/richedit/rtf2text.h

+void	WriterInit ();
+int	BeginFile ();

dlls/richedit/stdcharnames.h

+	"nothing",
+	"space",
+	"exclam",
+	"quotedbl",
+	"numbersign",
+	"dollar",
+	"percent",
+	"ampersand",
+	"quoteright",
+	"parenleft",
+	"parenright",
+	"asterisk",
+	"plus",
+	"comma",
+	"hyphen",
+	"period",
+	"slash",
+	"zero",
+	"one",
+	"two",
+	"three",
+	"four",
+	"five",
+	"six",
+	"seven",
+	"eight",
+	"nine",
+	"colon",
+	"semicolon",
+	"less",
+	"equal",
+	"greater",
+	"question",
+	"at",
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"T",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z",
+	"bracketleft",
+	"backslash",
+	"bracketright",
+	"asciicircum",
+	"underscore",
+	"quoteleft",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"braceleft",
+	"bar",
+	"braceright",
+	"asciitilde",
+	"exclamdown",
+	"cent",
+	"sterling",
+	"fraction",
+	"yen",
+	"florin",
+	"section",
+	"currency",
+	"quotedblleft",
+	"guillemotleft",
+	"guilsinglleft",
+	"guilsinglright",
+	"fi",
+	"fl",
+	"endash",
+	"dagger",
+	"daggerdbl",
+	"periodcentered",
+	"paragraph",
+	"bullet",
+	"quotesinglbase",
+	"quotedblbase",
+	"quotedblright",
+	"guillemotright",
+	"ellipsis",
+	"perthousand",
+	"questiondown",
+	"grave",
+	"acute",
+	"circumflex",
+	"tilde",
+	"macron",
+	"breve",
+	"dotaccent",
+	"dieresis",
+	"ring",
+	"cedilla",
+	"hungarumlaut",
+	"ogonek",
+	"caron",
+	"emdash",
+	"AE",
+	"ordfeminine",
+	"Lslash",
+	"Oslash",
+	"OE",
+	"ordmasculine",
+	"ae",
+	"dotlessi",
+	"lslash",
+	"oslash",
+	"oe",
+	"germandbls",
+	"Aacute",
+	"Acircumflex",
+	"Adieresis",
+	"Agrave",
+	"Aring",
+	"Atilde",
+	"Ccedilla",
+	"Eacute",
+	"Ecircumflex",
+	"Edieresis",
+	"Egrave",
+	"Eth",
+	"Iacute",
+	"Icircumflex",
+	"Idieresis",
+	"Igrave",
+	"Ntilde",
+	"Oacute",
+	"Ocircumflex",
+	"Odieresis",
+	"Ograve",
+	"Otilde",
+	"Scaron",
+	"Thorn",
+	"Uacute",
+	"Ucircumflex",
+	"Udieresis",
+	"Ugrave",
+	"Yacute",
+	"Ydieresis",
+	"aacute",
+	"acircumflex",
+	"adieresis",
+	"agrave",
+	"aring",
+	"atilde",
+	"brokenbar",
+	"ccedilla",
+	"copyright",
+	"degree",
+	"divide",
+	"eacute",
+	"ecircumflex",
+	"edieresis",
+	"egrave",
+	"eth",
+	"iacute",
+	"icircumflex",
+	"idieresis",
+	"igrave",
+	"logicalnot",
+	"minus",
+	"multiply",
+	"ntilde",
+	"oacute",
+	"ocircumflex",
+	"odieresis",
+	"ograve",
+	"onehalf",
+	"onequarter",
+	"onesuperior",
+	"otilde",
+	"plusminus",
+	"registered",
+	"thorn",
+	"threequarters",
+	"threesuperior",
+	"trademark",
+	"twosuperior",
+	"uacute",
+	"ucircumflex",
+	"udieresis",
+	"ugrave",
+	"yacute",
+	"ydieresis",
+	"Alpha",
+	"Beta",
+	"Chi",
+	"Delta",
+	"Epsilon",
+	"Phi",
+	"Gamma",
+	"Eta",
+	"Iota",
+	"Kappa",
+	"Lambda",
+	"Mu",
+	"Nu",
+	"Omicron",
+	"Pi",
+	"Theta",
+	"Rho",
+	"Sigma",
+	"Tau",
+	"Upsilon",
+	"varUpsilon",
+	"Omega",
+	"Xi",
+	"Psi",
+	"Zeta",
+	"alpha",
+	"beta",
+	"chi",
+	"delta",
+	"epsilon",
+	"phi",
+	"varphi",
+	"gamma",
+	"eta",
+	"iota",
+	"kappa",
+	"lambda",
+	"mu",
+	"nu",
+	"omicron",
+	"pi",
+	"varpi",
+	"theta",
+	"vartheta",
+	"rho",
+	"sigma",
+	"varsigma",
+	"tau",
+	"upsilon",
+	"omega",
+	"xi",
+	"psi",
+	"zeta",
+	"nobrkspace",
+	"nobrkhyphen",
+	"lessequal",
+	"greaterequal",
+	"infinity",
+	"integral",
+	"notequal",
+	"radical",
+	"radicalex",
+	"approxequal",
+	"apple",
+	"partialdiff",
+	"opthyphen",
+	"formula",
+	"lozenge",
+	"universal",
+	"existential",
+	"suchthat",
+	"congruent",
+	"therefore",
+	"perpendicular",
+	"minute",
+	"club",
+	"diamond",
+	"heart",
+	"spade",
+	"arrowboth",
+	"arrowleft",
+	"arrowup",
+	"arrowright",
+	"arrowdown",
+	"second",
+	"proportional",
+	"equivalence",
+	"arrowvertex",
+	"arrowhorizex",
+	"carriagereturn",
+	"aleph",
+	"Ifraktur",
+	"Rfraktur",
+	"weierstrass",
+	"circlemultiply",
+	"circleplus",
+	"emptyset",
+	"intersection",
+	"union",
+	"propersuperset",
+	"reflexsuperset",
+	"notsubset",
+	"propersubset",
+	"reflexsubset",
+	"element",
+	"notelement",
+	"angle",
+	"gradient",
+	"product",
+	"logicaland",
+	"logicalor",
+	"arrowdblboth",
+	"arrowdblleft",
+	"arrowdblup",
+	"arrowdblright",
+	"arrowdbldown",
+	"angleleft",
+	"registersans",
+	"copyrightsans",
+	"trademarksans",
+	"angleright",
+	"mathplus",
+	"mathminus",
+	"mathasterisk",
+	"mathnumbersign",
+	"dotmath",
+	"mathequal",
+	"mathtilde",

dlls/richedit/text-writer.c

+/*
+ * text-writer -- RTF-to-text translation writer code.
+ *
+ * Read RTF input, write text of document (text extraction).
+ *
+ * Wrapper must call WriterInit() once before processing any files,
+ * then set up input and call BeginFile() for each input file.
+ *
+ * This installs callbacks for the text and control token classes.
+ * The control class is necessary so that special characters such as
+ * \par, \tab, \sect, etc.  can be converted.
+ *
+ * It's problematic what to do with text in headers and footers, and
+ * what to do about tables.
+ *
+ * This really is quite a stupid program, for instance, it could keep
+ * track of the current leader character and dump that out when a tab
+ * is encountered.
+ *
+ * 04 Feb 91	Paul DuBois	dubois@primate.wisc.edu
+ *
+ * This software may be redistributed without restriction and used for
+ * any purpose whatsoever.
+ *
+ * 04 Feb 91
+ * -Created.
+ * 27 Feb 91
+ * - Updated for distribution 1.05.
+ * 13 Jul 93
+ * - Updated to compile under THINK C 6.0.
+ * 31 Aug 93
+ * - Added Mike Sendall's entries for Macintosh char map.
+ * 07 Sep 93
+ * - Uses charset map and output sequence map for character translation.
+ * 11 Mar 94
+ * - Updated for 1.10 distribution.
+ */
+
+# include	<stdio.h>
+
+# include	"rtf.h"
+# include	"rtf2text.h"
+# include       "charlist.h"
+
+static void	TextClass ();
+static void	ControlClass ();
+static void	Destination ();
+static void	SpecialChar ();
+static void	PutStdChar ();
+static void	PutLitChar ();
+static void	PutLitStr ();
+
+static char	*outMap[rtfSC_MaxChar];
+
+static CHARLIST charlist = {0, NULL, NULL};
+
+int RTFToBuffer(char* pBuffer, int nBufferSize);
+int RTFToBuffer(char* pBuffer, int nBufferSize)
+{
+    
+   /* check if the buffer is big enough to hold all characters  */    
+   /* we require one more for the '\0'                          */
+   
+   
+   if(nBufferSize < charlist.nCount + 1) {
+        return charlist.nCount + CHARLIST_CountChar(&charlist, '\n') + 1;
+   }
+  
+   while(charlist.nCount)
+   {
+       *pBuffer = CHARLIST_Dequeue(&charlist);
+       if(*pBuffer=='\n')
+       {
+         *pBuffer = '\r';
+         pBuffer++;
+         *pBuffer = '\n'; 
+       }
+       pBuffer++;
+   }
+   *pBuffer = '\0';
+
+   return 0;    
+}
+
+
+/*
+ * Initialize the writer.
+ */
+
+void
+WriterInit ()
+{
+	RTFReadOutputMap (outMap,1);
+}
+
+
+int
+BeginFile ()
+{
+	/* install class callbacks */
+
+	RTFSetClassCallback (rtfText, TextClass);
+	RTFSetClassCallback (rtfControl, ControlClass);
+
+	return (1);
+}
+
+
+/*
+ * Write out a character.  rtfMajor contains the input character, rtfMinor
+ * contains the corresponding standard character code.
+ *
+ * If the input character isn't in the charset map, try to print some
+ * representation of it.
+ */
+
+static void
+TextClass ()
+{
+char	buf[rtfBufSiz];
+
+	if (rtfMinor != rtfSC_nothing)
+		PutStdChar (rtfMinor);
+	else
+	{
+		if (rtfMajor < 128)	/* in ASCII range */
+			sprintf (buf, "[[%c]]", rtfMajor);
+		else
+			sprintf (buf, "[[\\'%02x]]", rtfMajor);
+		PutLitStr (buf);
+	}
+}
+
+
+static void
+ControlClass ()
+{
+	switch (rtfMajor)
+	{
+	case rtfDestination:
+		Destination ();
+		break;
+	case rtfSpecialChar:
+		SpecialChar ();
+		break;
+	}
+}
+
+
+/*
+ * This function notices destinations that should be ignored
+ * and skips to their ends.  This keeps, for instance, picture
+ * data from being considered as plain text.
+ */
+
+static void
+Destination ()
+{
+	switch (rtfMinor)
+	{
+	case rtfPict:
+	case rtfFNContSep:
+	case rtfFNContNotice:
+	case rtfInfo:
+	case rtfIndexRange:
+	case rtfITitle:
+	case rtfISubject:
+	case rtfIAuthor:
+	case rtfIOperator:
+	case rtfIKeywords:
+	case rtfIComment:
+	case rtfIVersion:
+	case rtfIDoccomm:
+		RTFSkipGroup ();
+		break;
+	}
+}
+
+
+/*
+ * The reason these use the rtfSC_xxx thingies instead of just writing
+ * out ' ', '-', '"', etc., is so that the mapping for these characters
+ * can be controlled by the text-map file.
+ */
+
+void SpecialChar ()
+{
+	switch (rtfMinor)
+	{
+	case rtfPage:
+	case rtfSect:
+	case rtfRow:
+	case rtfLine:
+	case rtfPar:
+		PutLitChar ('\n');
+		break;
+	case rtfCell:
+		PutStdChar (rtfSC_space);	/* make sure cells are separated */
+		break;
+	case rtfNoBrkSpace:
+		PutStdChar (rtfSC_nobrkspace);
+		break;
+	case rtfTab:
+		PutLitChar ('\t');
+		break;
+	case rtfNoBrkHyphen:
+		PutStdChar (rtfSC_nobrkhyphen);
+		break;
+	case rtfBullet:
+		PutStdChar (rtfSC_bullet);
+		break;
+	case rtfEmDash:
+		PutStdChar (rtfSC_emdash);
+		break;
+	case rtfEnDash:
+		PutStdChar (rtfSC_endash);
+		break;
+	case rtfLQuote:
+		PutStdChar (rtfSC_quoteleft);
+		break;
+	case rtfRQuote:
+		PutStdChar (rtfSC_quoteright);
+		break;
+	case rtfLDblQuote:
+		PutStdChar (rtfSC_quotedblleft);
+		break;
+	case rtfRDblQuote:
+		PutStdChar (rtfSC_quotedblright);
+		break;
+	}
+}
+
+
+/*
+ * Eventually this should keep track of the destination of the
+ * current state and only write text when in the initial state.
+ *
+ * If the output sequence is unspecified in the output map, write
+ * the character's standard name instead.  This makes map deficiencies
+ * obvious and provides incentive to fix it. :-)
+ */
+
+void PutStdChar (int stdCode)
+{
+  
+  char	*oStr = (char *) NULL;
+  char	buf[rtfBufSiz];
+  
+/*	if (stdCode == rtfSC_nothing)
+		RTFPanic ("Unknown character code, logic error\n");
+*/		
+	oStr = outMap[stdCode];
+	if (oStr == (char *) NULL)	/* no output sequence in map */
+	{
+		sprintf (buf, "[[%s]]", RTFStdCharName (stdCode));
+		oStr = buf;
+	}
+	PutLitStr (oStr);
+}
+
+
+void PutLitChar (int c)
+{
+	CHARLIST_Enqueue(&charlist, (char) c);
+        /* fputc (c, ostream); */
+}
+
+
+static void PutLitStr (char	*s)
+{
+	for(;*s;s++)
+	{
+	  CHARLIST_Enqueue(&charlist, *s);
+	}
+	/* fputs (s, ostream); */
+}

dlls/richedit/text_map.h

+/*
+ *  Output sequence map for rtf2text
+ * 
+ *  Field 1 is the standard character name.  Field 2 is the output sequence
+ *  to produce for that character.
+ * 
+ *  The output sequence is simply a string of characters.  If it contains
+ *  whitespace, it may be quoted.  If it contains quotes, it may be quoted
+ *  with a different quote character.
+ * 
+ *  characters in ASCII range (32-127
+ */
+
+char *text_map[] = {
+  "space"	      ," ",
+  "exclam"	      ,"!",
+  "quotedbl"	      ,"\"",
+  "numbersign"        ,"#",
+  "dollar"	      ,"$",
+  "percent"	      ,"%",
+  "ampersand"	      ,"&",
+  "quoteright"        ,"'",
+  "parenleft"	      ,"(",
+  "parenright"        ,")",
+  "asterisk"	      ,"*",
+  "plus"	      ,"+",
+  "comma"	      ,",",
+  "hyphen"	      ,"-",
+  "period"	      ,".",
+  "slash"	      ,"/",
+  "zero"	      ,"0",
+  "one" 	      ,"1",
+  "two" 	      ,"2",
+  "three"	      ,"3",
+  "four"	      ,"4",
+  "five"	      ,"5",
+  "six" 	      ,"6",
+  "seven"	      ,"7",
+  "eight"	      ,"8",
+  "nine"	      ,"9",
+  "colon"	      ,":",
+  "semicolon"	      ,";",
+  "less"	      ,"<",
+  "equal"	      ,"=",
+  "greater"	      ,">",
+  "question"	      ,"?",
+  "at"  	      ,"@",
+  "A"		      ,"A",
+  "B"		      ,"B",
+  "C"		      ,"C",
+  "D"		      ,"D",
+  "E"		      ,"E",
+  "F"		      ,"F",
+  "G"		      ,"G",
+  "H"		      ,"H",
+  "I"		      ,"I",
+  "J"		      ,"J",
+  "K"		      ,"K",
+  "L"		      ,"L",
+  "M"		      ,"M",
+  "N"		      ,"N",
+  "O"		      ,"O",
+  "P"		      ,"P",
+  "Q"		      ,"Q",
+  "R"		      ,"R",
+  "S"		      ,"S",
+  "T"		      ,"T",
+  "U"		      ,"U",
+  "V"		      ,"V",
+  "W"		      ,"W",
+  "X"		      ,"X",
+  "Y"		      ,"Y",
+  "Z"		      ,"Z",
+  "bracketleft"       ,"[",
+  "backslash"	      ,"\\",
+  "bracketright"      ,"]",
+  "asciicircum"       ,"^",
+  "underscore"        ,"_",
+  "quoteleft"	      ,"`",
+  "a"		      ,"a",
+  "b"		      ,"b",
+  "c"		      ,"c",
+  "d"		      ,"d",
+  "e"		      ,"e",
+  "f"		      ,"f",
+  "g"		      ,"g",
+  "h"		      ,"h",
+  "i"		      ,"i",
+  "j"		      ,"j",
+  "k"		      ,"k",
+  "l"		      ,"l",
+  "m"		      ,"m",
+  "n"		      ,"n",
+  "o"		      ,"o",
+  "p"		      ,"p",
+  "q"		      ,"q",
+  "r"		      ,"r",
+  "s"		      ,"s",
+  "t"		      ,"t",
+  "u"		      ,"u",
+  "v"		      ,"v",
+  "w"		      ,"w",
+  "x"		      ,"x",
+  "y"		      ,"y",
+  "z"		      ,"z",
+  "braceleft"	      ,"{",
+  "bar" 	      ,"|",
+  "braceright"        ,"}",
+  "asciitilde"        ,"~",
+  "AE"  	      ,"AE",
+  "OE"  	      ,"OE",
+  "acute"	      ,"'",
+  "ae"  	      ,"ae",
+  "angleleft"	      ,"<",
+  "angleright"        ,">",
+  "arrowboth"	      ,"<->",
+  "arrowdblboth"      ,"<=>",
+  "arrowdblleft"      ,"<=",
+  "arrowdblright"     ,"=>",
+  "arrowleft"	      ,"<-",
+  "arrowright"        ,"->",
+  "bullet"	      ,"o",
+  "cent"	      ,"cent",
+  "circumflex"        ,"^",
+  "copyright"	      ,"(c)",
+  "copyrightsans"     ,"(c)",
+  "degree"	      ,"deg.",
+  "divide"	      ,"/",
+  "dotlessi"	      ,"i",
+  "ellipsis"	      ,"...",
+  "emdash"	      ,"--",
+  "endash"	      ,"-",
+  "fi"  	      ,"fi",
+  "fl"  	      ,"fl",
+  "fraction"	      ,"/",
+  "germandbls"        ,"ss",
+  "grave"	      ,"`",
+  "greaterequal"      ,">=",
+  "guillemotleft"     ,"<<",
+  "guillemotright"    ,">>",
+  "guilsinglleft"     ,"<",
+  "guilsinglright"    ,">",
+  "lessequal"	      ,"<=",
+  "logicalnot"        ,"~",
+  "mathasterisk"      ,"*",
+  "mathequal"	      ,"=",
+  "mathminus"	      ,"-",
+  "mathnumbersign"    ,"#",
+  "mathplus"	      ,"+",
+  "mathtilde"	      ,"~",
+  "minus"	      ,"-",
+  "mu"  	      ,"u",
+  "multiply"	      ,"x",
+  "nobrkhyphen"       ,"-",
+  "nobrkspace"        ," ",
+  "notequal"	      ,"!=",
+  "oe"  	      ,"oe",
+  "onehalf"	      ,"1/2",
+  "onequarter"        ,"1/4",
+  "periodcentered"    ,".",
+  "plusminus"	      ,"+/-",
+  "quotedblbase"      ,",,",
+  "quotedblleft"      ,"\"",
+  "quotedblright"     ,"\"",
+  "quotesinglbase"    ,",",
+  "registered"        ,"reg.",
+  "registersans"      ,"reg.",
+  "threequarters"     ,"3/4",
+  "tilde"	      ,"~",
+  "trademark"	      ,"(TM)",
+  "trademarksans"     ,"(TM)"
+};

include/richedit.h

+#ifndef __WINE_RICHEDIT_H
+#define __WINE_RICHEDIT_H
+
+#include "windef.h"
+#include "pshpack4.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _RICHEDIT_VER
+#define _RICHEDIT_VER   0x0210
+#endif /* _RICHEDIT_VER */
+
+#define cchTextLimitDefault 0x7fff
+
+#define RICHEDIT_CLASS20A	"RichEdit20A"
+#define RICHEDIT_CLASS20W	L"RichEdit20W"
+#define RICHEDIT_CLASS10A	"RICHEDIT"
+
+#if (_RICHEDIT_VER >= 0x0200 )
+#define RICHEDIT_CLASS		WINELIB_NAME_AW(RICHEDIT_CLASS20)
+#else
+#define RICHEDIT_CLASS		RICHEDIT_CLASS10A
+#endif
+
+#define EM_CANPASTE		(WM_USER + 50)
+#define EM_DISPLAYBAND		(WM_USER + 51)
+#define EM_EXGETSEL		(WM_USER + 52)
+#define EM_EXLIMITTEXT		(WM_USER + 53)
+#define EM_EXLINEFROMCHAR	(WM_USER + 54)
+#define EM_EXSETSEL		(WM_USER + 55)
+#define EM_FINDTEXT		(WM_USER + 56)
+#define EM_FORMATRANGE		(WM_USER + 57)
+#define EM_GETCHARFORMAT	(WM_USER + 58)
+#define EM_GETEVENTMASK		(WM_USER + 59)
+#define EM_GETOLEINTERFACE	(WM_USER + 60)
+#define EM_GETPARAFORMAT	(WM_USER + 61)
+#define EM_GETSELTEXT		(WM_USER + 62)
+#define EM_HIDESELECTION	(WM_USER + 63)
+#define EM_PASTESPECIAL		(WM_USER + 64)
+#define EM_REQUESTRESIZE	(WM_USER + 65)
+#define EM_SELECTIONTYPE	(WM_USER + 66)
+#define EM_SETBKGNDCOLOR	(WM_USER + 67)
+#define EM_SETCHARFORMAT	(WM_USER + 68)
+#define EM_SETEVENTMASK		(WM_USER + 69)
+#define EM_SETOLECALLBACK	(WM_USER + 70)
+#define EM_SETPARAFORMAT	(WM_USER + 71)
+#define EM_SETTARGETDEVICE	(WM_USER + 72)
+#define EM_STREAMIN		(WM_USER + 73)
+#define EM_STREAMOUT		(WM_USER + 74)
+#define EM_GETTEXTRANGE		(WM_USER + 75)
+#define EM_FINDWORDBREAK	(WM_USER + 76)
+#define EM_SETOPTIONS		(WM_USER + 77)
+#define EM_GETOPTIONS		(WM_USER + 78)
+#define EM_FINDTEXTEX		(WM_USER + 79)
+#define EM_GETWORDBREAKPROCEX	(WM_USER + 80)
+#define EM_SETWORDBREAKPROCEX	(WM_USER + 81)
+
+typedef DWORD (CALLBACK* EDITSTREAMCALLBACK)( DWORD, LPBYTE, LONG, LONG );
+
+typedef struct
+{
+    DWORD		dwCookie;
+    DWORD		dwError;
+    EDITSTREAMCALLBACK	pfnCallback;
+} EDITSTREAM;
+
+#define SF_TEXT		0x0001
+#define SF_RTF		0x0002
+#define SF_RTFNOOBJS	0x0003
+#define SF_TEXTIZED	0x0004
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#include "poppack.h"
+
+#endif /* __WINE_RICHEDIT_H */