Context Navigation

source: trunk/src/helpers/gpih.c@ 13

Visit:

Last change on this file since 13 was 13, checked in by umoeller, 25 years ago
Updates for V0.9.6.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 62.8 KB

Line
1
2	/*
3	*@@sourcefile gpih.c:
4	* contains GPI (graphics) helper functions.
5	*
6	* Usage: All PM programs.
7	*
8	* A word about GPI rectangles: In general, graphics operations involving
9	* device coordinates (such as regions, bit maps and bit blts, and window
10	* management) use inclusive-exclusive rectangles. All other graphics
11	* operations, such as GPI functions that define paths, use inclusive-inclusive
12	* rectangles.
13	*
14	* Function prefixes (new with V0.81):
15	* -- gpih* GPI helper functions
16	*
17	* Note: Version numbering in this file relates to XWorkplace version
18	* numbering.
19	*
20	*@@header "helpers\gpih.h"
21	*/
22
23	/*
24	* Copyright (C) 1997-2000 Ulrich Mller.
25	* This file is part of the XWorkplace source package.
26	* XWorkplace is free software; you can redistribute it and/or modify
27	* it under the terms of the GNU General Public License as published
28	* by the Free Software Foundation, in version 2 as it comes in the
29	* "COPYING" file of the XWorkplace main distribution.
30	* This program is distributed in the hope that it will be useful,
31	* but WITHOUT ANY WARRANTY; without even the implied warranty of
32	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33	* GNU General Public License for more details.
34	*/
35
36	#define OS2EMX_PLAIN_CHAR
37	// this is needed for "os2emx.h"; if this is defined,
38	// emx will define PSZ as _signed_ char, otherwise
39	// as unsigned char
40
41	#define INCL_DOSDEVIOCTL
42	#define INCL_DOS
43	#define INCL_DOSERRORS
44	#define INCL_WIN
45	#define INCL_GPI
46	#include <os2.h>
47
48	#include <stdlib.h>
49	#include <string.h>
50	#include <stdio.h>
51	#include <sys/types.h>
52	#include <sys/stat.h>
53
54	#include "setup.h" // code generation and debugging options
55
56	#include "helpers\winh.h"
57	#include "helpers\gpih.h"
58
59	#pragma hdrstop
60
61	// array for querying device capabilities (gpihQueryDisplayCaps)
62	LONG DisplayCaps[CAPS_DEVICE_POLYSET_POINTS] = {0};
63	BOOL fCapsQueried = FALSE;
64
65	/*
66	*@@category: Helpers\PM helpers\GPI helpers\Devices
67	*/
68
69	/* ******************************************************************
70	* *
71	* Device helpers *
72	* *
73	********************************************************************/
74
75	/*
76	*@@ gpihQueryDisplayCaps:
77	* this returns certain device capabilities of
78	* the Display device. ulIndex must be one of
79	* the indices as described in DevQueryCaps.
80	*
81	* This function will load all the device capabilities
82	* only once into a global array and re-use them afterwards.
83	*/
84
85	ULONG gpihQueryDisplayCaps(ULONG ulIndex)
86	{
87	if (!fCapsQueried)
88	{
89	HPS hps = WinGetScreenPS(HWND_DESKTOP);
90	HDC hdc = GpiQueryDevice(hps);
91	DevQueryCaps(hdc, 0, CAPS_DEVICE_POLYSET_POINTS, &DisplayCaps[0]);
92	}
93
94	return (DisplayCaps[ulIndex]);
95	}
96
97	/*
98	*@@category: Helpers\PM helpers\GPI helpers\Colors
99	*/
100
101	/* ******************************************************************
102	* *
103	* Color helpers *
104	* *
105	********************************************************************/
106
107	/*
108	*@@ gpihManipulateRGB:
109	* this changes an RGB color value
110	* by multiplying each color component
111	* (red, green, blue) with bMultiplier
112	* and dividing it by bDivisor afterwards.
113	*
114	* Each color component is treated separately,
115	* so if overflows occur (because bMultiplier
116	* is > 1), this does not affect the other
117	* components.
118	*
119	* Example: if you pass a brigt red
120	* (0xFF0000) to this func, this will
121	* be 0x7F0000 if bMultiplier and
122	* bDivisor are 1 and 2.
123	*/
124
125	VOID gpihManipulateRGB(PLONG plColor, // in/out: RGB color
126	BYTE bMultiplier, // in: multiplier
127	BYTE bDivisor) // in: divisor
128	{
129	PBYTE pb = (PBYTE)plColor;
130	// in memory, the bytes are blue, green, red, unused
131	pb++ = (BYTE)((LONG)(pb) * bMultiplier / bDivisor); // blue
132	pb++ = (BYTE)((LONG)(pb) * bMultiplier / bDivisor); // green
133	pb++ = (BYTE)((LONG)(pb) * bMultiplier / bDivisor); // red
134	}
135
136	/*
137	*@@category: Helpers\PM helpers\GPI helpers\Drawing primitives
138	*/
139
140	/* ******************************************************************
141	* *
142	* Drawing primitives helpers *
143	* *
144	********************************************************************/
145
146	/*
147	*@@ gpihDrawRect:
148	* this draws a simple rectangle with the current
149	* color (use GpiSetColor before calling this function).
150	*
151	* The specified rectangle is inclusive, that is, the top
152	* right corner specifies the top right pixel to be drawn.
153	*
154	* This sets the current position to the bottom left corner
155	* of prcl.
156	*
157	*@added V0.9.0
158	*/
159
160	VOID gpihDrawRect(HPS hps, // in: presentation space for output
161	PRECTL prcl) // in: rectangle to draw (inclusive)
162	{
163	POINTL ptl1;
164
165	ptl1.x = prcl->xLeft;
166	ptl1.y = prcl->yBottom;
167	GpiMove(hps, &ptl1);
168	ptl1.y = prcl->yTop-1;
169	GpiLine(hps, &ptl1);
170	ptl1.x = prcl->xRight-1;
171	GpiLine(hps, &ptl1);
172	ptl1.y = prcl->yBottom;
173	GpiLine(hps, &ptl1);
174	ptl1.x = prcl->xLeft;
175	GpiLine(hps, &ptl1);
176	}
177
178	/*
179	*@@ gpihBox:
180	* this is a shortcurt to GpiBox, using the specified
181	* rectangle.
182	*
183	* As opposed to WinFillRect, this works with memory
184	* (bitmap) PS's also.
185	*
186	* The specified rectangle is exclusive, meaning that
187	* the top right point lies _outside_ the rectangle
188	* which is actually drawn. This is the same as with
189	* WinFillRect.
190	*
191	* Changes to the HPS:
192	* -- the current (foreground) color is changed to
193	* lBackColor;
194	* -- the current area color is changed to lForeColor;
195	* -- the current position is moved to the lower left
196	* corner of *prcl.
197	*
198	*@@changed V0.9.0 [umoeller]: renamed from gpihFillRect
199	*@@changed V0.9.0 [umoeller]: modified function prototype to support lControl
200	*/
201
202	VOID gpihBox(HPS hps, // in: presentation space for output
203	LONG lControl, // in: one of DRO_OUTLINE, DRO_FILL, DRO_OUTLINEFILL
204	PRECTL prcl, // in: rectangle to draw (exclusive)
205	LONG lColor) // in: color for outline and/or fill
206	{
207	POINTL ptl;
208
209	GpiSetColor(hps, lColor);
210	ptl.x = prcl->xLeft;
211	ptl.y = prcl->yBottom;
212	GpiMove(hps, &ptl);
213	ptl.x = prcl->xRight;
214	ptl.y = prcl->yTop;
215	GpiBox(hps,
216	lControl, // DRO_*
217	&ptl,
218	0, 0); // no corner rounding
219	}
220
221	/*
222	*@@ gpihMarker:
223	* this draws a quick marker (a filled
224	* rectangle) at the specified position.
225	* The rectangle will be drawn so that
226	* the specified point is in its center.
227	*
228	* No PS data is changed.
229	*/
230
231	VOID gpihMarker(HPS hps,
232	LONG x, // in: x-center of rectangle
233	LONG y, // in: y-center of rectangle
234	ULONG ulWidth, // in: rectangle width and height
235	LONG lColor) // in: color
236	{
237	POINTL ptlSave;
238	LONG lColorSave;
239	RECTL rclTemp;
240	ULONG ulWidth2 = ulWidth / 2;
241	rclTemp.xLeft = x - ulWidth2;
242	rclTemp.xRight = x + ulWidth2;
243	rclTemp.yBottom = y - ulWidth2;
244	rclTemp.yTop = y + ulWidth2;
245
246	lColorSave = GpiQueryColor(hps);
247	GpiQueryCurrentPosition(hps, &ptlSave);
248	gpihBox(hps,
249	DRO_FILL,
250	&rclTemp,
251	lColor);
252	GpiMove(hps, &ptlSave);
253	GpiSetColor(hps, lColorSave);
254	}
255
256	/*
257	*@@ gpihDraw3DFrame:
258	* this draws a rectangle in 3D style with a given line width
259	* and the given colors.
260	*
261	* The specified rectangle is inclusive, that is, the top
262	* right corner specifies the top right pixel to be drawn.
263	*
264	* If usWidth > 1, the additional pixels will be drawn towards
265	* the _center_ of the rectangle. prcl thus always specifies
266	* the bottom left and top right pixels to be drawn.
267	*
268	*@@changed V0.9.0 [umoeller]: changed function prototype to have colors specified
269	*/
270
271	VOID gpihDraw3DFrame(HPS hps,
272	PRECTL prcl, // in: rectangle
273	USHORT usWidth, // in: line width (>= 1)
274	LONG lColorLeft, // in: color to use for left and top; e.g. SYSCLR_BUTTONLIGHT
275	LONG lColorRight) // in: color to use for right and bottom; e.g. SYSCLR_BUTTONDARK
276	{
277	RECTL rcl2 = *prcl;
278	USHORT us;
279	POINTL ptl1;
280
281	for (us = 0; us < usWidth; us++)
282	{
283	GpiSetColor(hps, lColorLeft);
284	ptl1.x = rcl2.xLeft;
285	ptl1.y = rcl2.yBottom;
286	GpiMove(hps, &ptl1);
287	ptl1.y = rcl2.yTop-1;
288	GpiLine(hps, &ptl1);
289	ptl1.x = rcl2.xRight-1;
290	GpiLine(hps, &ptl1);
291	GpiSetColor(hps, lColorRight);
292	ptl1.y = rcl2.yBottom;
293	GpiLine(hps, &ptl1);
294	ptl1.x = rcl2.xLeft;
295	GpiLine(hps, &ptl1);
296
297	rcl2.xLeft++;
298	rcl2.yBottom++;
299	rcl2.xRight--;
300	rcl2.yTop--;
301	}
302	}
303
304	/*
305	*@@ gpihCharStringPosAt:
306	* wrapper for GpiCharStringPosAt.
307	* Since that function is limited to 512 characters
308	* (according to GPIREF; on my Warp 4 FP13, I actually
309	* get some 3000 characters... whatever this is),
310	* this splits the string into 512 byte chunks and
311	* calls GpiCharStringPosAt accordingly.
312	*
313	*@@added V0.9.3 (2000-05-06) [umoeller]
314	*/
315
316	LONG gpihCharStringPosAt(HPS hps,
317	PPOINTL pptlStart,
318	PRECTL prclRect,
319	ULONG flOptions,
320	LONG lCount,
321	PCH pchString)
322	{
323	LONG lHits = 0,
324	lCountLeft = lCount;
325	PCH pchThis = pchString;
326
327	GpiMove(hps, pptlStart);
328
329	if (lCount)
330	{
331	do
332	{
333	LONG lCountThis = lCountLeft;
334	if (lCountLeft >= 512)
335	lCountThis = 512;
336
337	lHits = GpiCharStringPos(hps,
338	prclRect,
339	flOptions,
340	lCountThis,
341	pchThis,
342	0);
343
344	pchThis += 512;
345	lCountLeft -= 512;
346	} while (lCountLeft > 0);
347	}
348
349	return (lHits);
350	}
351
352	/*
353	*@@category: Helpers\PM helpers\GPI helpers\Fonts
354	*/
355
356	/* ******************************************************************
357	* *
358	* Font helpers *
359	* *
360	********************************************************************/
361
362	/*
363	*@@ gpihSplitPresFont:
364	* splits a presentation parameter font
365	* string into the point size and face
366	* name so that it can be passed to
367	* gpihFindFont more easily.
368	*
369	*@@added V0.9.1 (2000-02-15) [umoeller]
370	*/
371
372	BOOL gpihSplitPresFont(PSZ pszFontNameSize, // in: e.g. "12.Courier"
373	PULONG pulSize, // out: integer point size (e.g. 12);
374	// ptr must be specified
375	PSZ *ppszFaceName) // out: ptr into pszFontNameSize
376	// (e.g. "Courier")
377	{
378	BOOL brc = FALSE;
379
380	if (pszFontNameSize)
381	{
382	PCHAR pcDot = strchr(pszFontNameSize, '.');
383	if (pcDot)
384	{
385	// _Pmpf(("Found font PP: %s", pszFontFound));
386	sscanf(pszFontNameSize, "%lu", pulSize);
387	*ppszFaceName = pcDot + 1;
388	brc = TRUE;
389	}
390	}
391
392	return (brc);
393	}
394
395	/*
396	*@@ gpihQueryNextLCID:
397	* returns the next available lcid for the given HPS.
398	* Actually, it's the next available lcid for the
399	* entire process, since there can be only 255 altogether.
400	* Gets called by gpihFindFont automatically.
401	*
402	* This is possibly the sickest code I've ever written.
403	*
404	* Warning: This function is _not_ thread-safe.
405	* We use GpiQueryNumberSetIds to find out the no. of
406	* LCID's in use by the process. In the worst case,
407	* between that call and the call to GpiCreateLogFont,
408	* another font has been created, and you'll get garbage.
409	*
410	*@@added V0.9.3 (2000-05-06) [umoeller]
411	*/
412
413	LONG gpihQueryNextFontID(HPS hps)
414	{
415	LONG lcidNext = -1;
416
417	LONG lCount = GpiQueryNumberSetIds(hps);
418	// the number of local identifiers
419	// (lcids) currently in use, and
420	// therefore the maximum number
421	// of objects for which information
422	// can be returned
423	if (lCount == 0)
424	// none in use yet:
425	lcidNext = 1;
426	else
427	{
428	#define GQNCL_BLOCK_SIZE 400*sizeof(LONG)
429	PLONG pBase;
430
431	APIRET arc;
432
433	// _Pmpf(("gpihQueryNextFontID: calling DosAllocMem"));
434
435	arc = DosAllocMem((PPVOID)(&pBase),
436	GQNCL_BLOCK_SIZE,
437	// space is needed for an array of lCount longs.
438	PAG_READ \|
439	PAG_WRITE);
440	if (arc == NO_ERROR)
441	{
442	arc = DosSubSetMem(pBase,
443	DOSSUB_INIT \| DOSSUB_SPARSE_OBJ,
444	GQNCL_BLOCK_SIZE);
445	if (arc == NO_ERROR)
446	{
447	PLONG alTypes; // object types
448	PSTR8 aNames; // font names
449	PLONG allcids; // local identifiers
450
451	arc = DosSubAllocMem((PVOID)pBase,
452	(PPVOID)(&aNames),
453	(ULONG)(lCount*(ULONG)sizeof(STR8)));
454	// space is needed for an array of
455	// lCount longs
456	if (arc == NO_ERROR)
457	{
458	arc = DosSubAllocMem((PVOID)pBase,
459	(PPVOID)(&allcids),
460	(ULONG)lCount*sizeof(LONG));
461	// space is needed for an array of
462	// lCount longs.
463	if (arc == NO_ERROR)
464	{
465	arc = DosSubAllocMem((PVOID)pBase,
466	(PPVOID)(&alTypes),
467	(ULONG)lCount*sizeof(LONG));
468	// space is needed for an array of
469	// lCount longs.
470	if (arc == NO_ERROR)
471	{
472	if (GpiQuerySetIds(hps,
473	lCount,
474	alTypes,
475	aNames,
476	allcids))
477	{
478	// FINALLY we have all the lcids in use.
479	BOOL fContinue = TRUE;
480	lcidNext = 1;
481
482	// now, check if this lcid is in use already:
483	while (fContinue)
484	{
485	BOOL fFound = FALSE;
486	ULONG ul;
487	fContinue = FALSE;
488	for (ul = 0;
489	ul < lCount;
490	ul++)
491	{
492	if (allcids[ul] == lcidNext)
493	{
494	fFound = TRUE;
495	break;
496	}
497	}
498
499	if (fFound)
500	{
501	// lcid found:
502	// try next higher one
503	lcidNext++;
504	fContinue = TRUE;
505	}
506	// else: return that one
507	}
508	}
509	}
510	}
511	}
512	}
513
514	arc = DosFreeMem(pBase);
515	}
516	}
517
518	return (lcidNext);
519	}
520
521	/*
522	*@@ gpihFindFont:
523	* this returns a new logical font ID (LCID) for the specified
524	* font by calling GpiCreateLogFont.
525	* This function performs the insane "11-step process" to
526	* match a font, as described in the GPI reference.
527	*
528	* This function can operate in two modes:
529	*
530	* -- "Family" mode. In that case, specify the font family name
531	* with pszName and set fFamily to TRUE. This is useful for
532	* WYSIWYG text viewing if you need several font faces for
533	* the same family, such as Courier Bold, Bold Italics, etc.
534	* You can specify those attributes with usFormat then.
535	*
536	* -- "Face" mode. In that case, specify the full font face name
537	* with pszName and set fFamily to FALSE. This is useful for
538	* font presentation parameters which use the "WarpSans Bold"
539	* format. In that case, set usFormat to 0.
540	*
541	* After the font has been created, if (pFontMetrics != NULL),
542	* *pFontMetrics receives the FONTMETRICS of the font which
543	* has been created. If an outline font has been created
544	* (instead of a bitmap font), FONTMETRICS.fsDefn will have
545	* the FM_DEFN_OUTLINE bit set.
546	*
547	* To then use the font whose LCID has been returned by this
548	* function for text output, call:
549	+ GpiSetCharSet(hps, lLCIDReturned);
550	*
551	* <B>Font Point Sizes:</B>
552	*
553	* 1) For image (bitmap) fonts, the size is fixed, and
554	* you can directly draw after the font has been
555	* selected. GpiSetCharBox has no effect on image
556	* fonts unless you switch to character mode 2
557	* (if you care for that: GpiSetCharMode).
558	*
559	* 2) For outline fonts however, you need to define a
560	* character box if you want to output text in a
561	* size other than the default size. This is almost
562	* as bad a mess as this function, so gpihSetPointSize
563	* has been provided for this. See remarks there.
564	*
565	* <B>Example:</B>
566	*
567	* This example prints text in "24.Courier".
568	*
569	+ PSZ pszOutput = "Test output";
570	+ FONTMETRICS FontMetrics;
571	+ LONG lLCID = gpihFindFont(hps,
572	+ 24, // point size
573	+ FALSE, // face, not family
574	+ "Courier",
575	+ 0,
576	+ &FontMetrics);
577	+ if (lLCID)
578	+ {
579	+ // no error:
580	+ GpiSetCharSet(hps, lLCID);
581	+ if (FontMetrics.fsDefn & FM_DEFN_OUTLINE)
582	+ // outline font found (should be the case):
583	+ gpihSetPointSize(hps, 24);
584	+ }
585	+ GpiCharString(hps, strlen(pszOutput), pszOutput);
586	*
587	* <B>Details:</B>
588	*
589	* First, GpiQueryFonts is called to enumerate all the fonts on
590	* the system. We then evaluate the awful FONTMETRICS data
591	* of those fonts to perform a "real" match.
592	*
593	* If that fails, we allow GPI to do a "close" match based
594	* on the input values. This might result in the system
595	* default font (System Proportional) to be found, in the
596	* worst case. But even then, a new LCID is returned.
597	*
598	* The "close match" comes in especially when using the
599	* font attributes (bold, italics) and we are unable to
600	* find the correct outline font for that. Unfortunately,
601	* the information in FONTMETRICS.fsSelection is wrong,
602	* wrong, wrong for the large majority of fonts. (For
603	* example, I get the "bold" flag set for regular fonts,
604	* and vice versa.) So we attempt to use the other fields,
605	* but this doesn't always help. Not even Netscape gets
606	* this right.
607	*
608	* <B>Font faces:</B>
609	*
610	* This is terribly complicated as well. You need to
611	* differentiate between "true" emphasis faces (that
612	* is, bold and italics are implemented thru separate
613	* font files) and the ugly GPI simulation, which simply
614	* makes the characters wider or shears them.
615	*
616	* This function even finds true "bold" and "italic" faces
617	* for outline fonts. To do this, always specify the "family"
618	* name as pszFaceName (e.g. "Courier" instead of "Courier
619	* Bold") and set the flags for usFormat (e.g. FATTR_SEL_BOLD).
620	* Note that this implies that you need call this function
621	* twice to create two logical fonts for regular and bold faces.
622	*
623	* If a "true" emphasis font is not found, the GPI simulation
624	* is enabled.
625	*
626	* <B>Remarks:</B>
627	*
628	* 1) This function _always_ creates a new logical font,
629	* whose ID is returned, even if the specified font
630	* was not found or a "close match" was performed by
631	* GPI. As a result, do not call this function twice
632	* for the same font specification, because there are
633	* only 255 logical font IDs for each process.
634	*
635	* 2) Since this function always creates an LCID,
636	* you should _always_ free the LCID later.
637	* This is only valid if the font is no longer selected
638	* into any presentation space. So use these calls:
639	+ GpiSetCharSet(hps, LCID_DEFAULT);
640	+ GpiDeleteSetId(hps, lLCIDReturnedByThis);
641	*
642	* 3) Using this function, bitmap fonts will have priority
643	* over outline fonts of the same face name. This is
644	* how the WPS does it too. This is most obvious with
645	* the "Helv" font, which exists as a bitmap font for
646	* certain point sizes only.
647	*
648	* 4) <B>Warning: This function is _not_ thread-safe.</B>
649	* Since logical font IDs are shared across the
650	* process, this function should _not_ be called
651	* from several threads at the same time.
652	*
653	* This calls gpihQueryNextFontID in turn to find the
654	* next free lcid. See remarks there.
655	* If your fonts suddenly change to "System Proportional"
656	* in your application, you probably have a serialization
657	* problem.
658	*
659	* To make this thread-safe, create your own wrapper
660	* function which calls this function while a mutex
661	* semaphore is held by the wrapper. Then use only
662	* the wrapper in your code.
663	*
664	*@@added V0.9.0 [umoeller]
665	*@@changed V0.9.3 (2000-05-06) [umoeller]: didn't work for more than one font; now using gpihQueryNextFontID
666	*@@changed V0.9.3 (2000-05-06) [umoeller]: usFormat didn't work; fixed
667	*@@changed V0.9.4 (2000-08-08) [umoeller]: added fFamily
668	*/
669
670	LONG gpihFindFont(HPS hps, // in: HPS for font selection
671	LONG lSize, // in: font point size
672	BOOL fFamily, // in: if TRUE, pszName specifies font family;
673	// if FALSE, pszName specifies font face
674	PSZ pszName, // in: font family or face name (without point size)
675	USHORT usFormat, // in: none, one or several of:
676	// -- FATTR_SEL_ITALIC
677	// -- FATTR_SEL_UNDERSCORE (underline)
678	// -- FATTR_SEL_BOLD
679	// -- FATTR_SEL_STRIKEOUT
680	// -- FATTR_SEL_OUTLINE (hollow)
681	PFONTMETRICS pFontMetrics) // out: font metrics of created font (optional)
682	{
683	LONG lLCIDReturn = 0;
684	ULONG ul = 0;
685	FATTRS FontAttrs;
686
687	// first find out how much memory we need to allocate
688	// for the FONTMETRICS structures
689	LONG lTemp = 0;
690	LONG cFonts = GpiQueryFonts(hps,
691	QF_PUBLIC \| QF_PRIVATE,
692	NULL, // pszFaceName,
693	&lTemp,
694	sizeof(FONTMETRICS),
695	NULL);
696	PFONTMETRICS pfm = (PFONTMETRICS)malloc(cFonts * sizeof(FONTMETRICS)),
697	pfm2 = pfm,
698	pfmFound = NULL;
699
700	// _Pmpf(("gpihFindFont: enumerating for %s, %d points", pszFaceName, lSize));
701
702	GpiQueryFonts(hps,
703	QF_PUBLIC \| QF_PRIVATE,
704	NULL, // pszFaceName,
705	&cFonts,
706	sizeof(FONTMETRICS), // length of each metrics structure
707	// -- _not_ total buffer size!
708	pfm);
709	// now we have an array of FONTMETRICS
710	// for EVERY font that is installed on the system...
711	// these things are completely unsorted, so there's
712	// nothing we can rely on, we have to check them all.
713
714	// fill in some default values for FATTRS,
715	// in case we don't find something better
716	// in the loop below; these values will be
717	// applied if
718	// a) an outline font has been found;
719	// b) bitmap fonts have been found, but
720	// none for the current device resolution
721	// exists;
722	// c) no font has been found at all.
723	// In all cases, GpiCreateLogFont will do
724	// a "close match" resolution (at the bottom).
725	FontAttrs.usRecordLength = sizeof(FATTRS);
726	FontAttrs.fsSelection = usFormat; // changed later if better font is found
727	FontAttrs.lMatch = 0L; // closest match
728	strcpy(FontAttrs.szFacename, pszName);
729	FontAttrs.idRegistry = 0; // default registry
730	FontAttrs.usCodePage = 0; // default codepage
731	// the following two must be zero, or outline fonts
732	// will not be found; if a bitmap font has been passed
733	// to us, we'll modify these two fields later
734	FontAttrs.lMaxBaselineExt = 0; // font size (height)
735	FontAttrs.lAveCharWidth = 0; // font size (width)
736	FontAttrs.fsType = 0; // default type
737	FontAttrs.fsFontUse = FATTR_FONTUSE_NOMIX;
738
739	// now go thru the array of FONTMETRICS
740	// to check if we have a bitmap font
741	// pszFaceName; the default WPS behavior
742	// is that bitmap fonts appear to take
743	// priority over outline fonts of the
744	// same name, so we check these first
745	pfm2 = pfm;
746	for (ul = 0;
747	ul < cFonts;
748	ul++)
749	{
750	/* _Pmpf((" Checking font: %s (Fam: %s), %d, %d, %d",
751	pszFaceName,
752	pfm2->szFamilyname,
753	pfm2->sNominalPointSize,
754	pfm2->lMaxBaselineExt,
755	pfm2->lAveCharWidth)); */
756
757	PSZ pszCompare = (fFamily)
758	? pfm2->szFamilyname
759	: pfm2->szFacename;
760
761	if (strcmp(pszCompare, pszName) == 0)
762	{
763	/* _Pmpf((" Found font %s; slope %d, usWeightClass %d",
764	pfm2->szFacename,
765	pfm2->sCharSlope,
766	pfm2->usWeightClass)); */
767
768	if ((pfm2->fsDefn & FM_DEFN_OUTLINE) == 0)
769	{
770	// image (bitmap) font:
771	// check point size
772	if (pfm2->sNominalPointSize == lSize * 10)
773	{
774	// OK: check device resolutions, because
775	// normally, there are always several image
776	// fonts for different resolutions
777	// for bitmap fonts, there are always two versions:
778	// one for low resolutions, one for high resolutions
779	LONG alDevRes[2];
780	DevQueryCaps(GpiQueryDevice(hps),
781	CAPS_HORIZONTAL_FONT_RES,
782	2L,
783	alDevRes);
784	if ( (pfm2->sXDeviceRes == alDevRes[0])
785	&& (pfm2->sYDeviceRes == alDevRes[1])
786	)
787	{
788	// OK: use this for GpiCreateLogFont
789	FontAttrs.lMaxBaselineExt = pfm2->lMaxBaselineExt;
790	FontAttrs.lAveCharWidth = pfm2->lAveCharWidth;
791	FontAttrs.lMatch = pfm2->lMatch;
792
793	pfmFound = pfm2;
794	break;
795	}
796	}
797	}
798	else
799	// outline font:
800	if (pfmFound == NULL)
801	{
802	/*
803	#define FATTR_SEL_ITALIC 0x0001
804	#define FATTR_SEL_UNDERSCORE 0x0002
805	#define FATTR_SEL_OUTLINE 0x0008
806	#define FATTR_SEL_STRIKEOUT 0x0010
807	#define FATTR_SEL_BOLD 0x0020
808	*/
809	// no bitmap font found yet:
810	if ( ( ( (usFormat & FATTR_SEL_BOLD)
811	&& (pfm2->usWeightClass == 7) // bold
812	)
813	\|\| ( ((usFormat & FATTR_SEL_BOLD) == 0)
814	&& (pfm2->usWeightClass == 5) // regular
815	)
816	)
817	&& ( ( (usFormat & FATTR_SEL_ITALIC)
818	&& (pfm2->sCharSlope != 0) // italics
819	)
820	\|\| ( ((usFormat & FATTR_SEL_ITALIC) == 0)
821	&& (pfm2->sCharSlope == 0) // regular
822	)
823	)
824	)
825	{
826	// yes, we found a true font for that face:
827	pfmFound = pfm2;
828	// use this exact font for GpiCreateLogFont
829	FontAttrs.lMatch = pfm2->lMatch;
830	// according to GPIREF, we must also specify
831	// the full face name... Jesus!
832	strcpy(FontAttrs.szFacename, pfm2->szFacename);
833	// unset flag in FATTRS, because this would
834	// duplicate bold or italic
835	FontAttrs.fsSelection = 0;
836
837	// _Pmpf((" --> using it"));
838	// but loop on, because we might have a bitmap
839	// font which should take priority
840	}
841	}
842	}
843
844	pfm2++;
845	}
846
847	if (pfmFound)
848	// FONTMETRICS found:
849	// copy font metrics?
850	if (pFontMetrics)
851	memcpy(pFontMetrics, pfmFound, sizeof(FONTMETRICS));
852
853	// free the FONTMETRICS array
854	free(pfm);
855
856	// new logical font ID: last used plus one
857	lLCIDReturn = gpihQueryNextFontID(hps);
858
859	GpiCreateLogFont(hps,
860	NULL, // don't create "logical font name" (STR8)
861	lLCIDReturn,
862	&FontAttrs);
863
864	return (lLCIDReturn);
865	}
866
867	/*
868	*@@ gpihFindPresFont:
869	* similar to gpihFindFont, but this one evaluates
870	* the PP_FONTNAMESIZE presentation parameter of the
871	* specified window instead. If that one is not set,
872	* the specified default font is used instead.
873	*
874	* Note that as opposed to gpihFindFont, this one
875	* takes a "8.Helv"-type string as input.
876	*
877	* See gpihFindFont for additional remarks, which
878	* gets called by this function.
879	*
880	* Again, if an outline font has been returned, you
881	* must also set the "character box" for the HPS, or
882	* your text will always have the same point size.
883	* Use gpihSetPointSize for that, using the presparam's
884	* point size, which is returned by this function
885	* into *plSize, if (plSize != NULL):
886	+
887	+ FONTMETRICS FontMetrics;
888	+ LONG lPointSize;
889	+ LONG lLCID = gpihFindPresFont(hwnd, hps, "8.Helv",
890	+ &FontMetrics,
891	+ &lPointSize);
892	+ GpiSetCharSet(hps, lLCID);
893	+ if (FontMetrics.fsDefn & FM_DEFN_OUTLINE)
894	+ gpihSetPointSize(hps, lPointSize);
895	*
896	* If errors occur, e.g. if the font string does not
897	* conform to the "size.face" format, null is returned.
898	*
899	*@@added V0.9.0 [umoeller]
900	*/
901
902	LONG gpihFindPresFont(HWND hwnd, // in: window to search for presparam
903	BOOL fInherit, // in: search parent windows too?
904	HPS hps, // in: HPS for font selection
905	PSZ pszDefaultFont, // in: default font if not found (i.e. "8.Helv")
906	PFONTMETRICS pFontMetrics, // out: font metrics of created font (optional)
907	PLONG plSize) // out: presparam's point size (optional)
908	{
909	CHAR szPPFont[200] = "";
910	PSZ pszFontFound = 0;
911	CHAR szFaceName[300] = "";
912	ULONG ulFontSize = 0;
913
914	if (WinQueryPresParam(hwnd,
915	PP_FONTNAMESIZE, // first PP to query
916	0, // second PP to query
917	NULL, // out: which one is returned
918	(ULONG)sizeof(szPPFont), // in: buffer size
919	(PVOID)&szPPFont, // out: PP value returned
920	(fInherit)
921	? 0
922	: QPF_NOINHERIT))
923	// PP found:
924	pszFontFound = szPPFont;
925	else
926	pszFontFound = pszDefaultFont;
927
928	if (pszFontFound)
929	{
930	PCHAR pcDot = strchr(pszFontFound, '.');
931	if (pcDot)
932	{
933	// _Pmpf(("Found font PP: %s", pszFontFound));
934	sscanf(pszFontFound, "%lu", &ulFontSize);
935	if (plSize)
936	*plSize = ulFontSize;
937	strcpy(szFaceName, pcDot + 1);
938	return (gpihFindFont(hps,
939	ulFontSize,
940	FALSE, // face, not family name
941	szFaceName,
942	0,
943	pFontMetrics));
944	}
945	}
946	return (0);
947	}
948
949	/*
950	*@@ gpihSetPointSize:
951	* this invokes GpiSetCharBox on the given HPS to
952	* set the correct "character box" with the proper
953	* parameters.
954	*
955	* This is necessary for text output with outline
956	* fonts. Bitmap fonts have a fixed size, and
957	* calling this function is not necessary for them.
958	*
959	* Unfortunately, IBM has almost not documented
960	* how to convert nominal point sizes to the
961	* correct character cell values. This involves
962	* querying the output device (DevQueryCaps).
963	*
964	* I have found one hint for this procedure in GPIREF
965	* (chapter "Character string primitives", "Using...",
966	* "Drawing text"), but the example code given
967	* there is buggy, because it must be "72" instead
968	* of "720". #%(%!"õ!!.
969	*
970	* So here we go. If you want to output text in,
971	* say, "Courier" and 24 points (nominal point size),
972	* select the font into your HPS and call
973	+ gpihSetPointSize(hps, 24)
974	* and you're done. See gpihFindFont for a complete
975	* example.
976	*
977	* Call this function as many times as needed. This
978	* consumes no resources at all.
979	*
980	* This returns the return value of GpiSetCharBox.
981	*
982	*@@added V0.9.0 [umoeller]
983	*/
984
985	BOOL gpihSetPointSize(HPS hps, // in: presentation space for output
986	LONG lPointSize) // in: desired nominal point size
987	{
988	SIZEF box;
989	LONG alDevRes[2];
990	DevQueryCaps(GpiQueryDevice(hps), // get the HDC from the HPS
991	CAPS_HORIZONTAL_FONT_RES,
992	2L,
993	alDevRes);
994	box.cx = MAKEFIXED((lPointSize * alDevRes[0]) / 72, 0);
995	box.cy = MAKEFIXED((lPointSize * alDevRes[1]) / 72, 0);
996	return (GpiSetCharBox(hps, &box));
997	}
998
999	/*
1000	*@@ gpihQueryLineSpacing:
1001	* this returns the optimal line spacing for text
1002	* output with the current HPS; this is computed
1003	* by evaluating those incredible FONTMETRICS.
1004	*
1005	* This might be helpful if you write text to the
1006	* screen yourself and need the height of a text
1007	* line to advance to the next.
1008	*/
1009
1010	LONG gpihQueryLineSpacing(HPS hps,
1011	PSZ pszText) // in: text to output
1012	{
1013	FONTMETRICS fm;
1014	POINTL aptlText[TXTBOX_COUNT];
1015	GpiQueryTextBox(hps, strlen(pszText), pszText,
1016	TXTBOX_COUNT, (PPOINTL)&aptlText);
1017
1018	if (GpiQueryFontMetrics(hps, sizeof(FONTMETRICS), &fm))
1019	return ( ( fm.lMaxBaselineExt // max vertical font space
1020	+fm.lExternalLeading) // space advised by font designer
1021	// * 12 / 10
1022	);
1023	else
1024	return (15);
1025	}
1026
1027	/*
1028	*@@category: Helpers\PM helpers\GPI helpers\Bitmaps/Icons
1029	*/
1030
1031	/* ******************************************************************
1032	* *
1033	* Bitmap helpers *
1034	* *
1035	********************************************************************/
1036
1037	/*
1038	*@@ gpihCreateMemPS:
1039	* creates a memory device context and presentation space so
1040	* that they are compatible with the screen device context and
1041	* presentation space. These are stored in hdcMem and hpsMem.
1042	*
1043	* This is a one-shot function for the standard code that is
1044	* always needed when working with bitmaps in a memory device
1045	* context.
1046	*
1047	* psizlPage must point to a SIZEL structure containing the
1048	* width and height for the memory PS. Specify the size of
1049	* the future bitmap here. Specify {0, 0} to get a PS with
1050	* the size of the full screen, which consumes quite a bit
1051	* of memory though.
1052	*
1053	* Returns FALSE upon errors. In that case, both hdcMem and
1054	* hpsMem are set to NULLHANDLE.
1055	*
1056	* To cleanup after this function has returned TRUE, use the
1057	* following:
1058	+ GpiDestroyPS(hpsMem);
1059	+ DevCloseDC(hdcMem);
1060	*
1061	*@@changed V0.9.3 (2000-05-18) [umoeller]: added psiszlPage
1062	*/
1063
1064	BOOL gpihCreateMemPS(HAB hab, // in: anchor block
1065	PSIZEL psizlPage, // in: width and height for mem PS
1066	HDC *hdcMem, // out: memory DC or NULLHANDLE upon errors
1067	HPS *hpsMem) // out: memory PS or NULLHANDLE upon errors
1068	{
1069	BOOL brc = FALSE;
1070	PSZ pszData[4] = { "Display", NULL, NULL, NULL };
1071
1072	// create new memory DC
1073	if ((*hdcMem = DevOpenDC(hab,
1074	OD_MEMORY, // create memory DC
1075	"*", // token: do not take INI info
1076	4, // item count in pszData
1077	(PDEVOPENDATA)pszData,
1078	NULLHANDLE))) // compatible with screen
1079	{
1080	// memory DC created successfully:
1081	// create compatible PS
1082	if ((*hpsMem = GpiCreatePS(hab,
1083	*hdcMem, // HDC to associate HPS with (GPIA_ASSOC);
1084	// mandatory for GPIT_MICRO
1085	psizlPage, // is (0, 0) == screen size
1086	PU_PELS // presentation page units: pixels
1087	\| GPIA_ASSOC // associate with hdcMem (req. for GPIT_MICRO)
1088	\| GPIT_MICRO))) // micro presentation space
1089	brc = TRUE;
1090	else
1091	{
1092	// error (hpsMem == NULLHANDLE):
1093	// close memory DC again
1094	DevCloseDC(*hdcMem);
1095	*hdcMem = NULLHANDLE;
1096	}
1097	}
1098
1099	return (brc);
1100	}
1101
1102	/*
1103	*@@ gpihCreateBitmap:
1104	* creates a new bitmap for a given memory PS.
1105	* This bitmap will have the cPlanes and bitcount
1106	* which are found in the memory PS.
1107	* For all the mysterious other values, we use
1108	* fixed default values, this doesn't seem to hurt.
1109	*
1110	* Note that the bitmap is _not_ yet selected into
1111	* the specified memory PS. You must call
1112	+ GpiSetBitmap(hpsMem, hbm)
1113	* to do this.
1114	*
1115	* Returns the bitmap handle or NULLHANDLE upon errors.
1116	*
1117	*@@changed V0.9.0 [umoeller]: function prototype changed to cx and cy
1118	*/
1119
1120	HBITMAP gpihCreateBitmap(HPS hpsMem, // in: memory DC
1121	ULONG cx, // in: width of new bitmap
1122	ULONG cy) // in: height of new bitmap
1123	{
1124	HBITMAP hbm = NULLHANDLE;
1125	LONG alData[2];
1126	BITMAPINFOHEADER2 bih2;
1127	PBITMAPINFO2 pbmi = NULL;
1128
1129	// determine the device's plane/bit-count format;
1130	// alData[0] then has cPlanes,
1131	// alData[1] has cBitCount
1132	if (GpiQueryDeviceBitmapFormats(hpsMem, 2, alData))
1133	{
1134	// set up the BITMAPINFOHEADER2 and BITMAPINFO2 structures
1135	bih2.cbFix = (ULONG)sizeof(BITMAPINFOHEADER2);
1136	bih2.cx = cx; // (prcl->xRight - prcl->xLeft); changed V0.9.0
1137	bih2.cy = cy; // (prcl->yTop - prcl->yBottom); changed V0.9.0
1138	bih2.cPlanes = alData[0];
1139	bih2.cBitCount = alData[1];
1140	bih2.ulCompression = BCA_UNCOMP;
1141	bih2.cbImage = ( ( (bih2.cx
1142	* (1 << bih2.cPlanes)
1143	* (1 << bih2.cBitCount)
1144	) + 31
1145	) / 32
1146	) * bih2.cy;
1147	bih2.cxResolution = 70;
1148	bih2.cyResolution = 70;
1149	bih2.cclrUsed = 2;
1150	bih2.cclrImportant = 0;
1151	bih2.usUnits = BRU_METRIC; // measure units for cxResolution/cyResolution: pels per meter
1152	bih2.usReserved = 0;
1153	bih2.usRecording = BRA_BOTTOMUP; // scan lines are bottom to top (default)
1154	bih2.usRendering = BRH_NOTHALFTONED; // other algorithms aren't documented anyways
1155	bih2.cSize1 = 0; // parameter for halftoning (undocumented anyways)
1156	bih2.cSize2 = 0; // parameter for halftoning (undocumented anyways)
1157	bih2.ulColorEncoding = BCE_RGB; // only possible value
1158	bih2.ulIdentifier = 0; // application-specific data
1159
1160	// allocate memory for info header
1161	if (DosAllocMem((PPVOID)&pbmi,
1162	sizeof(BITMAPINFO2) +
1163	(sizeof(RGB2)
1164	* (1 << bih2.cPlanes)
1165	* (1 << bih2.cBitCount)
1166	),
1167	PAG_COMMIT \| PAG_READ \| PAG_WRITE)
1168	== NO_ERROR)
1169	{
1170	pbmi->cbFix = bih2.cbFix;
1171	pbmi->cx = bih2.cx;
1172	pbmi->cy = bih2.cy;
1173	pbmi->cPlanes = bih2.cPlanes;
1174	pbmi->cBitCount = bih2.cBitCount;
1175	pbmi->ulCompression = BCA_UNCOMP;
1176	pbmi->cbImage = ((bih2.cx+31)/32) * bih2.cy;
1177	pbmi->cxResolution = 70;
1178	pbmi->cyResolution = 70;
1179	pbmi->cclrUsed = 2;
1180	pbmi->cclrImportant = 0;
1181	pbmi->usUnits = BRU_METRIC;
1182	pbmi->usReserved = 0;
1183	pbmi->usRecording = BRA_BOTTOMUP;
1184	pbmi->usRendering = BRH_NOTHALFTONED;
1185	pbmi->cSize1 = 0;
1186	pbmi->cSize2 = 0;
1187	pbmi->ulColorEncoding = BCE_RGB;
1188	pbmi->ulIdentifier = 0;
1189
1190	// create a bit map that is compatible with the display
1191	hbm = GpiCreateBitmap(hpsMem,
1192	&bih2,
1193	FALSE,
1194	NULL,
1195	pbmi);
1196
1197	// free the memory we allocated previously; GPI has
1198	// allocated all the resources it needs itself, so
1199	// we can release this
1200	DosFreeMem(pbmi);
1201	}
1202	}
1203
1204	return (hbm);
1205	}
1206
1207	/*
1208	*@@ gpihCreateBmpFromPS:
1209	* this creates a new bitmap and copies a screen rectangle
1210	* into it. Consider this a "screen capture" function.
1211	*
1212	* The new bitmap (which is returned) is compatible with the
1213	* device associated with hpsScreen. This function calls
1214	* gpihCreateMemPS and gpihCreateBitmap to have it created.
1215	* The memory PS is only temporary and freed again.
1216	*
1217	* This returns the handle of the new bitmap,
1218	* which can then be used for WinDrawBitmap and such, or
1219	* NULLHANDLE upon errors.
1220	*/
1221
1222	HBITMAP gpihCreateBmpFromPS(HAB hab, // in: anchor block
1223	HPS hpsScreen, // in: screen PS to copy from
1224	PRECTL prcl) // in: rectangle to copy
1225	{
1226
1227	/* To copy an image from a display screen to a bit map:
1228	1. Associate the memory device context with a presentation space.
1229	2. Create a bit map.
1230	3. Select the bit map into the memory device context by calling GpiSetBitmap.
1231	4. Determine the location (in device coordinates) of the image.
1232	5. Call GpiBitBlt and copy the image to the bit map. */
1233
1234	HDC hdcMem;
1235	HPS hpsMem;
1236	HBITMAP hbm = NULLHANDLE;
1237	POINTL aptl[3];
1238
1239	SIZEL szlPage = {0, 0};
1240	if (gpihCreateMemPS(hab, &szlPage, &hdcMem, &hpsMem))
1241	{
1242	if ((hbm = gpihCreateBitmap(hpsMem,
1243	prcl->xRight - prcl->xLeft,
1244	prcl->yTop - prcl->yBottom)))
1245	{
1246	// Associate the bit map and the memory presentation space.
1247	if (GpiSetBitmap(hpsMem, hbm)
1248	!= HBM_ERROR)
1249	{
1250	// Copy the screen to the bit map.
1251	aptl[0].x = 0; // lower-left corner of destination rectangle
1252	aptl[0].y = 0;
1253	aptl[1].x = prcl->xRight; // upper-right corner for both
1254	aptl[1].y = prcl->yTop;
1255	aptl[2].x = prcl->xLeft; // lower-left corner of source rectangle
1256	aptl[2].y = prcl->yBottom;
1257
1258	if (GpiBitBlt(hpsMem, hpsScreen,
1259	sizeof(aptl) / sizeof(POINTL), // Number of points in aptl
1260	aptl,
1261	ROP_SRCCOPY,
1262	BBO_IGNORE)
1263	== GPI_ERROR)
1264	{
1265	// error during bitblt:
1266	GpiDeleteBitmap(hbm);
1267	hbm = NULLHANDLE; // for return code
1268	}
1269	} else {
1270	// error selecting bitmap for hpsMem:
1271	GpiDeleteBitmap(hbm);
1272	hbm = NULLHANDLE; // for return code
1273	}
1274	}
1275
1276	GpiDestroyPS(hpsMem);
1277	DevCloseDC(hdcMem);
1278	} // end if (hdcMem = DevOpenDC())
1279
1280	return (hbm);
1281	}
1282
1283	/*
1284	*@@ gpihCreateHalftonedBitmap:
1285	* this creates a half-toned copy of the
1286	* input bitmap by doing the following:
1287	*
1288	* 1) create a new bitmap with the size of hbmSource;
1289	* 2) copy hbmSource to the new bitmap (using GpiWCBitBlt);
1290	* 3) overpaint every other pixel with lColorGray.
1291	*
1292	* Note that the memory DC is switched to RGB mode, so
1293	* lColorGray better be an RGB color.
1294	*
1295	* Note: hbmSource must _not_ be selected into any device
1296	* context, or otherwise GpiWCBitBlt will fail.
1297	*
1298	* This returns the new bitmap or NULLHANDLE upon errors.
1299	*
1300	*@added V0.9.0
1301	*/
1302
1303	HBITMAP gpihCreateHalftonedBitmap(HAB hab, // in: anchor block
1304	HBITMAP hbmSource, // in: source bitmap
1305	LONG lColorGray) // in: color used for gray
1306	{
1307	HBITMAP hbmReturn = NULLHANDLE;
1308
1309	HDC hdcMem;
1310	HPS hpsMem;
1311	BITMAPINFOHEADER2 bmi;
1312	// RECTL rclSource;
1313
1314	if (hbmSource)
1315	{
1316	SIZEL szlPage;
1317	// query bitmap info
1318	bmi.cbFix = sizeof(bmi);
1319	GpiQueryBitmapInfoHeader(hbmSource, &bmi);
1320
1321	szlPage.cx = bmi.cx;
1322	szlPage.cy = bmi.cy;
1323	if (gpihCreateMemPS(hab, &szlPage, &hdcMem, &hpsMem))
1324	{
1325	if ((hbmReturn = gpihCreateBitmap(hpsMem,
1326	bmi.cx,
1327	bmi.cy)))
1328	{
1329	if (GpiSetBitmap(hpsMem, hbmReturn) != HBM_ERROR)
1330	{
1331	POINTL aptl[4];
1332
1333	// step 1: copy bitmap
1334	memset(aptl, 0, sizeof(POINTL) * 4);
1335	// aptl[0]: target bottom-left, is all 0
1336	// aptl[1]: target top-right (inclusive!)
1337	aptl[1].x = bmi.cx - 1;
1338	aptl[1].y = bmi.cy - 1;
1339	// aptl[2]: source bottom-left, is all 0
1340
1341	// aptl[3]: source top-right (exclusive!)
1342	aptl[3].x = bmi.cx;
1343	aptl[3].y = bmi.cy;
1344	GpiWCBitBlt(hpsMem, // target HPS (bmp selected)
1345	hbmSource,
1346	4L, // must always be 4
1347	&aptl[0], // points array
1348	ROP_SRCCOPY,
1349	BBO_IGNORE);
1350	// doesn't matter here, because we're not stretching
1351
1352	// step 2: overpaint bitmap
1353	// with half-toned pattern
1354
1355	gpihSwitchToRGB(hpsMem);
1356
1357	GpiMove(hpsMem, &aptl[0]); // still 0, 0
1358	aptl[0].x = bmi.cx - 1;
1359	aptl[0].y = bmi.cy - 1;
1360	GpiSetColor(hpsMem, lColorGray);
1361	GpiSetPattern(hpsMem, PATSYM_HALFTONE);
1362	GpiBox(hpsMem,
1363	DRO_FILL, // interior only
1364	&aptl[0],
1365	0, 0); // no corner rounding
1366
1367	// unselect bitmap
1368	GpiSetBitmap(hpsMem, NULLHANDLE);
1369	} // end if (GpiSetBitmap(hpsMem, hbmReturn) != HBM_ERROR)
1370	else
1371	{
1372	// error selecting bitmap:
1373	GpiDeleteBitmap(hbmReturn);
1374	hbmReturn = NULLHANDLE;
1375	}
1376	} // end if (hbmReturn = gpihCreateBitmap...
1377
1378	GpiDestroyPS(hpsMem);
1379	DevCloseDC(hdcMem);
1380	} // end if (gpihCreateMemPS(hab, &hdcMem, &hpsMem))
1381	} // end if (hbmSource)
1382
1383	return (hbmReturn);
1384	}
1385
1386	/*
1387	*@@ gpihLoadBitmapFile:
1388	* this loads the specified bitmap file into
1389	* the given HPS. Note that the bitmap is _not_
1390	* yet selected into the HPS.
1391	*
1392	* This function can currently only handle OS/2 1.3
1393	* bitmaps.
1394	*
1395	* Returns the new bitmap handle or NULL upon errors
1396	* (e.g. if an OS/2 2.0 bitmap was accessed).
1397	*
1398	* In the latter case, *pulError is set to one of
1399	* the following:
1400	* -- -1: file not found
1401	* -- -2: malloc failed
1402	* -- -3: the bitmap data could not be read (fopen failed)
1403	* -- -4: file format not recognized (maybe OS/2 2.0 bitmap)
1404	* -- -5: GpiCreateBitmap error (maybe file corrupt)
1405	*
1406	*@@changed V0.9.4 (2000-08-03) [umoeller]: this didn't return NULLHANDLE on errors
1407	*/
1408
1409	HBITMAP gpihLoadBitmapFile(HPS hps, // in: HPS for bmp
1410	PSZ pszBmpFile, // in: bitmap filename
1411	PULONG pulError) // out: error code if FALSE is returned
1412	{
1413	HBITMAP hbm = NULLHANDLE;
1414	PBITMAPFILEHEADER2 pbfh;
1415
1416	struct stat st;
1417	PBYTE pBmpData;
1418	FILE *BmpFile;
1419
1420	if (stat(pszBmpFile, &st) == 0)
1421	{
1422
1423	if ((pBmpData = (PBYTE)malloc(st.st_size)))
1424	{
1425	// open bmp file
1426	if ((BmpFile = fopen(pszBmpFile, "rb")))
1427	{
1428	// read bmp data
1429	fread(pBmpData, 1, st.st_size, BmpFile);
1430	fclose(BmpFile);
1431
1432	// check bitmap magic codes
1433	if (pBmpData[0] == 'B' && pBmpData[1] == 'M')
1434	{
1435	pbfh = (PBITMAPFILEHEADER2)pBmpData;
1436	hbm = GpiCreateBitmap(hps,
1437	&pbfh->bmp2,
1438	CBM_INIT,
1439	(pBmpData + pbfh->offBits),
1440	(PBITMAPINFO2)&pbfh->bmp2);
1441
1442	if (hbm == NULLHANDLE)
1443	{
1444	if (pulError)
1445	*pulError = -5;
1446	}
1447	}
1448	else if (pulError)
1449	*pulError = -4;
1450
1451	}
1452	else if (pulError)
1453	*pulError = -3;
1454
1455	free(pBmpData);
1456	}
1457	else if (pulError)
1458	*pulError = -2;
1459	}
1460	else if (pulError)
1461	*pulError = -1;
1462
1463	return (hbm);
1464	}
1465
1466	/*
1467	*@@ gpihStretchBitmap:
1468	* this copies hbmSource to the bitmap selected
1469	* into hpsTarget, which must be a memory PS.
1470	*
1471	* The source size is the whole size of hbmSource,
1472	* the target size is specified in prclTarget
1473	* (which is exclusive, meaning that the top right
1474	* corner of that rectangle lies _outside_ the target).
1475	*
1476	* This uses GpiWCBitBlt to stretch the bitmap.
1477	* hbmSource therefore must _not_ be selected
1478	* into any presentation space, or GpiWCBitBlt will
1479	* fail.
1480	*
1481	* If (fPropotional == TRUE), the target size is
1482	* modified so that the proportions of the bitmap
1483	* are preserved. The bitmap data will then be
1484	* copied to a subrectangle of the target bitmap:
1485	* there will be extra space either to the left
1486	* and right of the bitmap data or to the bottom
1487	* and top.
1488	* The outside areas of the target bitmap are
1489	* not changed then, so you might want to fill
1490	* the bitmap with some color first.
1491	*
1492	* This returns the return value of GpiWCBitBlt,
1493	* which can be:
1494	* -- GPI_OK
1495	* -- GPI_HITS: correlate hits
1496	* -- GPI_ERROR: error occured (probably either hbmSource not free
1497	* or no bitmap selected into hpsTarget)
1498	*
1499	*@added V0.9.0
1500	*/
1501
1502	LONG gpihStretchBitmap(HPS hpsTarget, // in: memory PS to copy bitmap to
1503	HBITMAP hbmSource, // in: bitmap to be copied into hpsTarget (must be free)
1504	PRECTL prclSource, // in: source rectangle -- if NULL, use size of bitmap
1505	PRECTL prclTarget, // in: target rectangle (req.)
1506	BOOL fProportional) // in: preserve proportions when stretching?
1507	{
1508	LONG lHits = 0;
1509	BITMAPINFOHEADER2 bih2;
1510	POINTL aptl[4];
1511	BOOL fCalculated = FALSE;
1512
1513	memset(aptl, 0, sizeof(POINTL) * 4);
1514
1515	bih2.cbFix = sizeof(bih2);
1516	GpiQueryBitmapInfoHeader(hbmSource,
1517	&bih2);
1518
1519	// aptl[2]: source bottom-left, is all 0
1520	// aptl[3]: source top-right (exclusive!)
1521	aptl[3].x = bih2.cx;
1522	aptl[3].y = bih2.cy;
1523
1524	if (fProportional)
1525	{
1526	// proportional mode:
1527
1528	// 1) find out whether cx or cy is too
1529	// large
1530
1531	ULONG ulPropSource = (bih2.cx * 1000)
1532	/ bih2.cy;
1533	// e.g. if the bmp is 200 x 100, we now have 2000
1534	ULONG ulPropTarget = ((prclTarget->xRight - prclTarget->xLeft) * 1000)
1535	/ (prclTarget->yTop - prclTarget->yBottom);
1536	// case 1: if prclTarget is 300 x 100, we now have 3000 (> ulPropSource)
1537	// case 2: if prclTarget is 150 x 100, we now have 1500 (< ulPropSource)
1538
1539	// case 1:
1540	if (ulPropTarget > ulPropSource)
1541	{
1542	// prclTarget is too wide (horizontally):
1543	// decrease width, keep height
1544
1545	ULONG cx = (prclTarget->xRight - prclTarget->xLeft);
1546	ULONG cxNew = (cx * ulPropSource) / ulPropTarget;
1547
1548	// aptl[0]: target bottom-left
1549	// move left right (towards center)
1550	aptl[0].x = prclTarget->xLeft + ((cx - cxNew) / 2);
1551	aptl[0].y = prclTarget->yBottom;
1552
1553	// aptl[1]: target top-right (inclusive!)
1554	aptl[1].x = aptl[0].x + cxNew;
1555	aptl[1].y = prclTarget->yTop;
1556
1557	fCalculated = TRUE;
1558	}
1559	else
1560	{
1561	// prclTarget is too high (vertically):
1562	// keep width, decrease height
1563
1564	ULONG cy = (prclTarget->yTop - prclTarget->yBottom);
1565	ULONG cyNew = (cy * ulPropTarget) / ulPropSource;
1566
1567	// aptl[0]: target bottom-left
1568	aptl[0].x = prclTarget->xLeft;
1569	// move bottom up (towards center)
1570	aptl[0].y = prclTarget->yBottom + ((cy - cyNew) / 2);
1571
1572	// aptl[1]: target top-right (inclusive!)
1573	aptl[1].x = prclTarget->xRight;
1574	aptl[1].y = aptl[0].y + cyNew;
1575	// (prclTarget->yTop * ulPropSource) / ulPropTarget;
1576
1577	fCalculated = TRUE;
1578	}
1579	} // end if (pa->ulFlags & ANF_PROPORTIONAL)
1580
1581	if (!fCalculated)
1582	{
1583	// non-proportional mode or equal proportions:
1584	// stretch to whole size of prclTarget
1585
1586	// aptl[0]: target bottom-left
1587	aptl[0].x = prclTarget->xLeft;
1588	aptl[0].y = prclTarget->yBottom;
1589	// aptl[1]: target top-right (inclusive!)
1590	aptl[1].x = prclTarget->xRight;
1591	aptl[1].y = prclTarget->yTop;
1592	}
1593
1594	lHits = GpiWCBitBlt(hpsTarget, // target HPS (bmp selected)
1595	hbmSource,
1596	4L, // must always be 4
1597	&aptl[0], // points array
1598	ROP_SRCCOPY,
1599	BBO_IGNORE);
1600	// ignore eliminated rows or
1601	// columns; useful for color
1602
1603	return (lHits);
1604	}
1605
1606	/*
1607	*@@ gpihIcon2Bitmap:
1608	* this paints the given icon/pointer into
1609	* a bitmap.
1610	*
1611	* Returns FALSE upon errors.
1612	*
1613	*@@added V0.9.0 [umoeller]
1614	*/
1615
1616	BOOL gpihIcon2Bitmap(HPS hpsMem, // in: target memory PS with bitmap selected into it
1617	HPOINTER hptr, // in: source icon
1618	LONG lBkgndColor, // in: background color for transparent areas
1619	ULONG ulIconSize) // in: icon size (should be the value of WinQuerySysValue(HWND_DESKTOP, SV_CXICON))
1620	{
1621	BOOL brc = FALSE;
1622	POINTERINFO pi;
1623
1624	// Each icon consists of two (really three)
1625	// bitmaps, which are stored in the POINTERINFO
1626	// structure:
1627	// pi.hbmColor is the actual bitmap to be
1628	// drawn. The parts that are
1629	// to be transparent or inverted
1630	// are black in this image.
1631	// pi.hbmPointer has twice the height of
1632	// hbmColor. The upper bitmap
1633	// contains an XOR mask (for
1634	// inverting parts), the lower
1635	// bitmap an AND mask (for
1636	// transparent parts).
1637	if (WinQueryPointerInfo(hptr, &pi))
1638	{
1639	POINTL aptl[4];
1640	memset(aptl, 0, sizeof(POINTL) * 4);
1641
1642	// aptl[0]: target bottom-left, is all 0
1643
1644	// aptl[1]: target top-right (inclusive!)
1645	aptl[1].x = ulIconSize;
1646	aptl[1].y = ulIconSize;
1647
1648	// aptl[2]: source bottom-left, is all 0
1649
1650	// aptl[3]: source top-right (exclusive!)
1651	aptl[3].x = ulIconSize + 1;
1652	aptl[3].y = ulIconSize + 1;
1653
1654	GpiSetColor(hpsMem, CLR_WHITE);
1655	GpiSetBackColor(hpsMem, CLR_BLACK);
1656
1657	// GpiErase(hpsMem);
1658
1659	// work on the AND image
1660	GpiWCBitBlt(hpsMem,
1661	pi.hbmPointer,
1662	4L, // must always be 4
1663	&aptl[0], // point array
1664	ROP_SRCAND, // source AND target
1665	BBO_OR);
1666
1667	// paint the real image
1668	if (pi.hbmColor)
1669	GpiWCBitBlt(hpsMem,
1670	pi.hbmColor,
1671	4L, // must always be 4
1672	&aptl[0], // point array
1673	ROP_SRCPAINT, // source OR target
1674	BBO_OR);
1675
1676	GpiSetColor(hpsMem, lBkgndColor);
1677	// work on the XOR image
1678	aptl[2].y = ulIconSize;
1679	aptl[3].y = (ulIconSize * 2) + 1;
1680	GpiWCBitBlt(hpsMem,
1681	pi.hbmPointer,
1682	4L, // must always be 4
1683	&aptl[0], // point array
1684	ROP_SRCINVERT,
1685	BBO_OR);
1686
1687	brc = TRUE;
1688	}
1689
1690	return (brc);
1691	}
1692

Note: See TracBrowser for help on using the repository browser.

Download in other formats: