wined3d: Use the texture sampling function in a few more instructions (GLSL).
[wine] / dlls / riched20 / style.c
1 /*
2  * RichEdit style management functions
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 #include "editor.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(richedit);
24 WINE_DECLARE_DEBUG_CHANNEL(richedit_style);
25
26 static int all_refs = 0;
27
28 CHARFORMAT2W *ME_ToCF2W(CHARFORMAT2W *to, CHARFORMAT2W *from)
29 {
30   if (from->cbSize == sizeof(CHARFORMATA))
31   {
32     CHARFORMATA *f = (CHARFORMATA *)from;
33     CopyMemory(to, f, sizeof(*f)-sizeof(f->szFaceName));
34     to->cbSize = sizeof(CHARFORMAT2W);
35     if (f->dwMask & CFM_FACE) {
36       MultiByteToWideChar(0, 0, f->szFaceName, -1, to->szFaceName, sizeof(to->szFaceName)/sizeof(WCHAR));
37     }
38     return to;
39   }
40   if (from->cbSize == sizeof(CHARFORMATW))
41   {
42     CHARFORMATW *f = (CHARFORMATW *)from;
43     CopyMemory(to, f, sizeof(*f));
44     /* theoretically, we don't need to zero the remaining memory */
45     ZeroMemory(((CHARFORMATW *)to)+1, sizeof(CHARFORMAT2W)-sizeof(CHARFORMATW));
46     to->cbSize = sizeof(CHARFORMAT2W);
47     return to;
48   }
49   if (from->cbSize == sizeof(CHARFORMAT2A))
50   {
51     CHARFORMATA *f = (CHARFORMATA *)from;
52     /* copy the A structure without face name */
53     CopyMemory(to, f, sizeof(CHARFORMATA)-sizeof(f->szFaceName));
54     /* convert face name */
55     if (f->dwMask & CFM_FACE)
56       MultiByteToWideChar(0, 0, f->szFaceName, -1, to->szFaceName, sizeof(to->szFaceName)/sizeof(WCHAR));
57     /* copy the rest of the 2A structure to 2W */
58     CopyMemory(1+((CHARFORMATW *)to), f+1, sizeof(CHARFORMAT2A)-sizeof(CHARFORMATA));
59     to->cbSize = sizeof(CHARFORMAT2W);
60     return to;
61   }
62
63   assert(from->cbSize >= sizeof(CHARFORMAT2W));  
64   return from;
65 }
66
67 void ME_CopyToCF2W(CHARFORMAT2W *to, CHARFORMAT2W *from)
68 {
69   if (ME_ToCF2W(to, from) == from)
70     CopyMemory(to, from, sizeof(*from));
71 }
72
73 CHARFORMAT2W *ME_ToCFAny(CHARFORMAT2W *to, CHARFORMAT2W *from)
74 {
75   assert(from->cbSize == sizeof(CHARFORMAT2W));
76   if (to->cbSize == sizeof(CHARFORMATA))
77   {
78     CHARFORMATA *t = (CHARFORMATA *)to;
79     CopyMemory(t, from, sizeof(*t)-sizeof(t->szFaceName));
80     WideCharToMultiByte(0, 0, from->szFaceName, -1, t->szFaceName, sizeof(t->szFaceName), 0, 0);
81     t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
82     return to;
83   }
84   if (to->cbSize == sizeof(CHARFORMATW))
85   {
86     CHARFORMATW *t = (CHARFORMATW *)to;
87     CopyMemory(t, from, sizeof(*t));
88     t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
89     return to;
90   }
91   if (to->cbSize == sizeof(CHARFORMAT2A))
92   {
93     CHARFORMAT2A *t = (CHARFORMAT2A *)to;
94     /* copy the A structure without face name */
95     CopyMemory(t, from, sizeof(CHARFORMATA)-sizeof(t->szFaceName));
96     /* convert face name */
97     WideCharToMultiByte(0, 0, from->szFaceName, -1, t->szFaceName, sizeof(t->szFaceName), 0, 0);
98     /* copy the rest of the 2A structure to 2W */
99     CopyMemory(&t->wWeight, &from->wWeight, sizeof(CHARFORMAT2A)-sizeof(CHARFORMATA));
100     t->cbSize = sizeof(*t); /* it was overwritten by CopyMemory */
101     return to;
102   }
103   assert(to->cbSize >= sizeof(CHARFORMAT2W));  
104   return from;
105 }
106
107 void ME_CopyToCFAny(CHARFORMAT2W *to, CHARFORMAT2W *from)
108 {
109   if (ME_ToCFAny(to, from) == from)
110     CopyMemory(to, from, to->cbSize);
111 }
112
113 ME_Style *ME_MakeStyle(CHARFORMAT2W *style) {
114   CHARFORMAT2W styledata;
115   ME_Style *s = ALLOC_OBJ(ME_Style);
116   
117   style = ME_ToCF2W(&styledata, style);
118   memset(s, 0, sizeof(ME_Style));
119   if (style->cbSize <= sizeof(CHARFORMAT2W))
120     CopyMemory(&s->fmt, style, style->cbSize);
121   else
122     CopyMemory(&s->fmt, style, sizeof(CHARFORMAT2W));
123   s->fmt.cbSize = sizeof(CHARFORMAT2W);
124
125   s->nSequence = -2;
126   s->nRefs = 1;
127   s->hFont = NULL;
128   s->tm.tmAscent = -1;
129   all_refs++;
130   return s;
131 }
132
133 #define COPY_STYLE_ITEM(mask, member) \
134   if (style->dwMask & mask) { \
135     s->fmt.dwMask |= mask;\
136     s->fmt.member = style->member;\
137   }
138
139 #define COPY_STYLE_ITEM_MEMCPY(mask, member) \
140   if (style->dwMask & mask) { \
141     s->fmt.dwMask |= mask;\
142     CopyMemory(s->fmt.member, style->member, sizeof(style->member));\
143   }
144   
145 void ME_InitCharFormat2W(CHARFORMAT2W *pFmt)
146 {
147   ZeroMemory(pFmt, sizeof(CHARFORMAT2W));
148   pFmt->cbSize = sizeof(CHARFORMAT2W);
149 }
150
151 ME_Style *ME_ApplyStyle(ME_Style *sSrc, CHARFORMAT2W *style)
152 {
153   CHARFORMAT2W styledata;
154   ME_Style *s = ME_MakeStyle(&sSrc->fmt);
155   style = ME_ToCF2W(&styledata, style);
156   COPY_STYLE_ITEM(CFM_ANIMATION, bAnimation);
157   COPY_STYLE_ITEM(CFM_BACKCOLOR, crBackColor);
158   COPY_STYLE_ITEM(CFM_CHARSET, bCharSet);
159   COPY_STYLE_ITEM(CFM_COLOR, crTextColor);
160   COPY_STYLE_ITEM_MEMCPY(CFM_FACE, szFaceName);
161   COPY_STYLE_ITEM(CFM_KERNING, wKerning);
162   COPY_STYLE_ITEM(CFM_LCID, lcid);
163   COPY_STYLE_ITEM(CFM_OFFSET, yOffset);
164   COPY_STYLE_ITEM(CFM_REVAUTHOR, bRevAuthor);
165   COPY_STYLE_ITEM(CFM_SIZE, yHeight);
166   COPY_STYLE_ITEM(CFM_SPACING, sSpacing);
167   COPY_STYLE_ITEM(CFM_STYLE, sStyle);
168   COPY_STYLE_ITEM(CFM_UNDERLINETYPE, bUnderlineType);
169   COPY_STYLE_ITEM(CFM_WEIGHT, wWeight);
170   
171   s->fmt.dwEffects &= ~(style->dwMask);
172   s->fmt.dwEffects |= style->dwEffects & style->dwMask;
173   s->fmt.dwMask |= style->dwMask;
174   if (style->dwMask & CFM_COLOR)
175   {
176     if (style->dwEffects & CFE_AUTOCOLOR)
177       s->fmt.dwEffects |= CFE_AUTOCOLOR;
178     else
179       s->fmt.dwEffects &= ~CFE_AUTOCOLOR;
180   }
181   return s;
182 }
183
184 void ME_CopyCharFormat(CHARFORMAT2W *pDest, CHARFORMAT2W *pSrc)
185 {
186   /* using this with non-2W structs is forbidden */
187   assert(pSrc->cbSize == sizeof(CHARFORMAT2W));
188   assert(pDest->cbSize == sizeof(CHARFORMAT2W));
189   CopyMemory(pDest, pSrc, sizeof(CHARFORMAT2W));
190 }
191
192 static void ME_DumpStyleEffect(char **p, const char *name, CHARFORMAT2W *fmt, int mask)
193 {
194   *p += sprintf(*p, "%-22s%s\n", name, (fmt->dwMask & mask) ? ((fmt->dwEffects & mask) ? "YES" : "no") : "N/A");
195 }
196
197 void ME_DumpStyle(ME_Style *s)
198 {
199   char buf[2048];
200   ME_DumpStyleToBuf(&s->fmt, buf);
201   TRACE_(richedit_style)("%s\n", buf);
202 }
203
204 void ME_DumpStyleToBuf(CHARFORMAT2W *pFmt, char buf[2048])
205 {
206   /* FIXME only CHARFORMAT styles implemented */
207   /* this function sucks, doesn't check for buffer overruns but it's "good enough" as for debug code */
208   char *p;
209   p = buf;
210   p += sprintf(p, "Font face:            ");
211   if (pFmt->dwMask & CFM_FACE) {
212     WCHAR *q = pFmt->szFaceName;
213     while(*q) {
214       *p++ = (*q > 255) ? '?' : *q;
215       q++;      
216     }       
217   } else
218     p += sprintf(p, "N/A");
219
220   if (pFmt->dwMask & CFM_SIZE)
221     p += sprintf(p, "\nFont size:            %d\n", (int)pFmt->yHeight);
222   else
223     p += sprintf(p, "\nFont size:            N/A\n");
224     
225   if (pFmt->dwMask & CFM_OFFSET)
226     p += sprintf(p, "Char offset:          %d\n", (int)pFmt->yOffset);
227   else
228     p += sprintf(p, "Char offset:          N/A\n");
229
230   if (pFmt->dwMask & CFM_CHARSET)
231     p += sprintf(p, "Font charset:         %d\n", (int)pFmt->bCharSet);
232   else
233     p += sprintf(p, "Font charset:         N/A\n");
234     
235   /* I'm assuming CFM_xxx and CFE_xxx are the same values, fortunately it IS true wrt used flags*/
236   ME_DumpStyleEffect(&p, "Font bold:", pFmt, CFM_BOLD);
237   ME_DumpStyleEffect(&p, "Font italic:", pFmt, CFM_ITALIC);
238   ME_DumpStyleEffect(&p, "Font underline:", pFmt, CFM_UNDERLINE);
239   ME_DumpStyleEffect(&p, "Font strikeout:", pFmt, CFM_STRIKEOUT);
240   ME_DumpStyleEffect(&p, "Hidden text:", pFmt, CFM_HIDDEN);
241   p += sprintf(p, "Text color:           ");
242   if (pFmt->dwMask & CFM_COLOR)
243   {
244     if (pFmt->dwEffects & CFE_AUTOCOLOR)
245       p += sprintf(p, "auto\n");
246     else
247       p += sprintf(p, "%06x\n", (int)pFmt->crTextColor);
248   }
249   else
250     p += sprintf(p, "N/A\n");
251   ME_DumpStyleEffect(&p, "Text protected:", pFmt, CFM_PROTECTED);
252 }
253
254
255 static void
256 ME_LogFontFromStyle(HDC hDC, LOGFONTW *lf, ME_Style *s, int nZoomNumerator, int nZoomDenominator)
257 {
258   int rx, ry;
259   rx = GetDeviceCaps(hDC, LOGPIXELSX);
260   ry = GetDeviceCaps(hDC, LOGPIXELSY);
261   ZeroMemory(lf, sizeof(LOGFONTW));
262   lstrcpyW(lf->lfFaceName, s->fmt.szFaceName);
263
264   if (nZoomNumerator == 0)
265   {
266     nZoomNumerator = 1;
267     nZoomDenominator = 1;
268   }
269   lf->lfHeight = -s->fmt.yHeight*ry*nZoomNumerator/nZoomDenominator/1440;
270   
271   lf->lfWeight = 400;
272   if (s->fmt.dwEffects & s->fmt.dwMask & CFM_BOLD)
273     lf->lfWeight = 700;
274   if (s->fmt.dwEffects & s->fmt.dwMask & CFM_WEIGHT)
275     lf->lfWeight = s->fmt.wWeight;
276   if (s->fmt.dwEffects & s->fmt.dwMask & CFM_ITALIC)
277     lf->lfItalic = 1;
278   if (s->fmt.dwEffects & s->fmt.dwMask & (CFM_UNDERLINE | CFE_LINK))
279     lf->lfUnderline = 1;
280   if (s->fmt.dwEffects & s->fmt.dwMask & CFM_STRIKEOUT)
281     lf->lfStrikeOut = 1;
282   if (s->fmt.dwEffects & s->fmt.dwMask & (CFM_SUBSCRIPT|CFM_SUPERSCRIPT))
283     lf->lfHeight = (lf->lfHeight*2)/3;
284 /*lf.lfQuality = PROOF_QUALITY; */
285   lf->lfPitchAndFamily = s->fmt.bPitchAndFamily;
286   lf->lfCharSet = s->fmt.bCharSet;
287 }
288
289 void ME_CharFormatFromLogFont(HDC hDC, LOGFONTW *lf, CHARFORMAT2W *fmt)
290 {
291   int rx, ry;
292   
293   ME_InitCharFormat2W(fmt);
294   rx = GetDeviceCaps(hDC, LOGPIXELSX);
295   ry = GetDeviceCaps(hDC, LOGPIXELSY);
296   lstrcpyW(fmt->szFaceName, lf->lfFaceName);
297   fmt->dwEffects = 0;
298   fmt->dwMask = CFM_WEIGHT|CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT|CFM_SIZE|CFM_FACE|CFM_CHARSET;
299   fmt->wWeight = lf->lfWeight;
300   fmt->yHeight = -lf->lfHeight*1440/ry;
301   if (lf->lfWeight>400) fmt->dwEffects |= CFM_BOLD;
302   if (lf->lfItalic) fmt->dwEffects |= CFM_ITALIC;
303   if (lf->lfUnderline) fmt->dwEffects |= CFM_UNDERLINE;
304   /* notice that if a logfont was created with underline due to CFM_LINK, this
305       would add an erronious CFM_UNDERLINE. This isn't currently ever a problem */
306   if (lf->lfStrikeOut) fmt->dwEffects |= CFM_STRIKEOUT;
307   fmt->bPitchAndFamily = lf->lfPitchAndFamily;
308   fmt->bCharSet = lf->lfCharSet;  
309 }
310
311 BOOL ME_IsFontEqual(LOGFONTW *p1, LOGFONTW *p2)
312 {
313   if (memcmp(p1, p2, sizeof(LOGFONTW)-sizeof(p1->lfFaceName)))
314     return FALSE;
315   if (lstrcmpW(p1->lfFaceName, p2->lfFaceName))
316     return FALSE;
317   return TRUE;
318 }
319
320 HFONT ME_SelectStyleFont(ME_TextEditor *editor, HDC hDC, ME_Style *s)
321 {
322   HFONT hOldFont;
323   LOGFONTW lf;
324   int i, nEmpty, nAge = 0x7FFFFFFF;
325   ME_FontCacheItem *item;
326   assert(hDC);
327   assert(s);
328   
329   ME_LogFontFromStyle(hDC, &lf, s, editor->nZoomNumerator, editor->nZoomDenominator);
330   
331   for (i=0; i<HFONT_CACHE_SIZE; i++)
332     editor->pFontCache[i].nAge++;
333   for (i=0, nEmpty=-1, nAge=0; i<HFONT_CACHE_SIZE; i++)
334   {
335     item = &editor->pFontCache[i];
336     if (!item->nRefs)
337     {
338       if (item->nAge > nAge)
339         nEmpty = i, nAge = item->nAge;
340     }
341     if (item->hFont && ME_IsFontEqual(&item->lfSpecs, &lf))
342       break;
343   }
344   if (i < HFONT_CACHE_SIZE) /* found */
345   {
346     item = &editor->pFontCache[i];
347     TRACE_(richedit_style)("font reused %d\n", i);
348
349     s->hFont = item->hFont;
350     item->nRefs++;
351   }
352   else
353   {
354     item = &editor->pFontCache[nEmpty]; /* this legal even when nEmpty == -1, as we don't dereference it */
355
356     assert(nEmpty != -1); /* otherwise we leak cache entries or get too many fonts at once*/
357     if (item->hFont) {
358       TRACE_(richedit_style)("font deleted %d\n", nEmpty);
359       DeleteObject(item->hFont);
360       item->hFont = NULL;
361     }
362     s->hFont = CreateFontIndirectW(&lf);
363     assert(s->hFont);
364     TRACE_(richedit_style)("font created %d\n", nEmpty);
365     item->hFont = s->hFont;
366     item->nRefs = 1;
367     memcpy(&item->lfSpecs, &lf, sizeof(LOGFONTW));
368   }
369   hOldFont = SelectObject(hDC, s->hFont);
370   /* should be cached too, maybe ? */
371   GetTextMetricsW(hDC, &s->tm);
372   return hOldFont;
373 }
374
375 void ME_UnselectStyleFont(ME_TextEditor *editor, HDC hDC, ME_Style *s, HFONT hOldFont)
376 {
377   int i;
378   
379   assert(hDC);
380   assert(s);
381   SelectObject(hDC, hOldFont);
382   for (i=0; i<HFONT_CACHE_SIZE; i++)
383   {
384     ME_FontCacheItem *pItem = &editor->pFontCache[i];
385     if (pItem->hFont == s->hFont && pItem->nRefs > 0)
386     {
387       pItem->nRefs--;
388       pItem->nAge = 0;
389       s->hFont = NULL;
390       return;
391     }
392   }
393   assert(0 == "UnselectStyleFont without SelectStyleFont");
394 }
395
396 static void ME_DestroyStyle(ME_Style *s) {
397   if (s->hFont)
398   {
399     DeleteObject(s->hFont);
400     s->hFont = NULL;
401   }
402   FREE_OBJ(s);
403 }
404
405 void ME_AddRefStyle(ME_Style *s)
406 {
407   assert(s->nRefs>0); /* style with 0 references isn't supposed to exist */
408   s->nRefs++;
409   all_refs++;
410 }
411
412 void ME_ReleaseStyle(ME_Style *s)
413 {
414   s->nRefs--;
415   all_refs--;
416   if (s->nRefs==0)
417     TRACE_(richedit_style)("destroy style %p, total refs=%d\n", s, all_refs);
418   else
419     TRACE_(richedit_style)("release style %p, new refs=%d, total refs=%d\n", s, s->nRefs, all_refs);
420   if (!all_refs) TRACE("all style references freed (good!)\n");
421   assert(s->nRefs>=0);
422   if (!s->nRefs)
423     ME_DestroyStyle(s);
424 }
425
426 ME_Style *ME_GetInsertStyle(ME_TextEditor *editor, int nCursor) {
427   if (ME_IsSelection(editor))
428   {
429     ME_Cursor c;
430     int from, to;
431     
432     ME_GetSelection(editor, &from, &to);
433     ME_CursorFromCharOfs(editor, from, &c);
434     ME_AddRefStyle(c.pRun->member.run.style);
435     return c.pRun->member.run.style;
436   }
437   if (editor->pBuffer->pCharStyle) {
438     ME_AddRefStyle(editor->pBuffer->pCharStyle);
439     return editor->pBuffer->pCharStyle;
440   }
441   else
442   {
443     ME_Cursor *pCursor = &editor->pCursors[nCursor];
444     ME_DisplayItem *pRunItem = pCursor->pRun;
445     ME_DisplayItem *pPrevItem = NULL;
446     if (pCursor->nOffset) {
447       ME_Run *pRun = &pRunItem->member.run;
448       ME_AddRefStyle(pRun->style);
449       return pRun->style;
450     }
451     pPrevItem = ME_FindItemBack(pRunItem, diRunOrParagraph);
452     if (pPrevItem->type == diRun)
453     {
454       ME_AddRefStyle(pPrevItem->member.run.style);
455       return pPrevItem->member.run.style;
456     }
457     else
458     {
459       ME_AddRefStyle(pRunItem->member.run.style);
460       return pRunItem->member.run.style;
461     }
462   }
463 }
464
465 void ME_SaveTempStyle(ME_TextEditor *editor)
466 {
467   ME_Style *old_style = editor->pBuffer->pCharStyle;
468   editor->pBuffer->pCharStyle = ME_GetInsertStyle(editor, 0);
469   if (old_style)
470     ME_ReleaseStyle(old_style);
471 }
472
473 void ME_ClearTempStyle(ME_TextEditor *editor)
474 {
475   if (!editor->pBuffer->pCharStyle) return;
476   ME_ReleaseStyle(editor->pBuffer->pCharStyle);
477   editor->pBuffer->pCharStyle = NULL;
478 }