Jean-Claude Batista

Wraps some RichEdit control functionality on an Edit control. It uses
a free implementation of an RTF parser written by Paul DuBois
http://www.primate.wisc.edu/software/RTF/ which I modified a bit to
work with the control.
This commit is contained in:
Alexandre Julliard 2000-05-07 20:23:41 +00:00
parent 2de84c9bfa
commit 688c05301a
16 changed files with 6082 additions and 62 deletions

View File

@ -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@

211
dlls/richedit/ansi_gen.h Normal file
View File

@ -0,0 +1,211 @@
/*
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
};

112
dlls/richedit/ansi_sym.h Normal file
View File

@ -0,0 +1,112 @@
/*
* 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 ,'~'
};

121
dlls/richedit/charlist.c Normal file
View File

@ -0,0 +1,121 @@
/*
*
* 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;
}

26
dlls/richedit/charlist.h Normal file
View File

@ -0,0 +1,26 @@
#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

3005
dlls/richedit/reader.c Normal file

File diff suppressed because it is too large Load Diff

17
dlls/richedit/riched32.h Normal file
View File

@ -0,0 +1,17 @@
/*
* 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 */

View File

@ -1,3 +1,5 @@
name riched32
type win32
init RICHED32_Init
init RICHED32_LibMain
2 stdcall DllGetVersion (ptr) RICHED32_DllGetVersion

View File

@ -1,59 +0,0 @@
/*
* 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;
}

238
dlls/richedit/richedit.c Normal file
View File

@ -0,0 +1,238 @@
/*
* 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);
}

1461
dlls/richedit/rtf.h Normal file

File diff suppressed because it is too large Load Diff

2
dlls/richedit/rtf2text.h Normal file
View File

@ -0,0 +1,2 @@
void WriterInit ();
int BeginFile ();

View File

@ -0,0 +1,352 @@
"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",

276
dlls/richedit/text-writer.c Normal file
View File

@ -0,0 +1,276 @@
/*
* 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); */
}

172
dlls/richedit/text_map.h Normal file
View File

@ -0,0 +1,172 @@
/*
* 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)"
};

82
include/richedit.h Normal file
View File

@ -0,0 +1,82 @@
#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 */