Release 971221
Fri Dec 19 10:50:46 1997 Douglas Ridgway <ridgway@winehq.com>
* [Make.rules.in] [Makefile.in] [documentation/Makefile.in]
[documentation/README.documentation]
First cut at Wine API documentation. No longer install reference
manual by default.
Wed Dec 17 21:32:23 1997 Andreas Mohr <100.30936@germany.net>
* [files/file.c]
Fixed GetTempFileName16() to use current path of requested drive
as needed.
* [if1632/Makefile.in] [if1632/builtin.c] [if1632/dciman32.spec]
[if1632/msvfw32.spec] [if1632/tapi32.spec] [if1632/wow32.spec]
Added misc DLLs needed by various apps.
Wed Dec 17 12:01:50 1997 Morten Eriksen <mortene@sim.no>
* [if1632/gdi32.spec] [include/windows.h] [objects/palette.c]
Inserted empty stub for CreateHalftonePalette.
Tue Dec 16 22:08:06 1997 Huw D M Davies <h.davies1@physics.oxford.ac.uk>
* [windows/mdi.c]
Use VK_TAB instead of VK_SEPARATOR in TranslateMDISysAccel().
* [graphics/metafiledrv/init.c]
DeleteDC() on a MetaDC doesn't do anything - it shouldn't. Therefore
fix cleanup of MetaDCs in CloseMetaFile(); they now actually get
removed from the GDI heap!
* [graphics/x11drv/xfont.c]
Preserve FO_MATCH_XYINDEP flag in XFONT_MatchFIList(). Should reduce
the number of bold-italic matches.
Tue Dec 16 20:11:43 1997 Bertho Stultiens <bertho@panter.soci.aau.dk>
* [graphics/painting.c]
Included an implementation of DrawState
* [if1632/thunk.c]
Changed many fprintfs into dprintf_thunk
* [include/cache.h] [graphics/cache.c]
New files to hold cached handles to regulary used GDI object.
* [include/windows.h]
Added DRAWSTATExx typedefs
Added DSS_DEFAULT define for DrawState
* [objects/text.c]
New implementation of GrayString()
* [controls/uitools.c]
Implemented DrawFrameControl() functions
Changed DrawEdge() behaviour to win95 implementation
Mon Dec 15 23:43:01 1997 Martin Boehme <boehme@informatik.mu-luebeck.de>
* [graphics/path.c] [include/path.h] [graphics/painting.c]
[if1632/gdi32.spec] [include/gdi.h] [include/windows.h]
[objects/dc.c]
Added preliminary support for GDI paths.
* [objects/dc.c]
Added DC_Init_DC_INFO function for initializing WIN_DC_INFO
structure.
* [include/windows.h] [include/gdi.h] [objects/gdiobj.c]
Added DEFAULT_GUI_FONT.
* [include/winerror.h]
Added a few error codes.
* [memory/heap.c]
Changed HeapAlloc to make the correct calls to SetLastError
(now conforms to NT's behaviour).
* [windows/win.c]
Changed WIN_CreateWindowEx to allow child windows with zero
width / height.
Sun Dec 14 12:01:07 1997 Alexandre Julliard <julliard@lrc.epfl.ch>
* [if1632/*] [relay32/*]
Moved all 32-bit relay stuff to relay32/
* [fi1632/thunk.c] [win32/kernel32.c]
Moved all KERNEL32 ordinal functions to kernel32.c
* [memory/selector.c]
Initialize selectors in AllocSelectorArray.
* [tools/build.c]
Generate C instead of assembly for Win32 relays.
Fixed stack corruption in CallTo16 functions, found by Bertho
Stultiens.
Sun Dec 14 10:55:00 1997 Andreas Mohr <100.30936@germany.net>
* [if1632/Makefile.in] [if1632/builtin.c] [if1632/ole2thk.spec]
Added built-in OLE2THK.DLL.
* [if1632/toolhelp.spec] [include/toolhelp.h] [memory/selector.c]
[misc/toolhelp.c]
Added stubs for StackTraceFirst(), StackTraceCSIPFirst(),
StackTraceNext(), UTSelectorOffsetToLinear()
and UTLinearToSelectorOffset().
Sat Dec 13 17:26:41 1997 Alex Korobka <alex@trantor.pharm.sunysb.edu>
* [misc/winsock.c]
32-bit API fixes for reported problems (thanks to Marcus
and David).
* [graphics/x11drv/xfont.c]
Little tweak in point size calculation.
* [windows/defwnd.c] [windows/dce.c] [windows/winhelp.c]
[windows/winproc.c] [windows/win.c]
Bug fixes.
Sat Dec 13 16:35:14 1997 Kai Morich <kai.morich@rhein-neckar.netsurf.de>
* [files/dos_fs.c]
OpenFile with empty filename and OF_PARSE returns current dir.
* [misc/commdlg.c]
Ignore initial dir if bogus.
* [files/file.c]
Locking an identic region in a file must not be an error.
* [misc/lstr.c]
Use wide char ctype functions.
Fri Dec 12 23:46:22 1997 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
* [file/drive.c]
First attempt for GetDiskFreeSpaceEx.
Fri Dec 12 23:18:41 1997 Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>
* [loader/pe_resource.c]
Fixed wrongly appearing menus problem (only use default lookups in
last resource subtree).
* [multimedia/*.c]
Added win32 support for time* and joy* lowlevel drivers,
(not excessively tested), some misc fixes and cleanups.
* [misc/shellord.c][misc/shell.c][ole/folders.c][ole/ifs.c]
[include/interfaces.h][include/shlobj.h]
Added some more undocumented SHELL32 functions, some shell folder
interface stubs added, SHGetMalloc, SHGetDesktopFolder,
SHGetSpecialFolderLocation, SHGetPathFromIDList stubs added,
IMalloc, IUnknown implemented.
* [windows/msgbox.c]
Implemented MessageBoxIndirect*, some internal changes.
* [if1632/thunk.c]
KERNEL_431 implemented.
* [objects/gdiobj.c]
GetCurrentObject implemented.
Wed Dec 3 01:09:17 1997 Gordon Chaffee <chaffee@apu.cs.berkeley.edu>
* [objects/dib.c]
Fix a couple small DIB problems.
* [controls/edit.c]
Fix a typo.
* [files/dos_fs.c]
Try normal readdir in case fs is specified as vfat but isn't.
* [files/profile.c]
Implementation of WritePrivateProfileSection32A from Uwe Bonnes.
* [misc/printdrv.c]
OpenPrinter32A stub, helps Word97 start.
* [objects/text.c]
Fixup implementation of GetTextCharsetInfo.
* [scheduler/process.c]
Fix environment variable expansion.
* [win32/code_page.c]
Make MultiByteToWideChar and WideCharToMultiByte conform in return
values and error conditions to those in Windows NT 4.0.
* [windows/message.c]
Fix broadcasting problems in Win32. The Win32 docs say to use
HWND_TOPMOST to broadcast to all Win32 Windows.
* [memory/virtual.c] [loader/pe_image.c]
Do not map in VirtualAlloc if address is specified and space is
not available. This is required by Win32.
* [include/pen.h] [include/x11drv.h] [objects/dc.c]
[objects/pen.c] [graphics/x11drv/pen.c]
Support for ExtCreatePen.
Tue Dec 2 20:22:06 1997 Morten Welinder <terra@diku.dk>
* [*/*.c] [*/*.h]
Add lots of prototypes.
* [if1632/kernel32.spec][include/windows.h][include/winnt.h]
[misc/cpu.c]
Define IsProcessorFeaturePresent.
* [misc/crtdll.c]
(CRTDLL__getcwd): Allocate enough memory for the terminating zero.
* [misc/ver.c]
Improve check for null component in _find_data[AW]. Plug leaks
in VerQueryValue*.
* [win32/console.c][if1632/kernel32.spec]
Add stubs for GetConsoleCursorInfo32, SetConsoleCursorInfo32.
* [windows/message.c][if1632/user32.spec][include/windows.h]
Define SendMessageTimeout*.
* [graphics/x11drv/xfont.c]
Change algorithm of __genericCheckSum to be alignment safe.
* [misc/main.c] [misc/winsock.c] [misc/winsock_dns.c]
Include winsock.h early to avoid Solaris problem.
* [include/windows.h]
Undef FSHIFT before we define it.
* [rc/winerc.c]
Include <fcntl.h> instead of <sys/fcntl.h>.
* [files/file.c]
Use strerror in FILE_SetDosError if available.
* [include/config.h.in] [configure.in]
Check for strerror.
* [objects/gdiobj.c]
Make static font structures aligned.
Mon Dec 1 10:10:21 1997 Karl Garrison <karlos@eznet.net>
* [win32/console.c] [if1632/kernel32.spec] [include/windows.h]
Added stub for GetNumberOfConsoleMouseButtons.
Added stub for PeekConsoleInput(A,W).
Fixed parameter list for WriteConsole(A,W).
GetNumberOfConsoleInputEvents now returns 0 events instead of 1
(since low-level console functions are not yet supported).
GetConsoleMode no longer returns ENABLE_WINDOW_INPUT and
ENABLE_MOUSE_INPUT since these are not currently implemented.
diff --git a/controls/uitools.c b/controls/uitools.c
index b245ebc..e3c64de 100644
--- a/controls/uitools.c
+++ b/controls/uitools.c
@@ -2,12 +2,93 @@
* User Interface Functions
*
* Copyright 1997 Dimitrie O. Paun
+ * Copyright 1997 Bertho A. Stultiens
*/
#include <stdio.h>
#include "windows.h"
#include "debug.h"
+static const WORD wPattern_AA55[8] = { 0xaaaa, 0x5555, 0xaaaa, 0x5555,
+ 0xaaaa, 0x5555, 0xaaaa, 0x5555 };
+
+/* These tables are used in:
+ * UITOOLS_DrawDiagEdge()
+ * UITOOLS_DrawRectEdge()
+ */
+static const char LTInnerNormal[] = {
+ -1, -1, -1, -1,
+ -1, COLOR_BTNHIGHLIGHT, COLOR_BTNHIGHLIGHT, -1,
+ -1, COLOR_3DDKSHADOW, COLOR_3DDKSHADOW, -1,
+ -1, -1, -1, -1
+};
+
+static const char LTOuterNormal[] = {
+ -1, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
+ COLOR_BTNHIGHLIGHT, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
+ COLOR_3DDKSHADOW, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1,
+ -1, COLOR_3DLIGHT, COLOR_BTNSHADOW, -1
+};
+
+static const char RBInnerNormal[] = {
+ -1, -1, -1, -1,
+ -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, -1,
+ -1, COLOR_3DLIGHT, COLOR_3DLIGHT, -1,
+ -1, -1, -1, -1
+};
+
+static const char RBOuterNormal[] = {
+ -1, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
+ COLOR_BTNSHADOW, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
+ COLOR_3DLIGHT, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1,
+ -1, COLOR_3DDKSHADOW, COLOR_BTNHIGHLIGHT, -1
+};
+
+static const char LTInnerSoft[] = {
+ -1, -1, -1, -1,
+ -1, COLOR_3DLIGHT, COLOR_3DLIGHT, -1,
+ -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, -1,
+ -1, -1, -1, -1
+};
+
+static const char LTOuterSoft[] = {
+ -1, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
+ COLOR_3DLIGHT, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
+ COLOR_BTNSHADOW, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1,
+ -1, COLOR_BTNHIGHLIGHT, COLOR_3DDKSHADOW, -1
+};
+
+#define RBInnerSoft RBInnerNormal /* These are the same */
+#define RBOuterSoft RBOuterNormal
+
+static const char LTRBOuterMono[] = {
+ -1, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+ COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+ COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+ COLOR_WINDOW, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+};
+
+static const char LTRBInnerMono[] = {
+ -1, -1, -1, -1,
+ -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
+ -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
+ -1, COLOR_WINDOW, COLOR_WINDOW, COLOR_WINDOW,
+};
+
+static const char LTRBOuterFlat[] = {
+ -1, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
+ COLOR_WINDOWFRAME, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
+ COLOR_WINDOWFRAME, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
+ COLOR_WINDOWFRAME, COLOR_BTNSHADOW, COLOR_BTNSHADOW, COLOR_BTNSHADOW,
+};
+
+static const char LTRBInnerFlat[] = {
+ -1, -1, -1, -1,
+ -1, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+ -1, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+ -1, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME, COLOR_WINDOWFRAME,
+};
+
/***********************************************************************
* UITOOLS_DrawDiagEdge
*
@@ -19,143 +100,252 @@
* using the brushes returned by GetSysColorBrush func, but I did not have
* the patience to implement that yet.
*/
-static BOOL32 UITOOLS_DrawDiagEdge(HDC32 hdc, RECT32 *rect, UINT32 edge,
- UINT32 flags)
+/*********************************************************************
+ * 03-Dec-1997: Changed by Bertho Stultiens
+ *
+ * See also comments with UITOOLS_DrawRectEdge()
+ */
+static BOOL32 UITOOLS_DrawDiagEdge(HDC32 hdc, LPRECT32 rc, UINT32 uType, UINT32 uFlags)
{
- HPEN32 facePen, shadowPen, lightPen, blackPen, grayPen, nullPen;
- HPEN32 iPen, oPen, oldPen;
- HBRUSH32 oldBrush, faceBrush;
- int cl, cr, ct, cb;
- BOOL32 mainDiag;
- POINT32 tp;
- RECT32 r;
+ POINT32 Points[4];
+ char InnerI, OuterI;
+ HPEN32 InnerPen, OuterPen;
+ POINT32 SavePoint;
+ HPEN32 SavePen;
+ int spx, spy;
+ int epx, epy;
+ int Width = rc->right - rc->left;
+ int Height= rc->bottom - rc->top;
+ int SmallDiam = Width > Height ? Height : Width;
+ BOOL32 retval = !( ((uType & BDR_INNER) == BDR_INNER
+ || (uType & BDR_OUTER) == BDR_OUTER)
+ && !(uFlags & (BF_FLAT|BF_MONO)) );
+ int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
+ + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);
- /* If both rasied and sunken is specified, they anihilate one another */
- if( !((flags & BF_MONO) || (flags & BF_FLAT)) ){
- if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
- return FALSE;
- if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
- return FALSE;
- }
-
- /* Create/get the tools of the trade... */
- facePen = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNFACE));
- shadowPen = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNSHADOW));
- lightPen = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNHILIGHT));
- grayPen = CreatePen32(PS_SOLID, 0, RGB(168, 152, 144));
- blackPen = GetStockObject32(BLACK_PEN);
- nullPen = GetStockObject32(NULL_PEN);
- faceBrush = GetSysColorBrush32(COLOR_BTNFACE);
- oldPen = SelectObject32(hdc, nullPen);
- oldBrush = SelectObject32(hdc, faceBrush);
-
- /* this is my working rectangle */
- r = *rect;
-
- if(flags & BF_MONO){
- oPen = blackPen;
- iPen = nullPen;
- }else if(flags & BF_FLAT){
- oPen = shadowPen;
- iPen = facePen;
- }else {
- if(flags & BF_SOFT){
- if(flags & BF_BOTTOM){
- oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
- iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
- }
- else{
- oPen = (edge & BDR_RAISEDOUTER) ? lightPen : blackPen;
- iPen = (edge & BDR_RAISEDINNER) ? grayPen : shadowPen;
- }
+ /* Init some vars */
+ OuterPen = InnerPen = (HPEN32)GetStockObject32(NULL_PEN);
+ SavePen = (HPEN32)SelectObject32(hdc, InnerPen);
+ spx = spy = epx = epy = 0; /* Satisfy the compiler... */
+
+ /* Determine the colors of the edges */
+ if(uFlags & BF_MONO)
+ {
+ InnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
}
- else{
- if(flags & BF_BOTTOM){
- oPen = (edge & BDR_RAISEDOUTER) ? blackPen : lightPen;
- iPen = (edge & BDR_RAISEDINNER) ? shadowPen : grayPen;
- }
- else{
- oPen = (edge & BDR_RAISEDOUTER) ? grayPen : shadowPen;
- iPen = (edge & BDR_RAISEDINNER) ? lightPen : blackPen;
- }
+ else if(uFlags & BF_FLAT)
+ {
+ InnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
}
- }
-
- if(flags & BF_BOTTOM){
- if(flags & BF_LEFT){
- cr = -1; cl = 0;
- ct = 0; cb = -1;
- mainDiag = TRUE;
- tp.x = r.left; tp.y = r.top;
+ else if(uFlags & BF_SOFT)
+ {
+ if(uFlags & BF_BOTTOM)
+ {
+ InnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
+ }
+ else
+ {
+ InnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
+ }
}
- else{ /* RIGHT */
- cr = -1; cl = 0;
- ct = 1; cb = 0;
- tp.x = r.left; tp.y = r.bottom-1;
- mainDiag = FALSE;
+ else
+ {
+ if(uFlags & BF_BOTTOM)
+ {
+ InnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
+ }
+ else
+ {
+ InnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
+ OuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
+ }
}
- }
- else{ /* TOP */
- if(flags & BF_LEFT){
- cr = 0; cl = 1;
- ct = 0; cb = -1;
- mainDiag = FALSE;
- tp.x = r.right; tp.y = r.top;
+
+ if(InnerI != -1) InnerPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)InnerI));
+ if(OuterI != -1) OuterPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)OuterI));
+
+ MoveToEx32(hdc, 0, 0, &SavePoint);
+
+ /* Don't ask me why, but this is what is visible... */
+ /* This must be possible to do much simpler, but I fail to */
+ /* see the logic in the MS implementation (sigh...). */
+ /* So, this might look a bit brute force here (and it is), but */
+ /* it gets the job done;) */
+
+ switch(uFlags & BF_RECT)
+ {
+ case 0:
+ case BF_LEFT:
+ case BF_BOTTOM:
+ case BF_BOTTOMLEFT:
+ /* Left bottom endpoint */
+ epx = rc->left-1;
+ spx = epx + SmallDiam;
+ epy = rc->bottom;
+ spy = epy - SmallDiam;
+ break;
+
+ case BF_TOPLEFT:
+ case BF_BOTTOMRIGHT:
+ /* Left top endpoint */
+ epx = rc->left-1;
+ spx = epx + SmallDiam;
+ epy = rc->top-1;
+ spy = epy + SmallDiam;
+ break;
+
+ case BF_TOP:
+ case BF_RIGHT:
+ case BF_TOPRIGHT:
+ case BF_RIGHT|BF_LEFT:
+ case BF_RIGHT|BF_LEFT|BF_TOP:
+ case BF_BOTTOM|BF_TOP:
+ case BF_BOTTOM|BF_TOP|BF_LEFT:
+ case BF_BOTTOMRIGHT|BF_LEFT:
+ case BF_BOTTOMRIGHT|BF_TOP:
+ case BF_RECT:
+ /* Right top endpoint */
+ spx = rc->left;
+ epx = spx + SmallDiam;
+ spy = rc->bottom-1;
+ epy = spy - SmallDiam;
+ break;
}
- else{ /* RIGHT */
- cr = 0; cl = 1;
- ct = 1; cb = 0;
- tp.x = r.right; tp.y = r.bottom-1;
- mainDiag = TRUE;
+
+ MoveToEx32(hdc, spx, spy, NULL);
+ SelectObject32(hdc, OuterPen);
+ LineTo32(hdc, epx, epy);
+
+ SelectObject32(hdc, InnerPen);
+
+ switch(uFlags & (BF_RECT|BF_DIAGONAL))
+ {
+ case BF_DIAGONAL_ENDBOTTOMLEFT:
+ case (BF_DIAGONAL|BF_BOTTOM):
+ case BF_DIAGONAL:
+ case (BF_DIAGONAL|BF_LEFT):
+ MoveToEx32(hdc, spx-1, spy, NULL);
+ LineTo32(hdc, epx, epy-1);
+ Points[0].x = spx-add;
+ Points[0].y = spy;
+ Points[1].x = rc->left;
+ Points[1].y = rc->top;
+ Points[2].x = epx+1;
+ Points[2].y = epy-1-add;
+ Points[3] = Points[2];
+ break;
+
+ case BF_DIAGONAL_ENDBOTTOMRIGHT:
+ MoveToEx32(hdc, spx-1, spy, NULL);
+ LineTo32(hdc, epx, epy+1);
+ Points[0].x = spx-add;
+ Points[0].y = spy;
+ Points[1].x = rc->left;
+ Points[1].y = rc->bottom-1;
+ Points[2].x = epx+1;
+ Points[2].y = epy+1+add;
+ Points[3] = Points[2];
+ break;
+
+ case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP):
+ case (BF_DIAGONAL|BF_BOTTOM|BF_RIGHT|BF_TOP|BF_LEFT):
+ case BF_DIAGONAL_ENDTOPRIGHT:
+ case (BF_DIAGONAL|BF_RIGHT|BF_TOP|BF_LEFT):
+ MoveToEx32(hdc, spx+1, spy, NULL);
+ LineTo32(hdc, epx, epy+1);
+ Points[0].x = epx-1;
+ Points[0].y = epy+1+add;
+ Points[1].x = rc->right-1;
+ Points[1].y = rc->top+add;
+ Points[2].x = rc->right-1;
+ Points[2].y = rc->bottom-1;
+ Points[3].x = spx+add;
+ Points[3].y = spy;
+ break;
+
+ case BF_DIAGONAL_ENDTOPLEFT:
+ MoveToEx32(hdc, spx, spy-1, NULL);
+ LineTo32(hdc, epx+1, epy);
+ Points[0].x = epx+1+add;
+ Points[0].y = epy+1;
+ Points[1].x = rc->right-1;
+ Points[1].y = rc->top;
+ Points[2].x = rc->right-1;
+ Points[2].y = rc->bottom-1-add;
+ Points[3].x = spx;
+ Points[3].y = spy-add;
+ break;
+
+ case (BF_DIAGONAL|BF_TOP):
+ case (BF_DIAGONAL|BF_BOTTOM|BF_TOP):
+ case (BF_DIAGONAL|BF_BOTTOM|BF_TOP|BF_LEFT):
+ MoveToEx32(hdc, spx+1, spy-1, NULL);
+ LineTo32(hdc, epx, epy);
+ Points[0].x = epx-1;
+ Points[0].y = epy+1;
+ Points[1].x = rc->right-1;
+ Points[1].y = rc->top;
+ Points[2].x = rc->right-1;
+ Points[2].y = rc->bottom-1-add;
+ Points[3].x = spx+add;
+ Points[3].y = spy-add;
+ break;
+
+ case (BF_DIAGONAL|BF_RIGHT):
+ case (BF_DIAGONAL|BF_RIGHT|BF_LEFT):
+ case (BF_DIAGONAL|BF_RIGHT|BF_LEFT|BF_BOTTOM):
+ MoveToEx32(hdc, spx, spy, NULL);
+ LineTo32(hdc, epx-1, epy+1);
+ Points[0].x = spx;
+ Points[0].y = spy;
+ Points[1].x = rc->left;
+ Points[1].y = rc->top+add;
+ Points[2].x = epx-1-add;
+ Points[2].y = epy+1+add;
+ Points[3] = Points[2];
+ break;
}
- }
- /* if it has external edge, draw it */
- if(edge & BDR_OUTER){
- SelectObject32(hdc, oPen);
- MoveToEx32(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
- LineTo32(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
- r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
- }
+ /* Fill the interior if asked */
+ if((uFlags & BF_MIDDLE) && retval)
+ {
+ HBRUSH32 hbsave;
+ HBRUSH32 hb = uFlags & BF_MONO ? GetSysColorBrush32(COLOR_WINDOW)
+ : GetSysColorBrush32(COLOR_BTNFACE);
+ HPEN32 hpsave;
+ HPEN32 hp = CreatePen32(PS_SOLID, 0, uFlags & BF_MONO ? GetSysColor32(COLOR_WINDOW)
+ : GetSysColor32(COLOR_BTNFACE));
+ hbsave = (HBRUSH32)SelectObject32(hdc, hb);
+ hpsave = (HPEN32)SelectObject32(hdc, hp);
+ Polygon32(hdc, Points, 4);
+ SelectObject32(hdc, hbsave);
+ SelectObject32(hdc, hpsave);
+ DeleteObject32(hp);
+ }
- /* if it has internal edge, draw it */
- if(edge & BDR_INNER){
- SelectObject32(hdc, iPen);
- MoveToEx32(hdc, r.left, mainDiag ? r.bottom-1 : r.top, 0);
- LineTo32(hdc, r.right, mainDiag ? r.top-1 : r.bottom);
- r.left += cl; r.right += cr; r.top += ct; r.bottom += cb;
- }
+ /* Adjust rectangle if asked */
+ if(uFlags & BF_ADJUST)
+ {
+ if(uFlags & BF_LEFT) rc->left += add;
+ if(uFlags & BF_RIGHT) rc->right -= add;
+ if(uFlags & BF_TOP) rc->top += add;
+ if(uFlags & BF_BOTTOM) rc->bottom -= add;
+ }
- if((flags & BF_MIDDLE) && !(flags & BF_MONO)){
- POINT32 p[3];
- p[0].x = mainDiag ? r.right: r.left;
- p[0].y = r.top;
- p[1].x = mainDiag ? r.left : r.right;
- p[1].y = r.bottom;
- p[2].x = tp.x;
- p[2].y = tp.y;
- SelectObject32(hdc, nullPen);
- SelectObject32(hdc, faceBrush);
- Polygon32(hdc, p, 3);
- }
+ /* Cleanup */
+ SelectObject32(hdc, SavePen);
+ if(InnerI != -1) DeleteObject32(InnerPen);
+ if(OuterI != -1) DeleteObject32(OuterPen);
+ MoveToEx32(hdc, SavePoint.x, SavePoint.y, NULL);
- if(flags & BF_ADJUST)
- *rect = r;
-
- /* Restore the DC */
- SelectObject32(hdc, oldPen);
- SelectObject32(hdc, oldBrush);
-
- /* Clean-up */
- DeleteObject32(facePen);
- DeleteObject32(shadowPen);
- DeleteObject32(lightPen);
- DeleteObject32(grayPen);
-
- return TRUE;
+ return retval;
}
-
/***********************************************************************
* UITOOLS_DrawRectEdge
*
@@ -167,115 +357,208 @@
* one generated by the native DrawEdge and it is identical on all cases that
* I tried, and I tried quite a few.
*/
-static BOOL32 UITOOLS_DrawRectEdge(HDC32 hdc, RECT32 *rect,
- UINT32 edge, UINT32 flags)
+/*********************************************************************
+ * 23-Nov-1997: Changed by Bertho Stultiens
+ *
+ * Well, I started testing this and found out that there are a few things
+ * that weren't quite as win95. The following rewrite should reproduce
+ * win95 results completely.
+ * The colorselection is table-driven to avoid awfull if-statements.
+ * The table below show the color settings.
+ *
+ * Pen selection table for uFlags = 0
+ *
+ * uType | LTI | LTO | RBI | RBO
+ * ------+-------+-------+-------+-------
+ * 0000 | x | x | x | x
+ * 0001 | x | 22 | x | 21
+ * 0010 | x | 16 | x | 20
+ * 0011 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 0100 | x | 20 | x | 16
+ * 0101 | 20 | 22 | 16 | 21
+ * 0110 | 20 | 16 | 16 | 20
+ * 0111 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 1000 | x | 21 | x | 22
+ * 1001 | 21 | 22 | 22 | 21
+ * 1010 | 21 | 16 | 22 | 20
+ * 1011 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 1100 | x | x | x | x
+ * 1101 | x | x (22)| x | x (21)
+ * 1110 | x | x (16)| x | x (20)
+ * 1111 | x | x | x | x
+ *
+ * Pen selection table for uFlags = BF_SOFT
+ *
+ * uType | LTI | LTO | RBI | RBO
+ * ------+-------+-------+-------+-------
+ * 0000 | x | x | x | x
+ * 0001 | x | 20 | x | 21
+ * 0010 | x | 21 | x | 20
+ * 0011 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 0100 | x | 22 | x | 16
+ * 0101 | 22 | 20 | 16 | 21
+ * 0110 | 22 | 21 | 16 | 20
+ * 0111 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 1000 | x | 16 | x | 22
+ * 1001 | 16 | 20 | 22 | 21
+ * 1010 | 16 | 21 | 22 | 20
+ * 1011 | x | x | x | x
+ * ------+-------+-------+-------+-------
+ * 1100 | x | x | x | x
+ * 1101 | x | x (20)| x | x (21)
+ * 1110 | x | x (21)| x | x (20)
+ * 1111 | x | x | x | x
+ *
+ * x = don't care; (n) = is what win95 actually uses
+ * LTI = left Top Inner line
+ * LTO = left Top Outer line
+ * RBI = Right Bottom Inner line
+ * RBO = Right Bottom Outer line
+ * 15 = COLOR_BTNFACE
+ * 16 = COLOR_BTNSHADOW
+ * 20 = COLOR_BTNHIGHLIGHT
+ * 21 = COLOR_3DDKSHADOW
+ * 22 = COLOR_3DLIGHT
+ */
+
+
+static BOOL32 UITOOLS_DrawRectEdge(HDC32 hdc, LPRECT32 rc, UINT32 uType, UINT32 uFlags)
{
- HBRUSH32 faceBrush, shadowBrush, lightBrush, blackBrush, grayBrush, nullBrush;
- HBRUSH32 iNBrush, iSBrush, iEBrush, iWBrush;
- HBRUSH32 oNBrush, oSBrush, oEBrush, oWBrush;
- HBRUSH32 oldBrush;
- RECT32 r;
+ char LTInnerI, LTOuterI;
+ char RBInnerI, RBOuterI;
+ HPEN32 LTInnerPen, LTOuterPen;
+ HPEN32 RBInnerPen, RBOuterPen;
+ RECT32 InnerRect = *rc;
+ POINT32 SavePoint;
+ HPEN32 SavePen;
+ int LBpenplus = 0;
+ int LTpenplus = 0;
+ int RTpenplus = 0;
+ int RBpenplus = 0;
+ BOOL32 retval = !( ((uType & BDR_INNER) == BDR_INNER
+ || (uType & BDR_OUTER) == BDR_OUTER)
+ && !(uFlags & (BF_FLAT|BF_MONO)) );
+
+ /* Init some vars */
+ LTInnerPen = LTOuterPen = RBInnerPen = RBOuterPen = (HPEN32)GetStockObject32(NULL_PEN);
+ SavePen = (HPEN32)SelectObject32(hdc, LTInnerPen);
- /* If both rasied and sunken is specified, they anihilate one another */
- if( !((flags & BF_MONO) || (flags & BF_FLAT)) ){
- if( (edge & BDR_RAISEDOUTER) && (edge & BDR_SUNKENOUTER) )
- return FALSE;
- if( (edge & BDR_RAISEDINNER) && (edge & BDR_SUNKENINNER) )
- return FALSE;
- }
+ /* Determine the colors of the edges */
+ if(uFlags & BF_MONO)
+ {
+ LTInnerI = RBInnerI = LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)];
+ LTOuterI = RBOuterI = LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)];
+ }
+ else if(uFlags & BF_FLAT)
+ {
+ LTInnerI = RBInnerI = LTRBInnerFlat[uType & (BDR_INNER|BDR_OUTER)];
+ LTOuterI = RBOuterI = LTRBOuterFlat[uType & (BDR_INNER|BDR_OUTER)];
+ }
+ else if(uFlags & BF_SOFT)
+ {
+ LTInnerI = LTInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
+ LTOuterI = LTOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
+ RBInnerI = RBInnerSoft[uType & (BDR_INNER|BDR_OUTER)];
+ RBOuterI = RBOuterSoft[uType & (BDR_INNER|BDR_OUTER)];
+ }
+ else
+ {
+ LTInnerI = LTInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
+ LTOuterI = LTOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
+ RBInnerI = RBInnerNormal[uType & (BDR_INNER|BDR_OUTER)];
+ RBOuterI = RBOuterNormal[uType & (BDR_INNER|BDR_OUTER)];
+ }
- faceBrush = GetSysColorBrush32(COLOR_BTNFACE);
- shadowBrush = GetSysColorBrush32(COLOR_BTNSHADOW);
- lightBrush = GetSysColorBrush32(COLOR_BTNHILIGHT);
- blackBrush = GetStockObject32(BLACK_BRUSH);
- grayBrush = GetStockObject32(LTGRAY_BRUSH);
- nullBrush = GetStockObject32(NULL_BRUSH);
- oldBrush = SelectObject32(hdc, nullBrush);
+ if((uFlags & BF_BOTTOMLEFT) == BF_BOTTOMLEFT) LBpenplus = 1;
+ if((uFlags & BF_TOPRIGHT) == BF_TOPRIGHT) RTpenplus = 1;
+ if((uFlags & BF_BOTTOMRIGHT) == BF_BOTTOMRIGHT) RBpenplus = 1;
+ if((uFlags & BF_TOPLEFT) == BF_TOPLEFT) LTpenplus = 1;
- /* this is my working rectangle */
- r = *rect;
+ if(LTInnerI != -1) LTInnerPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)LTInnerI));
+ if(LTOuterI != -1) LTOuterPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)LTOuterI));
+ if(RBInnerI != -1) RBInnerPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)RBInnerI));
+ if(RBOuterI != -1) RBOuterPen = CreatePen32(PS_SOLID, 0, GetSysColor32((int)RBOuterI));
- if(flags & BF_MONO){
- oNBrush = oSBrush = oEBrush = oWBrush = blackBrush;
- iNBrush = iSBrush = iEBrush = iWBrush = nullBrush;
- }else if(flags & BF_FLAT){
- oNBrush = oSBrush = oEBrush = oWBrush = shadowBrush;
- iNBrush = iSBrush = iEBrush = iWBrush = faceBrush;
- }else {
- if(flags & BF_SOFT){
- oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? lightBrush : blackBrush;
- oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
- iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? grayBrush : shadowBrush;
- iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
+ if((uFlags & BF_MIDDLE) && retval)
+ {
+ FillRect32(hdc, &InnerRect, (uFlags & BF_MONO) ? GetSysColorBrush32(COLOR_WINDOW)
+ : GetSysColorBrush32(COLOR_BTNFACE));
}
- else{
- oNBrush = oWBrush = (edge & BDR_RAISEDOUTER) ? grayBrush : shadowBrush;
- oSBrush = oEBrush = (edge & BDR_RAISEDOUTER) ? blackBrush : lightBrush;
- iNBrush = iWBrush = (edge & BDR_RAISEDINNER) ? lightBrush : blackBrush;
- iSBrush = iEBrush = (edge & BDR_RAISEDINNER) ? shadowBrush : grayBrush;
- }
- }
- /* if it has external edge, draw it */
- if(edge & BDR_OUTER){
- if(flags & BF_RIGHT){
- SelectObject32(hdc, oEBrush);
- PatBlt32(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
- r.right--;
- }
- if(flags & BF_BOTTOM){
- SelectObject32(hdc, oSBrush);
- PatBlt32(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
- r.bottom--;
- }
- if(flags & BF_LEFT){
- SelectObject32(hdc, oWBrush);
- PatBlt32(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
- r.left++;
- }
- if(flags & BF_TOP){
- SelectObject32(hdc, oNBrush);
- PatBlt32(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
- r.top++;
- }
- }
+ MoveToEx32(hdc, 0, 0, &SavePoint);
- /* if it has internal edge, draw it */
- if(edge & BDR_INNER){
- if(flags & BF_RIGHT){
- SelectObject32(hdc, iEBrush);
- PatBlt32(hdc, r.right-1, r.top, 1, r.bottom - r.top, PATCOPY);
- r.right--;
+ /* Draw the outer edge */
+ SelectObject32(hdc, LTOuterPen);
+ if(uFlags & BF_TOP)
+ {
+ MoveToEx32(hdc, InnerRect.left, InnerRect.top, NULL);
+ LineTo32(hdc, InnerRect.right, InnerRect.top);
}
- if(flags & BF_BOTTOM){
- SelectObject32(hdc, iSBrush);
- PatBlt32(hdc, r.left, r.bottom-1, r.right-r.left, 1, PATCOPY);
- r.bottom--;
+ if(uFlags & BF_LEFT)
+ {
+ MoveToEx32(hdc, InnerRect.left, InnerRect.top, NULL);
+ LineTo32(hdc, InnerRect.left, InnerRect.bottom);
}
- if(flags & BF_LEFT){
- SelectObject32(hdc, iWBrush);
- PatBlt32(hdc, r.left, r.top, 1, r.bottom - r.top, PATCOPY);
- r.left++;
+ SelectObject32(hdc, RBOuterPen);
+ if(uFlags & BF_BOTTOM)
+ {
+ MoveToEx32(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL);
+ LineTo32(hdc, InnerRect.left-1, InnerRect.bottom-1);
}
- if(flags & BF_TOP){
- SelectObject32(hdc, iNBrush);
- PatBlt32(hdc, r.left, r.top, r.right-r.left, 1, PATCOPY);
- r.top++;
+ if(uFlags & BF_RIGHT)
+ {
+ MoveToEx32(hdc, InnerRect.right-1, InnerRect.bottom-1, NULL);
+ LineTo32(hdc, InnerRect.right-1, InnerRect.top-1);
}
- }
- /* if we got to fill the middle, to it now */
- if((flags & BF_MIDDLE) && !(flags & BF_MONO))
- FillRect32(hdc, &r, faceBrush);
+ /* Draw the inner edge */
+ SelectObject32(hdc, LTInnerPen);
+ if(uFlags & BF_TOP)
+ {
+ MoveToEx32(hdc, InnerRect.left+LTpenplus, InnerRect.top+1, NULL);
+ LineTo32(hdc, InnerRect.right-RTpenplus, InnerRect.top+1);
+ }
+ if(uFlags & BF_LEFT)
+ {
+ MoveToEx32(hdc, InnerRect.left+1, InnerRect.top+LTpenplus, NULL);
+ LineTo32(hdc, InnerRect.left+1, InnerRect.bottom-LBpenplus);
+ }
+ SelectObject32(hdc, RBInnerPen);
+ if(uFlags & BF_BOTTOM)
+ {
+ MoveToEx32(hdc, InnerRect.right-1-RBpenplus, InnerRect.bottom-2, NULL);
+ LineTo32(hdc, InnerRect.left-1+LBpenplus, InnerRect.bottom-2);
+ }
+ if(uFlags & BF_RIGHT)
+ {
+ MoveToEx32(hdc, InnerRect.right-2, InnerRect.bottom-1-RBpenplus, NULL);
+ LineTo32(hdc, InnerRect.right-2, InnerRect.top-1+RTpenplus);
+ }
- /* adjust the rectangle if required */
- if(flags & BF_ADJUST)
- *rect = r;
+ /* Adjust rectangle if asked */
+ if(uFlags & BF_ADJUST)
+ {
+ int add = (LTRBInnerMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0)
+ + (LTRBOuterMono[uType & (BDR_INNER|BDR_OUTER)] != -1 ? 1 : 0);
+ if(uFlags & BF_LEFT) rc->left += add;
+ if(uFlags & BF_RIGHT) rc->right -= add;
+ if(uFlags & BF_TOP) rc->top += add;
+ if(uFlags & BF_BOTTOM) rc->bottom -= add;
+ }
- /* Restore the DC */
- SelectObject32(hdc, oldBrush);
-
- return TRUE;
+ /* Cleanup */
+ SelectObject32(hdc, SavePen);
+ if(LTInnerI != -1) DeleteObject32(LTInnerPen);
+ if(LTOuterI != -1) DeleteObject32(LTOuterPen);
+ if(RBInnerI != -1) DeleteObject32(RBInnerPen);
+ if(RBOuterI != -1) DeleteObject32(RBOuterPen);
+ MoveToEx32(hdc, SavePoint.x, SavePoint.y, NULL);
+ return retval;
}
@@ -309,44 +592,823 @@
}
+/************************************************************************
+ * UITOOLS_MakeSquareRect
+ *
+ * Utility to create a square rectangle and returning the width
+ */
+static int UITOOLS_MakeSquareRect(LPRECT32 src, LPRECT32 dst)
+{
+ int Width = src->right - src->left;
+ int Height = src->bottom - src->top;
+ int SmallDiam = Width > Height ? Height : Width;
+
+ *dst = *src;
+
+ /* Make it a square box */
+ if(Width < Height) /* SmallDiam == Width */
+ {
+ dst->top += (Height-Width)/2;
+ dst->bottom = dst->top + SmallDiam;
+ }
+ else if(Width > Height) /* SmallDiam == Height */
+ {
+ dst->left += (Width-Height)/2;
+ dst->right = dst->left + SmallDiam;
+ }
+
+ return SmallDiam;
+}
+
+
+/************************************************************************
+ * UITOOLS_DFC_ButtonPush
+ *
+ * Draw a push button coming from DrawFrameControl()
+ *
+ * Does a pretty good job in emulating MS behavior. Some quirks are
+ * however there because MS uses a TrueType font (Marlett) to draw
+ * the buttons.
+ */
+static BOOL32 UITOOLS_DFC_ButtonPush(HDC32 dc, LPRECT32 r, UINT32 uFlags)
+{
+ UINT32 edge;
+ RECT32 myr = *r;
+
+ if(uFlags & (DFCS_PUSHED | DFCS_CHECKED | DFCS_FLAT))
+ edge = EDGE_SUNKEN;
+ else
+ edge = EDGE_RAISED;
+
+ if(uFlags & DFCS_CHECKED)
+ {
+ if(uFlags & DFCS_MONO)
+ UITOOLS_DrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST);
+ else
+ UITOOLS_DrawRectEdge(dc, &myr, edge, (uFlags&DFCS_FLAT)|BF_RECT|BF_SOFT|BF_ADJUST);
+
+ if(GetSysColor32(COLOR_BTNHIGHLIGHT) == RGB(255, 255, 255))
+ {
+ HBITMAP32 hbm = CreateBitmap32(8, 8, 1, 1, wPattern_AA55);
+ HBRUSH32 hbsave;
+ HBRUSH32 hb = CreatePatternBrush32(hbm);
+
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNFACE));
+ hbsave = (HBRUSH32)SelectObject32(dc, hb);
+ PatBlt32(dc, myr.left, myr.top, myr.right-myr.left, myr.bottom-myr.top, 0x00FA0089);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hb);
+ DeleteObject32(hbm);
+ }
+ else
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ }
+ }
+ else
+ {
+ if(uFlags & DFCS_MONO)
+ {
+ UITOOLS_DrawRectEdge(dc, &myr, edge, BF_MONO|BF_RECT|BF_ADJUST);
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNFACE));
+ }
+ else
+ {
+ UITOOLS_DrawRectEdge(dc, r, edge, (uFlags&DFCS_FLAT) | BF_MIDDLE |BF_SOFT| BF_RECT);
+ }
+ }
+
+ /* Adjust rectangle if asked */
+ if(uFlags & DFCS_ADJUSTRECT)
+ {
+ r->left += 2;
+ r->right -= 2;
+ r->top += 2;
+ r->bottom -= 2;
+ }
+
+ return TRUE;
+}
+
+
+/************************************************************************
+ * UITOOLS_DFC_ButtonChcek
+ *
+ * Draw a check/3state button coming from DrawFrameControl()
+ *
+ * Does a pretty good job in emulating MS behavior. Some quirks are
+ * however there because MS uses a TrueType font (Marlett) to draw
+ * the buttons.
+ */
+#define DFC_CHECKPOINTSMAX 6
+
+static BOOL32 UITOOLS_DFC_ButtonCheck(HDC32 dc, LPRECT32 r, UINT32 uFlags)
+{
+ RECT32 myr;
+ int SmallDiam = UITOOLS_MakeSquareRect(r, &myr);
+ int BorderShrink = SmallDiam / 16;
+
+ if(BorderShrink < 1) BorderShrink = 1;
+
+ /* FIXME: The FillRect() sequence doesn't work for sizes less than */
+ /* 4 pixels in diameter. Not really a problem but it isn't M$'s */
+ /* 100% equivalent. */
+ if(uFlags & (DFCS_FLAT|DFCS_MONO))
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_WINDOWFRAME));
+ myr.left += 2 * BorderShrink;
+ myr.right -= 2 * BorderShrink;
+ myr.top += 2 * BorderShrink;
+ myr.bottom -= 2 * BorderShrink;
+ }
+ else
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ myr.right -= BorderShrink;
+ myr.bottom -= BorderShrink;
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNSHADOW));
+ myr.left += BorderShrink;
+ myr.top += BorderShrink;
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_3DLIGHT));
+ myr.right -= BorderShrink;
+ myr.bottom -= BorderShrink;
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_3DDKSHADOW));
+ myr.left += BorderShrink;
+ myr.top += BorderShrink;
+ }
+
+ if(uFlags & (DFCS_INACTIVE|DFCS_PUSHED))
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNFACE));
+ }
+ else if(uFlags & DFCS_CHECKED)
+ {
+ if(GetSysColor32(COLOR_BTNHIGHLIGHT) == RGB(255, 255, 255))
+ {
+ HBITMAP32 hbm = CreateBitmap32(8, 8, 1, 1, wPattern_AA55);
+ HBRUSH32 hbsave;
+ HBRUSH32 hb = CreatePatternBrush32(hbm);
+
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNFACE));
+ hbsave = (HBRUSH32)SelectObject32(dc, hb);
+ PatBlt32(dc, myr.left, myr.top, myr.right-myr.left, myr.bottom-myr.top, 0x00FA0089);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hb);
+ DeleteObject32(hbm);
+ }
+ else
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ }
+ }
+ else
+ {
+ FillRect32(dc, &myr, GetSysColorBrush32(COLOR_WINDOW));
+ }
+
+ if(uFlags & DFCS_CHECKED)
+ {
+ POINT32 CheckPoints[DFC_CHECKPOINTSMAX];
+ int i;
+ HBRUSH32 hbsave;
+ HPEN32 hp, hpsave;
+
+ /* FIXME: This comes very close to M$'s checkmark, but not */
+ /* exactly... When small or large there is a few pixels */
+ /* shift. Not bad, but could be better :) */
+ UITOOLS_MakeSquareRect(r, &myr);
+ CheckPoints[0].x = myr.left + 253*SmallDiam/1000;
+ CheckPoints[0].y = myr.top + 345*SmallDiam/1000;
+ CheckPoints[1].x = myr.left + 409*SmallDiam/1000;
+ CheckPoints[1].y = CheckPoints[0].y + (CheckPoints[1].x-CheckPoints[0].x);
+ CheckPoints[2].x = myr.left + 690*SmallDiam/1000;
+ CheckPoints[2].y = CheckPoints[1].y - (CheckPoints[2].x-CheckPoints[1].x);
+ CheckPoints[3].x = CheckPoints[2].x;
+ CheckPoints[3].y = CheckPoints[2].y + 3*SmallDiam/16;
+ CheckPoints[4].x = CheckPoints[1].x;
+ CheckPoints[4].y = CheckPoints[1].y + 3*SmallDiam/16;
+ CheckPoints[5].x = CheckPoints[0].x;
+ CheckPoints[5].y = CheckPoints[0].y + 3*SmallDiam/16;
+
+ i = (uFlags & DFCS_INACTIVE) || (uFlags & 0xff) == DFCS_BUTTON3STATE ? COLOR_BTNSHADOW : COLOR_WINDOWTEXT;
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(i));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(i));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Polygon32(dc, CheckPoints, DFC_CHECKPOINTSMAX);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+ }
+ return TRUE;
+}
+
+
+/************************************************************************
+ * UITOOLS_DFC_ButtonRadio
+ *
+ * Draw a radio/radioimage/radiomask button coming from DrawFrameControl()
+ *
+ * Does a pretty good job in emulating MS behavior. Some quirks are
+ * however there because MS uses a TrueType font (Marlett) to draw
+ * the buttons.
+ */
+static BOOL32 UITOOLS_DFC_ButtonRadio(HDC32 dc, LPRECT32 r, UINT32 uFlags)
+{
+ RECT32 myr;
+ int i;
+ int SmallDiam = UITOOLS_MakeSquareRect(r, &myr);
+ int BorderShrink = SmallDiam / 16;
+ HPEN32 hpsave, hp;
+ HBRUSH32 hbsave;
+ int xe, ye;
+ int xc, yc;
+
+ if(BorderShrink < 1) BorderShrink = 1;
+
+ if((uFlags & 0xff) == DFCS_BUTTONRADIOIMAGE)
+ {
+ FillRect32(dc, r, (HBRUSH32)GetStockObject32(BLACK_BRUSH));
+ }
+
+ xe = myr.left;
+ ye = myr.top + SmallDiam - SmallDiam/2;
+
+ xc = myr.left + SmallDiam - SmallDiam/2;
+ yc = myr.top + SmallDiam - SmallDiam/2;
+
+ /* Define bounding box */
+ i = 14*SmallDiam/16;
+ myr.left = xc - i+i/2;
+ myr.right = xc + i/2;
+ myr.top = yc - i+i/2;
+ myr.bottom = yc + i/2;
+
+ if((uFlags & 0xff) == DFCS_BUTTONRADIOMASK)
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetStockObject32(BLACK_BRUSH));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, xe, ye, xe, ye);
+ SelectObject32(dc, hbsave);
+ }
+ else
+ {
+ if(uFlags & (DFCS_FLAT|DFCS_MONO))
+ {
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_WINDOWFRAME));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_WINDOWFRAME));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, xe, ye, xe, ye);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+ }
+ else
+ {
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNHIGHLIGHT));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, myr.left-1, myr.bottom, myr.right-1, myr.top);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNSHADOW));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNSHADOW));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, myr.right+1, myr.top, myr.left+1, myr.bottom);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+
+ myr.left += BorderShrink;
+ myr.right -= BorderShrink;
+ myr.top += BorderShrink;
+ myr.bottom -= BorderShrink;
+
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_3DLIGHT));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_3DLIGHT));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, myr.left-1, myr.bottom, myr.right-1, myr.top);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_3DDKSHADOW));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_3DDKSHADOW));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, myr.right+1, myr.top, myr.left+1, myr.bottom);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+ }
+
+ i = 10*SmallDiam/16;
+ myr.left = xc - i+i/2;
+ myr.right = xc + i/2;
+ myr.top = yc - i+i/2;
+ myr.bottom = yc + i/2;
+ i= !(uFlags & (DFCS_INACTIVE|DFCS_PUSHED)) ? COLOR_WINDOW : COLOR_BTNFACE;
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(i));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(i));
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, xe, ye, xe, ye);
+ SelectObject32(dc, hbsave);
+ SelectObject32(dc, hpsave);
+ DeleteObject32(hp);
+ }
+
+ if(uFlags & DFCS_CHECKED)
+ {
+ i = 6*SmallDiam/16;
+ i = i < 1 ? 1 : i;
+ myr.left = xc - i+i/2;
+ myr.right = xc + i/2;
+ myr.top = yc - i+i/2;
+ myr.bottom = yc + i/2;
+
+ i = uFlags & DFCS_INACTIVE ? COLOR_BTNSHADOW : COLOR_WINDOWTEXT;
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(i));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(i));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, xe, ye, xe, ye);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+ }
+
+ /* FIXME: M$ has a polygon in the center at relative points: */
+ /* 0.476, 0.476 (times SmallDiam, SmallDiam) */
+ /* 0.476, 0.525 */
+ /* 0.500, 0.500 */
+ /* 0.500, 0.499 */
+ /* when the button is unchecked. The reason for it is unknown. The */
+ /* color is COLOR_BTNHIGHLIGHT, although the polygon gets painted at */
+ /* least 3 times (it looks like a clip-region when you see it happen). */
+ /* I do not really see a reason why this should be implemented. If you */
+ /* have a good reason, let me know. Maybe this is a quirk in the Marlett */
+ /* font. */
+
+ return TRUE;
+}
+
/***********************************************************************
* UITOOLS_DrawFrameButton
*/
static BOOL32 UITOOLS_DrawFrameButton(HDC32 hdc, LPRECT32 rc, UINT32 uState)
{
- fprintf( stdnimp,"DrawFrameButton(%x,%p,%x), empty stub!\n",
- hdc,rc,uState );
+ switch(uState & 0xff)
+ {
+ case DFCS_BUTTONPUSH:
+ return UITOOLS_DFC_ButtonPush(hdc, rc, uState);
+
+ case DFCS_BUTTONCHECK:
+ case DFCS_BUTTON3STATE:
+ return UITOOLS_DFC_ButtonCheck(hdc, rc, uState);
+
+ case DFCS_BUTTONRADIOIMAGE:
+ case DFCS_BUTTONRADIOMASK:
+ case DFCS_BUTTONRADIO:
+ return UITOOLS_DFC_ButtonRadio(hdc, rc, uState);
+
+ default:
+ fprintf(stdnimp, "UITOOLS_DrawFrameButton: Report this: Invalid button state: 0x%04x\n", uState);
+ }
+
return FALSE;
}
/***********************************************************************
* UITOOLS_DrawFrameCaption
+ *
+ * Draw caption buttons (win95), coming from DrawFrameControl()
*/
-static BOOL32 UITOOLS_DrawFrameCaption(HDC32 hdc, LPRECT32 rc, UINT32 uState)
+
+static BOOL32 UITOOLS_DrawFrameCaption(HDC32 dc, LPRECT32 r, UINT32 uFlags)
{
- fprintf( stdnimp,"DrawFrameCaption(%x,%p,%x), empty stub!\n",
- hdc,rc,uState );
- return FALSE;
+ POINT32 Line1[10];
+ POINT32 Line2[10];
+ int Line1N;
+ int Line2N;
+ RECT32 myr;
+ int SmallDiam = UITOOLS_MakeSquareRect(r, &myr)-2;
+ int i;
+ HBRUSH32 hbsave;
+ HPEN32 hpsave, hp;
+ HFONT32 hfsave, hf;
+ int xc = (myr.left+myr.right)/2;
+ int yc = (myr.top+myr.bottom)/2;
+ int edge, move;
+ char str[2] = "?";
+ UINT32 alignsave;
+ int bksave;
+ COLORREF clrsave;
+ SIZE32 size;
+
+ UITOOLS_DFC_ButtonPush(dc, r, uFlags & 0xff00);
+
+ switch(uFlags & 0xff)
+ {
+ case DFCS_CAPTIONCLOSE:
+ edge = 328*SmallDiam/1000;
+ move = 95*SmallDiam/1000;
+ Line1[0].x = Line2[0].x = Line1[1].x = Line2[1].x = xc - edge;
+ Line1[2].y = Line2[5].y = Line1[1].y = Line2[4].y = yc - edge;
+ Line1[3].x = Line2[3].x = Line1[4].x = Line2[4].x = xc + edge;
+ Line1[5].y = Line2[2].y = Line1[4].y = Line2[1].y = yc + edge;
+ Line1[2].x = Line2[2].x = Line1[1].x + move;
+ Line1[0].y = Line2[3].y = Line1[1].y + move;
+ Line1[5].x = Line2[5].x = Line1[4].x - move;
+ Line1[3].y = Line2[0].y = Line1[4].y - move;
+ Line1N = 6;
+ Line2N = 6;
+ break;
+
+ case DFCS_CAPTIONHELP:
+ /* This one breaks the flow */
+ /* FIXME: We need the Marlett font in order to get this right. */
+
+ hf = CreateFont32A(-SmallDiam, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
+ ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
+ DEFAULT_QUALITY, FIXED_PITCH|FF_DONTCARE, "System");
+ alignsave = SetTextAlign32(dc, TA_TOP|TA_LEFT);
+ bksave = SetBkMode32(dc, TRANSPARENT);
+ clrsave = GetTextColor32(dc);
+ hfsave = (HFONT32)SelectObject32(dc, hf);
+ GetTextExtentPoint32A(dc, str, 1, &size);
+
+ if(uFlags & DFCS_INACTIVE)
+ {
+ SetTextColor32(dc, GetSysColor32(COLOR_BTNHIGHLIGHT));
+ TextOut32A(dc, xc-size.cx/2+1, yc-size.cy/2+1, str, 1);
+ }
+ SetTextColor32(dc, GetSysColor32(uFlags & DFCS_INACTIVE ? COLOR_BTNSHADOW : COLOR_BTNTEXT));
+ TextOut32A(dc, xc-size.cx/2, yc-size.cy/2, str, 1);
+
+ SelectObject32(dc, hfsave);
+ SetTextColor32(dc, clrsave);
+ SetBkMode32(dc, bksave);
+ SetTextAlign32(dc, alignsave);
+ DeleteObject32(hf);
+ return TRUE;
+
+ case DFCS_CAPTIONMIN:
+ Line1[0].x = Line1[3].x = myr.left + 96*SmallDiam/750+2;
+ Line1[1].x = Line1[2].x = Line1[0].x + 372*SmallDiam/750;
+ Line1[0].y = Line1[1].y = myr.top + 563*SmallDiam/750+1;
+ Line1[2].y = Line1[3].y = Line1[0].y + 92*SmallDiam/750;
+ Line1N = 4;
+ Line2N = 0;
+ break;
+
+ case DFCS_CAPTIONMAX:
+ edge = 47*SmallDiam/750;
+ Line1[0].x = Line1[5].x = myr.left + 57*SmallDiam/750+3;
+ Line1[0].y = Line1[1].y = myr.top + 143*SmallDiam/750+1;
+ Line1[1].x = Line1[2].x = Line1[0].x + 562*SmallDiam/750;
+ Line1[5].y = Line1[4].y = Line1[0].y + 93*SmallDiam/750;
+ Line1[2].y = Line1[3].y = Line1[0].y + 513*SmallDiam/750;
+ Line1[3].x = Line1[4].x = Line1[1].x - edge;
+
+ Line2[0].x = Line2[5].x = Line1[0].x;
+ Line2[3].x = Line2[4].x = Line1[1].x;
+ Line2[1].x = Line2[2].x = Line1[0].x + edge;
+ Line2[0].y = Line2[1].y = Line1[0].y;
+ Line2[4].y = Line2[5].y = Line1[2].y;
+ Line2[2].y = Line2[3].y = Line1[2].y - edge;
+ Line1N = 6;
+ Line2N = 6;
+ break;
+
+ case DFCS_CAPTIONRESTORE:
+ /* FIXME: this one looks bad at small sizes < 15x15 :( */
+ edge = 47*SmallDiam/750;
+ move = 420*SmallDiam/750;
+ Line1[0].x = Line1[9].x = myr.left + 198*SmallDiam/750+2;
+ Line1[0].y = Line1[1].y = myr.top + 169*SmallDiam/750+1;
+ Line1[6].y = Line1[7].y = Line1[0].y + 93*SmallDiam/750;
+ Line1[7].x = Line1[8].x = Line1[0].x + edge;
+ Line1[1].x = Line1[2].x = Line1[0].x + move;
+ Line1[5].x = Line1[6].x = Line1[1].x - edge;
+ Line1[9].y = Line1[8].y = Line1[0].y + 187*SmallDiam/750;
+ Line1[2].y = Line1[3].y = Line1[0].y + 327*SmallDiam/750;
+ Line1[4].y = Line1[5].y = Line1[2].y - edge;
+ Line1[3].x = Line1[4].x = Line1[2].x - 140*SmallDiam/750;
+
+ Line2[1].x = Line2[2].x = Line1[3].x;
+ Line2[7].x = Line2[8].x = Line2[1].x - edge;
+ Line2[0].x = Line2[9].x = Line2[3].x = Line2[4].x = Line2[1].x - move;
+ Line2[5].x = Line2[6].x = Line2[0].x + edge;
+ Line2[0].y = Line2[1].y = Line1[9].y;
+ Line2[4].y = Line2[5].y = Line2[8].y = Line2[9].y = Line2[0].y + 93*SmallDiam/750;
+ Line2[2].y = Line2[3].y = Line2[0].y + 327*SmallDiam/750;
+ Line2[6].y = Line2[7].y = Line2[2].y - edge;
+ Line1N = 10;
+ Line2N = 10;
+ break;
+
+ default:
+ fprintf(stdnimp, "UITOOLS_DrawFrameCaption: Report this: Invalid caption; flags: 0x%04x\n", uFlags);
+ return FALSE;
+ }
+
+ /* Here the drawing takes place */
+ if(uFlags & DFCS_INACTIVE)
+ {
+ /* If we have an inactive button, then you see a shadow */
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNHIGHLIGHT));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Polygon32(dc, Line1, Line1N);
+ if(Line2N > 0)
+ Polygon32(dc, Line2, Line2N);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+ }
+
+ /* Correct for the shadow shift */
+ for(i = 0; i < Line1N; i++)
+ {
+ Line1[i].x--;
+ Line1[i].y--;
+ }
+ for(i = 0; i < Line2N; i++)
+ {
+ Line2[i].x--;
+ Line2[i].y--;
+ }
+
+ /* Make the final picture */
+ if(uFlags & DFCS_INACTIVE)
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNSHADOW));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNSHADOW));
+ }
+ else
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNTEXT));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNTEXT));
+ }
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Polygon32(dc, Line1, Line1N);
+ if(Line2N > 0)
+ Polygon32(dc, Line2, Line2N);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+
+ return TRUE;
}
-/***********************************************************************
- * UITOOLS_DrawFrameMenu
+
+/************************************************************************
+ * UITOOLS_DrawFrameScroll
+ *
+ * Draw a scroll-bar control coming from DrawFrameControl()
*/
-static BOOL32 UITOOLS_DrawFrameMenu(HDC32 hdc, LPRECT32 rc, UINT32 uState)
+static BOOL32 UITOOLS_DrawFrameScroll(HDC32 dc, LPRECT32 r, UINT32 uFlags)
{
- fprintf( stdnimp,"DrawFrameMenu32(%x,%p,%x), empty stub!\n",
- hdc,rc,uState );
- return FALSE;
+ POINT32 Line[4];
+ RECT32 myr;
+ int SmallDiam = UITOOLS_MakeSquareRect(r, &myr) - 2;
+ int i;
+ HBRUSH32 hbsave, hb, hb2;
+ HPEN32 hpsave, hp, hp2;
+ int tri = 310*SmallDiam/1000;
+ int d46, d93;
+
+ switch(uFlags & 0xff)
+ {
+ case DFCS_SCROLLCOMBOBOX:
+ case DFCS_SCROLLDOWN:
+ Line[2].x = myr.left + 470*SmallDiam/1000 + 2;
+ Line[2].y = myr.top + 687*SmallDiam/1000 + 1;
+ Line[0].x = Line[2].x - tri;
+ Line[1].x = Line[2].x + tri;
+ Line[0].y = Line[1].y = Line[2].y - tri;
+ break;
+
+ case DFCS_SCROLLUP:
+ Line[2].x = myr.left + 470*SmallDiam/1000 + 2;
+ Line[2].y = myr.top + 313*SmallDiam/1000 + 1;
+ Line[0].x = Line[2].x - tri;
+ Line[1].x = Line[2].x + tri;
+ Line[0].y = Line[1].y = Line[2].y + tri;
+ break;
+
+ case DFCS_SCROLLLEFT:
+ Line[2].x = myr.left + 313*SmallDiam/1000 + 1;
+ Line[2].y = myr.top + 470*SmallDiam/1000 + 2;
+ Line[0].y = Line[2].y - tri;
+ Line[1].y = Line[2].y + tri;
+ Line[0].x = Line[1].x = Line[2].x + tri;
+ break;
+
+ case DFCS_SCROLLRIGHT:
+ Line[2].x = myr.left + 687*SmallDiam/1000 + 1;
+ Line[2].y = myr.top + 470*SmallDiam/1000 + 2;
+ Line[0].y = Line[2].y - tri;
+ Line[1].y = Line[2].y + tri;
+ Line[0].x = Line[1].x = Line[2].x - tri;
+ break;
+
+ case DFCS_SCROLLSIZEGRIP:
+ /* This one breaks the flow... */
+ UITOOLS_DrawRectEdge(dc, r, EDGE_BUMP, BF_MIDDLE | ((uFlags&(DFCS_MONO|DFCS_FLAT)) ? BF_MONO : 0));
+ hpsave = (HPEN32)SelectObject32(dc, GetStockObject32(NULL_PEN));
+ hbsave = (HBRUSH32)SelectObject32(dc, GetStockObject32(NULL_BRUSH));
+ if(uFlags & (DFCS_MONO|DFCS_FLAT))
+ {
+ hp = hp2 = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_WINDOWFRAME));
+ hb = hb2 = GetSysColorBrush32(COLOR_WINDOWFRAME);
+ }
+ else
+ {
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNHIGHLIGHT));
+ hp2 = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNSHADOW));
+ hb = GetSysColorBrush32(COLOR_BTNHIGHLIGHT);
+ hb2 = GetSysColorBrush32(COLOR_BTNSHADOW);
+ }
+ Line[0].x = Line[1].x = r->right-1;
+ Line[2].y = Line[3].y = r->bottom-1;
+ d46 = 46*SmallDiam/750;
+ d93 = 93*SmallDiam/750;
+
+ i = 586*SmallDiam/750;
+ Line[0].y = r->bottom - i - 1;
+ Line[3].x = r->right - i - 1;
+ Line[1].y = Line[0].y + d46;
+ Line[2].x = Line[3].x + d46;
+ SelectObject32(dc, hb);
+ SelectObject32(dc, hp);
+ Polygon32(dc, Line, 4);
+
+ Line[1].y++; Line[2].x++;
+ Line[0].y = Line[1].y + d93;
+ Line[3].x = Line[2].x + d93;
+ SelectObject32(dc, hb2);
+ SelectObject32(dc, hp2);
+ Polygon32(dc, Line, 4);
+
+ i = 398*SmallDiam/750;
+ Line[0].y = r->bottom - i - 1;
+ Line[3].x = r->right - i - 1;
+ Line[1].y = Line[0].y + d46;
+ Line[2].x = Line[3].x + d46;
+ SelectObject32(dc, hb);
+ SelectObject32(dc, hp);
+ Polygon32(dc, Line, 4);
+
+ Line[1].y++; Line[2].x++;
+ Line[0].y = Line[1].y + d93;
+ Line[3].x = Line[2].x + d93;
+ SelectObject32(dc, hb2);
+ SelectObject32(dc, hp2);
+ Polygon32(dc, Line, 4);
+
+ i = 210*SmallDiam/750;
+ Line[0].y = r->bottom - i - 1;
+ Line[3].x = r->right - i - 1;
+ Line[1].y = Line[0].y + d46;
+ Line[2].x = Line[3].x + d46;
+ SelectObject32(dc, hb);
+ SelectObject32(dc, hp);
+ Polygon32(dc, Line, 4);
+
+ Line[1].y++; Line[2].x++;
+ Line[0].y = Line[1].y + d93;
+ Line[3].x = Line[2].x + d93;
+ SelectObject32(dc, hb2);
+ SelectObject32(dc, hp2);
+ Polygon32(dc, Line, 4);
+
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+ DeleteObject32(hp2);
+ return TRUE;
+
+ default:
+ fprintf(stdnimp, "UITOOLS_DrawFrameScroll: Report this: Invalid scroll; flags: 0x%04x\n", uFlags);
+ return FALSE;
+ }
+
+ /* Here do the real scroll-bar controls end up */
+ UITOOLS_DFC_ButtonPush(dc, r, uFlags & 0xff00);
+
+ if(uFlags & DFCS_INACTIVE)
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNHIGHLIGHT));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNHIGHLIGHT));
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Polygon32(dc, Line, 3);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+ }
+
+ for(i = 0; i < 3; i++)
+ {
+ Line[i].x--;
+ Line[i].y--;
+ }
+
+ if(uFlags & DFCS_INACTIVE)
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNSHADOW));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNSHADOW));
+ }
+ else
+ {
+ hbsave = (HBRUSH32)SelectObject32(dc, GetSysColorBrush32(COLOR_BTNTEXT));
+ hp = CreatePen32(PS_SOLID, 0, GetSysColor32(COLOR_BTNTEXT));
+ }
+ hpsave = (HPEN32)SelectObject32(dc, hp);
+ Polygon32(dc, Line, 3);
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ DeleteObject32(hp);
+
+ return TRUE;
}
-/***********************************************************************
- * UITOOLS_DrawFrameScroll
+/************************************************************************
+ * UITOOLS_DrawFrameMenu
+ *
+ * Draw a menu control coming from DrawFrameControl()
*/
-static BOOL32 UITOOLS_DrawFrameScroll(HDC32 hdc, LPRECT32 rc, UINT32 uState)
+static BOOL32 UITOOLS_DrawFrameMenu(HDC32 dc, LPRECT32 r, UINT32 uFlags)
{
- fprintf( stdnimp,"DrawFrameScroll32(%x,%p,%x), empty stub!\n",
- hdc,rc,uState );
- return FALSE;
+ POINT32 Points[6];
+ RECT32 myr;
+ int SmallDiam = UITOOLS_MakeSquareRect(r, &myr);
+ int i;
+ HBRUSH32 hbsave;
+ HPEN32 hpsave;
+ int xe, ye;
+ int xc, yc;
+ BOOL32 retval = TRUE;
+
+ /* Using black and white seems to be utterly wrong, but win95 doesn't */
+ /* use anything else. I think I tried all sys-colors to change things */
+ /* without luck. It seems as if this behavior is inherited from the */
+ /* win31 DFC() implementation... (you remember, B/W menus). */
+
+ FillRect32(dc, r, (HBRUSH32)GetStockObject32(WHITE_BRUSH));
+
+ hbsave = (HBRUSH32)SelectObject32(dc, GetStockObject32(BLACK_BRUSH));
+ hpsave = (HPEN32)SelectObject32(dc, GetStockObject32(BLACK_PEN));
+
+ switch(uFlags & 0xff)
+ {
+ case DFCS_MENUARROW:
+ i = 187*SmallDiam/750;
+ Points[2].x = myr.left + 468*SmallDiam/750;
+ Points[2].y = myr.top + 352*SmallDiam/750+1;
+ Points[0].y = Points[2].y - i;
+ Points[1].y = Points[2].y + i;
+ Points[0].x = Points[1].x = Points[2].x - i;
+ Polygon32(dc, Points, 3);
+ break;
+
+ case DFCS_MENUBULLET:
+ xe = myr.left;
+ ye = myr.top + SmallDiam - SmallDiam/2;
+ xc = myr.left + SmallDiam - SmallDiam/2;
+ yc = myr.top + SmallDiam - SmallDiam/2;
+ i = 234*SmallDiam/750;
+ i = i < 1 ? 1 : i;
+ myr.left = xc - i+i/2;
+ myr.right = xc + i/2;
+ myr.top = yc - i+i/2;
+ myr.bottom = yc + i/2;
+ Pie32(dc, myr.left, myr.top, myr.right, myr.bottom, xe, ye, xe, ye);
+ break;
+
+ case DFCS_MENUCHECK:
+ Points[0].x = myr.left + 253*SmallDiam/1000;
+ Points[0].y = myr.top + 445*SmallDiam/1000;
+ Points[1].x = myr.left + 409*SmallDiam/1000;
+ Points[1].y = Points[0].y + (Points[1].x-Points[0].x);
+ Points[2].x = myr.left + 690*SmallDiam/1000;
+ Points[2].y = Points[1].y - (Points[2].x-Points[1].x);
+ Points[3].x = Points[2].x;
+ Points[3].y = Points[2].y + 3*SmallDiam/16;
+ Points[4].x = Points[1].x;
+ Points[4].y = Points[1].y + 3*SmallDiam/16;
+ Points[5].x = Points[0].x;
+ Points[5].y = Points[0].y + 3*SmallDiam/16;
+ Polygon32(dc, Points, 6);
+ break;
+
+ default:
+ fprintf(stdnimp, "UITOOLS_DrawFrameMenu: Report this: Invalid menu; flags: 0x%04x\n", uFlags);
+ retval = FALSE;
+ break;
+ }
+
+ SelectObject32(dc, hpsave);
+ SelectObject32(dc, hbsave);
+ return retval;
}
@@ -372,6 +1434,10 @@
BOOL32 WINAPI DrawFrameControl32( HDC32 hdc, LPRECT32 rc, UINT32 uType,
UINT32 uState )
{
+ /* Win95 doesn't support drawing in other mapping modes */
+ if(GetMapMode32(hdc) != MM_TEXT)
+ return FALSE;
+
switch(uType)
{
case DFC_BUTTON:
