diff options
Diffstat (limited to 'win')
113 files changed, 19774 insertions, 0 deletions
diff --git a/win/README b/win/README new file mode 100644 index 0000000..17a488c --- /dev/null +++ b/win/README @@ -0,0 +1,124 @@ +Tk 8.0p2 for Windows + +by Scott Stanton +Sun Microsystems Laboratories +scott.stanton@eng.sun.com + +SCCS: @(#) README 1.20 97/11/21 15:17:54 + +1. Introduction +--------------- + +This is the directory where you configure and compile the Windows +version of Tk. This directory also contains source files for Tk +that are specific to Microsoft Windows. The rest of this file +contains information specific to the Windows version of Tk. + +2. Distribution notes +--------------------- + +Tk 8.0 for Windows is distributed in binary form in addition to the +common source release. The binary distribution is a self-extracting +archive with a built-in installation script. + +Look for the binary release in the same location as the source release +(ftp.smli.com:/pub/tcl or any of the mirror sites). For most users, +the binary release will be much easier to install and use. You only +need the source release if you plan to modify the core of Tcl, or if +you need to compile with a different compiler. With the addition of +the dynamic loading interface, it is no longer necessary to have the +source distribution in order to build and use extensions. + +3. Compiling Tk +---------------- + +In order to compile Tk for Windows, you need the following items: + + Tcl 8.0 Source Distribution (plus any patches) + Tk 8.0 Source Distribution (plus any patches) + + The latest Win32 SDK header files + + Borland C++ 4.5 or later (32-bit compiler) + or + Visual C++ 2.x or later + + +In the "win" subdirectory of the source release, you will find two +files called "makefile.bc" and "makefile.vc". These are the makefiles +for the Borland and Visual C++ compilers respectively. You should +copy the appropriate one to "makefile" and update the paths at the top +of the file to reflect your system configuration. Now you can use +"make" (or "nmake" for VC++) to build the tk libraries and the wish +executable. + +In order to use the binaries generated by these makefiles, you will +need to place the Tk script library files someplace where Tk can +find them. Tk looks in one of two places for the library files: + + 1) The environment variable "TK_LIBRARY". + + 2) In the lib\tk8.0 directory under the Tcl installation directory + as specified in the registry: + + For Windows NT & 95: + HKEY_LOCAL_MACHINE\SOFTWARE\Sun\Tcl\8.0 + Value Name is "Root" + + For Win32s: + HKEY_CLASSES_ROOT\SOFTWARE\Sun\Tcl\8.0\ + + 2) Relative to the directory containing the current .exe. + Tk will look for a directory "..\lib\tk8.0" relative to the + directory containing the currently running .exe. + +Note that in order to run wish80.exe, you must ensure that tcl80.dll, +tclpip80.dll (plus tcl1680.dll under Win32s), and tk80.dll are on your +path, in the system directory, or in the directory containing +wish80.exe. + +4. Test suite +------------- + +The Windows version of Tk does not pass many of the tests in the test +suite. This is primarily due to dependencies in the test suite on the +size of particular X fonts, and other X related features as well as +problems with "exec". We will be working to develop a more general +test suite for Tk under Windows, but for now, you will not be able to +pass many of the tests. + +5. Known Bugs +------------- + +Here is the current list of known bugs/missing features for the +Windows beta version of Tk: + +- There is no support for custom cursors/application icons. The core + set of X cursors is supported, although you cannot change their color. +- Stippling of arcs isn't implemented yet. +- Some "wm" functions don't map to Windows and aren't implemented; + others should map, but just aren't implemented. The worst offenders + are the icon manipulation routines. +- Under Win32s, you can only start one instance of Wish at a time. +- Color management on some displays doesn't work properly resulting in + Tk switching to monochrome mode. +- Tk seems to fail to draw anything on some Matrox Millenium cards. +- Send and winfo interps are not currently supported +- Printing does not work for images (e.g. GIF) on a canvas. +- Tk_dialog appears in the upper left corner. This is a symptom of a + larger problem with "wm geometry" when applied to unmapped or + iconified windows. +- Some keys don't work on international keyboards. +- Grabs do not affect native menus or the title bar. +- PPM images are using the wrong translation mode for writing to + files, resulting in CR/LF terminated PPM files. +- Tk crashes if the display depth changes while it is running. Tk + also doesn't consistently track changes in the system colors. + +If you have comments or bug reports for the Windows version of Tk, +please direct them to: + +Scott Stanton +scott.stanton@eng.sun.com + +or post them to the newsgroup comp.lang.tcl. diff --git a/win/makefile.bc b/win/makefile.bc new file mode 100644 index 0000000..a77c0ed --- /dev/null +++ b/win/makefile.bc @@ -0,0 +1,341 @@ +# Borland C++ 4.5 makefile for Tk +# +# Copyright (c) 1995-1996 by Sun Microsystems, Inc. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# +# SCCS: @(#) makefile.bc 1.73 97/11/05 16:12:27 + + +# +# Project directories +# +# ROOT = top of source tree +# TMPDIR = location where .obj files should be stored during build +# TCLDIR = location of top of Tcl source heirarchy +# + +ROOT = .. +TMPDIR = . +TOOLS = c:\bc45 +TCLDIR = ..\..\tcl8.0 + +# uncomment the following line to compile with symbols +#DEBUG=1 + +# uncomment the following line to compile with TCL_MEM_DEBUG +#DEBUGDEFINES =TCL_MEM_DEBUG + +# +# Borland C++ tools +# + +BORLAND = $(TOOLS) +IMPLIB = $(BORLAND)\bin\Implib +BCC32 = $(BORLAND)\bin\Bcc32 +TLINK32 = $(BORLAND)\bin\tlink32 +RC = $(BORLAND)\bin\brcc32 +CP = copy +RM = del + +INCLUDES = $(BORLAND)\include;$(ROOT)\generic;$(ROOT)\bitmaps;$(ROOT)\xlib;$(ROOT)\win;$(TCLDIR)\generic +LIBDIRS = $(BORLAND)\lib;$(ROOT)\win +TCLLIBDIR = $(TCLDIR)\win + + +!ifndef DEBUG + +# these macros cause maximum optimization and no symbols +DEBUGLDFLAGS = +DEBUGCCFLAGS = -v- -vi- -O2 + +!else + +# these macros enable debugging +DEBUGLDFLAGS = -v +DEBUGCCFLAGS = -k -Od -v + +!endif + +DEFINES = MT;_RTLDLL;STRICT;$(DEBUGDEFINES) +PROJECTCCFLAGS= $(DEBUGCCFLAGS) -w-par -w-stu + +LNFLAGS_exe = -Tpe -aa -c $(DEBUGLDFLAGS) $(BORLAND)\lib\c0w32 +LNFLAGS_dll = -Tpd -aa -c $(DEBUGLDFLAGS) $(BORLAND)\lib\c0d32 + +LNLIBS_exe = $(TKLIB) $(TCLLIBDIR)\$(TCLLIB) import32 cw32mti +LNLIBS_dll = $(TCLLIBDIR)\$(TCLLIB) import32 cw32mti + +# +# Global makefile settings +# + +.AUTODEPEND +.CACHEAUTODEPEND + +.suffixes: .c .dll .lib .obj .exe + +.path.c=$(ROOT)\win;$(ROOT)\generic;$(ROOT)\xlib;$(ROOT)\unix +.path.obj=$(TMPDIR) + +WISHOBJS = \ + $(TMPDIR)\tkConsole.obj \ + $(TMPDIR)\winMain.obj + +TKTESTOBJS = \ + $(TMPDIR)\tkConsole.obj \ + $(TMPDIR)\tkTest.obj \ + $(TMPDIR)\tkSquare.obj \ + $(TMPDIR)\testMain.obj + +XLIBOBJS = \ + $(TMPDIR)\xcolors.obj \ + $(TMPDIR)\xdraw.obj \ + $(TMPDIR)\xgc.obj \ + $(TMPDIR)\ximage.obj \ + $(TMPDIR)\xutil.obj + +TKOBJS = \ + $(TMPDIR)\tkUnixMenubu.obj \ + $(TMPDIR)\tkUnixScale.obj \ + $(XLIBOBJS) \ + $(TMPDIR)\tkWin3d.obj \ + $(TMPDIR)\tkWin32Dll.obj \ + $(TMPDIR)\tkWinButton.obj \ + $(TMPDIR)\tkWinClipboard.obj \ + $(TMPDIR)\tkWinColor.obj \ + $(TMPDIR)\tkWinCursor.obj \ + $(TMPDIR)\tkWinDialog.obj \ + $(TMPDIR)\tkWinDraw.obj \ + $(TMPDIR)\tkWinEmbed.obj \ + $(TMPDIR)\tkWinFont.obj \ + $(TMPDIR)\tkWinImage.obj \ + $(TMPDIR)\tkWinInit.obj \ + $(TMPDIR)\tkWinKey.obj \ + $(TMPDIR)\tkWinMenu.obj \ + $(TMPDIR)\tkWinPixmap.obj \ + $(TMPDIR)\tkWinPointer.obj \ + $(TMPDIR)\tkWinRegion.obj \ + $(TMPDIR)\tkWinScrlbr.obj \ + $(TMPDIR)\tkWinSend.obj \ + $(TMPDIR)\tkWinWindow.obj \ + $(TMPDIR)\tkWinWm.obj \ + $(TMPDIR)\tkWinX.obj \ + $(TMPDIR)\stubs.obj \ + $(TMPDIR)\tk3d.obj \ + $(TMPDIR)\tkArgv.obj \ + $(TMPDIR)\tkAtom.obj \ + $(TMPDIR)\tkBind.obj \ + $(TMPDIR)\tkBitmap.obj \ + $(TMPDIR)\tkButton.obj \ + $(TMPDIR)\tkCanvArc.obj \ + $(TMPDIR)\tkCanvBmap.obj \ + $(TMPDIR)\tkCanvImg.obj \ + $(TMPDIR)\tkCanvLine.obj \ + $(TMPDIR)\tkCanvPoly.obj \ + $(TMPDIR)\tkCanvPs.obj \ + $(TMPDIR)\tkCanvText.obj \ + $(TMPDIR)\tkCanvUtil.obj \ + $(TMPDIR)\tkCanvWind.obj \ + $(TMPDIR)\tkCanvas.obj \ + $(TMPDIR)\tkClipboard.obj \ + $(TMPDIR)\tkCmds.obj \ + $(TMPDIR)\tkColor.obj \ + $(TMPDIR)\tkConfig.obj \ + $(TMPDIR)\tkCursor.obj \ + $(TMPDIR)\tkEntry.obj \ + $(TMPDIR)\tkError.obj \ + $(TMPDIR)\tkEvent.obj \ + $(TMPDIR)\tkFileFilter.obj \ + $(TMPDIR)\tkFocus.obj \ + $(TMPDIR)\tkFont.obj \ + $(TMPDIR)\tkFrame.obj \ + $(TMPDIR)\tkGC.obj \ + $(TMPDIR)\tkGeometry.obj \ + $(TMPDIR)\tkGet.obj \ + $(TMPDIR)\tkGrab.obj \ + $(TMPDIR)\tkGrid.obj \ + $(TMPDIR)\tkImage.obj \ + $(TMPDIR)\tkImgBmap.obj \ + $(TMPDIR)\tkImgGIF.obj \ + $(TMPDIR)\tkImgPPM.obj \ + $(TMPDIR)\tkImgPhoto.obj \ + $(TMPDIR)\tkImgUtil.obj \ + $(TMPDIR)\tkListbox.obj \ + $(TMPDIR)\tkMacWinMenu.obj \ + $(TMPDIR)\tkMain.obj \ + $(TMPDIR)\tkMenu.obj \ + $(TMPDIR)\tkMenubutton.obj \ + $(TMPDIR)\tkMenuDraw.obj \ + $(TMPDIR)\tkMessage.obj \ + $(TMPDIR)\tkOption.obj \ + $(TMPDIR)\tkPack.obj \ + $(TMPDIR)\tkPlace.obj \ + $(TMPDIR)\tkPointer.obj \ + $(TMPDIR)\tkRectOval.obj \ + $(TMPDIR)\tkScale.obj \ + $(TMPDIR)\tkScrollbar.obj \ + $(TMPDIR)\tkSelect.obj \ + $(TMPDIR)\tkText.obj \ + $(TMPDIR)\tkTextBTree.obj \ + $(TMPDIR)\tkTextDisp.obj \ + $(TMPDIR)\tkTextImage.obj \ + $(TMPDIR)\tkTextIndex.obj \ + $(TMPDIR)\tkTextMark.obj \ + $(TMPDIR)\tkTextTag.obj \ + $(TMPDIR)\tkTextWind.obj \ + $(TMPDIR)\tkTrig.obj \ + $(TMPDIR)\tkUtil.obj \ + $(TMPDIR)\tkVisual.obj \ + $(TMPDIR)\tkWindow.obj + +TCLDLL = tcl80.dll +TCLLIB = tcl80.lib +TKDLL = tk80.dll +TKLIB = tk80.lib +WISH = wish80.exe +TKTEST = tktest.exe + +# +# Targets +# + +all: cfgdll $(TKDLL) cfgexe $(WISH) cfgcln +tktest: cfgdll $(TKDLL) cfgtest $(TKTEST) cfgcln + +test: tktest + $(TKTEST) &&| + cd ../tests + console show + update + source all +| + +# Implicit Targets + +.c.obj: + @$(BCC32) {$< } + +.dll.lib: + $(IMPLIB) -c $@ $< + +.rc.res: + $(RC) -i$(INCLUDES) $< + +# +# Special case object file targets +# + +$(TMPDIR)\testMain.obj : $(ROOT)\win\winMain.c + $(BCC32) -c -o$@ $(ROOT)\win\winMain.c + +# +# Configuration file targets - these files are implicitly used by the compiler +# + +cfgdll: + @$(CP) &&| + -n$(TMPDIR) -I$(INCLUDES) -c -WM + -D$(DEFINES) -3 -d $(PROJECTCCFLAGS) +| bcc32.cfg >NUL + +cfgexe: + @$(CP) &&| + -n$(TMPDIR) -I$(INCLUDES) -c -W + -D$(DEFINES) -3 -d $(PROJECTCCFLAGS) +| bcc32.cfg >NUL + +cfgtest: + @$(CP) &&| + -n$(TMPDIR) -I$(INCLUDES) -c -W + -D$(DEFINES);TK_TEST -3 -d $(PROJECTCCFLAGS) +| bcc32.cfg >NUL + +cfgcln: + @$(RM) bcc32.cfg + +# +# Executable targets +# + +$(TKDLL): $(TKOBJS) tk.def rc\tk.res + $(TLINK32) @&&| +$(LNFLAGS_dll) $(TKOBJS) +$@ +-x +$(LNLIBS_dll) +tk.def +rc\tk.res +| + +$(WISH): $(WISHOBJS) $(TKLIB) rc\wish.res + $(TLINK32) @&&| +$(LNFLAGS_exe) $(WISHOBJS) +$@ +-x +$(LNLIBS_exe) +|, &&| +EXETYPE WINDOWS +CODE PRELOAD MOVEABLE DISCARDABLE +DATA PRELOAD MOVEABLE MULTIPLE +|, rc\wish.res + +$(TKTEST): $(TKTESTOBJS) $(TKLIB) + $(TLINK32) $(LNFLAGS_exe) @&&| +$(TKTESTOBJS) +$@ +-x +$(LNLIBS_exe) +|, &&| +EXETYPE WINDOWS +CODE PRELOAD MOVEABLE DISCARDABLE +DATA PRELOAD MOVEABLE MULTIPLE +|, + +# +# Other dependencies +# + +rc\wish.res: rc\wish.ico +rc\tk.res: rc\tk.ico rc\*.cur + +# The following rule automatically generates a tk.def file containing +# an export entry for every public symbol in the $(TKDLL) library. + +tk.def: $(TKOBJS) + $(TCLLIBDIR)\dumpexts.exe -o $@ $(TKDLL) @&&| + $(TKOBJS) +| + +# rule to build library object files + +# debugging rules, the .dll and .exe files must be in the same +# directory as the object files for debugging purposes + +$(TMPDIR)\$(TKDLL): $(TKDLL) + $(CP) $(TKDLL) $(TMPDIR) + +$(TMPDIR)\$(TCLDLL): $(TCLLIBDIR)\$(TCLDLL) + $(CP) $(TCLLIBDIR)\$(TCLDLL) $(TMPDIR) + +$(TMPDIR)\$(WISH): $(WISH) + $(CP) $(WISH) $(TMPDIR) + +$(TMPDIR)\$(TKTEST): $(TKTEST) + $(CP) $(TKTEST) $(TMPDIR) + +debug: $(TMPDIR)\$(TKDLL) $(TMPDIR)\$(TCLDLL) $(TMPDIR)\$(TKTEST) + + +# remove all generated files + +clean: + $(RM) $(WISH) + $(RM) $(TKTEST) + $(RM) $(TKLIB) + $(RM) $(TKDLL) + $(RM) rc\*.res + $(RM) tk.def + $(RM) $(TMPDIR)\*.obj + $(RM) *.cfg diff --git a/win/makefile.vc b/win/makefile.vc new file mode 100644 index 0000000..7312db0 --- /dev/null +++ b/win/makefile.vc @@ -0,0 +1,397 @@ +# Visual C++ 2.x and 4.0 makefile +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# +# Copyright (c) 1995-1996 Sun Microsystems, Inc. +# SCCS: @(#) makefile.vc 1.64 97/10/27 17:27:20 + +# Does not depend on the presence of any environment variables in +# order to compile tcl; all needed information is derived from +# location of the compiler directories. + +# +# Project directories +# +# ROOT = top of source tree +# +# TMPDIR = location where .obj files should be stored during build +# +# TOOLS32 = location of VC++ 32-bit development tools. Note that the +# VC++ 2.0 header files are broken, so you need to use the +# ones that come with the developer network CD's, or later +# versions of VC++. +# +# TCLDIR = location of top of Tcl source heirarchy +# + +ROOT = .. +TMPDIR = . +TOOLS32 = c:\msdev +TCLDIR = ..\..\tcl8.0 + +# Set this to the appropriate value of /MACHINE: for your platform +MACHINE = IX86 + +# Comment the following line to compile with symbols +NODEBUG=1 + +# uncomment the following two lines to compile with TCL_MEM_DEBUG +#DEBUGDEFINES =-DTCL_MEM_DEBUG + +###################################################################### +# Do not modify below this line +###################################################################### + +VERSION = 80 + +TCLDLL = tcl$(VERSION).dll +TCLLIB = tcl$(VERSION).lib +TCLPLUGINDLL = tcl$(VERSION)p.dll +TCLPLUGINLIB = tcl$(VERSION)p.lib +TKDLL = tk$(VERSION).dll +TKLIB = tk$(VERSION).lib +TKPLUGINDLL = tk$(VERSION)p.dll +TKPLUGINLIB = tk$(VERSION)p.lib + +WISH = wish$(VERSION).exe +WISHP = wishp$(VERSION).exe +TKTEST = tktest.exe +DUMPEXTS = $(TMPDIR)\dumpexts.exe + +WISHOBJS = \ + $(TMPDIR)\tkConsole.obj \ + $(TMPDIR)\winMain.obj + +TKTESTOBJS = \ + $(TMPDIR)\tkConsole.obj \ + $(TMPDIR)\tkTest.obj \ + $(TMPDIR)\tkSquare.obj \ + $(TMPDIR)\testMain.obj + +XLIBOBJS = \ + $(TMPDIR)\xcolors.obj \ + $(TMPDIR)\xdraw.obj \ + $(TMPDIR)\xgc.obj \ + $(TMPDIR)\ximage.obj \ + $(TMPDIR)\xutil.obj + +TKOBJS = \ + $(TMPDIR)\tkUnixMenubu.obj \ + $(TMPDIR)\tkUnixScale.obj \ + $(XLIBOBJS) \ + $(TMPDIR)\tkWin3d.obj \ + $(TMPDIR)\tkWin32Dll.obj \ + $(TMPDIR)\tkWinButton.obj \ + $(TMPDIR)\tkWinClipboard.obj \ + $(TMPDIR)\tkWinColor.obj \ + $(TMPDIR)\tkWinCursor.obj \ + $(TMPDIR)\tkWinDialog.obj \ + $(TMPDIR)\tkWinDraw.obj \ + $(TMPDIR)\tkWinEmbed.obj \ + $(TMPDIR)\tkWinFont.obj \ + $(TMPDIR)\tkWinImage.obj \ + $(TMPDIR)\tkWinInit.obj \ + $(TMPDIR)\tkWinKey.obj \ + $(TMPDIR)\tkWinMenu.obj \ + $(TMPDIR)\tkWinPixmap.obj \ + $(TMPDIR)\tkWinPointer.obj \ + $(TMPDIR)\tkWinRegion.obj \ + $(TMPDIR)\tkWinScrlbr.obj \ + $(TMPDIR)\tkWinSend.obj \ + $(TMPDIR)\tkWinWindow.obj \ + $(TMPDIR)\tkWinWm.obj \ + $(TMPDIR)\tkWinX.obj \ + $(TMPDIR)\stubs.obj \ + $(TMPDIR)\tk3d.obj \ + $(TMPDIR)\tkArgv.obj \ + $(TMPDIR)\tkAtom.obj \ + $(TMPDIR)\tkBind.obj \ + $(TMPDIR)\tkBitmap.obj \ + $(TMPDIR)\tkButton.obj \ + $(TMPDIR)\tkCanvArc.obj \ + $(TMPDIR)\tkCanvBmap.obj \ + $(TMPDIR)\tkCanvImg.obj \ + $(TMPDIR)\tkCanvLine.obj \ + $(TMPDIR)\tkCanvPoly.obj \ + $(TMPDIR)\tkCanvPs.obj \ + $(TMPDIR)\tkCanvText.obj \ + $(TMPDIR)\tkCanvUtil.obj \ + $(TMPDIR)\tkCanvWind.obj \ + $(TMPDIR)\tkCanvas.obj \ + $(TMPDIR)\tkClipboard.obj \ + $(TMPDIR)\tkCmds.obj \ + $(TMPDIR)\tkColor.obj \ + $(TMPDIR)\tkConfig.obj \ + $(TMPDIR)\tkCursor.obj \ + $(TMPDIR)\tkEntry.obj \ + $(TMPDIR)\tkError.obj \ + $(TMPDIR)\tkEvent.obj \ + $(TMPDIR)\tkFileFilter.obj \ + $(TMPDIR)\tkFocus.obj \ + $(TMPDIR)\tkFont.obj \ + $(TMPDIR)\tkFrame.obj \ + $(TMPDIR)\tkGC.obj \ + $(TMPDIR)\tkGeometry.obj \ + $(TMPDIR)\tkGet.obj \ + $(TMPDIR)\tkGrab.obj \ + $(TMPDIR)\tkGrid.obj \ + $(TMPDIR)\tkImage.obj \ + $(TMPDIR)\tkImgBmap.obj \ + $(TMPDIR)\tkImgGIF.obj \ + $(TMPDIR)\tkImgPPM.obj \ + $(TMPDIR)\tkImgPhoto.obj \ + $(TMPDIR)\tkImgUtil.obj \ + $(TMPDIR)\tkListbox.obj \ + $(TMPDIR)\tkMacWinMenu.obj \ + $(TMPDIR)\tkMain.obj \ + $(TMPDIR)\tkMenu.obj \ + $(TMPDIR)\tkMenubutton.obj \ + $(TMPDIR)\tkMenuDraw.obj \ + $(TMPDIR)\tkMessage.obj \ + $(TMPDIR)\tkOption.obj \ + $(TMPDIR)\tkPack.obj \ + $(TMPDIR)\tkPlace.obj \ + $(TMPDIR)\tkPointer.obj \ + $(TMPDIR)\tkRectOval.obj \ + $(TMPDIR)\tkScale.obj \ + $(TMPDIR)\tkScrollbar.obj \ + $(TMPDIR)\tkSelect.obj \ + $(TMPDIR)\tkText.obj \ + $(TMPDIR)\tkTextBTree.obj \ + $(TMPDIR)\tkTextDisp.obj \ + $(TMPDIR)\tkTextImage.obj \ + $(TMPDIR)\tkTextIndex.obj \ + $(TMPDIR)\tkTextMark.obj \ + $(TMPDIR)\tkTextTag.obj \ + $(TMPDIR)\tkTextWind.obj \ + $(TMPDIR)\tkTrig.obj \ + $(TMPDIR)\tkUtil.obj \ + $(TMPDIR)\tkVisual.obj \ + $(TMPDIR)\tkWindow.obj + +cc32 = $(TOOLS32)\bin\cl.exe +link32 = $(TOOLS32)\bin\link.exe +rc32 = $(TOOLS32)\bin\rc.exe +include32 = -I$(TOOLS32)\include + +WINDIR = $(ROOT)\win +GENERICDIR = $(ROOT)\generic +XLIBDIR = $(ROOT)\xlib +BITMAPDIR = $(ROOT)\bitmaps +TCLLIBDIR = $(TCLDIR)\win +RCDIR = $(WINDIR)\rc + +TK_INCLUDES = -I$(WINDIR) -I$(GENERICDIR) -I$(BITMAPDIR) -I$(XLIBDIR) \ + -I$(TCLDIR)\generic +TK_DEFINES = $(DEBUGDEFINES) + +TK_CFLAGS = $(cdebug) $(cflags) $(cvarsdll) $(include32) \ + $(TK_INCLUDES) $(TK_DEFINES) + +###################################################################### +# Link flags +###################################################################### + +!IFDEF NODEBUG +ldebug = /RELEASE +!ELSE +ldebug = -debug:full -debugtype:cv +!ENDIF + +# declarations common to all linker options +lcommon = /NODEFAULTLIB /RELEASE /NOLOGO + +# declarations for use on Intel i386, i486, and Pentium systems +!IF "$(MACHINE)" == "IX86" +DLLENTRY = @12 +lflags = $(lcommon) -align:0x1000 /MACHINE:$(MACHINE) +!ELSE +lflags = $(lcommon) /MACHINE:$(MACHINE) +!ENDIF + +conlflags = $(lflags) -subsystem:console -entry:mainCRTStartup +guilflags = $(lflags) -subsystem:windows -entry:WinMainCRTStartup +dlllflags = $(lflags) -entry:_DllMainCRTStartup$(DLLENTRY) -dll + +!IF "$(MACHINE)" == "PPC" +libc = libc.lib +libcdll = crtdll.lib +!ELSE +libc = libc.lib oldnames.lib +libcdll = msvcrt.lib oldnames.lib +!ENDIF + +baselibs = kernel32.lib $(optlibs) advapi32.lib +winlibs = $(baselibs) user32.lib gdi32.lib comdlg32.lib winspool.lib +guilibs = $(libc) $(winlibs) + +guilibsdll = $(libcdll) $(winlibs) + +###################################################################### +# Compile flags +###################################################################### + +!IFDEF NODEBUG +cdebug = -Oti -Gs -GD +!ELSE +cdebug = -Z7 -Od -WX +!ENDIF + +# declarations common to all compiler options +ccommon = -c -W3 -nologo -YX + +!IF "$(MACHINE)" == "IX86" +cflags = $(ccommon) -D_X86_=1 +!ELSE +!IF "$(MACHINE)" == "MIPS" +cflags = $(ccommon) -D_MIPS_=1 +!ELSE +!IF "$(MACHINE)" == "PPC" +cflags = $(ccommon) -D_PPC_=1 +!ELSE +!IF "$(MACHINE)" == "ALPHA" +cflags = $(ccommon) -D_ALPHA_=1 +!ENDIF +!ENDIF +!ENDIF +!ENDIF + +cvars = -DWIN32 -D_WIN32 +cvarsmt = $(cvars) -D_MT +cvarsdll = $(cvarsmt) -D_DLL + +CON_CFLAGS = $(cdebug) $(cflags) $(cvars) $(include32) -DCONSOLE + +###################################################################### +# Project specific targets +###################################################################### + +all: $(WISH) +test: $(TKTEST) +plugin: $(TKPLUGINDLL) $(WISHP) + +$(TKLIB): $(TKDLL) + +$(TKDLL): $(TKOBJS) $(TMPDIR)\tk.res $(TMPDIR)\tk.def + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(dlllflags) -def:$(TMPDIR)\tk.def \ + -out:$@ $(TMPDIR)\tk.res $(TCLLIBDIR)\$(TCLLIB) \ + $(guilibsdll) @<< + $(TKOBJS) +<< + +$(TKPLUGINLIB): $(TKPLUGINDLL) + +$(TKPLUGINDLL): $(TKOBJS) $(TMPDIR)\tk.res $(TMPDIR)\plugin.def + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(dlllflags) -def:$(TMPDIR)\plugin.def \ + -out:$@ $(TMPDIR)\tk.res $(TCLLIBDIR)\$(TCLPLUGINLIB) \ + $(guilibsdll) @<< + $(TKOBJS) +<< + +$(WISH): $(WISHOBJS) $(TKLIB) $(TMPDIR)\wish.res + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(guilflags) $(TMPDIR)\wish.res -out:$@ \ + $(guilibsdll) $(TCLLIBDIR)\$(TCLLIB) $(TKLIB) $(WISHOBJS) + +$(WISHP): $(WISHOBJS) $(TKPLUGINLIB) $(TMPDIR)\wish.res + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(guilflags) $(TMPDIR)\wish.res -out:$@ \ + $(guilibsdll) $(TCLLIBDIR)\$(TCLPLUGINLIB) \ + $(TKPLUGINLIB) $(WISHOBJS) + +$(TKTEST): $(TKTESTOBJS) $(TKLIB) $(TMPDIR)\wish.res + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(guilflags) $(TMPDIR)\wish.res -out:$@ \ + $(guilibsdll) $(TCLLIBDIR)\$(TCLLIB) $(TKLIB) $(TKTESTOBJS) + +$(TMPDIR)\tk.def: $(DUMPEXTS) $(TKOBJS) + $(DUMPEXTS) -o $@ $(TKDLL) @<< + $(TKOBJS) +<< + +$(TMPDIR)\plugin.def: $(DUMPEXTS) $(TKOBJS) + $(DUMPEXTS) -o $@ $(TKPLUGINDLL) @<< + $(TKOBJS) +<< + +$(DUMPEXTS): $(TCLDIR)\win\winDumpExts.c + $(cc32) $(CON_CFLAGS) -Fo$(TMPDIR)\ $? + set LIB=$(TOOLS32)\lib + $(link32) $(ldebug) $(conlflags) $(guilibs) -out:$@ \ + $(TMPDIR)\winDumpExts.obj + +# +# Special case object file targets +# + +$(TMPDIR)\testMain.obj: $(ROOT)\win\winMain.c + $(cc32) $(TK_CFLAGS) -DTK_TEST -Fo$@ $? + +# +# Implicit rules +# + +{$(XLIBDIR)}.c{$(TMPDIR)}.obj: + $(cc32) $(TK_CFLAGS) -Fo$(TMPDIR)\ $< + +{$(GENERICDIR)}.c{$(TMPDIR)}.obj: + $(cc32) $(TK_CFLAGS) -Fo$(TMPDIR)\ $< + +{$(WINDIR)}.c{$(TMPDIR)}.obj: + $(cc32) $(TK_CFLAGS) -Fo$(TMPDIR)\ $< + +{$(ROOT)\unix}.c{$(TMPDIR)}.obj: + $(cc32) $(TK_CFLAGS) -Fo$(TMPDIR)\ $< + +{$(RCDIR)}.rc{$(TMPDIR)}.res: + $(rc32) -fo $@ -r -i $(GENERICDIR) $< + +clean: + -@del *.exp + -@del *.lib + -@del *.dll + -@del *.exe + -@del $(TMPDIR)\*.obj + -@del $(TMPDIR)\*.res + -@del $(TMPDIR)\*.def + +# dependencies + +$(TMPDIR)\tk.res: \ + $(RCDIR)\buttons.bmp \ + $(RCDIR)\cursor*.cur \ + $(RCDIR)\tk.ico + +$(GENERICDIR)/default.h: $(WINDIR)/tkWinDefault.h +$(GENERICDIR)/tkButton.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkCanvas.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkEntry.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkFrame.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkListbox.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkMenu.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkMenubutton.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkMessage.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkScale.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkScrollbar.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkText.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkTextIndex.c: $(GENERICDIR)/default.h +$(GENERICDIR)/tkTextTag.c: $(GENERICDIR)/default.h + +$(GENERICDIR)/tkText.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextBTree.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextDisp.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextDisp.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextImage.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextIndex.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextMark.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextTag.c: $(GENERICDIR)/tkText.h +$(GENERICDIR)/tkTextWind.c: $(GENERICDIR)/tkText.h + +$(GENERICDIR)/tkMacWinMenu.c: $(GENERICDIR)/tkMenu.h +$(GENERICDIR)/tkMenu.c: $(GENERICDIR)/tkMenu.h +$(GENERICDIR)/tkMenuDraw.c: $(GENERICDIR)/tkMenu.h +$(WINDIR)/tkWinMenu.c: $(GENERICDIR)/tkMenu.h + diff --git a/win/rc/buttons.bmp b/win/rc/buttons.bmp new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/buttons.bmp diff --git a/win/rc/cursor00.cur b/win/rc/cursor00.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor00.cur diff --git a/win/rc/cursor02.cur b/win/rc/cursor02.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor02.cur diff --git a/win/rc/cursor04.cur b/win/rc/cursor04.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor04.cur diff --git a/win/rc/cursor06.cur b/win/rc/cursor06.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor06.cur diff --git a/win/rc/cursor08.cur b/win/rc/cursor08.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor08.cur diff --git a/win/rc/cursor0a.cur b/win/rc/cursor0a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor0a.cur diff --git a/win/rc/cursor0c.cur b/win/rc/cursor0c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor0c.cur diff --git a/win/rc/cursor0e.cur b/win/rc/cursor0e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor0e.cur diff --git a/win/rc/cursor10.cur b/win/rc/cursor10.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor10.cur diff --git a/win/rc/cursor12.cur b/win/rc/cursor12.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor12.cur diff --git a/win/rc/cursor14.cur b/win/rc/cursor14.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor14.cur diff --git a/win/rc/cursor16.cur b/win/rc/cursor16.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor16.cur diff --git a/win/rc/cursor18.cur b/win/rc/cursor18.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor18.cur diff --git a/win/rc/cursor1a.cur b/win/rc/cursor1a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor1a.cur diff --git a/win/rc/cursor1c.cur b/win/rc/cursor1c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor1c.cur diff --git a/win/rc/cursor1e.cur b/win/rc/cursor1e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor1e.cur diff --git a/win/rc/cursor20.cur b/win/rc/cursor20.cur new file mode 100644 index 0000000..95c4dc1 --- /dev/null +++ b/win/rc/cursor20.cur @@ -0,0 +1,2 @@ + 0( @ÿÿÿB„¢ŠR”*¨Ð + ü~ü~ diff --git a/win/rc/cursor22.cur b/win/rc/cursor22.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor22.cur diff --git a/win/rc/cursor24.cur b/win/rc/cursor24.cur new file mode 100644 index 0000000..c971b66 --- /dev/null +++ b/win/rc/cursor24.cur @@ -0,0 +1,2 @@ + 0( @ÿÿÿ€À + "ˆB„þþþþB„"ˆ diff --git a/win/rc/cursor26.cur b/win/rc/cursor26.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor26.cur diff --git a/win/rc/cursor28.cur b/win/rc/cursor28.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor28.cur diff --git a/win/rc/cursor2a.cur b/win/rc/cursor2a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor2a.cur diff --git a/win/rc/cursor2c.cur b/win/rc/cursor2c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor2c.cur diff --git a/win/rc/cursor2e.cur b/win/rc/cursor2e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor2e.cur diff --git a/win/rc/cursor30.cur b/win/rc/cursor30.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor30.cur diff --git a/win/rc/cursor32.cur b/win/rc/cursor32.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor32.cur diff --git a/win/rc/cursor34.cur b/win/rc/cursor34.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor34.cur diff --git a/win/rc/cursor36.cur b/win/rc/cursor36.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor36.cur diff --git a/win/rc/cursor38.cur b/win/rc/cursor38.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor38.cur diff --git a/win/rc/cursor3a.cur b/win/rc/cursor3a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor3a.cur diff --git a/win/rc/cursor3c.cur b/win/rc/cursor3c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor3c.cur diff --git a/win/rc/cursor3e.cur b/win/rc/cursor3e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor3e.cur diff --git a/win/rc/cursor40.cur b/win/rc/cursor40.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor40.cur diff --git a/win/rc/cursor42.cur b/win/rc/cursor42.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor42.cur diff --git a/win/rc/cursor44.cur b/win/rc/cursor44.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor44.cur diff --git a/win/rc/cursor46.cur b/win/rc/cursor46.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor46.cur diff --git a/win/rc/cursor48.cur b/win/rc/cursor48.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor48.cur diff --git a/win/rc/cursor4a.cur b/win/rc/cursor4a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor4a.cur diff --git a/win/rc/cursor4c.cur b/win/rc/cursor4c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor4c.cur diff --git a/win/rc/cursor4e.cur b/win/rc/cursor4e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor4e.cur diff --git a/win/rc/cursor50.cur b/win/rc/cursor50.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor50.cur diff --git a/win/rc/cursor52.cur b/win/rc/cursor52.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor52.cur diff --git a/win/rc/cursor54.cur b/win/rc/cursor54.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor54.cur diff --git a/win/rc/cursor56.cur b/win/rc/cursor56.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor56.cur diff --git a/win/rc/cursor58.cur b/win/rc/cursor58.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor58.cur diff --git a/win/rc/cursor5a.cur b/win/rc/cursor5a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor5a.cur diff --git a/win/rc/cursor5c.cur b/win/rc/cursor5c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor5c.cur diff --git a/win/rc/cursor5e.cur b/win/rc/cursor5e.cur new file mode 100644 index 0000000..9141887 --- /dev/null +++ b/win/rc/cursor5e.cur @@ -0,0 +1 @@ + diff --git a/win/rc/cursor60.cur b/win/rc/cursor60.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor60.cur diff --git a/win/rc/cursor62.cur b/win/rc/cursor62.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor62.cur diff --git a/win/rc/cursor64.cur b/win/rc/cursor64.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor64.cur diff --git a/win/rc/cursor66.cur b/win/rc/cursor66.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor66.cur diff --git a/win/rc/cursor68.cur b/win/rc/cursor68.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor68.cur diff --git a/win/rc/cursor6a.cur b/win/rc/cursor6a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor6a.cur diff --git a/win/rc/cursor6c.cur b/win/rc/cursor6c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor6c.cur diff --git a/win/rc/cursor6e.cur b/win/rc/cursor6e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor6e.cur diff --git a/win/rc/cursor70.cur b/win/rc/cursor70.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor70.cur diff --git a/win/rc/cursor72.cur b/win/rc/cursor72.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor72.cur diff --git a/win/rc/cursor74.cur b/win/rc/cursor74.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor74.cur diff --git a/win/rc/cursor76.cur b/win/rc/cursor76.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor76.cur diff --git a/win/rc/cursor78.cur b/win/rc/cursor78.cur new file mode 100644 index 0000000..53ab3d0 --- /dev/null +++ b/win/rc/cursor78.cur @@ -0,0 +1 @@ + 0( @ÿÿÿþ diff --git a/win/rc/cursor7a.cur b/win/rc/cursor7a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor7a.cur diff --git a/win/rc/cursor7c.cur b/win/rc/cursor7c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor7c.cur diff --git a/win/rc/cursor7e.cur b/win/rc/cursor7e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor7e.cur diff --git a/win/rc/cursor80.cur b/win/rc/cursor80.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor80.cur diff --git a/win/rc/cursor82.cur b/win/rc/cursor82.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor82.cur diff --git a/win/rc/cursor84.cur b/win/rc/cursor84.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor84.cur diff --git a/win/rc/cursor86.cur b/win/rc/cursor86.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor86.cur diff --git a/win/rc/cursor88.cur b/win/rc/cursor88.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor88.cur diff --git a/win/rc/cursor8a.cur b/win/rc/cursor8a.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor8a.cur diff --git a/win/rc/cursor8c.cur b/win/rc/cursor8c.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor8c.cur diff --git a/win/rc/cursor8e.cur b/win/rc/cursor8e.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor8e.cur diff --git a/win/rc/cursor90.cur b/win/rc/cursor90.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor90.cur diff --git a/win/rc/cursor92.cur b/win/rc/cursor92.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor92.cur diff --git a/win/rc/cursor94.cur b/win/rc/cursor94.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor94.cur diff --git a/win/rc/cursor96.cur b/win/rc/cursor96.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor96.cur diff --git a/win/rc/cursor98.cur b/win/rc/cursor98.cur new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/cursor98.cur diff --git a/win/rc/tk.ico b/win/rc/tk.ico new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/tk.ico diff --git a/win/rc/tk.rc b/win/rc/tk.rc new file mode 100644 index 0000000..0d74ec3 --- /dev/null +++ b/win/rc/tk.rc @@ -0,0 +1,132 @@ +// SCCS: @(#) tk.rc 1.22 97/03/21 18:35:14 +// +// Version +// + +#define RESOURCE_INCLUDED +#include <tk.h> + +#define STRINGIFY1(x) #x +#define STRINGIFY(x) STRINGIFY1(x) + +VS_VERSION_INFO VERSIONINFO + FILEVERSION TK_MAJOR_VERSION,TK_MINOR_VERSION,TK_RELEASE_LEVEL,TK_RELEASE_SERIAL + PRODUCTVERSION TK_MAJOR_VERSION,TK_MINOR_VERSION,TK_RELEASE_LEVEL,TK_RELEASE_SERIAL + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "FileDescription", "Tk DLL\0" + VALUE "OriginalFilename", "tk" STRINGIFY(TK_MAJOR_VERSION) STRINGIFY(TK_MINOR_VERSION) ".dll\0" + VALUE "CompanyName", "Sun Microsystems, Inc.\0" + VALUE "FileVersion", TK_PATCH_LEVEL + VALUE "LegalCopyright", "Copyright \251 1995-1996\0" + VALUE "ProductName", "Tk " TK_VERSION " for Windows\0" + VALUE "ProductVersion", TK_PATCH_LEVEL + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +// +// Icons +// + +tk ICON DISCARDABLE "tk.ico" + +// +// Bitmaps +// + +buttons BITMAP DISCARDABLE "buttons.bmp" + +// +// Cursors +// + +X_cursor CURSOR DISCARDABLE "cursor00.cur" +arrow CURSOR DISCARDABLE "cursor02.cur" +based_arrow_down CURSOR DISCARDABLE "cursor04.cur" +based_arrow_up CURSOR DISCARDABLE "cursor06.cur" +boat CURSOR DISCARDABLE "cursor08.cur" +bogosity CURSOR DISCARDABLE "cursor0a.cur" +bottom_left_corner CURSOR DISCARDABLE "cursor0c.cur" +bottom_right_corner CURSOR DISCARDABLE "cursor0e.cur" +bottom_side CURSOR DISCARDABLE "cursor10.cur" +bottom_tee CURSOR DISCARDABLE "cursor12.cur" +box_spiral CURSOR DISCARDABLE "cursor14.cur" +center_ptr CURSOR DISCARDABLE "cursor16.cur" +circle CURSOR DISCARDABLE "cursor18.cur" +clock CURSOR DISCARDABLE "cursor1a.cur" +coffee_mug CURSOR DISCARDABLE "cursor1c.cur" +cross CURSOR DISCARDABLE "cursor1e.cur" +cross_reverse CURSOR DISCARDABLE "cursor20.cur" +crosshair CURSOR DISCARDABLE "cursor22.cur" +diamond_cross CURSOR DISCARDABLE "cursor24.cur" +dot CURSOR DISCARDABLE "cursor26.cur" +dotbox CURSOR DISCARDABLE "cursor28.cur" +double_arrow CURSOR DISCARDABLE "cursor2a.cur" +draft_large CURSOR DISCARDABLE "cursor2c.cur" +draft_small CURSOR DISCARDABLE "cursor2e.cur" +draped_box CURSOR DISCARDABLE "cursor30.cur" +exchange CURSOR DISCARDABLE "cursor32.cur" +fleur CURSOR DISCARDABLE "cursor34.cur" +gobbler CURSOR DISCARDABLE "cursor36.cur" +gumby CURSOR DISCARDABLE "cursor38.cur" +hand1 CURSOR DISCARDABLE "cursor3a.cur" +hand2 CURSOR DISCARDABLE "cursor3c.cur" +heart CURSOR DISCARDABLE "cursor3e.cur" +icon CURSOR DISCARDABLE "cursor40.cur" +iron_cross CURSOR DISCARDABLE "cursor42.cur" +left_ptr CURSOR DISCARDABLE "cursor44.cur" +left_side CURSOR DISCARDABLE "cursor46.cur" +left_tee CURSOR DISCARDABLE "cursor48.cur" +leftbutton CURSOR DISCARDABLE "cursor4a.cur" +ll_angle CURSOR DISCARDABLE "cursor4c.cur" +lr_angle CURSOR DISCARDABLE "cursor4e.cur" +man CURSOR DISCARDABLE "cursor50.cur" +middlebutton CURSOR DISCARDABLE "cursor52.cur" +mouse CURSOR DISCARDABLE "cursor54.cur" +pencil CURSOR DISCARDABLE "cursor56.cur" +pirate CURSOR DISCARDABLE "cursor58.cur" +plus CURSOR DISCARDABLE "cursor5a.cur" +question_arrow CURSOR DISCARDABLE "cursor5c.cur" +right_ptr CURSOR DISCARDABLE "cursor5e.cur" +right_side CURSOR DISCARDABLE "cursor60.cur" +right_tee CURSOR DISCARDABLE "cursor62.cur" +rightbutton CURSOR DISCARDABLE "cursor64.cur" +rtl_logo CURSOR DISCARDABLE "cursor66.cur" +sailboat CURSOR DISCARDABLE "cursor68.cur" +sb_down_arrow CURSOR DISCARDABLE "cursor6a.cur" +sb_h_double_arrow CURSOR DISCARDABLE "cursor6c.cur" +sb_left_arrow CURSOR DISCARDABLE "cursor6e.cur" +sb_right_arrow CURSOR DISCARDABLE "cursor70.cur" +sb_up_arrow CURSOR DISCARDABLE "cursor72.cur" +sb_v_double_arrow CURSOR DISCARDABLE "cursor74.cur" +shuttle CURSOR DISCARDABLE "cursor76.cur" +sizing CURSOR DISCARDABLE "cursor78.cur" +spider CURSOR DISCARDABLE "cursor7a.cur" +spraycan CURSOR DISCARDABLE "cursor7c.cur" +star CURSOR DISCARDABLE "cursor7e.cur" +target CURSOR DISCARDABLE "cursor80.cur" +tcross CURSOR DISCARDABLE "cursor82.cur" +top_left_arrow CURSOR DISCARDABLE "cursor84.cur" +top_left_corner CURSOR DISCARDABLE "cursor86.cur" +top_right_corner CURSOR DISCARDABLE "cursor88.cur" +top_side CURSOR DISCARDABLE "cursor8a.cur" +top_tee CURSOR DISCARDABLE "cursor8c.cur" +trek CURSOR DISCARDABLE "cursor8e.cur" +ul_angle CURSOR DISCARDABLE "cursor90.cur" +umbrella CURSOR DISCARDABLE "cursor92.cur" +ur_angle CURSOR DISCARDABLE "cursor94.cur" +watch CURSOR DISCARDABLE "cursor96.cur" +xterm CURSOR DISCARDABLE "cursor98.cur" diff --git a/win/rc/wish.ico b/win/rc/wish.ico new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/win/rc/wish.ico diff --git a/win/rc/wish.rc b/win/rc/wish.rc new file mode 100644 index 0000000..76cf124 --- /dev/null +++ b/win/rc/wish.rc @@ -0,0 +1,44 @@ +// SCCS: @(#) wish.rc 1.15 96/09/17 13:24:11 +// +// Version +// + +#define RESOURCE_INCLUDED +#include <tk.h> + +#define STRINGIFY1(x) #x +#define STRINGIFY(x) STRINGIFY1(x) + +VS_VERSION_INFO VERSIONINFO + FILEVERSION TK_MAJOR_VERSION,TK_MINOR_VERSION,TK_RELEASE_LEVEL,TK_RELEASE_SERIAL + PRODUCTVERSION TK_MAJOR_VERSION,TK_MINOR_VERSION,TK_RELEASE_LEVEL,TK_RELEASE_SERIAL + FILEFLAGSMASK 0x3fL + FILEFLAGS 0x0L + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "FileDescription", "Wish Application\0" + VALUE "OriginalFilename", "wish" STRINGIFY(TK_MAJOR_VERSION) STRINGIFY(TK_MINOR_VERSION) ".exe\0" + VALUE "CompanyName", "Sun Microsystems, Inc.\0" + VALUE "FileVersion", TK_PATCH_LEVEL + VALUE "LegalCopyright", "Copyright \251 1995-1996\0" + VALUE "ProductName", "Tk " TK_VERSION " for Windows\0" + VALUE "ProductVersion", TK_PATCH_LEVEL + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +// +// Icon +// + +wish ICON DISCARDABLE "wish.ico" diff --git a/win/stubs.c b/win/stubs.c new file mode 100644 index 0000000..c9b97f5 --- /dev/null +++ b/win/stubs.c @@ -0,0 +1,397 @@ +#include <X11/X.h> +#include <X11/Xlib.h> +#include <stdio.h> +#include <tkInt.h> +#include <tkPort.h> + +/* + * Undocumented Xlib internal function + */ + +_XInitImageFuncPtrs(XImage *image) +{ + return 0; +} + +/* + * From Xutil.h + */ + +void +XSetWMClientMachine(display, w, text_prop) + Display* display; + Window w; + XTextProperty* text_prop; +{ +} + +Status +XStringListToTextProperty(list, count, text_prop_return) + char** list; + int count; + XTextProperty* text_prop_return; +{ + return (Status) NULL; +} + +/* + * From Xlib.h + */ + +void +XChangeProperty(display, w, property, type, format, mode, data, nelements) + Display* display; + Window w; + Atom property; + Atom type; + int format; + int mode; + _Xconst unsigned char* data; + int nelements; +{ +} + +Cursor +XCreateGlyphCursor(display, source_font, mask_font, source_char, mask_char, + foreground_color, background_color) + Display* display; + Font source_font; + Font mask_font; + unsigned int source_char; + unsigned int mask_char; + XColor* foreground_color; + XColor* background_color; +{ + return 1; +} + +XIC +XCreateIC() +{ + return NULL; +} + +Cursor +XCreatePixmapCursor(display, source, mask, foreground_color, + background_color, x, y) + Display* display; + Pixmap source; + Pixmap mask; + XColor* foreground_color; + XColor* background_color; + unsigned int x; + unsigned int y; +{ + return (Cursor) NULL; +} + +void +XDeleteProperty(display, w, property) + Display* display; + Window w; + Atom property; +{ +} + +void +XDestroyIC(ic) + XIC ic; +{ +} + +Bool +XFilterEvent(event, window) + XEvent* event; + Window window; +{ + return 0; +} + +extern void XForceScreenSaver(display, mode) + Display* display; + int mode; +{ +} + +void +XFreeCursor(display, cursor) + Display* display; + Cursor cursor; +{ +} + +GContext +XGContextFromGC(gc) + GC gc; +{ + return (GContext) NULL; +} + +char * +XGetAtomName(display, atom) + Display* display; + Atom atom; +{ + return NULL; +} + +int +XGetWindowAttributes(display, w, window_attributes_return) + Display* display; + Window w; + XWindowAttributes* window_attributes_return; +{ + return 0; +} + +Status +XGetWMColormapWindows(display, w, windows_return, count_return) + Display* display; + Window w; + Window** windows_return; + int* count_return; +{ + return (Status) NULL; +} + +int +XIconifyWindow(display, w, screen_number) + Display* display; + Window w; + int screen_number; +{ + return 0; +} + +XHostAddress * +XListHosts(display, nhosts_return, state_return) + Display* display; + int* nhosts_return; + Bool* state_return; +{ + return NULL; +} + +int +XLookupColor(display, colormap, color_name, exact_def_return, + screen_def_return) + Display* display; + Colormap colormap; + _Xconst char* color_name; + XColor* exact_def_return; + XColor* screen_def_return; +{ + return 0; +} + +void +XNextEvent(display, event_return) + Display* display; + XEvent* event_return; +{ +} + +void +XPutBackEvent(display, event) + Display* display; + XEvent* event; +{ +} + +void +XQueryColors(display, colormap, defs_in_out, ncolors) + Display* display; + Colormap colormap; + XColor* defs_in_out; + int ncolors; +{ +} + +int +XQueryTree(display, w, root_return, parent_return, children_return, + nchildren_return) + Display* display; + Window w; + Window* root_return; + Window* parent_return; + Window** children_return; + unsigned int* nchildren_return; +{ + return 0; +} + +void +XRefreshKeyboardMapping(event_map) + XMappingEvent* event_map; +{ +} + +Window +XRootWindow(display, screen_number) + Display* display; + int screen_number; +{ + return (Window) NULL; +} + +void +XSelectInput(display, w, event_mask) + Display* display; + Window w; + long event_mask; +{ +} + +int +XSendEvent(display, w, propagate, event_mask, event_send) + Display* display; + Window w; + Bool propagate; + long event_mask; + XEvent* event_send; +{ + return 0; +} + +void +XSetCommand(display, w, argv, argc) + Display* display; + Window w; + char** argv; + int argc; +{ +} + +XErrorHandler +XSetErrorHandler (handler) + XErrorHandler handler; +{ + return NULL; +} + +void +XSetIconName(display, w, icon_name) + Display* display; + Window w; + _Xconst char* icon_name; +{ +} + +void +XSetWindowBackground(display, w, background_pixel) + Display* display; + Window w; + unsigned long background_pixel; +{ +} + +void +XSetWindowBackgroundPixmap(display, w, background_pixmap) + Display* display; + Window w; + Pixmap background_pixmap; +{ +} + +void +XSetWindowBorder(display, w, border_pixel) + Display* display; + Window w; + unsigned long border_pixel; +{ +} + +void +XSetWindowBorderPixmap(display, w, border_pixmap) + Display* display; + Window w; + Pixmap border_pixmap; +{ +} + +void +XSetWindowBorderWidth(display, w, width) + Display* display; + Window w; + unsigned int width; +{ +} + +void +XSetWindowColormap(display, w, colormap) + Display* display; + Window w; + Colormap colormap; +{ +} + +Bool +XTranslateCoordinates(display, src_w, dest_w, src_x, src_y, dest_x_return, + dest_y_return, child_return) + Display* display; + Window src_w; + Window dest_w; + int src_x; + int src_y; + int* dest_x_return; + int* dest_y_return; + Window* child_return; +{ + return 0; +} + +void +XWindowEvent(display, w, event_mask, event_return) + Display* display; + Window w; + long event_mask; + XEvent* event_return; +{ +} + +int +XWithdrawWindow(display, w, screen_number) + Display* display; + Window w; + int screen_number; +{ + return 0; +} + +int +XmbLookupString(ic, event, buffer_return, bytes_buffer, keysym_return, + status_return) + XIC ic; + XKeyPressedEvent* event; + char* buffer_return; + int bytes_buffer; + KeySym* keysym_return; + Status* status_return; +{ + return 0; +} + +int +XGetWindowProperty(display, w, property, long_offset, long_length, delete, + req_type, actual_type_return, actual_format_return, nitems_return, + bytes_after_return, prop_return) + Display* display; + Window w; + Atom property; + long long_offset; + long long_length; + Bool delete; + Atom req_type; + Atom* actual_type_return; + int* actual_format_return; + unsigned long* nitems_return; + unsigned long* bytes_after_return; + unsigned char** prop_return; +{ + *actual_type_return = None; + *actual_format_return = 0; + *nitems_return = 0; + *bytes_after_return = 0; + *prop_return = NULL; + return BadValue; +} diff --git a/win/tkWin.h b/win/tkWin.h new file mode 100644 index 0000000..c9d9360 --- /dev/null +++ b/win/tkWin.h @@ -0,0 +1,56 @@ +/* + * tkWin.h -- + * + * Declarations of public types and interfaces that are only + * available under Windows. + * + * Copyright (c) 1996 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWin.h 1.6 96/08/15 13:19:41 + */ + +#ifndef _TKWIN +#define _TKWIN + +#ifndef _TK +#include <tk.h> +#endif + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#undef WIN32_LEAN_AND_MEAN + +/* + * The following messages are use to communicate between a Tk toplevel + * and its container window. + */ + +#define TK_CLAIMFOCUS (WM_USER) +#define TK_GEOMETRYREQ (WM_USER+1) +#define TK_ATTACHWINDOW (WM_USER+2) +#define TK_DETACHWINDOW (WM_USER+3) + + +/* + *-------------------------------------------------------------- + * + * Exported procedures defined for the Windows platform only. + * + *-------------------------------------------------------------- + */ + +EXTERN Window Tk_AttachHWND _ANSI_ARGS_((Tk_Window tkwin, + HWND hwnd)); +EXTERN HINSTANCE Tk_GetHINSTANCE _ANSI_ARGS_((void)); +EXTERN HWND Tk_GetHWND _ANSI_ARGS_((Window window)); +EXTERN Tk_Window Tk_HWNDToWindow _ANSI_ARGS_((HWND hwnd)); +EXTERN void Tk_PointerEvent _ANSI_ARGS_((HWND hwnd, + int x, int y)); +EXTERN int Tk_TranslateWinEvent _ANSI_ARGS_((HWND hwnd, + UINT message, WPARAM wParam, LPARAM lParam, + LRESULT *result)); + +#endif /* _TKWIN */ diff --git a/win/tkWin32Dll.c b/win/tkWin32Dll.c new file mode 100644 index 0000000..969e687 --- /dev/null +++ b/win/tkWin32Dll.c @@ -0,0 +1,85 @@ +/* + * tkWin32Dll.c -- + * + * This file contains a stub dll entry point. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWin32Dll.c 1.9 96/08/06 15:59:08 + */ + +#include "tkPort.h" +#include "tkWinInt.h" + +/* + * The following declaration is for the VC++ DLL entry point. + */ + +BOOL APIENTRY DllMain _ANSI_ARGS_((HINSTANCE hInst, + DWORD reason, LPVOID reserved)); + +/* + *---------------------------------------------------------------------- + * + * DllEntryPoint -- + * + * This wrapper function is used by Borland to invoke the + * initialization code for Tk. It simply calls the DllMain + * routine. + * + * Results: + * See DllMain. + * + * Side effects: + * See DllMain. + * + *---------------------------------------------------------------------- + */ + +BOOL APIENTRY +DllEntryPoint(hInst, reason, reserved) + HINSTANCE hInst; /* Library instance handle. */ + DWORD reason; /* Reason this function is being called. */ + LPVOID reserved; /* Not used. */ +{ + return DllMain(hInst, reason, reserved); +} + +/* + *---------------------------------------------------------------------- + * + * DllMain -- + * + * DLL entry point. + * + * Results: + * TRUE on sucess, FALSE on failure. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +BOOL APIENTRY +DllMain(hInstance, reason, reserved) + HINSTANCE hInstance; + DWORD reason; + LPVOID reserved; +{ + /* + * If we are attaching to the DLL from a new process, tell Tk about + * the hInstance to use. If we are detaching then clean up any + * data structures related to this DLL. + */ + + if (reason == DLL_PROCESS_ATTACH) { + TkWinXInit(hInstance); + } else if (reason == DLL_PROCESS_DETACH) { + TkWinXCleanup(hInstance); + } + return(TRUE); +} diff --git a/win/tkWin3d.c b/win/tkWin3d.c new file mode 100644 index 0000000..3ee9907 --- /dev/null +++ b/win/tkWin3d.c @@ -0,0 +1,535 @@ +/* + * tkWin3d.c -- + * + * This file contains the platform specific routines for + * drawing 3d borders in the Windows 95 style. + * + * Copyright (c) 1996 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWin3d.c 1.6 97/08/12 14:28:54 + */ + +#include <tk3d.h> +#include <tkWinInt.h> + +/* + * This structure is used to keep track of the extra colors used by + * Windows 3d borders. + */ + +typedef struct { + TkBorder info; + XColor *light2ColorPtr; /* System3dLight */ + XColor *dark2ColorPtr; /* System3dDarkShadow */ +} WinBorder; + + +/* + *---------------------------------------------------------------------- + * + * TkpGetBorder -- + * + * This function allocates a new TkBorder structure. + * + * Results: + * Returns a newly allocated TkBorder. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +TkBorder * +TkpGetBorder() +{ + WinBorder *borderPtr = (WinBorder *) ckalloc(sizeof(WinBorder)); + borderPtr->light2ColorPtr = NULL; + borderPtr->dark2ColorPtr = NULL; + return (TkBorder *) borderPtr; +} + +/* + *---------------------------------------------------------------------- + * + * TkpFreeBorder -- + * + * This function frees any colors allocated by the platform + * specific part of this module. + * + * Results: + * None. + * + * Side effects: + * May deallocate some colors. + * + *---------------------------------------------------------------------- + */ + +void +TkpFreeBorder(borderPtr) + TkBorder *borderPtr; +{ + WinBorder *winBorderPtr = (WinBorder *) borderPtr; + if (winBorderPtr->light2ColorPtr) { + Tk_FreeColor(winBorderPtr->light2ColorPtr); + } + if (winBorderPtr->dark2ColorPtr) { + Tk_FreeColor(winBorderPtr->dark2ColorPtr); + } +} + +/* + *-------------------------------------------------------------- + * + * Tk_3DVerticalBevel -- + * + * This procedure draws a vertical bevel along one side of + * an object. The bevel is always rectangular in shape: + * ||| + * ||| + * ||| + * ||| + * ||| + * ||| + * An appropriate shadow color is chosen for the bevel based + * on the leftBevel and relief arguments. Normally this + * procedure is called first, then Tk_3DHorizontalBevel is + * called next to draw neat corners. + * + * Results: + * None. + * + * Side effects: + * Graphics are drawn in drawable. + * + *-------------------------------------------------------------- + */ + +void +Tk_3DVerticalBevel(tkwin, drawable, border, x, y, width, height, + leftBevel, relief) + Tk_Window tkwin; /* Window for which border was allocated. */ + Drawable drawable; /* X window or pixmap in which to draw. */ + Tk_3DBorder border; /* Token for border to draw. */ + int x, y, width, height; /* Area of vertical bevel. */ + int leftBevel; /* Non-zero means this bevel forms the + * left side of the object; 0 means it + * forms the right side. */ + int relief; /* Kind of bevel to draw. For example, + * TK_RELIEF_RAISED means interior of + * object should appear higher than + * exterior. */ +{ + TkBorder *borderPtr = (TkBorder *) border; + int left, right; + Display *display = Tk_Display(tkwin); + TkWinDCState state; + HDC dc = TkWinGetDrawableDC(display, drawable, &state); + int half; + + if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) { + TkpGetShadows(borderPtr, tkwin); + } + + switch (relief) { + case TK_RELIEF_RAISED: + left = (leftBevel) + ? borderPtr->lightGC->foreground + : borderPtr->darkGC->foreground; + right = (leftBevel) + ? ((WinBorder *)borderPtr)->light2ColorPtr->pixel + : ((WinBorder *)borderPtr)->dark2ColorPtr->pixel; + break; + case TK_RELIEF_SUNKEN: + left = (leftBevel) + ? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel + : ((WinBorder *)borderPtr)->light2ColorPtr->pixel; + right = (leftBevel) + ? borderPtr->darkGC->foreground + : borderPtr->lightGC->foreground; + break; + case TK_RELIEF_RIDGE: + left = borderPtr->lightGC->foreground; + right = borderPtr->darkGC->foreground; + break; + case TK_RELIEF_GROOVE: + left = borderPtr->darkGC->foreground; + right = borderPtr->lightGC->foreground; + break; + case TK_RELIEF_FLAT: + left = right = borderPtr->bgGC->foreground; + break; + case TK_RELIEF_SOLID: + left = right = RGB(0,0,0); + break; + } + half = width/2; + if (leftBevel && (width & 1)) { + half++; + } + TkWinFillRect(dc, x, y, half, height, left); + TkWinFillRect(dc, x+half, y, width-half, height, right); + TkWinReleaseDrawableDC(drawable, dc, &state); +} + +/* + *-------------------------------------------------------------- + * + * Tk_3DHorizontalBevel -- + * + * This procedure draws a horizontal bevel along one side of + * an object. The bevel has mitered corners (depending on + * leftIn and rightIn arguments). + * + * Results: + * None. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + +void +Tk_3DHorizontalBevel(tkwin, drawable, border, x, y, width, height, + leftIn, rightIn, topBevel, relief) + Tk_Window tkwin; /* Window for which border was allocated. */ + Drawable drawable; /* X window or pixmap in which to draw. */ + Tk_3DBorder border; /* Token for border to draw. */ + int x, y, width, height; /* Bounding box of area of bevel. Height + * gives width of border. */ + int leftIn, rightIn; /* Describes whether the left and right + * edges of the bevel angle in or out as + * they go down. For example, if "leftIn" + * is true, the left side of the bevel + * looks like this: + * ___________ + * __________ + * _________ + * ________ + */ + int topBevel; /* Non-zero means this bevel forms the + * top side of the object; 0 means it + * forms the bottom side. */ + int relief; /* Kind of bevel to draw. For example, + * TK_RELIEF_RAISED means interior of + * object should appear higher than + * exterior. */ +{ + TkBorder *borderPtr = (TkBorder *) border; + Display *display = Tk_Display(tkwin); + int bottom, halfway, x1, x2, x1Delta, x2Delta; + TkWinDCState state; + HDC dc = TkWinGetDrawableDC(display, drawable, &state); + int topColor, bottomColor; + + if ((borderPtr->lightGC == None) && (relief != TK_RELIEF_FLAT)) { + TkpGetShadows(borderPtr, tkwin); + } + + /* + * Compute a GC for the top half of the bevel and a GC for the + * bottom half (they're the same in many cases). + */ + + switch (relief) { + case TK_RELIEF_RAISED: + topColor = (topBevel) + ? borderPtr->lightGC->foreground + : borderPtr->darkGC->foreground; + bottomColor = (topBevel) + ? ((WinBorder *)borderPtr)->light2ColorPtr->pixel + : ((WinBorder *)borderPtr)->dark2ColorPtr->pixel; + break; + case TK_RELIEF_SUNKEN: + topColor = (topBevel) + ? ((WinBorder *)borderPtr)->dark2ColorPtr->pixel + : ((WinBorder *)borderPtr)->light2ColorPtr->pixel; + bottomColor = (topBevel) + ? borderPtr->darkGC->foreground + : borderPtr->lightGC->foreground; + break; + case TK_RELIEF_RIDGE: + topColor = borderPtr->lightGC->foreground; + bottomColor = borderPtr->darkGC->foreground; + break; + case TK_RELIEF_GROOVE: + topColor = borderPtr->darkGC->foreground; + bottomColor = borderPtr->lightGC->foreground; + break; + case TK_RELIEF_FLAT: + topColor = bottomColor = borderPtr->bgGC->foreground; + break; + case TK_RELIEF_SOLID: + topColor = bottomColor = RGB(0,0,0); + } + + /* + * Compute various other geometry-related stuff. + */ + + if (leftIn) { + x1 = x+1; + } else { + x1 = x+height-1; + } + x2 = x+width; + if (rightIn) { + x2--; + } else { + x2 -= height; + } + x1Delta = (leftIn) ? 1 : -1; + x2Delta = (rightIn) ? -1 : 1; + halfway = y + height/2; + if (topBevel && (height & 1)) { + halfway++; + } + bottom = y + height; + + /* + * Draw one line for each y-coordinate covered by the bevel. + */ + + for ( ; y < bottom; y++) { + /* + * In some weird cases (such as large border widths for skinny + * rectangles) x1 can be >= x2. Don't draw the lines + * in these cases. + */ + + if (x1 < x2) { + TkWinFillRect(dc, x1, y, x2-x1, 1, + (y < halfway) ? topColor : bottomColor); + } + x1 += x1Delta; + x2 += x2Delta; + } + TkWinReleaseDrawableDC(drawable, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetShadows -- + * + * This procedure computes the shadow colors for a 3-D border + * and fills in the corresponding fields of the Border structure. + * It's called lazily, so that the colors aren't allocated until + * something is actually drawn with them. That way, if a border + * is only used for flat backgrounds the shadow colors will + * never be allocated. + * + * Results: + * None. + * + * Side effects: + * The lightGC and darkGC fields in borderPtr get filled in, + * if they weren't already. + * + *---------------------------------------------------------------------- + */ + +void +TkpGetShadows(borderPtr, tkwin) + TkBorder *borderPtr; /* Information about border. */ + Tk_Window tkwin; /* Window where border will be used for + * drawing. */ +{ + XColor lightColor, darkColor; + int tmp1, tmp2; + XGCValues gcValues; + + if (borderPtr->lightGC != None) { + return; + } + + /* + * Handle the special case of the default system colors. + */ + + if ((TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_3DFACE) + || (TkWinIndexOfColor(borderPtr->bgColorPtr) == COLOR_WINDOW)) { + borderPtr->darkColorPtr = Tk_GetColor(NULL, tkwin, + Tk_GetUid("SystemButtonShadow")); + gcValues.foreground = borderPtr->darkColorPtr->pixel; + borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + borderPtr->lightColorPtr = Tk_GetColor(NULL, tkwin, + Tk_GetUid("SystemButtonHighlight")); + gcValues.foreground = borderPtr->lightColorPtr->pixel; + borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + ((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColor(NULL, tkwin, + Tk_GetUid("System3dDarkShadow")); + ((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColor(NULL, tkwin, + Tk_GetUid("System3dLight")); + return; + } else { + darkColor.red = 0; + darkColor.green = 0; + darkColor.blue = 0; + ((WinBorder*)borderPtr)->dark2ColorPtr = Tk_GetColorByValue(tkwin, + &darkColor); + lightColor = *(borderPtr->bgColorPtr); + ((WinBorder*)borderPtr)->light2ColorPtr = Tk_GetColorByValue(tkwin, + &lightColor); + } + + /* + * First, handle the case of a color display with lots of colors. + * The shadow colors get computed using whichever formula results + * in the greatest change in color: + * 1. Lighter shadow is half-way to white, darker shadow is half + * way to dark. + * 2. Lighter shadow is 40% brighter than background, darker shadow + * is 40% darker than background. + */ + + if (Tk_Depth(tkwin) >= 6) { + /* + * This is a color display with lots of colors. For the dark + * shadow, cut 40% from each of the background color components. + * For the light shadow, boost each component by 40% or half-way + * to white, whichever is greater (the first approach works + * better for unsaturated colors, the second for saturated ones). + */ + + darkColor.red = (60 * (int) borderPtr->bgColorPtr->red)/100; + darkColor.green = (60 * (int) borderPtr->bgColorPtr->green)/100; + darkColor.blue = (60 * (int) borderPtr->bgColorPtr->blue)/100; + borderPtr->darkColorPtr = Tk_GetColorByValue(tkwin, &darkColor); + gcValues.foreground = borderPtr->darkColorPtr->pixel; + borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + + /* + * Compute the colors using integers, not using lightColor.red + * etc.: these are shorts and may have problems with integer + * overflow. + */ + + tmp1 = (14 * (int) borderPtr->bgColorPtr->red)/10; + if (tmp1 > MAX_INTENSITY) { + tmp1 = MAX_INTENSITY; + } + tmp2 = (MAX_INTENSITY + (int) borderPtr->bgColorPtr->red)/2; + lightColor.red = (tmp1 > tmp2) ? tmp1 : tmp2; + tmp1 = (14 * (int) borderPtr->bgColorPtr->green)/10; + if (tmp1 > MAX_INTENSITY) { + tmp1 = MAX_INTENSITY; + } + tmp2 = (MAX_INTENSITY + (int) borderPtr->bgColorPtr->green)/2; + lightColor.green = (tmp1 > tmp2) ? tmp1 : tmp2; + tmp1 = (14 * (int) borderPtr->bgColorPtr->blue)/10; + if (tmp1 > MAX_INTENSITY) { + tmp1 = MAX_INTENSITY; + } + tmp2 = (MAX_INTENSITY + (int) borderPtr->bgColorPtr->blue)/2; + lightColor.blue = (tmp1 > tmp2) ? tmp1 : tmp2; + borderPtr->lightColorPtr = Tk_GetColorByValue(tkwin, &lightColor); + gcValues.foreground = borderPtr->lightColorPtr->pixel; + borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + return; + } + + if (borderPtr->shadow == None) { + borderPtr->shadow = Tk_GetBitmap((Tcl_Interp *) NULL, tkwin, + Tk_GetUid("gray50")); + if (borderPtr->shadow == None) { + panic("TkpGetShadows couldn't allocate bitmap for border"); + } + } + if (borderPtr->visual->map_entries > 2) { + /* + * This isn't a monochrome display, but the colormap either + * ran out of entries or didn't have very many to begin with. + * Generate the light shadows with a white stipple and the + * dark shadows with a black stipple. + */ + + gcValues.foreground = borderPtr->bgColorPtr->pixel; + gcValues.background = BlackPixelOfScreen(borderPtr->screen); + gcValues.stipple = borderPtr->shadow; + gcValues.fill_style = FillOpaqueStippled; + borderPtr->darkGC = Tk_GetGC(tkwin, + GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues); + gcValues.foreground = WhitePixelOfScreen(borderPtr->screen); + gcValues.background = borderPtr->bgColorPtr->pixel; + borderPtr->lightGC = Tk_GetGC(tkwin, + GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues); + return; + } + + /* + * This is just a measly monochrome display, hardly even worth its + * existence on this earth. Make one shadow a 50% stipple and the + * other the opposite of the background. + */ + + gcValues.foreground = WhitePixelOfScreen(borderPtr->screen); + gcValues.background = BlackPixelOfScreen(borderPtr->screen); + gcValues.stipple = borderPtr->shadow; + gcValues.fill_style = FillOpaqueStippled; + borderPtr->lightGC = Tk_GetGC(tkwin, + GCForeground|GCBackground|GCStipple|GCFillStyle, &gcValues); + if (borderPtr->bgColorPtr->pixel + == WhitePixelOfScreen(borderPtr->screen)) { + gcValues.foreground = BlackPixelOfScreen(borderPtr->screen); + borderPtr->darkGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + } else { + borderPtr->darkGC = borderPtr->lightGC; + borderPtr->lightGC = Tk_GetGC(tkwin, GCForeground, &gcValues); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinGetBorderPixels -- + * + * This routine returns the 5 COLORREFs used to draw a given + * 3d border. + * + * Results: + * Returns the colors in the specified array. + * + * Side effects: + * May cause the remaining colors to be allocated. + * + *---------------------------------------------------------------------- + */ + +COLORREF +TkWinGetBorderPixels(tkwin, border, which) + Tk_Window tkwin; + Tk_3DBorder border; + int which; /* One of TK_3D_FLAT_GC, TK_3D_LIGHT_GC, + * TK_3D_DARK_GC, TK_3D_LIGHT2, TK_3D_DARK2 */ +{ + WinBorder *borderPtr = (WinBorder *) border; + + if (borderPtr->info.lightGC == None) { + TkpGetShadows(&borderPtr->info, tkwin); + } + switch (which) { + case TK_3D_FLAT_GC: + return borderPtr->info.bgColorPtr->pixel; + case TK_3D_LIGHT_GC: + if (borderPtr->info.lightColorPtr == NULL) { + return WhitePixelOfScreen(borderPtr->info.screen); + } + return borderPtr->info.lightColorPtr->pixel; + case TK_3D_DARK_GC: + if (borderPtr->info.darkColorPtr == NULL) { + return BlackPixelOfScreen(borderPtr->info.screen); + } + return borderPtr->info.darkColorPtr->pixel; + case TK_3D_LIGHT2: + return borderPtr->light2ColorPtr->pixel; + case TK_3D_DARK2: + return borderPtr->dark2ColorPtr->pixel; + } + return 0; +} diff --git a/win/tkWinButton.c b/win/tkWinButton.c new file mode 100644 index 0000000..47a74e6 --- /dev/null +++ b/win/tkWinButton.c @@ -0,0 +1,811 @@ +/* + * tkWinButton.c -- + * + * This file implements the Windows specific portion of the button + * widgets. + * + * Copyright (c) 1996 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinButton.c 1.12 97/09/02 13:18:27 + */ + +#define OEMRESOURCE +#include "tkWinInt.h" +#include "tkButton.h" + +/* + * These macros define the base style flags for the different button types. + */ + +#define LABEL_STYLE (BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS) +#define PUSH_STYLE (BS_OWNERDRAW | BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS) +#define CHECK_STYLE (BS_OWNERDRAW | BS_CHECKBOX | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS) +#define RADIO_STYLE (BS_OWNERDRAW | BS_RADIOBUTTON | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS) + +static DWORD buttonStyles[] = { + LABEL_STYLE, PUSH_STYLE, CHECK_STYLE, RADIO_STYLE +}; + +/* + * Declaration of Windows specific button structure. + */ + +typedef struct WinButton { + TkButton info; /* Generic button info. */ + WNDPROC oldProc; /* Old window procedure. */ + HWND hwnd; /* Current window handle. */ + Pixmap pixmap; /* Bitmap for rendering the button. */ + DWORD style; /* Window style flags. */ +} WinButton; + + +/* + * The following macro reverses the order of RGB bytes to convert + * between RGBQUAD and COLORREF values. + */ + +#define FlipColor(rgb) (RGB(GetBValue(rgb),GetGValue(rgb),GetRValue(rgb))) + +/* + * The following enumeration defines the meaning of the palette entries + * in the "buttons" image used to draw checkbox and radiobutton indicators. + */ + +enum { + PAL_CHECK = 0, + PAL_TOP_OUTER = 1, + PAL_BOTTOM_OUTER = 2, + PAL_BOTTOM_INNER = 3, + PAL_INTERIOR = 4, + PAL_TOP_INNER = 5, + PAL_BACKGROUND = 6 +}; + +/* + * Set to non-zero if this module is initialized. + */ + +static int initialized = 0; + +/* + * Variables for the cached information about the boxes bitmap. + */ + +static BITMAPINFOHEADER *boxesPtr = NULL; /* Information about the bitmap. */ +static DWORD *boxesPalette = NULL; /* Pointer to color palette. */ +static LPSTR boxesBits = NULL; /* Pointer to bitmap data. */ +static DWORD boxHeight = 0, boxWidth = 0; /* Size of each sub-image. */ + +/* + * This variable holds the default border width for a button in string + * form for use in a Tk_ConfigSpec. + */ + +static char defWidth[8]; + +/* + * Declarations for functions defined in this file. + */ + +static int ButtonBindProc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, XEvent *eventPtr, + Tk_Window tkwin, KeySym keySym)); +static LRESULT CALLBACK ButtonProc _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); +static DWORD ComputeStyle _ANSI_ARGS_((WinButton* butPtr)); +static Window CreateProc _ANSI_ARGS_((Tk_Window tkwin, + Window parent, ClientData instanceData)); +static void InitBoxes _ANSI_ARGS_((void)); +static void UpdateButtonDefaults _ANSI_ARGS_((void)); + +/* + * The class procedure table for the button widgets. + */ + +TkClassProcs tkpButtonProcs = { + CreateProc, /* createProc. */ + TkButtonWorldChanged, /* geometryProc. */ + NULL /* modalProc. */ +}; + + +/* + *---------------------------------------------------------------------- + * + * InitBoxes -- + * + * This function load the Tk 3d button bitmap. "buttons" is a 16 + * color bitmap that is laid out such that the top row contains + * the 4 checkbox images, and the bottom row contains the radio + * button images. Note that the bitmap is stored in bottom-up + * format. Also, the first seven palette entries are used to + * identify the different parts of the bitmaps so we can do the + * appropriate color mappings based on the current button colors. + * + * Results: + * None. + * + * Side effects: + * Loads the "buttons" resource. + * + *---------------------------------------------------------------------- + */ + +static void +InitBoxes() +{ + /* + * For DLLs like Tk, the HINSTANCE is the same as the HMODULE. + */ + + HMODULE module = (HINSTANCE) Tk_GetHINSTANCE(); + HRSRC hrsrc; + HGLOBAL hblk; + LPBITMAPINFOHEADER newBitmap; + DWORD size; + + hrsrc = FindResource(module, "buttons", RT_BITMAP); + if (hrsrc) { + hblk = LoadResource(module, hrsrc); + boxesPtr = (LPBITMAPINFOHEADER)LockResource(hblk); + } + + /* + * Copy the DIBitmap into writable memory. + */ + + if (boxesPtr != NULL && !(boxesPtr->biWidth % 4) + && !(boxesPtr->biHeight % 2)) { + size = boxesPtr->biSize + (1 << boxesPtr->biBitCount) * sizeof(RGBQUAD) + + boxesPtr->biSizeImage; + newBitmap = (LPBITMAPINFOHEADER) ckalloc(size); + memcpy(newBitmap, boxesPtr, size); + boxesPtr = newBitmap; + boxWidth = boxesPtr->biWidth / 4; + boxHeight = boxesPtr->biHeight / 2; + boxesPalette = (DWORD*) (((LPSTR)boxesPtr) + boxesPtr->biSize); + boxesBits = ((LPSTR)boxesPalette) + + ((1 << boxesPtr->biBitCount) * sizeof(RGBQUAD)); + } else { + boxesPtr = NULL; + } +} + +/* + *---------------------------------------------------------------------- + * + * UpdateButtonDefaults -- + * + * This function retrieves the current system defaults for + * the button widgets. + * + * Results: + * None. + * + * Side effects: + * Updates the configuration defaults for buttons. + * + *---------------------------------------------------------------------- + */ + +void +UpdateButtonDefaults() +{ + Tk_ConfigSpec *specPtr; + int width = GetSystemMetrics(SM_CXEDGE); + + if (width == 0) { + width = 1; + } + sprintf(defWidth, "%d", width); + for (specPtr = tkpButtonConfigSpecs; specPtr->type != TK_CONFIG_END; + specPtr++) { + if (specPtr->offset == Tk_Offset(TkButton, borderWidth)) { + specPtr->defValue = defWidth; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpCreateButton -- + * + * Allocate a new TkButton structure. + * + * Results: + * Returns a newly allocated TkButton structure. + * + * Side effects: + * Registers an event handler for the widget. + * + *---------------------------------------------------------------------- + */ + +TkButton * +TkpCreateButton(tkwin) + Tk_Window tkwin; +{ + WinButton *butPtr; + + if (!initialized) { + UpdateButtonDefaults(); + initialized = 1; + } + + butPtr = (WinButton *)ckalloc(sizeof(WinButton)); + butPtr->hwnd = NULL; + return (TkButton *) butPtr; +} + +/* + *---------------------------------------------------------------------- + * + * CreateProc -- + * + * This function creates a new Button control, subclasses + * the instance, and generates a new Window object. + * + * Results: + * Returns the newly allocated Window object, or None on failure. + * + * Side effects: + * Causes a new Button control to come into existence. + * + *---------------------------------------------------------------------- + */ + +static Window +CreateProc(tkwin, parentWin, instanceData) + Tk_Window tkwin; /* Token for window. */ + Window parentWin; /* Parent of new window. */ + ClientData instanceData; /* Button instance data. */ +{ + Window window; + HWND parent; + char *class; + WinButton *butPtr = (WinButton *)instanceData; + + parent = Tk_GetHWND(parentWin); + if (butPtr->info.type == TYPE_LABEL) { + class = "STATIC"; + butPtr->style = SS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS; + } else { + class = "BUTTON"; + butPtr->style = BS_OWNERDRAW | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS; + } + butPtr->hwnd = CreateWindow(class, NULL, butPtr->style, + Tk_X(tkwin), Tk_Y(tkwin), Tk_Width(tkwin), Tk_Height(tkwin), + parent, NULL, Tk_GetHINSTANCE(), NULL); + SetWindowPos(butPtr->hwnd, HWND_TOP, 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); + butPtr->oldProc = (WNDPROC)SetWindowLong(butPtr->hwnd, GWL_WNDPROC, + (DWORD) ButtonProc); + + window = Tk_AttachHWND(tkwin, butPtr->hwnd); + return window; +} + +/* + *---------------------------------------------------------------------- + * + * TkpDestroyButton -- + * + * Free data structures associated with the button control. + * + * Results: + * None. + * + * Side effects: + * Restores the default control state. + * + *---------------------------------------------------------------------- + */ + +void +TkpDestroyButton(butPtr) + TkButton *butPtr; +{ + WinButton *winButPtr = (WinButton *)butPtr; + HWND hwnd = winButPtr->hwnd; + if (hwnd) { + SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) winButPtr->oldProc); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpDisplayButton -- + * + * This procedure is invoked to display a button widget. It is + * normally invoked as an idle handler. + * + * Results: + * None. + * + * Side effects: + * Information appears on the screen. The REDRAW_PENDING flag + * is cleared. + * + *---------------------------------------------------------------------- + */ + +void +TkpDisplayButton(clientData) + ClientData clientData; /* Information about widget. */ +{ + TkWinDCState state; + HDC dc; + register TkButton *butPtr = (TkButton *) clientData; + GC gc; + Tk_3DBorder border; + Pixmap pixmap; + int x = 0; /* Initialization only needed to stop + * compiler warning. */ + int y, relief; + register Tk_Window tkwin = butPtr->tkwin; + int width, height; + int defaultWidth; /* Width of default ring. */ + int offset; /* 0 means this is a label widget. 1 means + * it is a flavor of button, so we offset + * the text to make the button appear to + * move up and down as the relief changes. */ + + butPtr->flags &= ~REDRAW_PENDING; + if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) { + return; + } + + border = butPtr->normalBorder; + if ((butPtr->state == tkDisabledUid) && (butPtr->disabledFg != NULL)) { + gc = butPtr->disabledGC; + } else if ((butPtr->state == tkActiveUid) + && !Tk_StrictMotif(butPtr->tkwin)) { + gc = butPtr->activeTextGC; + border = butPtr->activeBorder; + } else { + gc = butPtr->normalTextGC; + } + if ((butPtr->flags & SELECTED) && (butPtr->state != tkActiveUid) + && (butPtr->selectBorder != NULL) && !butPtr->indicatorOn) { + border = butPtr->selectBorder; + } + + /* + * Override the relief specified for the button if this is a + * checkbutton or radiobutton and there's no indicator. + */ + + relief = butPtr->relief; + if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) { + relief = (butPtr->flags & SELECTED) ? TK_RELIEF_SUNKEN + : TK_RELIEF_RAISED; + } + + /* + * Compute width of default ring and offset for pushed buttons. + */ + + if (butPtr->type == TYPE_BUTTON) { + defaultWidth = ((butPtr->defaultState == tkActiveUid) + ? butPtr->highlightWidth : 0); + offset = 1; + } else { + defaultWidth = 0; + if ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn) { + offset = 1; + } else { + offset = 0; + } + } + + /* + * In order to avoid screen flashes, this procedure redraws + * the button in a pixmap, then copies the pixmap to the + * screen in a single operation. This means that there's no + * point in time where the on-sreen image has been cleared. + */ + + pixmap = Tk_GetPixmap(butPtr->display, Tk_WindowId(tkwin), + Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin)); + Tk_Fill3DRectangle(tkwin, pixmap, border, 0, 0, Tk_Width(tkwin), + Tk_Height(tkwin), 0, TK_RELIEF_FLAT); + + /* + * Display image or bitmap or text for button. + */ + + if (butPtr->image != None) { + Tk_SizeOfImage(butPtr->image, &width, &height); + + imageOrBitmap: + TkComputeAnchor(butPtr->anchor, tkwin, 0, 0, + butPtr->indicatorSpace + width, height, &x, &y); + x += butPtr->indicatorSpace; + + if (relief == TK_RELIEF_SUNKEN) { + x += offset; + y += offset; + } + if (butPtr->image != NULL) { + if ((butPtr->selectImage != NULL) && (butPtr->flags & SELECTED)) { + Tk_RedrawImage(butPtr->selectImage, 0, 0, width, height, + pixmap, x, y); + } else { + Tk_RedrawImage(butPtr->image, 0, 0, width, height, pixmap, + x, y); + } + } else { + XSetClipOrigin(butPtr->display, gc, x, y); + XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0, + (unsigned int) width, (unsigned int) height, x, y, 1); + XSetClipOrigin(butPtr->display, gc, 0, 0); + } + y += height/2; + } else if (butPtr->bitmap != None) { + Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height); + goto imageOrBitmap; + } else { + RECT rect; + TkComputeAnchor(butPtr->anchor, tkwin, butPtr->padX, butPtr->padY, + butPtr->indicatorSpace + butPtr->textWidth, butPtr->textHeight, + &x, &y); + + x += butPtr->indicatorSpace; + + if (relief == TK_RELIEF_SUNKEN) { + x += offset; + y += offset; + } + Tk_DrawTextLayout(butPtr->display, pixmap, gc, butPtr->textLayout, + x, y, 0, -1); + Tk_UnderlineTextLayout(butPtr->display, pixmap, gc, + butPtr->textLayout, x, y, butPtr->underline); + + /* + * Draw the focus ring. If this is a push button then we need to put + * it around the inner edge of the border, otherwise we put it around + * the text. + */ + + if (butPtr->flags & GOT_FOCUS && butPtr->type != TYPE_LABEL) { + dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state); + if (butPtr->type == TYPE_BUTTON || !butPtr->indicatorOn) { + rect.top = butPtr->borderWidth + 1 + defaultWidth; + rect.left = rect.top; + rect.right = Tk_Width(tkwin) - rect.left; + rect.bottom = Tk_Height(tkwin) - rect.top; + } else { + rect.top = y-2; + rect.left = x-2; + rect.right = x+butPtr->textWidth + 1; + rect.bottom = y+butPtr->textHeight + 1; + } + SetTextColor(dc, gc->foreground); + SetBkColor(dc, gc->background); + DrawFocusRect(dc, &rect); + TkWinReleaseDrawableDC(pixmap, dc, &state); + } + y += butPtr->textHeight/2; + } + + /* + * Draw the indicator for check buttons and radio buttons. At this + * point x and y refer to the top-left corner of the text or image + * or bitmap. + */ + + if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn + && boxesPtr) { + int xSrc, ySrc; + + x -= butPtr->indicatorSpace; + y -= butPtr->indicatorDiameter / 2; + + xSrc = (butPtr->flags & SELECTED) ? boxWidth : 0; + if (butPtr->state == tkActiveUid) { + xSrc += boxWidth*2; + } + ySrc = (butPtr->type == TYPE_RADIO_BUTTON) ? 0 : boxHeight; + + /* + * Update the palette in the boxes bitmap to reflect the current + * button colors. Note that this code relies on the layout of the + * bitmap's palette. Also, all of the colors used to draw the + * bitmap must be in the palette that is selected into the DC of + * the offscreen pixmap. This requires that the static colors + * be placed into the palette. + */ + + boxesPalette[PAL_CHECK] = FlipColor(gc->foreground); + boxesPalette[PAL_TOP_OUTER] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_DARK_GC)); + boxesPalette[PAL_TOP_INNER] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_DARK2)); + boxesPalette[PAL_BOTTOM_INNER] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_LIGHT2)); + boxesPalette[PAL_BOTTOM_OUTER] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_LIGHT_GC)); + if (butPtr->state == tkDisabledUid) { + boxesPalette[PAL_INTERIOR] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_LIGHT2)); + } else if (butPtr->selectBorder != NULL) { + boxesPalette[PAL_INTERIOR] = FlipColor(TkWinGetBorderPixels(tkwin, + butPtr->selectBorder, TK_3D_FLAT_GC)); + } else { + boxesPalette[PAL_INTERIOR] = FlipColor(GetSysColor(COLOR_WINDOW)); + } + boxesPalette[PAL_BACKGROUND] = FlipColor(TkWinGetBorderPixels(tkwin, + border, TK_3D_FLAT_GC)); + + dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state); + StretchDIBits(dc, x, y, boxWidth, boxHeight, xSrc, ySrc, + boxWidth, boxHeight, boxesBits, (LPBITMAPINFO)boxesPtr, + DIB_RGB_COLORS, SRCCOPY); + TkWinReleaseDrawableDC(pixmap, dc, &state); + } + + /* + * If the button is disabled with a stipple rather than a special + * foreground color, generate the stippled effect. If the widget + * is selected and we use a different background color when selected, + * must temporarily modify the GC. + */ + + if ((butPtr->state == tkDisabledUid) + && ((butPtr->disabledFg == NULL) || (butPtr->image != NULL))) { + if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn + && (butPtr->selectBorder != NULL)) { + XSetForeground(butPtr->display, butPtr->disabledGC, + Tk_3DBorderColor(butPtr->selectBorder)->pixel); + } + XFillRectangle(butPtr->display, pixmap, butPtr->disabledGC, + butPtr->inset, butPtr->inset, + (unsigned) (Tk_Width(tkwin) - 2*butPtr->inset), + (unsigned) (Tk_Height(tkwin) - 2*butPtr->inset)); + if ((butPtr->flags & SELECTED) && !butPtr->indicatorOn + && (butPtr->selectBorder != NULL)) { + XSetForeground(butPtr->display, butPtr->disabledGC, + Tk_3DBorderColor(butPtr->normalBorder)->pixel); + } + } + + /* + * Draw the border and traversal highlight last. This way, if the + * button's contents overflow they'll be covered up by the border. + */ + + if (relief != TK_RELIEF_FLAT) { + Tk_Draw3DRectangle(tkwin, pixmap, border, + defaultWidth, defaultWidth, + Tk_Width(tkwin) - 2*defaultWidth, + Tk_Height(tkwin) - 2*defaultWidth, + butPtr->borderWidth, relief); + } + if (defaultWidth != 0) { + dc = TkWinGetDrawableDC(butPtr->display, pixmap, &state); + TkWinFillRect(dc, 0, 0, Tk_Width(tkwin), defaultWidth, + butPtr->highlightColorPtr->pixel); + TkWinFillRect(dc, 0, 0, defaultWidth, Tk_Height(tkwin), + butPtr->highlightColorPtr->pixel); + TkWinFillRect(dc, 0, Tk_Height(tkwin) - defaultWidth, + Tk_Width(tkwin), defaultWidth, + butPtr->highlightColorPtr->pixel); + TkWinFillRect(dc, Tk_Width(tkwin) - defaultWidth, 0, + defaultWidth, Tk_Height(tkwin), + butPtr->highlightColorPtr->pixel); + TkWinReleaseDrawableDC(pixmap, dc, &state); + } + + /* + * Copy the information from the off-screen pixmap onto the screen, + * then delete the pixmap. + */ + + XCopyArea(butPtr->display, pixmap, Tk_WindowId(tkwin), + butPtr->copyGC, 0, 0, (unsigned) Tk_Width(tkwin), + (unsigned) Tk_Height(tkwin), 0, 0); + Tk_FreePixmap(butPtr->display, pixmap); +} + +/* + *---------------------------------------------------------------------- + * + * TkpComputeButtonGeometry -- + * + * After changes in a button's text or bitmap, this procedure + * recomputes the button's geometry and passes this information + * along to the geometry manager for the window. + * + * Results: + * None. + * + * Side effects: + * The button's window may change size. + * + *---------------------------------------------------------------------- + */ + +void +TkpComputeButtonGeometry(butPtr) + register TkButton *butPtr; /* Button whose geometry may have changed. */ +{ + int width, height, avgWidth; + Tk_FontMetrics fm; + + if (butPtr->highlightWidth < 0) { + butPtr->highlightWidth = 0; + } + butPtr->inset = butPtr->highlightWidth + butPtr->borderWidth; + butPtr->indicatorSpace = 0; + + if (!boxesPtr) { + InitBoxes(); + } + + if (butPtr->image != NULL) { + Tk_SizeOfImage(butPtr->image, &width, &height); + imageOrBitmap: + if (butPtr->width > 0) { + width = butPtr->width; + } + if (butPtr->height > 0) { + height = butPtr->height; + } + if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) { + butPtr->indicatorSpace = boxWidth * 2; + butPtr->indicatorDiameter = boxHeight; + } + } else if (butPtr->bitmap != None) { + Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height); + goto imageOrBitmap; + } else { + Tk_FreeTextLayout(butPtr->textLayout); + butPtr->textLayout = Tk_ComputeTextLayout(butPtr->tkfont, + butPtr->text, -1, butPtr->wrapLength, butPtr->justify, 0, + &butPtr->textWidth, &butPtr->textHeight); + + width = butPtr->textWidth; + height = butPtr->textHeight; + avgWidth = Tk_TextWidth(butPtr->tkfont, "0", 1); + Tk_GetFontMetrics(butPtr->tkfont, &fm); + + if (butPtr->width > 0) { + width = butPtr->width * avgWidth; + } + if (butPtr->height > 0) { + height = butPtr->height * fm.linespace; + } + + if ((butPtr->type >= TYPE_CHECK_BUTTON) && butPtr->indicatorOn) { + butPtr->indicatorDiameter = boxHeight; + butPtr->indicatorSpace = butPtr->indicatorDiameter + avgWidth; + } + + /* + * Increase the inset to allow for the focus ring. + */ + + if (butPtr->type != TYPE_LABEL) { + butPtr->inset += 3; + } + } + + /* + * When issuing the geometry request, add extra space for the indicator, + * if any, and for the border and padding, plus an extra pixel so the + * display can be offset by 1 pixel in either direction for the raised + * or lowered effect. + */ + + if ((butPtr->image == NULL) && (butPtr->bitmap == None)) { + width += 2*butPtr->padX; + height += 2*butPtr->padY; + } + if ((butPtr->type == TYPE_BUTTON) + || ((butPtr->type >= TYPE_CHECK_BUTTON) && !butPtr->indicatorOn)) { + width += 1; + height += 1; + } + Tk_GeometryRequest(butPtr->tkwin, (int) (width + butPtr->indicatorSpace + + 2*butPtr->inset), (int) (height + 2*butPtr->inset)); + Tk_SetInternalBorder(butPtr->tkwin, butPtr->inset); +} + +/* + *---------------------------------------------------------------------- + * + * ButtonProc -- + * + * This function is call by Windows whenever an event occurs on + * a button control created by Tk. + * + * Results: + * Standard Windows return value. + * + * Side effects: + * May generate events. + * + *---------------------------------------------------------------------- + */ + +static LRESULT CALLBACK +ButtonProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + LRESULT result; + WinButton *butPtr; + Tk_Window tkwin = Tk_HWNDToWindow(hwnd); + + if (tkwin == NULL) { + panic("ButtonProc called on an invalid HWND"); + } + butPtr = (WinButton *)((TkWindow*)tkwin)->instanceData; + + switch(message) { + case WM_ERASEBKGND: + return 0; + + case BM_GETCHECK: + if (((butPtr->info.type == TYPE_CHECK_BUTTON) + || (butPtr->info.type == TYPE_RADIO_BUTTON)) + && butPtr->info.indicatorOn) { + return (butPtr->info.flags & SELECTED) + ? BST_CHECKED : BST_UNCHECKED; + } + return 0; + + case BM_GETSTATE: { + DWORD state = 0; + if (((butPtr->info.type == TYPE_CHECK_BUTTON) + || (butPtr->info.type == TYPE_RADIO_BUTTON)) + && butPtr->info.indicatorOn) { + state = (butPtr->info.flags & SELECTED) + ? BST_CHECKED : BST_UNCHECKED; + } + if (butPtr->info.flags & GOT_FOCUS) { + state |= BST_FOCUS; + } + return state; + } + case WM_ENABLE: + break; + + case WM_PAINT: { + PAINTSTRUCT ps; + BeginPaint(hwnd, &ps); + EndPaint(hwnd, &ps); + TkpDisplayButton((ClientData)butPtr); + return 0; + } + case BN_CLICKED: { + int code; + Tcl_Interp *interp = butPtr->info.interp; + if (butPtr->info.state != tkDisabledUid) { + Tcl_Preserve((ClientData)interp); + code = TkInvokeButton((TkButton*)butPtr); + if (code != TCL_OK && code != TCL_CONTINUE + && code != TCL_BREAK) { + Tcl_AddErrorInfo(interp, "\n (button invoke)"); + Tcl_BackgroundError(interp); + } + Tcl_Release((ClientData)interp); + } + Tcl_ServiceAll(); + return 0; + } + + default: + if (Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) { + return result; + } + } + return DefWindowProc(hwnd, message, wParam, lParam); +} diff --git a/win/tkWinClipboard.c b/win/tkWinClipboard.c new file mode 100644 index 0000000..9d4237a --- /dev/null +++ b/win/tkWinClipboard.c @@ -0,0 +1,291 @@ +/* + * tkWinClipboard.c -- + * + * This file contains functions for managing the clipboard. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinClipboard.c 1.8 97/05/20 17:01:13 + */ + +#include "tkWinInt.h" +#include "tkSelect.h" + + +/* + *---------------------------------------------------------------------- + * + * TkSelGetSelection -- + * + * Retrieve the specified selection from another process. For + * now, only fetching XA_STRING from CLIPBOARD is supported. + * Eventually other types should be allowed. + * + * Results: + * The return value is a standard Tcl return value. + * If an error occurs (such as no selection exists) + * then an error message is left in interp->result. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkSelGetSelection(interp, tkwin, selection, target, proc, clientData) + Tcl_Interp *interp; /* Interpreter to use for reporting + * errors. */ + Tk_Window tkwin; /* Window on whose behalf to retrieve + * the selection (determines display + * from which to retrieve). */ + Atom selection; /* Selection to retrieve. */ + Atom target; /* Desired form in which selection + * is to be returned. */ + Tk_GetSelProc *proc; /* Procedure to call to process the + * selection, once it has been retrieved. */ + ClientData clientData; /* Arbitrary value to pass to proc. */ +{ + char *data, *buffer, *destPtr; + HGLOBAL handle; + int result, length; + + if ((selection == Tk_InternAtom(tkwin, "CLIPBOARD")) + && (target == XA_STRING)) { + if (OpenClipboard(NULL)) { + handle = GetClipboardData(CF_TEXT); + if (handle != NULL) { + data = GlobalLock(handle); + length = strlen(data); + buffer = ckalloc(length+1); + destPtr = buffer; + while (*data != '\0') { + if (*data != '\r') { + *destPtr = *data; + destPtr++; + } + data++; + } + *destPtr = '\0'; + GlobalUnlock(handle); + CloseClipboard(); + result = (*proc)(clientData, interp, buffer); + ckfree(buffer); + return result; + } + CloseClipboard(); + } + } + + Tcl_AppendResult(interp, Tk_GetAtomName(tkwin, selection), + " selection doesn't exist or form \"", Tk_GetAtomName(tkwin, target), + "\" not defined", (char *) NULL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * TkSetSelectionOwner -- + * + * This function claims ownership of the specified selection. + * If the selection is CLIPBOARD, then we empty the system + * clipboard. + * + * Results: + * None. + * + * Side effects: + * Empties the system clipboard, and claims ownership. + * + *---------------------------------------------------------------------- + */ + +void +XSetSelectionOwner(display, selection, owner, time) + Display* display; + Atom selection; + Window owner; + Time time; +{ + HWND hwnd = owner ? TkWinGetHWND(owner) : NULL; + Tk_Window tkwin; + + /* + * This is a gross hack because the Tk_InternAtom interface is broken. + * It expects a Tk_Window, even though it only needs a Tk_Display. + */ + + tkwin = (Tk_Window)tkMainWindowList->winPtr; + + if (selection == Tk_InternAtom(tkwin, "CLIPBOARD")) { + + /* + * Only claim and empty the clipboard if we aren't already the + * owner of the clipboard. + */ + + if (GetClipboardOwner() != hwnd) { + OpenClipboard(hwnd); + EmptyClipboard(); + SetClipboardData(CF_TEXT, NULL); + CloseClipboard(); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinClipboardRender -- + * + * This function supplies the contents of the clipboard in + * response to a WM_RENDERFORMAT message. + * + * Results: + * None. + * + * Side effects: + * Sets the contents of the clipboard. + * + *---------------------------------------------------------------------- + */ + +void +TkWinClipboardRender(dispPtr, format) + TkDisplay *dispPtr; + UINT format; +{ + TkClipboardTarget *targetPtr; + TkClipboardBuffer *cbPtr; + HGLOBAL handle; + char *buffer, *p, *endPtr; + int length; + + for (targetPtr = dispPtr->clipTargetPtr; targetPtr != NULL; + targetPtr = targetPtr->nextPtr) { + if (targetPtr->type == XA_STRING) + break; + } + length = 0; + if (targetPtr != NULL) { + for (cbPtr = targetPtr->firstBufferPtr; cbPtr != NULL; + cbPtr = cbPtr->nextPtr) { + length += cbPtr->length; + for (p = cbPtr->buffer, endPtr = p + cbPtr->length; + p < endPtr; p++) { + if (*p == '\n') { + length++; + } + } + } + } + handle = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, length+1); + if (!handle) { + return; + } + buffer = GlobalLock(handle); + if (targetPtr != NULL) { + for (cbPtr = targetPtr->firstBufferPtr; cbPtr != NULL; + cbPtr = cbPtr->nextPtr) { + for (p = cbPtr->buffer, endPtr = p + cbPtr->length; + p < endPtr; p++) { + if (*p == '\n') { + *buffer++ = '\r'; + } + *buffer++ = *p; + } + } + } + *buffer = '\0'; + GlobalUnlock(handle); + SetClipboardData(CF_TEXT, handle); + return; +} + +/* + *---------------------------------------------------------------------- + * + * TkSelUpdateClipboard -- + * + * This function is called to force the clipboard to be updated + * after new data is added. + * + * Results: + * None. + * + * Side effects: + * Clears the current contents of the clipboard. + * + *---------------------------------------------------------------------- + */ + +void +TkSelUpdateClipboard(winPtr, targetPtr) + TkWindow *winPtr; + TkClipboardTarget *targetPtr; +{ + HWND hwnd = TkWinGetHWND(winPtr->window); + + OpenClipboard(hwnd); + EmptyClipboard(); + SetClipboardData(CF_TEXT, NULL); + CloseClipboard(); +} + +/* + *-------------------------------------------------------------- + * + * TkSelEventProc -- + * + * This procedure is invoked whenever a selection-related + * event occurs. + * + * Results: + * None. + * + * Side effects: + * Lots: depends on the type of event. + * + *-------------------------------------------------------------- + */ + +void +TkSelEventProc(tkwin, eventPtr) + Tk_Window tkwin; /* Window for which event was + * targeted. */ + register XEvent *eventPtr; /* X event: either SelectionClear, + * SelectionRequest, or + * SelectionNotify. */ +{ + if (eventPtr->type == SelectionClear) { + TkSelClearSelection(tkwin, eventPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkSelPropProc -- + * + * This procedure is invoked when property-change events + * occur on windows not known to the toolkit. This is a stub + * function under Windows. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkSelPropProc(eventPtr) + register XEvent *eventPtr; /* X PropertyChange event. */ +{ +} diff --git a/win/tkWinColor.c b/win/tkWinColor.c new file mode 100644 index 0000000..2cc3d09 --- /dev/null +++ b/win/tkWinColor.c @@ -0,0 +1,615 @@ +/* + * tkWinColor.c -- + * + * Functions to map color names to system color values. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * Copyright (c) 1994 Software Research Associates, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinColor.c 1.20 97/10/27 16:39:23 + */ + +#include <tkColor.h> +#include <tkWinInt.h> + +/* + * The following structure is used to keep track of each color that is + * allocated by this module. + */ + +typedef struct WinColor { + TkColor info; /* Generic color information. */ + int index; /* Index for GetSysColor(), -1 if color + * is not a "live" system color. */ +} WinColor; + +/* + * colorTable is a hash table used to look up X colors by name. + */ + +static Tcl_HashTable colorTable; + +/* + * The sysColors array contains the names and index values for the + * Windows indirect system color names. In use, all of the names + * will have the string "System" prepended, but we omit it in the table + * to save space. + */ + +typedef struct { + char *name; + int index; +} SystemColorEntry; + + +static SystemColorEntry sysColors[] = { + "3dDarkShadow", COLOR_3DDKSHADOW, + "3dLight", COLOR_3DLIGHT, + "ActiveBorder", COLOR_ACTIVEBORDER, + "ActiveCaption", COLOR_ACTIVECAPTION, + "AppWorkspace", COLOR_APPWORKSPACE, + "Background", COLOR_BACKGROUND, + "ButtonFace", COLOR_BTNFACE, + "ButtonHighlight", COLOR_BTNHIGHLIGHT, + "ButtonShadow", COLOR_BTNSHADOW, + "ButtonText", COLOR_BTNTEXT, + "CaptionText", COLOR_CAPTIONTEXT, + "DisabledText", COLOR_GRAYTEXT, + "GrayText", COLOR_GRAYTEXT, + "Highlight", COLOR_HIGHLIGHT, + "HighlightText", COLOR_HIGHLIGHTTEXT, + "InactiveBorder", COLOR_INACTIVEBORDER, + "InactiveCaption", COLOR_INACTIVECAPTION, + "InactiveCaptionText", COLOR_INACTIVECAPTIONTEXT, + "InfoBackground", COLOR_INFOBK, + "InfoText", COLOR_INFOTEXT, + "Menu", COLOR_MENU, + "MenuText", COLOR_MENUTEXT, + "Scrollbar", COLOR_SCROLLBAR, + "Window", COLOR_WINDOW, + "WindowFrame", COLOR_WINDOWFRAME, + "WindowText", COLOR_WINDOWTEXT, + NULL, 0 +}; + +static int ncolors = 0; + +/* + * Forward declarations for functions defined later in this file. + */ + +static int FindSystemColor _ANSI_ARGS_((const char *name, + XColor *colorPtr, int *indexPtr)); +static int GetColorByName _ANSI_ARGS_((char *name, XColor *color)); +static int GetColorByValue _ANSI_ARGS_((char *value, XColor *color)); + +/* + *---------------------------------------------------------------------- + * + * FindSystemColor -- + * + * This routine finds the color entry that corresponds to the + * specified color. + * + * Results: + * Returns non-zero on success. The RGB values of the XColor + * will be initialized to the proper values on success. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +FindSystemColor(name, colorPtr, indexPtr) + const char *name; /* Color name. */ + XColor *colorPtr; /* Where to store results. */ + int *indexPtr; /* Out parameter to store color index. */ +{ + int l, u, r, i; + + /* + * Count the number of elements in the color array if we haven't + * done so yet. + */ + + if (ncolors == 0) { + SystemColorEntry *ePtr; + int version; + + version = LOBYTE(LOWORD(GetVersion())); + for (ePtr = sysColors; ePtr->name != NULL; ePtr++) { + if (version < 4) { + if (ePtr->index == COLOR_3DDKSHADOW) { + ePtr->index = COLOR_BTNSHADOW; + } else if (ePtr->index == COLOR_3DLIGHT) { + ePtr->index = COLOR_BTNHIGHLIGHT; + } + } + ncolors++; + } + } + + /* + * Perform a binary search on the sorted array of colors. + */ + + l = 0; + u = ncolors - 1; + while (l <= u) { + i = (l + u) / 2; + r = strcasecmp(name, sysColors[i].name); + if (r == 0) { + break; + } else if (r < 0) { + u = i-1; + } else { + l = i+1; + } + } + if (l > u) { + return 0; + } + + *indexPtr = sysColors[i].index; + colorPtr->pixel = GetSysColor(sysColors[i].index); + colorPtr->red = GetRValue(colorPtr->pixel) << 8; + colorPtr->green = GetGValue(colorPtr->pixel) << 8; + colorPtr->blue = GetBValue(colorPtr->pixel) << 8; + colorPtr->flags = DoRed|DoGreen|DoBlue; + colorPtr->pad = 0; + return 1; +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetColor -- + * + * Allocate a new TkColor for the color with the given name. + * + * Results: + * Returns a newly allocated TkColor, or NULL on failure. + * + * Side effects: + * May invalidate the colormap cache associated with tkwin upon + * allocating a new colormap entry. Allocates a new TkColor + * structure. + * + *---------------------------------------------------------------------- + */ + +TkColor * +TkpGetColor(tkwin, name) + Tk_Window tkwin; /* Window in which color will be used. */ + Tk_Uid name; /* Name of color to allocated (in form + * suitable for passing to XParseColor). */ +{ + WinColor *winColPtr; + XColor color; + int index = -1; /* -1 indicates that this is not an indirect + * sytem color. */ + + /* + * Check to see if it is a system color or an X color string. If the + * color is found, allocate a new WinColor and store the XColor and the + * system color index. + */ + + if (((strncasecmp(name, "system", 6) == 0) + && FindSystemColor(name+6, &color, &index)) + || XParseColor(Tk_Display(tkwin), Tk_Colormap(tkwin), name, + &color)) { + winColPtr = (WinColor *) ckalloc(sizeof(WinColor)); + winColPtr->info.color = color; + winColPtr->index = index; + + XAllocColor(Tk_Display(tkwin), Tk_Colormap(tkwin), + &winColPtr->info.color); + return (TkColor *) winColPtr; + } + return (TkColor *) NULL; +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetColorByValue -- + * + * Given a desired set of red-green-blue intensities for a color, + * locate a pixel value to use to draw that color in a given + * window. + * + * Results: + * The return value is a pointer to an TkColor structure that + * indicates the closest red, blue, and green intensities available + * to those specified in colorPtr, and also specifies a pixel + * value to use to draw in that color. + * + * Side effects: + * May invalidate the colormap cache for the specified window. + * Allocates a new TkColor structure. + * + *---------------------------------------------------------------------- + */ + +TkColor * +TkpGetColorByValue(tkwin, colorPtr) + Tk_Window tkwin; /* Window in which color will be used. */ + XColor *colorPtr; /* Red, green, and blue fields indicate + * desired color. */ +{ + WinColor *tkColPtr = (WinColor *) ckalloc(sizeof(WinColor)); + + tkColPtr->info.color.red = colorPtr->red; + tkColPtr->info.color.green = colorPtr->green; + tkColPtr->info.color.blue = colorPtr->blue; + tkColPtr->info.color.pixel = 0; + tkColPtr->index = -1; + XAllocColor(Tk_Display(tkwin), Tk_Colormap(tkwin), &tkColPtr->info.color); + return (TkColor *) tkColPtr; +} + +/* + *---------------------------------------------------------------------- + * + * TkpFreeColor -- + * + * Release the specified color back to the system. + * + * Results: + * None + * + * Side effects: + * Invalidates the colormap cache for the colormap associated with + * the given color. + * + *---------------------------------------------------------------------- + */ + +void +TkpFreeColor(tkColPtr) + TkColor *tkColPtr; /* Color to be released. Must have been + * allocated by TkpGetColor or + * TkpGetColorByValue. */ +{ + Screen *screen = tkColPtr->screen; + + XFreeColors(DisplayOfScreen(screen), tkColPtr->colormap, + &tkColPtr->color.pixel, 1, 0L); +} + +/* + *---------------------------------------------------------------------- + * + * TkWinIndexOfColor -- + * + * Given a color, return the system color index that was used + * to create the color. + * + * Results: + * If the color was allocated using a system indirect color name, + * then the corresponding GetSysColor() index is returned. + * Otherwise, -1 is returned. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkWinIndexOfColor(colorPtr) + XColor *colorPtr; +{ + register WinColor *winColPtr = (WinColor *) colorPtr; + if (winColPtr->info.magic == COLOR_MAGIC) { + return winColPtr->index; + } + return -1; +} + +/* + *---------------------------------------------------------------------- + * + * XAllocColor -- + * + * Find the closest available color to the specified XColor. + * + * Results: + * Updates the color argument and returns 1 on success. Otherwise + * returns 0. + * + * Side effects: + * Allocates a new color in the palette. + * + *---------------------------------------------------------------------- + */ + +int +XAllocColor(display, colormap, color) + Display* display; + Colormap colormap; + XColor* color; +{ + TkWinColormap *cmap = (TkWinColormap *) colormap; + PALETTEENTRY entry, closeEntry; + HDC dc = GetDC(NULL); + + entry.peRed = (color->red) >> 8; + entry.peGreen = (color->green) >> 8; + entry.peBlue = (color->blue) >> 8; + entry.peFlags = 0; + + if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE) { + unsigned long sizePalette = GetDeviceCaps(dc, SIZEPALETTE); + UINT newPixel, closePixel; + int new, refCount; + Tcl_HashEntry *entryPtr; + UINT index; + + /* + * Find the nearest existing palette entry. + */ + + newPixel = RGB(entry.peRed, entry.peGreen, entry.peBlue); + index = GetNearestPaletteIndex(cmap->palette, newPixel); + GetPaletteEntries(cmap->palette, index, 1, &closeEntry); + closePixel = RGB(closeEntry.peRed, closeEntry.peGreen, + closeEntry.peBlue); + + /* + * If this is not a duplicate, allocate a new entry. Note that + * we may get values for index that are above the current size + * of the palette. This happens because we don't shrink the size of + * the palette object when we deallocate colors so there may be + * stale values that match in the upper slots. We should ignore + * those values and just put the new color in as if the colors + * had not matched. + */ + + if ((index >= cmap->size) || (newPixel != closePixel)) { + if (cmap->size == sizePalette) { + color->red = closeEntry.peRed << 8; + color->green = closeEntry.peGreen << 8; + color->blue = closeEntry.peBlue << 8; + entry = closeEntry; + if (index >= cmap->size) { + OutputDebugString("XAllocColor: Colormap is bigger than we thought"); + } + } else { + cmap->size++; + ResizePalette(cmap->palette, cmap->size); + SetPaletteEntries(cmap->palette, cmap->size - 1, 1, &entry); + } + } + + color->pixel = PALETTERGB(entry.peRed, entry.peGreen, entry.peBlue); + entryPtr = Tcl_CreateHashEntry(&cmap->refCounts, + (char *) color->pixel, &new); + if (new) { + refCount = 1; + } else { + refCount = ((int) Tcl_GetHashValue(entryPtr)) + 1; + } + Tcl_SetHashValue(entryPtr, (ClientData)refCount); + } else { + + /* + * Determine what color will actually be used on non-colormap systems. + */ + + color->pixel = GetNearestColor(dc, + RGB(entry.peRed, entry.peGreen, entry.peBlue)); + color->red = (GetRValue(color->pixel) << 8); + color->green = (GetGValue(color->pixel) << 8); + color->blue = (GetBValue(color->pixel) << 8); + } + + ReleaseDC(NULL, dc); + return 1; +} + +/* + *---------------------------------------------------------------------- + * + * XFreeColors -- + * + * Deallocate a block of colors. + * + * Results: + * None. + * + * Side effects: + * Removes entries for the current palette and compacts the + * remaining set. + * + *---------------------------------------------------------------------- + */ + +void +XFreeColors(display, colormap, pixels, npixels, planes) + Display* display; + Colormap colormap; + unsigned long* pixels; + int npixels; + unsigned long planes; +{ + TkWinColormap *cmap = (TkWinColormap *) colormap; + COLORREF cref; + UINT count, index, refCount; + int i; + PALETTEENTRY entry, *entries; + Tcl_HashEntry *entryPtr; + HDC dc = GetDC(NULL); + + /* + * We don't have to do anything for non-palette devices. + */ + + if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE) { + + /* + * This is really slow for large values of npixels. + */ + + for (i = 0; i < npixels; i++) { + entryPtr = Tcl_FindHashEntry(&cmap->refCounts, + (char *) pixels[i]); + if (!entryPtr) { + panic("Tried to free a color that isn't allocated."); + } + refCount = (int) Tcl_GetHashValue(entryPtr) - 1; + if (refCount == 0) { + cref = pixels[i] & 0x00ffffff; + index = GetNearestPaletteIndex(cmap->palette, cref); + GetPaletteEntries(cmap->palette, index, 1, &entry); + if (cref == RGB(entry.peRed, entry.peGreen, entry.peBlue)) { + count = cmap->size - index; + entries = (PALETTEENTRY *) ckalloc(sizeof(PALETTEENTRY) + * count); + GetPaletteEntries(cmap->palette, index+1, count, entries); + SetPaletteEntries(cmap->palette, index, count, entries); + ckfree((char *) entries); + cmap->size--; + } else { + panic("Tried to free a color that isn't allocated."); + } + Tcl_DeleteHashEntry(entryPtr); + } else { + Tcl_SetHashValue(entryPtr, (ClientData)refCount); + } + } + } + ReleaseDC(NULL, dc); +} + +/* + *---------------------------------------------------------------------- + * + * XCreateColormap -- + * + * Allocate a new colormap. + * + * Results: + * Returns a newly allocated colormap. + * + * Side effects: + * Allocates an empty palette and color list. + * + *---------------------------------------------------------------------- + */ + +Colormap +XCreateColormap(display, w, visual, alloc) + Display* display; + Window w; + Visual* visual; + int alloc; +{ + char logPalBuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)]; + LOGPALETTE *logPalettePtr; + PALETTEENTRY *entryPtr; + TkWinColormap *cmap; + Tcl_HashEntry *hashPtr; + int new; + UINT i; + HPALETTE sysPal; + + /* + * Allocate a starting palette with all of the reserved colors. + */ + + logPalettePtr = (LOGPALETTE *) logPalBuf; + logPalettePtr->palVersion = 0x300; + sysPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE); + logPalettePtr->palNumEntries = GetPaletteEntries(sysPal, 0, 256, + logPalettePtr->palPalEntry); + + cmap = (TkWinColormap *) ckalloc(sizeof(TkWinColormap)); + cmap->size = logPalettePtr->palNumEntries; + cmap->stale = 0; + cmap->palette = CreatePalette(logPalettePtr); + + /* + * Add hash entries for each of the static colors. + */ + + Tcl_InitHashTable(&cmap->refCounts, TCL_ONE_WORD_KEYS); + for (i = 0; i < logPalettePtr->palNumEntries; i++) { + entryPtr = logPalettePtr->palPalEntry + i; + hashPtr = Tcl_CreateHashEntry(&cmap->refCounts, (char*) PALETTERGB( + entryPtr->peRed, entryPtr->peGreen, entryPtr->peBlue), &new); + Tcl_SetHashValue(hashPtr, (ClientData)1); + } + + return (Colormap)cmap; +} + +/* + *---------------------------------------------------------------------- + * + * XFreeColormap -- + * + * Frees the resources associated with the given colormap. + * + * Results: + * None. + * + * Side effects: + * Deletes the palette associated with the colormap. Note that + * the palette must not be selected into a device context when + * this occurs. + * + *---------------------------------------------------------------------- + */ + +void +XFreeColormap(display, colormap) + Display* display; + Colormap colormap; +{ + TkWinColormap *cmap = (TkWinColormap *) colormap; + if (!DeleteObject(cmap->palette)) { + panic("Unable to free colormap, palette is still selected."); + } + Tcl_DeleteHashTable(&cmap->refCounts); + ckfree((char *) cmap); +} + +/* + *---------------------------------------------------------------------- + * + * TkWinSelectPalette -- + * + * This function sets up the specified device context with a + * given palette. If the palette is stale, it realizes it in + * the background unless the palette is the current global + * palette. + * + * Results: + * Returns the previous palette selected into the device context. + * + * Side effects: + * May change the system palette. + * + *---------------------------------------------------------------------- + */ + +HPALETTE +TkWinSelectPalette(dc, colormap) + HDC dc; + Colormap colormap; +{ + TkWinColormap *cmap = (TkWinColormap *) colormap; + HPALETTE oldPalette; + + oldPalette = SelectPalette(dc, cmap->palette, + (cmap->palette == TkWinGetSystemPalette()) ? FALSE : TRUE); + RealizePalette(dc); + return oldPalette; +} diff --git a/win/tkWinCursor.c b/win/tkWinCursor.c new file mode 100644 index 0000000..bf81d8f --- /dev/null +++ b/win/tkWinCursor.c @@ -0,0 +1,210 @@ +/* + * tkWinCursor.c -- + * + * This file contains Win32 specific cursor related routines. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinCursor.c 1.10 97/09/02 13:21:01 + */ + +#include "tkWinInt.h" + +/* + * The following data structure contains the system specific data + * necessary to control Windows cursors. + */ + +typedef struct { + TkCursor info; /* Generic cursor info used by tkCursor.c */ + HCURSOR winCursor; /* Win32 cursor handle. */ + int system; /* 1 if cursor is a system cursor, else 0. */ +} TkWinCursor; + +/* + * The table below is used to map from the name of a predefined cursor + * to its resource identifier. + */ + +static struct CursorName { + char *name; + LPCTSTR id; +} cursorNames[] = { + {"starting", IDC_APPSTARTING}, + {"arrow", IDC_ARROW}, + {"ibeam", IDC_IBEAM}, + {"icon", IDC_ICON}, + {"no", IDC_NO}, + {"size", IDC_SIZE}, + {"size_ne_sw", IDC_SIZENESW}, + {"size_ns", IDC_SIZENS}, + {"size_nw_se", IDC_SIZENWSE}, + {"size_we", IDC_SIZEWE}, + {"uparrow", IDC_UPARROW}, + {"wait", IDC_WAIT}, + {"crosshair", IDC_CROSS}, + {"fleur", IDC_SIZE}, + {"sb_v_double_arrow", IDC_SIZENS}, + {"sb_h_double_arrow", IDC_SIZEWE}, + {"center_ptr", IDC_UPARROW}, + {"watch", IDC_WAIT}, + {"xterm", IDC_IBEAM}, + {NULL, 0} +}; + +/* + * The default cursor is used whenever no other cursor has been specified. + */ + +#define TK_DEFAULT_CURSOR IDC_ARROW + + +/* + *---------------------------------------------------------------------- + * + * TkGetCursorByName -- + * + * Retrieve a system cursor by name. + * + * Results: + * Returns a new cursor, or NULL on errors. + * + * Side effects: + * Allocates a new cursor. + * + *---------------------------------------------------------------------- + */ + +TkCursor * +TkGetCursorByName(interp, tkwin, string) + Tcl_Interp *interp; /* Interpreter to use for error reporting. */ + Tk_Window tkwin; /* Window in which cursor will be used. */ + Tk_Uid string; /* Description of cursor. See manual entry + * for details on legal syntax. */ +{ + struct CursorName *namePtr; + TkWinCursor *cursorPtr; + + /* + * Check for the cursor in the system cursor set. + */ + + for (namePtr = cursorNames; namePtr->name != NULL; namePtr++) { + if (strcmp(namePtr->name, string) == 0) { + break; + } + } + + cursorPtr = (TkWinCursor *) ckalloc(sizeof(TkWinCursor)); + cursorPtr->info.cursor = (Tk_Cursor) cursorPtr; + cursorPtr->winCursor = NULL; + if (namePtr->name != NULL) { + cursorPtr->winCursor = LoadCursor(NULL, namePtr->id); + cursorPtr->system = 1; + } + if (cursorPtr->winCursor == NULL) { + cursorPtr->winCursor = LoadCursor(Tk_GetHINSTANCE(), string); + cursorPtr->system = 0; + } + if (cursorPtr->winCursor == NULL) { + ckfree((char *)cursorPtr); + Tcl_AppendResult(interp, "bad cursor spec \"", string, "\"", + (char *) NULL); + return NULL; + } else { + return (TkCursor *) cursorPtr; + } +} + +/* + *---------------------------------------------------------------------- + * + * TkCreateCursorFromData -- + * + * Creates a cursor from the source and mask bits. + * + * Results: + * Returns a new cursor, or NULL on errors. + * + * Side effects: + * Allocates a new cursor. + * + *---------------------------------------------------------------------- + */ + +TkCursor * +TkCreateCursorFromData(tkwin, source, mask, width, height, xHot, yHot, + fgColor, bgColor) + Tk_Window tkwin; /* Window in which cursor will be used. */ + char *source; /* Bitmap data for cursor shape. */ + char *mask; /* Bitmap data for cursor mask. */ + int width, height; /* Dimensions of cursor. */ + int xHot, yHot; /* Location of hot-spot in cursor. */ + XColor fgColor; /* Foreground color for cursor. */ + XColor bgColor; /* Background color for cursor. */ +{ + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * TkFreeCursor -- + * + * This procedure is called to release a cursor allocated by + * TkGetCursorByName. + * + * Results: + * None. + * + * Side effects: + * The cursor data structure is deallocated. + * + *---------------------------------------------------------------------- + */ + +void +TkFreeCursor(cursorPtr) + TkCursor *cursorPtr; +{ + TkWinCursor *winCursorPtr = (TkWinCursor *) cursorPtr; + ckfree((char *) winCursorPtr); +} + +/* + *---------------------------------------------------------------------- + * + * TkpSetCursor -- + * + * Set the global cursor. If the cursor is None, then use the + * default Tk cursor. + * + * Results: + * None. + * + * Side effects: + * Changes the mouse cursor. + * + *---------------------------------------------------------------------- + */ + +void +TkpSetCursor(cursor) + TkpCursor cursor; +{ + HCURSOR hcursor; + TkWinCursor *winCursor = (TkWinCursor *) cursor; + + if (winCursor == NULL || winCursor->winCursor == NULL) { + hcursor = LoadCursor(NULL, TK_DEFAULT_CURSOR); + } else { + hcursor = winCursor->winCursor; + } + + if (hcursor != NULL) { + SetCursor(hcursor); + } +} diff --git a/win/tkWinDefault.h b/win/tkWinDefault.h new file mode 100644 index 0000000..c82f3c8 --- /dev/null +++ b/win/tkWinDefault.h @@ -0,0 +1,456 @@ +/* + * tkWinDefault.h -- + * + * This file defines the defaults for all options for all of + * the Tk widgets. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinDefault.h 1.34 97/10/09 17:45:20 + */ + +#ifndef _TKWINDEFAULT +#define _TKWINDEFAULT + +/* + * The definitions below provide symbolic names for the default colors. + * NORMAL_BG - Normal background color. + * ACTIVE_BG - Background color when widget is active. + * SELECT_BG - Background color for selected text. + * TROUGH - Background color for troughs in scales and scrollbars. + * INDICATOR - Color for indicator when button is selected. + * DISABLED - Foreground color when widget is disabled. + */ + +#define BLACK "Black" +#define WHITE "White" + +#define CTL_FONT "{MS Sans Serif} 8" +#define NORMAL_BG "SystemButtonFace" +#define NORMAL_FG "SystemButtonText" +#define ACTIVE_BG NORMAL_BG +#define TEXT_FG "SystemWindowText" +#define SELECT_BG "SystemHighlight" +#define SELECT_FG "SystemHighlightText" +#define TROUGH "SystemScrollbar" +#define INDICATOR "SystemWindow" +#define DISABLED "SystemDisabledText" +#define MENU_BG "SystemMenu" +#define MENU_FG "SystemMenuText" +#define HIGHLIGHT "SystemWindowFrame" + +/* + * Defaults for labels, buttons, checkbuttons, and radiobuttons: + */ + +#define DEF_BUTTON_ANCHOR "center" +#define DEF_BUTTON_ACTIVE_BG_COLOR NORMAL_BG +#define DEF_BUTTON_ACTIVE_BG_MONO BLACK +#define DEF_BUTTON_ACTIVE_FG_COLOR NORMAL_FG +#define DEF_CHKRAD_ACTIVE_FG_COLOR TEXT_FG +#define DEF_BUTTON_ACTIVE_FG_MONO WHITE +#define DEF_BUTTON_BG_COLOR NORMAL_BG +#define DEF_BUTTON_BG_MONO WHITE +#define DEF_BUTTON_BITMAP "" +#define DEF_BUTTON_BORDER_WIDTH "2" +#define DEF_BUTTON_CURSOR "" +#define DEF_BUTTON_COMMAND "" +#define DEF_BUTTON_DEFAULT "disabled" +#define DEF_BUTTON_DISABLED_FG_COLOR DISABLED +#define DEF_BUTTON_DISABLED_FG_MONO "" +#define DEF_BUTTON_FG NORMAL_FG +#define DEF_CHKRAD_FG TEXT_FG +#define DEF_BUTTON_FONT CTL_FONT +#define DEF_BUTTON_HEIGHT "0" +#define DEF_BUTTON_HIGHLIGHT_BG NORMAL_BG +#define DEF_BUTTON_HIGHLIGHT HIGHLIGHT +#define DEF_LABEL_HIGHLIGHT_WIDTH "0" +#define DEF_BUTTON_HIGHLIGHT_WIDTH "1" +#define DEF_BUTTON_IMAGE (char *) NULL +#define DEF_BUTTON_INDICATOR "1" +#define DEF_BUTTON_JUSTIFY "center" +#define DEF_BUTTON_OFF_VALUE "0" +#define DEF_BUTTON_ON_VALUE "1" +#define DEF_BUTTON_PADX "1" +#define DEF_LABCHKRAD_PADX "1" +#define DEF_BUTTON_PADY "1" +#define DEF_LABCHKRAD_PADY "1" +#define DEF_BUTTON_RELIEF "raised" +#define DEF_LABCHKRAD_RELIEF "flat" +#define DEF_BUTTON_SELECT_COLOR INDICATOR +#define DEF_BUTTON_SELECT_MONO BLACK +#define DEF_BUTTON_SELECT_IMAGE (char *) NULL +#define DEF_BUTTON_STATE "normal" +#define DEF_LABEL_TAKE_FOCUS "0" +#define DEF_BUTTON_TAKE_FOCUS (char *) NULL +#define DEF_BUTTON_TEXT "" +#define DEF_BUTTON_TEXT_VARIABLE "" +#define DEF_BUTTON_UNDERLINE "-1" +#define DEF_BUTTON_VALUE "" +#define DEF_BUTTON_WIDTH "0" +#define DEF_BUTTON_WRAP_LENGTH "0" +#define DEF_RADIOBUTTON_VARIABLE "selectedButton" +#define DEF_CHECKBUTTON_VARIABLE "" + +/* + * Defaults for canvases: + */ + +#define DEF_CANVAS_BG_COLOR NORMAL_BG +#define DEF_CANVAS_BG_MONO WHITE +#define DEF_CANVAS_BORDER_WIDTH "0" +#define DEF_CANVAS_CLOSE_ENOUGH "1" +#define DEF_CANVAS_CONFINE "1" +#define DEF_CANVAS_CURSOR "" +#define DEF_CANVAS_HEIGHT "7c" +#define DEF_CANVAS_HIGHLIGHT_BG NORMAL_BG +#define DEF_CANVAS_HIGHLIGHT HIGHLIGHT +#define DEF_CANVAS_HIGHLIGHT_WIDTH "2" +#define DEF_CANVAS_INSERT_BG NORMAL_FG +#define DEF_CANVAS_INSERT_BD_COLOR "0" +#define DEF_CANVAS_INSERT_BD_MONO "0" +#define DEF_CANVAS_INSERT_OFF_TIME "300" +#define DEF_CANVAS_INSERT_ON_TIME "600" +#define DEF_CANVAS_INSERT_WIDTH "2" +#define DEF_CANVAS_RELIEF "flat" +#define DEF_CANVAS_SCROLL_REGION "" +#define DEF_CANVAS_SELECT_COLOR SELECT_BG +#define DEF_CANVAS_SELECT_MONO BLACK +#define DEF_CANVAS_SELECT_BD_COLOR "1" +#define DEF_CANVAS_SELECT_BD_MONO "0" +#define DEF_CANVAS_SELECT_FG_COLOR SELECT_FG +#define DEF_CANVAS_SELECT_FG_MONO WHITE +#define DEF_CANVAS_TAKE_FOCUS (char *) NULL +#define DEF_CANVAS_WIDTH "10c" +#define DEF_CANVAS_X_SCROLL_CMD "" +#define DEF_CANVAS_X_SCROLL_INCREMENT "0" +#define DEF_CANVAS_Y_SCROLL_CMD "" +#define DEF_CANVAS_Y_SCROLL_INCREMENT "0" + +/* + * Defaults for entries: + */ + +#define DEF_ENTRY_BG_COLOR "SystemWindow" +#define DEF_ENTRY_BG_MONO WHITE +#define DEF_ENTRY_BORDER_WIDTH "2" +#define DEF_ENTRY_CURSOR "xterm" +#define DEF_ENTRY_EXPORT_SELECTION "1" +#define DEF_ENTRY_FONT CTL_FONT +#define DEF_ENTRY_FG TEXT_FG +#define DEF_ENTRY_HIGHLIGHT_BG NORMAL_BG +#define DEF_ENTRY_HIGHLIGHT HIGHLIGHT +#define DEF_ENTRY_HIGHLIGHT_WIDTH "0" +#define DEF_ENTRY_INSERT_BG TEXT_FG +#define DEF_ENTRY_INSERT_BD_COLOR "0" +#define DEF_ENTRY_INSERT_BD_MONO "0" +#define DEF_ENTRY_INSERT_OFF_TIME "300" +#define DEF_ENTRY_INSERT_ON_TIME "600" +#define DEF_ENTRY_INSERT_WIDTH "2" +#define DEF_ENTRY_JUSTIFY "left" +#define DEF_ENTRY_RELIEF "sunken" +#define DEF_ENTRY_SCROLL_COMMAND "" +#define DEF_ENTRY_SELECT_COLOR SELECT_BG +#define DEF_ENTRY_SELECT_MONO BLACK +#define DEF_ENTRY_SELECT_BD_COLOR "0" +#define DEF_ENTRY_SELECT_BD_MONO "0" +#define DEF_ENTRY_SELECT_FG_COLOR SELECT_FG +#define DEF_ENTRY_SELECT_FG_MONO WHITE +#define DEF_ENTRY_SHOW (char *) NULL +#define DEF_ENTRY_STATE "normal" +#define DEF_ENTRY_TAKE_FOCUS (char *) NULL +#define DEF_ENTRY_TEXT_VARIABLE "" +#define DEF_ENTRY_WIDTH "20" + +/* + * Defaults for frames: + */ + +#define DEF_FRAME_BG_COLOR NORMAL_BG +#define DEF_FRAME_BG_MONO WHITE +#define DEF_FRAME_BORDER_WIDTH "0" +#define DEF_FRAME_CLASS "Frame" +#define DEF_FRAME_COLORMAP "" +#define DEF_FRAME_CONTAINER "0" +#define DEF_FRAME_CURSOR "" +#define DEF_FRAME_HEIGHT "0" +#define DEF_FRAME_HIGHLIGHT_BG NORMAL_BG +#define DEF_FRAME_HIGHLIGHT HIGHLIGHT +#define DEF_FRAME_HIGHLIGHT_WIDTH "0" +#define DEF_FRAME_RELIEF "flat" +#define DEF_FRAME_TAKE_FOCUS "0" +#define DEF_FRAME_USE "" +#define DEF_FRAME_VISUAL "" +#define DEF_FRAME_WIDTH "0" + +/* + * Defaults for listboxes: + */ + +#define DEF_LISTBOX_BG_COLOR NORMAL_BG +#define DEF_LISTBOX_BG_MONO WHITE +#define DEF_LISTBOX_BORDER_WIDTH "2" +#define DEF_LISTBOX_CURSOR "" +#define DEF_LISTBOX_EXPORT_SELECTION "1" +#define DEF_LISTBOX_FONT CTL_FONT +#define DEF_LISTBOX_FG NORMAL_FG +#define DEF_LISTBOX_HEIGHT "10" +#define DEF_LISTBOX_HIGHLIGHT_BG NORMAL_BG +#define DEF_LISTBOX_HIGHLIGHT HIGHLIGHT +#define DEF_LISTBOX_HIGHLIGHT_WIDTH "1" +#define DEF_LISTBOX_RELIEF "sunken" +#define DEF_LISTBOX_SCROLL_COMMAND "" +#define DEF_LISTBOX_SELECT_COLOR SELECT_BG +#define DEF_LISTBOX_SELECT_MONO BLACK +#define DEF_LISTBOX_SELECT_BD "1" +#define DEF_LISTBOX_SELECT_FG_COLOR SELECT_FG +#define DEF_LISTBOX_SELECT_FG_MONO WHITE +#define DEF_LISTBOX_SELECT_MODE "browse" +#define DEF_LISTBOX_SET_GRID "0" +#define DEF_LISTBOX_TAKE_FOCUS (char *) NULL +#define DEF_LISTBOX_WIDTH "20" + +/* + * Defaults for individual entries of menus: + */ + +#define DEF_MENU_ENTRY_ACTIVE_BG (char *) NULL +#define DEF_MENU_ENTRY_ACTIVE_FG (char *) NULL +#define DEF_MENU_ENTRY_ACCELERATOR (char *) NULL +#define DEF_MENU_ENTRY_BG (char *) NULL +#define DEF_MENU_ENTRY_BITMAP None +#define DEF_MENU_ENTRY_COLUMN_BREAK "0" +#define DEF_MENU_ENTRY_COMMAND (char *) NULL +#define DEF_MENU_ENTRY_FG (char *) NULL +#define DEF_MENU_ENTRY_FONT (char *) NULL +#define DEF_MENU_ENTRY_HIDE_MARGIN "0" +#define DEF_MENU_ENTRY_IMAGE (char *) NULL +#define DEF_MENU_ENTRY_INDICATOR "1" +#define DEF_MENU_ENTRY_LABEL (char *) NULL +#define DEF_MENU_ENTRY_MENU (char *) NULL +#define DEF_MENU_ENTRY_OFF_VALUE "0" +#define DEF_MENU_ENTRY_ON_VALUE "1" +#define DEF_MENU_ENTRY_SELECT_IMAGE (char *) NULL +#define DEF_MENU_ENTRY_STATE "normal" +#define DEF_MENU_ENTRY_VALUE (char *) NULL +#define DEF_MENU_ENTRY_CHECK_VARIABLE (char *) NULL +#define DEF_MENU_ENTRY_RADIO_VARIABLE "selectedButton" +#define DEF_MENU_ENTRY_SELECT (char *) NULL +#define DEF_MENU_ENTRY_UNDERLINE "-1" + +/* + * Defaults for menus overall: + */ + +#define DEF_MENU_ACTIVE_BG_COLOR SELECT_BG +#define DEF_MENU_ACTIVE_BG_MONO BLACK +#define DEF_MENU_ACTIVE_BORDER_WIDTH "0" +#define DEF_MENU_ACTIVE_FG_COLOR SELECT_FG +#define DEF_MENU_ACTIVE_FG_MONO WHITE +#define DEF_MENU_BG_COLOR MENU_BG +#define DEF_MENU_BG_MONO WHITE +#define DEF_MENU_BORDER_WIDTH "0" +#define DEF_MENU_CURSOR "arrow" +#define DEF_MENU_DISABLED_FG_COLOR DISABLED +#define DEF_MENU_DISABLED_FG_MONO "" +#define DEF_MENU_FONT CTL_FONT +#define DEF_MENU_FG MENU_FG +#define DEF_MENU_POST_COMMAND "" +#define DEF_MENU_RELIEF "flat" +#define DEF_MENU_SELECT_COLOR MENU_FG +#define DEF_MENU_SELECT_MONO BLACK +#define DEF_MENU_TAKE_FOCUS "0" +#define DEF_MENU_TEAROFF "1" +#define DEF_MENU_TEAROFF_CMD (char *) NULL +#define DEF_MENU_TITLE "" +#define DEF_MENU_TYPE "normal" + +/* + * Defaults for menubuttons: + */ + +#define DEF_MENUBUTTON_ANCHOR "center" +#define DEF_MENUBUTTON_ACTIVE_BG_COLOR ACTIVE_BG +#define DEF_MENUBUTTON_ACTIVE_BG_MONO BLACK +#define DEF_MENUBUTTON_ACTIVE_FG_COLOR NORMAL_FG +#define DEF_MENUBUTTON_ACTIVE_FG_MONO WHITE +#define DEF_MENUBUTTON_BG_COLOR NORMAL_BG +#define DEF_MENUBUTTON_BG_MONO WHITE +#define DEF_MENUBUTTON_BITMAP "" +#define DEF_MENUBUTTON_BORDER_WIDTH "2" +#define DEF_MENUBUTTON_CURSOR "" +#define DEF_MENUBUTTON_DIRECTION "below" +#define DEF_MENUBUTTON_DISABLED_FG_COLOR DISABLED +#define DEF_MENUBUTTON_DISABLED_FG_MONO "" +#define DEF_MENUBUTTON_FONT CTL_FONT +#define DEF_MENUBUTTON_FG NORMAL_FG +#define DEF_MENUBUTTON_HEIGHT "0" +#define DEF_MENUBUTTON_HIGHLIGHT_BG NORMAL_BG +#define DEF_MENUBUTTON_HIGHLIGHT HIGHLIGHT +#define DEF_MENUBUTTON_HIGHLIGHT_WIDTH "0" +#define DEF_MENUBUTTON_IMAGE (char *) NULL +#define DEF_MENUBUTTON_INDICATOR "0" +#define DEF_MENUBUTTON_JUSTIFY "center" +#define DEF_MENUBUTTON_MENU "" +#define DEF_MENUBUTTON_PADX "4p" +#define DEF_MENUBUTTON_PADY "3p" +#define DEF_MENUBUTTON_RELIEF "flat" +#define DEF_MENUBUTTON_STATE "normal" +#define DEF_MENUBUTTON_TAKE_FOCUS "0" +#define DEF_MENUBUTTON_TEXT "" +#define DEF_MENUBUTTON_TEXT_VARIABLE "" +#define DEF_MENUBUTTON_UNDERLINE "-1" +#define DEF_MENUBUTTON_WIDTH "0" +#define DEF_MENUBUTTON_WRAP_LENGTH "0" + +/* + * Defaults for messages: + */ + +#define DEF_MESSAGE_ANCHOR "center" +#define DEF_MESSAGE_ASPECT "150" +#define DEF_MESSAGE_BG_COLOR NORMAL_BG +#define DEF_MESSAGE_BG_MONO WHITE +#define DEF_MESSAGE_BORDER_WIDTH "2" +#define DEF_MESSAGE_CURSOR "" +#define DEF_MESSAGE_FG NORMAL_FG +#define DEF_MESSAGE_FONT CTL_FONT +#define DEF_MESSAGE_HIGHLIGHT_BG NORMAL_BG +#define DEF_MESSAGE_HIGHLIGHT HIGHLIGHT +#define DEF_MESSAGE_HIGHLIGHT_WIDTH "0" +#define DEF_MESSAGE_JUSTIFY "left" +#define DEF_MESSAGE_PADX "-1" +#define DEF_MESSAGE_PADY "-1" +#define DEF_MESSAGE_RELIEF "flat" +#define DEF_MESSAGE_TAKE_FOCUS "0" +#define DEF_MESSAGE_TEXT "" +#define DEF_MESSAGE_TEXT_VARIABLE "" +#define DEF_MESSAGE_WIDTH "0" + +/* + * Defaults for scales: + */ + +#define DEF_SCALE_ACTIVE_BG_COLOR ACTIVE_BG +#define DEF_SCALE_ACTIVE_BG_MONO BLACK +#define DEF_SCALE_BG_COLOR NORMAL_BG +#define DEF_SCALE_BG_MONO WHITE +#define DEF_SCALE_BIG_INCREMENT "0" +#define DEF_SCALE_BORDER_WIDTH "2" +#define DEF_SCALE_COMMAND "" +#define DEF_SCALE_CURSOR "" +#define DEF_SCALE_DIGITS "0" +#define DEF_SCALE_FONT CTL_FONT +#define DEF_SCALE_FG_COLOR NORMAL_FG +#define DEF_SCALE_FG_MONO BLACK +#define DEF_SCALE_FROM "0" +#define DEF_SCALE_HIGHLIGHT_BG NORMAL_BG +#define DEF_SCALE_HIGHLIGHT HIGHLIGHT +#define DEF_SCALE_HIGHLIGHT_WIDTH "2" +#define DEF_SCALE_LABEL "" +#define DEF_SCALE_LENGTH "100" +#define DEF_SCALE_ORIENT "vertical" +#define DEF_SCALE_RELIEF "flat" +#define DEF_SCALE_REPEAT_DELAY "300" +#define DEF_SCALE_REPEAT_INTERVAL "100" +#define DEF_SCALE_RESOLUTION "1" +#define DEF_SCALE_TROUGH_COLOR TROUGH +#define DEF_SCALE_TROUGH_MONO WHITE +#define DEF_SCALE_SHOW_VALUE "1" +#define DEF_SCALE_SLIDER_LENGTH "30" +#define DEF_SCALE_SLIDER_RELIEF "raised" +#define DEF_SCALE_STATE "normal" +#define DEF_SCALE_TAKE_FOCUS (char *) NULL +#define DEF_SCALE_TICK_INTERVAL "0" +#define DEF_SCALE_TO "100" +#define DEF_SCALE_VARIABLE "" +#define DEF_SCALE_WIDTH "15" + +/* + * Defaults for scrollbars: + */ + +#define DEF_SCROLLBAR_ACTIVE_BG_COLOR ACTIVE_BG +#define DEF_SCROLLBAR_ACTIVE_BG_MONO BLACK +#define DEF_SCROLLBAR_ACTIVE_RELIEF "raised" +#define DEF_SCROLLBAR_BG_COLOR NORMAL_BG +#define DEF_SCROLLBAR_BG_MONO WHITE +#define DEF_SCROLLBAR_BORDER_WIDTH "0" +#define DEF_SCROLLBAR_COMMAND "" +#define DEF_SCROLLBAR_CURSOR "" +#define DEF_SCROLLBAR_EL_BORDER_WIDTH "-1" +#define DEF_SCROLLBAR_HIGHLIGHT_BG NORMAL_BG +#define DEF_SCROLLBAR_HIGHLIGHT HIGHLIGHT +#define DEF_SCROLLBAR_HIGHLIGHT_WIDTH "0" +#define DEF_SCROLLBAR_JUMP "0" +#define DEF_SCROLLBAR_ORIENT "vertical" +#define DEF_SCROLLBAR_RELIEF "sunken" +#define DEF_SCROLLBAR_REPEAT_DELAY "300" +#define DEF_SCROLLBAR_REPEAT_INTERVAL "100" +#define DEF_SCROLLBAR_TAKE_FOCUS (char *) NULL +#define DEF_SCROLLBAR_TROUGH_COLOR TROUGH +#define DEF_SCROLLBAR_TROUGH_MONO WHITE +#define DEF_SCROLLBAR_WIDTH "10" + +/* + * Defaults for texts: + */ + +#define DEF_TEXT_BG_COLOR "SystemWindow" +#define DEF_TEXT_BG_MONO WHITE +#define DEF_TEXT_BORDER_WIDTH "2" +#define DEF_TEXT_CURSOR "xterm" +#define DEF_TEXT_FG TEXT_FG +#define DEF_TEXT_EXPORT_SELECTION "1" +#define DEF_TEXT_FONT CTL_FONT +#define DEF_TEXT_HEIGHT "24" +#define DEF_TEXT_HIGHLIGHT_BG NORMAL_BG +#define DEF_TEXT_HIGHLIGHT HIGHLIGHT +#define DEF_TEXT_HIGHLIGHT_WIDTH "0" +#define DEF_TEXT_INSERT_BG TEXT_FG +#define DEF_TEXT_INSERT_BD_COLOR "0" +#define DEF_TEXT_INSERT_BD_MONO "0" +#define DEF_TEXT_INSERT_OFF_TIME "300" +#define DEF_TEXT_INSERT_ON_TIME "600" +#define DEF_TEXT_INSERT_WIDTH "2" +#define DEF_TEXT_PADX "1" +#define DEF_TEXT_PADY "1" +#define DEF_TEXT_RELIEF "sunken" +#define DEF_TEXT_SELECT_COLOR SELECT_BG +#define DEF_TEXT_SELECT_MONO BLACK +#define DEF_TEXT_SELECT_BD_COLOR "0" +#define DEF_TEXT_SELECT_BD_MONO "0" +#define DEF_TEXT_SELECT_FG_COLOR SELECT_FG +#define DEF_TEXT_SELECT_FG_MONO WHITE +#define DEF_TEXT_SELECT_RELIEF "flat" +#define DEF_TEXT_SET_GRID "0" +#define DEF_TEXT_SPACING1 "0" +#define DEF_TEXT_SPACING2 "0" +#define DEF_TEXT_SPACING3 "0" +#define DEF_TEXT_STATE "normal" +#define DEF_TEXT_TABS "" +#define DEF_TEXT_TAKE_FOCUS (char *) NULL +#define DEF_TEXT_WIDTH "80" +#define DEF_TEXT_WRAP "char" +#define DEF_TEXT_XSCROLL_COMMAND "" +#define DEF_TEXT_YSCROLL_COMMAND "" + +/* + * Defaults for canvas text: + */ + +#define DEF_CANVTEXT_FONT CTL_FONT + +/* + * Defaults for toplevels (most of the defaults for frames also apply + * to toplevels): + */ + +#define DEF_TOPLEVEL_CLASS "Toplevel" +#define DEF_TOPLEVEL_MENU "" +#define DEF_TOPLEVEL_SCREEN "" + +#endif /* _TKWINDEFAULT */ diff --git a/win/tkWinDialog.c b/win/tkWinDialog.c new file mode 100644 index 0000000..7d01edb --- /dev/null +++ b/win/tkWinDialog.c @@ -0,0 +1,1050 @@ +/* + * tkWinDialog.c -- + * + * Contains the Windows implementation of the common dialog boxes. + * + * Copyright (c) 1996-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinDialog.c 1.10 97/10/21 11:29:18 + * + */ + +#include "tkWinInt.h" +#include "tkFileFilter.h" + +#include <commdlg.h> /* includes common dialog functionality */ +#include <dlgs.h> /* includes common dialog template defines */ +#include <cderr.h> /* includes the common dialog error codes */ + +#if ((TK_MAJOR_VERSION == 4) && (TK_MINOR_VERSION <= 2)) +/* + * The following function is implemented on tk4.3 and after only + */ +#define Tk_GetHWND TkWinGetHWND +#endif + +#define SAVE_FILE 0 +#define OPEN_FILE 1 + +/*---------------------------------------------------------------------- + * MsgTypeInfo -- + * + * This structure stores the type of available message box in an + * easy-to-process format. Used by th Tk_MessageBox() function + *---------------------------------------------------------------------- + */ +typedef struct MsgTypeInfo { + char * name; + int type; + int numButtons; + char * btnNames[3]; +} MsgTypeInfo; + +#define NUM_TYPES 6 + +static MsgTypeInfo +msgTypeInfo[NUM_TYPES] = { + {"abortretryignore", MB_ABORTRETRYIGNORE, 3, {"abort", "retry", "ignore"}}, + {"ok", MB_OK, 1, {"ok" }}, + {"okcancel", MB_OKCANCEL, 2, {"ok", "cancel" }}, + {"retrycancel", MB_RETRYCANCEL, 2, {"retry", "cancel" }}, + {"yesno", MB_YESNO, 2, {"yes", "no" }}, + {"yesnocancel", MB_YESNOCANCEL, 3, {"yes", "no", "cancel"}} +}; + +/* + * The following structure is used in the GetOpenFileName() and + * GetSaveFileName() calls. + */ +typedef struct _OpenFileData { + Tcl_Interp * interp; + TCHAR szFile[MAX_PATH+1]; +} OpenFileData; + +/* + * The following structure is used in the ChooseColor() call. + */ +typedef struct _ChooseColorData { + Tcl_Interp * interp; + char * title; /* Title of the color dialog */ +} ChooseColorData; + + +static int GetFileName _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, int argc, char **argv, + int isOpen)); +static UINT CALLBACK ColorDlgHookProc _ANSI_ARGS_((HWND hDlg, UINT uMsg, + WPARAM wParam, LPARAM lParam)); +static int MakeFilter _ANSI_ARGS_((Tcl_Interp *interp, + OPENFILENAME *ofnPtr, char * string)); +static int ParseFileDlgArgs _ANSI_ARGS_((Tcl_Interp * interp, + OPENFILENAME *ofnPtr, int argc, char ** argv, + int isOpen)); +static int ProcessCDError _ANSI_ARGS_((Tcl_Interp * interp, + DWORD dwErrorCode, HWND hWnd)); + +/* + *---------------------------------------------------------------------- + * + * EvalArgv -- + * + * Invokes the Tcl procedure with the arguments. argv[0] is set by + * the caller of this function. It may be different than cmdName. + * The TCL command will see argv[0], not cmdName, as its name if it + * invokes [lindex [info level 0] 0] + * + * Results: + * TCL_ERROR if the command does not exist and cannot be autoloaded. + * Otherwise, return the result of the evaluation of the command. + * + * Side effects: + * The command may be autoloaded. + * + *---------------------------------------------------------------------- + */ + +static int +EvalArgv(interp, cmdName, argc, argv) + Tcl_Interp *interp; /* Current interpreter. */ + char * cmdName; /* Name of the TCL command to call */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + Tcl_CmdInfo cmdInfo; + + if (!Tcl_GetCommandInfo(interp, cmdName, &cmdInfo)) { + char * cmdArgv[2]; + + /* + * This comand is not in the interpreter yet -- looks like we + * have to auto-load it + */ + if (!Tcl_GetCommandInfo(interp, "auto_load", &cmdInfo)) { + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "cannot execute command \"auto_load\"", + NULL); + return TCL_ERROR; + } + + cmdArgv[0] = "auto_load"; + cmdArgv[1] = cmdName; + + if ((*cmdInfo.proc)(cmdInfo.clientData, interp, 2, cmdArgv)!= TCL_OK){ + return TCL_ERROR; + } + + if (!Tcl_GetCommandInfo(interp, cmdName, &cmdInfo)) { + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "cannot auto-load command \"", + cmdName, "\"",NULL); + return TCL_ERROR; + } + } + + return (*cmdInfo.proc)(cmdInfo.clientData, interp, argc, argv); +} + +/* + *---------------------------------------------------------------------- + * + * Tk_ChooseColorCmd -- + * + * This procedure implements the color dialog box for the Windows + * platform. See the user documentation for details on what it + * does. + * + * Results: + * See user documentation. + * + * Side effects: + * A dialog window is created the first time this procedure is called. + * This window is not destroyed and will be reused the next time the + * application invokes the "tk_chooseColor" command. + * + *---------------------------------------------------------------------- + */ + +int +Tk_ChooseColorCmd(clientData, interp, argc, argv) + ClientData clientData; /* Main window associated with interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + Tk_Window parent = Tk_MainWindow(interp); + ChooseColorData custData; + int oldMode; + CHOOSECOLOR chooseColor; + char * colorStr = NULL; + int i; + int winCode, tclCode; + XColor * colorPtr = NULL; + static inited = 0; + static long dwCustColors[16]; + static long oldColor; /* the color selected last time */ + + custData.title = NULL; + + if (!inited) { + /* + * dwCustColors stores the custom color which the user can + * modify. We store these colors in a fixed array so that the next + * time the color dialog pops up, the same set of custom colors + * remain in the dialog. + */ + for (i=0; i<16; i++) { + dwCustColors[i] = (RGB(255-i*10, i, i*10)) ; + } + oldColor = RGB(0xa0,0xa0,0xa0); + inited = 1; + } + + /* + * 1. Parse the arguments + */ + + chooseColor.lStructSize = sizeof(CHOOSECOLOR) ; + chooseColor.hwndOwner = 0; /* filled in below */ + chooseColor.hInstance = 0; + chooseColor.rgbResult = oldColor; + chooseColor.lpCustColors = (LPDWORD) dwCustColors ; + chooseColor.Flags = CC_RGBINIT | CC_FULLOPEN | CC_ENABLEHOOK; + chooseColor.lCustData = (LPARAM)&custData; + chooseColor.lpfnHook = ColorDlgHookProc; + chooseColor.lpTemplateName = NULL; + + for (i=1; i<argc; i+=2) { + int v = i+1; + int len = strlen(argv[i]); + + if (strncmp(argv[i], "-initialcolor", len)==0) { + if (v==argc) {goto arg_missing;} + + colorStr = argv[v]; + } + else if (strncmp(argv[i], "-parent", len)==0) { + if (v==argc) {goto arg_missing;} + + parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp)); + if (parent == NULL) { + return TCL_ERROR; + } + } + else if (strncmp(argv[i], "-title", len)==0) { + if (v==argc) {goto arg_missing;} + + custData.title = argv[v]; + } + else { + Tcl_AppendResult(interp, "unknown option \"", + argv[i], "\", must be -initialcolor, -parent or -title", + NULL); + return TCL_ERROR; + } + } + + if (Tk_WindowId(parent) == None) { + Tk_MakeWindowExist(parent); + } + chooseColor.hwndOwner = Tk_GetHWND(Tk_WindowId(parent)); + + if (colorStr != NULL) { + colorPtr = Tk_GetColor(interp, Tk_MainWindow(interp), colorStr); + if (!colorPtr) { + return TCL_ERROR; + } + chooseColor.rgbResult = RGB((colorPtr->red/0x100), + (colorPtr->green/0x100), (colorPtr->blue/0x100)); + } + + /* + * 2. Popup the dialog + */ + + oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + winCode = ChooseColor(&chooseColor); + (void) Tcl_SetServiceMode(oldMode); + + /* + * Clear the interp result since anything may have happened during the + * modal loop. + */ + + Tcl_ResetResult(interp); + + /* + * 3. Process the result of the dialog + */ + if (winCode) { + /* + * User has selected a color + */ + char result[100]; + + sprintf(result, "#%02x%02x%02x", + GetRValue(chooseColor.rgbResult), + GetGValue(chooseColor.rgbResult), + GetBValue(chooseColor.rgbResult)); + Tcl_AppendResult(interp, result, NULL); + tclCode = TCL_OK; + + oldColor = chooseColor.rgbResult; + } else { + /* + * User probably pressed Cancel, or an error occurred + */ + tclCode = ProcessCDError(interp, CommDlgExtendedError(), + chooseColor.hwndOwner); + } + + if (colorPtr) { + Tk_FreeColor(colorPtr); + } + + return tclCode; + + arg_missing: + Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing", + NULL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * ColorDlgHookProc -- + * + * Gets called during the execution of the color dialog. It processes + * the "interesting" messages that Windows send to the dialog. + * + * Results: + * TRUE if the message has been processed, FALSE otherwise. + * + * Side effects: + * Changes the title of the dialog window when it is popped up. + * + *---------------------------------------------------------------------- + */ + +static UINT +CALLBACK ColorDlgHookProc(hDlg, uMsg, wParam, lParam) + HWND hDlg; /* Handle to the color dialog */ + UINT uMsg; /* Type of message */ + WPARAM wParam; /* word param, interpretation depends on uMsg*/ + LPARAM lParam; /* long param, interpretation depends on uMsg*/ +{ + CHOOSECOLOR * ccPtr; + ChooseColorData * pCustData; + + switch (uMsg) { + case WM_INITDIALOG: + /* Save the pointer to CHOOSECOLOR so that we can use it later */ + SetWindowLong(hDlg, DWL_USER, lParam); + + /* Set the title string of the dialog */ + ccPtr = (CHOOSECOLOR*)lParam; + pCustData = (ChooseColorData*)(ccPtr->lCustData); + if (pCustData->title && *(pCustData->title)) { + SetWindowText(hDlg, (LPCSTR)pCustData->title); + } + + return TRUE; + } + + return FALSE; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetOpenFileCmd -- + * + * This procedure implements the "open file" dialog box for the + * Windows platform. See the user documentation for details on what + * it does. + * + * Results: + * See user documentation. + * + * Side effects: + * A dialog window is created the first this procedure is called. + * This window is not destroyed and will be reused the next time + * the application invokes the "tk_getOpenFile" or + * "tk_getSaveFile" command. + * + *---------------------------------------------------------------------- + */ + +int +Tk_GetOpenFileCmd(clientData, interp, argc, argv) + ClientData clientData; /* Main window associated with interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + return GetFileName(clientData, interp, argc, argv, OPEN_FILE); +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetSaveFileCmd -- + * + * Same as Tk_GetOpenFileCmd but opens a "save file" dialog box + * instead + * + * Results: + * Same as Tk_GetOpenFileCmd. + * + * Side effects: + * Same as Tk_GetOpenFileCmd. + * + *---------------------------------------------------------------------- + */ + +int +Tk_GetSaveFileCmd(clientData, interp, argc, argv) + ClientData clientData; /* Main window associated with interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + return GetFileName(clientData, interp, argc, argv, SAVE_FILE); +} + +/* + *---------------------------------------------------------------------- + * + * GetFileName -- + * + * Calls GetOpenFileName() or GetSaveFileName(). + * + * Results: + * See user documentation. + * + * Side effects: + * See user documentation. + * + *---------------------------------------------------------------------- + */ + +static int +GetFileName(clientData, interp, argc, argv, isOpen) + ClientData clientData; /* Main window associated with interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ + int isOpen; /* true if we should call GetOpenFileName(), + * false if we should call GetSaveFileName() */ +{ + OPENFILENAME openFileName, *ofnPtr; + int tclCode, winCode, oldMode; + OpenFileData *custData; + char buffer[MAX_PATH+1]; + + ofnPtr = &openFileName; + + /* + * 1. Parse the arguments. + */ + if (ParseFileDlgArgs(interp, ofnPtr, argc, argv, isOpen) != TCL_OK) { + return TCL_ERROR; + } + custData = (OpenFileData*) ofnPtr->lCustData; + + /* + * 2. Call the common dialog function. + */ + oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + GetCurrentDirectory(MAX_PATH+1, buffer); + if (isOpen) { + winCode = GetOpenFileName(ofnPtr); + } else { + winCode = GetSaveFileName(ofnPtr); + } + SetCurrentDirectory(buffer); + (void) Tcl_SetServiceMode(oldMode); + + /* + * Clear the interp result since anything may have happened during the + * modal loop. + */ + + Tcl_ResetResult(interp); + + if (ofnPtr->lpstrInitialDir != NULL) { + ckfree((char*) ofnPtr->lpstrInitialDir); + } + + /* + * 3. Process the results. + */ + if (winCode) { + char *p; + Tcl_ResetResult(interp); + + for (p = custData->szFile; p && *p; p++) { + /* + * Change the pathname to the Tcl "normalized" pathname, where + * back slashes are used instead of forward slashes + */ + if (*p == '\\') { + *p = '/'; + } + } + Tcl_AppendResult(interp, custData->szFile, NULL); + tclCode = TCL_OK; + } else { + tclCode = ProcessCDError(interp, CommDlgExtendedError(), + ofnPtr->hwndOwner); + } + + if (custData) { + ckfree((char*)custData); + } + if (ofnPtr->lpstrFilter) { + ckfree((char*)ofnPtr->lpstrFilter); + } + + return tclCode; +} + +/* + *---------------------------------------------------------------------- + * + * ParseFileDlgArgs -- + * + * Parses the arguments passed to tk_getOpenFile and tk_getSaveFile. + * + * Results: + * A standard TCL return value. + * + * Side effects: + * The OPENFILENAME structure is initialized and modified according + * to the arguments. + * + *---------------------------------------------------------------------- + */ + +static int +ParseFileDlgArgs(interp, ofnPtr, argc, argv, isOpen) + Tcl_Interp * interp; /* Current interpreter. */ + OPENFILENAME *ofnPtr; /* Info about the file dialog */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ + int isOpen; /* true if we should call GetOpenFileName(), + * false if we should call GetSaveFileName() */ +{ + OpenFileData * custData; + int i; + Tk_Window parent = Tk_MainWindow(interp); + int doneFilter = 0; + int windowsMajorVersion; + Tcl_DString buffer; + + custData = (OpenFileData*)ckalloc(sizeof(OpenFileData)); + custData->interp = interp; + strcpy(custData->szFile, ""); + + /* Fill in the OPENFILENAME structure to */ + ofnPtr->lStructSize = sizeof(OPENFILENAME); + ofnPtr->hwndOwner = 0; /* filled in below */ + ofnPtr->lpstrFilter = NULL; + ofnPtr->lpstrCustomFilter = NULL; + ofnPtr->nMaxCustFilter = 0; + ofnPtr->nFilterIndex = 0; + ofnPtr->lpstrFile = custData->szFile; + ofnPtr->nMaxFile = sizeof(custData->szFile); + ofnPtr->lpstrFileTitle = NULL; + ofnPtr->nMaxFileTitle = 0; + ofnPtr->lpstrInitialDir = NULL; + ofnPtr->lpstrTitle = NULL; + ofnPtr->nFileOffset = 0; + ofnPtr->nFileExtension = 0; + ofnPtr->lpstrDefExt = NULL; + ofnPtr->lpfnHook = NULL; + ofnPtr->lCustData = (DWORD)custData; + ofnPtr->lpTemplateName = NULL; + ofnPtr->Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST; + + windowsMajorVersion = LOBYTE(LOWORD(GetVersion())); + if (windowsMajorVersion >= 4) { + /* + * Use the "explorer" style file selection box on platforms that + * support it (Win95 and NT4.0, both have a major version number + * of 4) + */ + ofnPtr->Flags |= OFN_EXPLORER; + } + + + if (isOpen) { + ofnPtr->Flags |= OFN_FILEMUSTEXIST; + } else { + ofnPtr->Flags |= OFN_OVERWRITEPROMPT; + } + + for (i=1; i<argc; i+=2) { + int v = i+1; + int len = strlen(argv[i]); + + if (strncmp(argv[i], "-defaultextension", len)==0) { + if (v==argc) {goto arg_missing;} + + ofnPtr->lpstrDefExt = argv[v]; + if (ofnPtr->lpstrDefExt[0] == '.') { + /* Windows will insert the dot for us */ + ofnPtr->lpstrDefExt ++; + } + } + else if (strncmp(argv[i], "-filetypes", len)==0) { + if (v==argc) {goto arg_missing;} + + if (MakeFilter(interp, ofnPtr, argv[v]) != TCL_OK) { + return TCL_ERROR; + } + doneFilter = 1; + } + else if (strncmp(argv[i], "-initialdir", len)==0) { + if (v==argc) {goto arg_missing;} + + if (Tcl_TranslateFileName(interp, argv[v], &buffer) == NULL) { + return TCL_ERROR; + } + ofnPtr->lpstrInitialDir = ckalloc(Tcl_DStringLength(&buffer)+1); + strcpy((char*)ofnPtr->lpstrInitialDir, Tcl_DStringValue(&buffer)); + Tcl_DStringFree(&buffer); + } + else if (strncmp(argv[i], "-initialfile", len)==0) { + if (v==argc) {goto arg_missing;} + + if (Tcl_TranslateFileName(interp, argv[v], &buffer) == NULL) { + return TCL_ERROR; + } + strcpy(ofnPtr->lpstrFile, Tcl_DStringValue(&buffer)); + Tcl_DStringFree(&buffer); + } + else if (strncmp(argv[i], "-parent", len)==0) { + if (v==argc) {goto arg_missing;} + + parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp)); + if (parent == NULL) { + return TCL_ERROR; + } + } + else if (strncmp(argv[i], "-title", len)==0) { + if (v==argc) {goto arg_missing;} + + ofnPtr->lpstrTitle = argv[v]; + } + else { + Tcl_AppendResult(interp, "unknown option \"", + argv[i], "\", must be -defaultextension, ", + "-filetypes, -initialdir, -initialfile, -parent or -title", + NULL); + return TCL_ERROR; + } + } + + if (!doneFilter) { + if (MakeFilter(interp, ofnPtr, "") != TCL_OK) { + return TCL_ERROR; + } + } + + if (Tk_WindowId(parent) == None) { + Tk_MakeWindowExist(parent); + } + ofnPtr->hwndOwner = Tk_GetHWND(Tk_WindowId(parent)); + + return TCL_OK; + + arg_missing: + Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing", + NULL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * MakeFilter -- + * + * Allocate a buffer to store the filters in a format understood by + * Windows + * + * Results: + * A standard TCL return value. + * + * Side effects: + * ofnPtr->lpstrFilter is modified. + * + *---------------------------------------------------------------------- + */ +static int MakeFilter(interp, ofnPtr, string) + Tcl_Interp *interp; /* Current interpreter. */ + OPENFILENAME *ofnPtr; /* Info about the file dialog */ + char *string; /* String value of the -filetypes option */ +{ + char *filterStr; + char *p; + int pass; + FileFilterList flist; + FileFilter *filterPtr; + + TkInitFileFilters(&flist); + if (TkGetFileFilters(interp, &flist, string, 1) != TCL_OK) { + return TCL_ERROR; + } + + if (flist.filters == NULL) { + /* + * Use "All Files (*.*) as the default filter is none is specified + */ + char *defaultFilter = "All Files (*.*)"; + + p = filterStr = (char*)ckalloc(30 * sizeof(char)); + + strcpy(p, defaultFilter); + p+= strlen(defaultFilter); + + *p++ = '\0'; + *p++ = '*'; + *p++ = '.'; + *p++ = '*'; + *p++ = '\0'; + *p++ = '\0'; + *p = '\0'; + + } else { + /* We format the filetype into a string understood by Windows: + * {"Text Documents" {.doc .txt} {TEXT}} becomes + * "Text Documents (*.doc,*.txt)\0*.doc;*.txt\0" + * + * See the Windows OPENFILENAME manual page for details on the filter + * string format. + */ + + /* + * Since we may only add asterisks (*) to the filter, we need at most + * twice the size of the string to format the filter + */ + filterStr = ckalloc(strlen(string) * 3); + + for (filterPtr = flist.filters, p = filterStr; filterPtr; + filterPtr = filterPtr->next) { + char *sep; + FileFilterClause *clausePtr; + + /* + * First, put in the name of the file type + */ + strcpy(p, filterPtr->name); + p+= strlen(filterPtr->name); + *p++ = ' '; + *p++ = '('; + + for (pass = 1; pass <= 2; pass++) { + /* + * In the first pass, we format the extensions in the + * name field. In the second pass, we format the extensions in + * the filter pattern field + */ + sep = ""; + for (clausePtr=filterPtr->clauses;clausePtr; + clausePtr=clausePtr->next) { + GlobPattern *globPtr; + + + for (globPtr=clausePtr->patterns; globPtr; + globPtr=globPtr->next) { + strcpy(p, sep); + p+= strlen(sep); + strcpy(p, globPtr->pattern); + p+= strlen(globPtr->pattern); + + if (pass==1) { + sep = ","; + } else { + sep = ";"; + } + } + } + if (pass == 1) { + if (pass == 1) { + *p ++ = ')'; + } + } + *p ++ = '\0'; + } + } + + /* + * Windows requires the filter string to be ended by two NULL + * characters. + */ + *p++ = '\0'; + *p = '\0'; + } + + if (ofnPtr->lpstrFilter != NULL) { + ckfree((char*)ofnPtr->lpstrFilter); + } + ofnPtr->lpstrFilter = filterStr; + + TkFreeFileFilters(&flist); + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_MessageBoxCmd -- + * + * This procedure implements the MessageBox window for the + * Windows platform. See the user documentation for details on what + * it does. + * + * Results: + * See user documentation. + * + * Side effects: + * None. The MessageBox window will be destroy before this procedure + * returns. + * + *---------------------------------------------------------------------- + */ + +int +Tk_MessageBoxCmd(clientData, interp, argc, argv) + ClientData clientData; /* Main window associated with interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + int flags; + Tk_Window parent = Tk_MainWindow(interp); + HWND hWnd; + char *message = ""; + char *title = ""; + int icon = MB_ICONINFORMATION; + int type = MB_OK; + int i, j; + char *result; + int code, oldMode; + char *defaultBtn = NULL; + int defaultBtnIdx = -1; + + for (i=1; i<argc; i+=2) { + int v = i+1; + int len = strlen(argv[i]); + + if (strncmp(argv[i], "-default", len)==0) { + if (v==argc) {goto arg_missing;} + + defaultBtn = argv[v]; + } + else if (strncmp(argv[i], "-icon", len)==0) { + if (v==argc) {goto arg_missing;} + + if (strcmp(argv[v], "error") == 0) { + icon = MB_ICONERROR; + } + else if (strcmp(argv[v], "info") == 0) { + icon = MB_ICONINFORMATION; + } + else if (strcmp(argv[v], "question") == 0) { + icon = MB_ICONQUESTION; + } + else if (strcmp(argv[v], "warning") == 0) { + icon = MB_ICONWARNING; + } + else { + Tcl_AppendResult(interp, "invalid icon \"", argv[v], + "\", must be error, info, question or warning", NULL); + return TCL_ERROR; + } + } + else if (strncmp(argv[i], "-message", len)==0) { + if (v==argc) {goto arg_missing;} + + message = argv[v]; + } + else if (strncmp(argv[i], "-parent", len)==0) { + if (v==argc) {goto arg_missing;} + + parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp)); + if (parent == NULL) { + return TCL_ERROR; + } + } + else if (strncmp(argv[i], "-title", len)==0) { + if (v==argc) {goto arg_missing;} + + title = argv[v]; + } + else if (strncmp(argv[i], "-type", len)==0) { + int found = 0; + + if (v==argc) {goto arg_missing;} + + for (j=0; j<NUM_TYPES; j++) { + if (strcmp(argv[v], msgTypeInfo[j].name) == 0) { + type = msgTypeInfo[j].type; + found = 1; + break; + } + } + if (!found) { + Tcl_AppendResult(interp, "invalid message box type \"", + argv[v], "\", must be abortretryignore, ok, ", + "okcancel, retrycancel, yesno or yesnocancel", NULL); + return TCL_ERROR; + } + } + else { + Tcl_AppendResult(interp, "unknown option \"", + argv[i], "\", must be -default, -icon, ", + "-message, -parent, -title or -type", NULL); + return TCL_ERROR; + } + } + + /* Make sure we have a valid hWnd to act as the parent of this message box + */ + if (Tk_WindowId(parent) == None) { + Tk_MakeWindowExist(parent); + } + hWnd = Tk_GetHWND(Tk_WindowId(parent)); + + if (defaultBtn != NULL) { + for (i=0; i<NUM_TYPES; i++) { + if (type == msgTypeInfo[i].type) { + for (j=0; j<msgTypeInfo[i].numButtons; j++) { + if (strcmp(defaultBtn, msgTypeInfo[i].btnNames[j])==0) { + defaultBtnIdx = j; + break; + } + } + if (defaultBtnIdx < 0) { + Tcl_AppendResult(interp, "invalid default button \"", + defaultBtn, "\"", NULL); + return TCL_ERROR; + } + break; + } + } + + switch (defaultBtnIdx) { + case 0: flags = MB_DEFBUTTON1; break; + case 1: flags = MB_DEFBUTTON2; break; + case 2: flags = MB_DEFBUTTON3; break; + case 3: flags = MB_DEFBUTTON4; break; + } + } else { + flags = 0; + } + + flags |= icon | type; + oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + code = MessageBox(hWnd, message, title, flags|MB_SYSTEMMODAL); + (void) Tcl_SetServiceMode(oldMode); + + switch (code) { + case IDABORT: result = "abort"; break; + case IDCANCEL: result = "cancel"; break; + case IDIGNORE: result = "ignore"; break; + case IDNO: result = "no"; break; + case IDOK: result = "ok"; break; + case IDRETRY: result = "retry"; break; + case IDYES: result = "yes"; break; + default: result = ""; + } + + /* + * When we come to here interp->result may have been changed by some + * background scripts. Call Tcl_SetResult() to make sure that any stuff + * lingering in interp->result will not appear in the result of + * this command. + */ + + Tcl_SetResult(interp, result, TCL_STATIC); + return TCL_OK; + + arg_missing: + Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing", + NULL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * ProcessCDError -- + * + * This procedure gets called if a Windows-specific error message + * has occurred during the execution of a common dialog or the + * user has pressed the CANCEL button. + * + * Results: + * If an error has indeed happened, returns a standard TCL result + * that reports the error code in string format. If the user has + * pressed the CANCEL button (dwErrorCode == 0), resets + * interp->result to the empty string. + * + * Side effects: + * interp->result is changed. + * + *---------------------------------------------------------------------- + */ +static int ProcessCDError(interp, dwErrorCode, hWnd) + Tcl_Interp * interp; /* Current interpreter. */ + DWORD dwErrorCode; /* The Windows-specific error code */ + HWND hWnd; /* window in which the error happened*/ +{ + char *string; + + Tcl_ResetResult(interp); + + switch(dwErrorCode) { + case 0: /* User has hit CANCEL */ + return TCL_OK; + + case CDERR_DIALOGFAILURE: string="CDERR_DIALOGFAILURE"; break; + case CDERR_STRUCTSIZE: string="CDERR_STRUCTSIZE"; break; + case CDERR_INITIALIZATION: string="CDERR_INITIALIZATION"; break; + case CDERR_NOTEMPLATE: string="CDERR_NOTEMPLATE"; break; + case CDERR_NOHINSTANCE: string="CDERR_NOHINSTANCE"; break; + case CDERR_LOADSTRFAILURE: string="CDERR_LOADSTRFAILURE"; break; + case CDERR_FINDRESFAILURE: string="CDERR_FINDRESFAILURE"; break; + case CDERR_LOADRESFAILURE: string="CDERR_LOADRESFAILURE"; break; + case CDERR_LOCKRESFAILURE: string="CDERR_LOCKRESFAILURE"; break; + case CDERR_MEMALLOCFAILURE: string="CDERR_MEMALLOCFAILURE"; break; + case CDERR_MEMLOCKFAILURE: string="CDERR_MEMLOCKFAILURE"; break; + case CDERR_NOHOOK: string="CDERR_NOHOOK"; break; + case PDERR_SETUPFAILURE: string="PDERR_SETUPFAILURE"; break; + case PDERR_PARSEFAILURE: string="PDERR_PARSEFAILURE"; break; + case PDERR_RETDEFFAILURE: string="PDERR_RETDEFFAILURE"; break; + case PDERR_LOADDRVFAILURE: string="PDERR_LOADDRVFAILURE"; break; + case PDERR_GETDEVMODEFAIL: string="PDERR_GETDEVMODEFAIL"; break; + case PDERR_INITFAILURE: string="PDERR_INITFAILURE"; break; + case PDERR_NODEVICES: string="PDERR_NODEVICES"; break; + case PDERR_NODEFAULTPRN: string="PDERR_NODEFAULTPRN"; break; + case PDERR_DNDMMISMATCH: string="PDERR_DNDMMISMATCH"; break; + case PDERR_CREATEICFAILURE: string="PDERR_CREATEICFAILURE"; break; + case PDERR_PRINTERNOTFOUND: string="PDERR_PRINTERNOTFOUND"; break; + case CFERR_NOFONTS: string="CFERR_NOFONTS"; break; + case FNERR_SUBCLASSFAILURE: string="FNERR_SUBCLASSFAILURE"; break; + case FNERR_INVALIDFILENAME: string="FNERR_INVALIDFILENAME"; break; + case FNERR_BUFFERTOOSMALL: string="FNERR_BUFFERTOOSMALL"; break; + + default: + string="unknown error"; + } + + Tcl_AppendResult(interp, "Win32 internal error: ", string, NULL); + return TCL_ERROR; +} diff --git a/win/tkWinDraw.c b/win/tkWinDraw.c new file mode 100644 index 0000000..e972365 --- /dev/null +++ b/win/tkWinDraw.c @@ -0,0 +1,1264 @@ +/* + * tkWinDraw.c -- + * + * This file contains the Xlib emulation functions pertaining to + * actually drawing objects on a window. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * Copyright (c) 1994 Software Research Associates, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinDraw.c 1.30 97/03/21 11:20:05 + */ + +#include "tkWinInt.h" + +/* + * These macros convert between X's bizarre angle units to radians. + */ + +#define PI 3.14159265358979 +#define XAngleToRadians(a) ((double)(a) / 64 * PI / 180); + +/* + * Translation table between X gc functions and Win32 raster op modes. + */ + +int tkpWinRopModes[] = { + R2_BLACK, /* GXclear */ + R2_MASKPEN, /* GXand */ + R2_MASKPENNOT, /* GXandReverse */ + R2_COPYPEN, /* GXcopy */ + R2_MASKNOTPEN, /* GXandInverted */ + R2_NOT, /* GXnoop */ + R2_XORPEN, /* GXxor */ + R2_MERGEPEN, /* GXor */ + R2_NOTMERGEPEN, /* GXnor */ + R2_NOTXORPEN, /* GXequiv */ + R2_NOT, /* GXinvert */ + R2_MERGEPENNOT, /* GXorReverse */ + R2_NOTCOPYPEN, /* GXcopyInverted */ + R2_MERGENOTPEN, /* GXorInverted */ + R2_NOTMASKPEN, /* GXnand */ + R2_WHITE /* GXset */ +}; + +/* + * Translation table between X gc functions and Win32 BitBlt op modes. Some + * of the operations defined in X don't have names, so we have to construct + * new opcodes for those functions. This is arcane and probably not all that + * useful, but at least it's accurate. + */ + +#define NOTSRCAND (DWORD)0x00220326 /* dest = (NOT source) AND dest */ +#define NOTSRCINVERT (DWORD)0x00990066 /* dest = (NOT source) XOR dest */ +#define SRCORREVERSE (DWORD)0x00DD0228 /* dest = source OR (NOT dest) */ +#define SRCNAND (DWORD)0x007700E6 /* dest = NOT (source AND dest) */ + +static int bltModes[] = { + BLACKNESS, /* GXclear */ + SRCAND, /* GXand */ + SRCERASE, /* GXandReverse */ + SRCCOPY, /* GXcopy */ + NOTSRCAND, /* GXandInverted */ + PATCOPY, /* GXnoop */ + SRCINVERT, /* GXxor */ + SRCPAINT, /* GXor */ + NOTSRCERASE, /* GXnor */ + NOTSRCINVERT, /* GXequiv */ + DSTINVERT, /* GXinvert */ + SRCORREVERSE, /* GXorReverse */ + NOTSRCCOPY, /* GXcopyInverted */ + MERGEPAINT, /* GXorInverted */ + SRCNAND, /* GXnand */ + WHITENESS /* GXset */ +}; + +/* + * The following raster op uses the source bitmap as a mask for the + * pattern. This is used to draw in a foreground color but leave the + * background color transparent. + */ + +#define MASKPAT 0x00E20746 /* dest = (src & pat) | (!src & dst) */ + +/* + * The following two raster ops are used to copy the foreground and background + * bits of a source pattern as defined by a stipple used as the pattern. + */ + +#define COPYFG 0x00CA0749 /* dest = (pat & src) | (!pat & dst) */ +#define COPYBG 0x00AC0744 /* dest = (!pat & src) | (pat & dst) */ + +/* + * Macros used later in the file. + */ + +#define MIN(a,b) ((a>b) ? b : a) +#define MAX(a,b) ((a<b) ? b : a) + +/* + * The followng typedef is used to pass Windows GDI drawing functions. + */ + +typedef BOOL (CALLBACK *WinDrawFunc) _ANSI_ARGS_((HDC dc, + CONST POINT* points, int npoints)); + +/* + * Forward declarations for procedures defined in this file: + */ + +static POINT * ConvertPoints _ANSI_ARGS_((XPoint *points, int npoints, + int mode, RECT *bbox)); +static void DrawOrFillArc _ANSI_ARGS_((Display *display, + Drawable d, GC gc, int x, int y, + unsigned int width, unsigned int height, + int start, int extent, int fill)); +static void RenderObject _ANSI_ARGS_((HDC dc, GC gc, + XPoint* points, int npoints, int mode, HPEN pen, + WinDrawFunc func)); + +/* + *---------------------------------------------------------------------- + * + * TkWinGetDrawableDC -- + * + * Retrieve the DC from a drawable. + * + * Results: + * Returns the window DC for windows. Returns a new memory DC + * for pixmaps. + * + * Side effects: + * Sets up the palette for the device context, and saves the old + * device context state in the passed in TkWinDCState structure. + * + *---------------------------------------------------------------------- + */ + +HDC +TkWinGetDrawableDC(display, d, state) + Display *display; + Drawable d; + TkWinDCState* state; +{ + HDC dc; + TkWinDrawable *twdPtr = (TkWinDrawable *)d; + Colormap cmap; + + if (twdPtr->type == TWD_WINDOW) { + TkWindow *winPtr = twdPtr->window.winPtr; + + dc = GetDC(twdPtr->window.handle); + if (winPtr == NULL) { + cmap = DefaultColormap(display, DefaultScreen(display)); + } else { + cmap = winPtr->atts.colormap; + } + } else if (twdPtr->type == TWD_WINDC) { + dc = twdPtr->winDC.hdc; + cmap = DefaultColormap(display, DefaultScreen(display)); + } else { + dc = CreateCompatibleDC(NULL); + SelectObject(dc, twdPtr->bitmap.handle); + cmap = twdPtr->bitmap.colormap; + } + state->palette = TkWinSelectPalette(dc, cmap); + return dc; +} + +/* + *---------------------------------------------------------------------- + * + * TkWinReleaseDrawableDC -- + * + * Frees the resources associated with a drawable's DC. + * + * Results: + * None. + * + * Side effects: + * Restores the old bitmap handle to the memory DC for pixmaps. + * + *---------------------------------------------------------------------- + */ + +void +TkWinReleaseDrawableDC(d, dc, state) + Drawable d; + HDC dc; + TkWinDCState *state; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *)d; + SelectPalette(dc, state->palette, TRUE); + RealizePalette(dc); + if (twdPtr->type == TWD_WINDOW) { + ReleaseDC(TkWinGetHWND(d), dc); + } else if (twdPtr->type == TWD_BITMAP) { + DeleteDC(dc); + } +} + +/* + *---------------------------------------------------------------------- + * + * ConvertPoints -- + * + * Convert an array of X points to an array of Win32 points. + * + * Results: + * Returns the converted array of POINTs. + * + * Side effects: + * Allocates a block of memory that should not be freed. + * + *---------------------------------------------------------------------- + */ + +static POINT * +ConvertPoints(points, npoints, mode, bbox) + XPoint *points; + int npoints; + int mode; /* CoordModeOrigin or CoordModePrevious. */ + RECT *bbox; /* Bounding box of points. */ +{ + static POINT *winPoints = NULL; /* Array of points that is reused. */ + static int nWinPoints = -1; /* Current size of point array. */ + int i; + + /* + * To avoid paying the cost of a malloc on every drawing routine, + * we reuse the last array if it is large enough. + */ + + if (npoints > nWinPoints) { + if (winPoints != NULL) { + ckfree((char *) winPoints); + } + winPoints = (POINT *) ckalloc(sizeof(POINT) * npoints); + if (winPoints == NULL) { + nWinPoints = -1; + return NULL; + } + nWinPoints = npoints; + } + + bbox->left = bbox->right = points[0].x; + bbox->top = bbox->bottom = points[0].y; + + if (mode == CoordModeOrigin) { + for (i = 0; i < npoints; i++) { + winPoints[i].x = points[i].x; + winPoints[i].y = points[i].y; + bbox->left = MIN(bbox->left, winPoints[i].x); + bbox->right = MAX(bbox->right, winPoints[i].x); + bbox->top = MIN(bbox->top, winPoints[i].y); + bbox->bottom = MAX(bbox->bottom, winPoints[i].y); + } + } else { + winPoints[0].x = points[0].x; + winPoints[0].y = points[0].y; + for (i = 1; i < npoints; i++) { + winPoints[i].x = winPoints[i-1].x + points[i].x; + winPoints[i].y = winPoints[i-1].y + points[i].y; + bbox->left = MIN(bbox->left, winPoints[i].x); + bbox->right = MAX(bbox->right, winPoints[i].x); + bbox->top = MIN(bbox->top, winPoints[i].y); + bbox->bottom = MAX(bbox->bottom, winPoints[i].y); + } + } + return winPoints; +} + +/* + *---------------------------------------------------------------------- + * + * XCopyArea -- + * + * Copies data from one drawable to another using block transfer + * routines. + * + * Results: + * None. + * + * Side effects: + * Data is moved from a window or bitmap to a second window or + * bitmap. + * + *---------------------------------------------------------------------- + */ + +void +XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y) + Display* display; + Drawable src; + Drawable dest; + GC gc; + int src_x, src_y; + unsigned int width, height; + int dest_x, dest_y; +{ + HDC srcDC, destDC; + TkWinDCState srcState, destState; + TkpClipMask *clipPtr = (TkpClipMask*)gc->clip_mask; + + srcDC = TkWinGetDrawableDC(display, src, &srcState); + + if (src != dest) { + destDC = TkWinGetDrawableDC(display, dest, &destState); + } else { + destDC = srcDC; + } + + if (clipPtr && clipPtr->type == TKP_CLIP_REGION) { + SelectClipRgn(destDC, (HRGN) clipPtr->value.region); + OffsetClipRgn(destDC, gc->clip_x_origin, gc->clip_y_origin); + } + + BitBlt(destDC, dest_x, dest_y, width, height, srcDC, src_x, src_y, + bltModes[gc->function]); + + SelectClipRgn(destDC, NULL); + + if (src != dest) { + TkWinReleaseDrawableDC(dest, destDC, &destState); + } + TkWinReleaseDrawableDC(src, srcDC, &srcState); +} + +/* + *---------------------------------------------------------------------- + * + * XCopyPlane -- + * + * Copies a bitmap from a source drawable to a destination + * drawable. The plane argument specifies which bit plane of + * the source contains the bitmap. Note that this implementation + * ignores the gc->function. + * + * Results: + * None. + * + * Side effects: + * Changes the destination drawable. + * + *---------------------------------------------------------------------- + */ + +void +XCopyPlane(display, src, dest, gc, src_x, src_y, width, height, dest_x, + dest_y, plane) + Display* display; + Drawable src; + Drawable dest; + GC gc; + int src_x, src_y; + unsigned int width, height; + int dest_x, dest_y; + unsigned long plane; +{ + HDC srcDC, destDC; + TkWinDCState srcState, destState; + HBRUSH bgBrush, fgBrush, oldBrush; + TkpClipMask *clipPtr = (TkpClipMask*)gc->clip_mask; + + display->request++; + + if (plane != 1) { + panic("Unexpected plane specified for XCopyPlane"); + } + + srcDC = TkWinGetDrawableDC(display, src, &srcState); + + if (src != dest) { + destDC = TkWinGetDrawableDC(display, dest, &destState); + } else { + destDC = srcDC; + } + + if (clipPtr == NULL || clipPtr->type == TKP_CLIP_REGION) { + + /* + * Case 1: opaque bitmaps. Windows handles the conversion + * from one bit to multiple bits by setting 0 to the + * foreground color, and 1 to the background color (seems + * backwards, but there you are). + */ + + if (clipPtr && clipPtr->type == TKP_CLIP_REGION) { + SelectClipRgn(destDC, (HRGN) clipPtr->value.region); + OffsetClipRgn(destDC, gc->clip_x_origin, gc->clip_y_origin); + } + + SetBkMode(destDC, OPAQUE); + SetBkColor(destDC, gc->foreground); + SetTextColor(destDC, gc->background); + BitBlt(destDC, dest_x, dest_y, width, height, srcDC, src_x, src_y, + SRCCOPY); + + SelectClipRgn(destDC, NULL); + } else if (clipPtr->type == TKP_CLIP_PIXMAP) { + if (clipPtr->value.pixmap == src) { + + /* + * Case 2: transparent bitmaps are handled by setting the + * destination to the foreground color whenever the source + * pixel is set. + */ + + fgBrush = CreateSolidBrush(gc->foreground); + oldBrush = SelectObject(destDC, fgBrush); + BitBlt(destDC, dest_x, dest_y, width, height, srcDC, src_x, src_y, + MASKPAT); + SelectObject(destDC, oldBrush); + DeleteObject(fgBrush); + } else { + + /* + * Case 3: two arbitrary bitmaps. Copy the source rectangle + * into a color pixmap. Use the result as a brush when + * copying the clip mask into the destination. + */ + + HDC memDC, maskDC; + HBITMAP bitmap; + TkWinDCState maskState; + + fgBrush = CreateSolidBrush(gc->foreground); + bgBrush = CreateSolidBrush(gc->background); + maskDC = TkWinGetDrawableDC(display, clipPtr->value.pixmap, + &maskState); + memDC = CreateCompatibleDC(destDC); + bitmap = CreateBitmap(width, height, 1, 1, NULL); + SelectObject(memDC, bitmap); + + /* + * Set foreground bits. We create a new bitmap containing + * (source AND mask), then use it to set the foreground color + * into the destination. + */ + + BitBlt(memDC, 0, 0, width, height, srcDC, src_x, src_y, SRCCOPY); + BitBlt(memDC, 0, 0, width, height, maskDC, + dest_x - gc->clip_x_origin, dest_y - gc->clip_y_origin, + SRCAND); + oldBrush = SelectObject(destDC, fgBrush); + BitBlt(destDC, dest_x, dest_y, width, height, memDC, 0, 0, + MASKPAT); + + /* + * Set background bits. Same as foreground, except we use + * ((NOT source) AND mask) and the background brush. + */ + + BitBlt(memDC, 0, 0, width, height, srcDC, src_x, src_y, + NOTSRCCOPY); + BitBlt(memDC, 0, 0, width, height, maskDC, + dest_x - gc->clip_x_origin, dest_y - gc->clip_y_origin, + SRCAND); + SelectObject(destDC, bgBrush); + BitBlt(destDC, dest_x, dest_y, width, height, memDC, 0, 0, + MASKPAT); + + TkWinReleaseDrawableDC(clipPtr->value.pixmap, maskDC, &maskState); + SelectObject(destDC, oldBrush); + DeleteDC(memDC); + DeleteObject(bitmap); + DeleteObject(fgBrush); + DeleteObject(bgBrush); + } + } + if (src != dest) { + TkWinReleaseDrawableDC(dest, destDC, &destState); + } + TkWinReleaseDrawableDC(src, srcDC, &srcState); +} + +/* + *---------------------------------------------------------------------- + * + * TkPutImage -- + * + * Copies a subimage from an in-memory image to a rectangle of + * of the specified drawable. + * + * Results: + * None. + * + * Side effects: + * Draws the image on the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +TkPutImage(colors, ncolors, display, d, gc, image, src_x, src_y, dest_x, + dest_y, width, height) + unsigned long *colors; /* Array of pixel values used by this + * image. May be NULL. */ + int ncolors; /* Number of colors used, or 0. */ + Display* display; + Drawable d; /* Destination drawable. */ + GC gc; + XImage* image; /* Source image. */ + int src_x, src_y; /* Offset of subimage. */ + int dest_x, dest_y; /* Position of subimage origin in + * drawable. */ + unsigned int width, height; /* Dimensions of subimage. */ +{ + HDC dc, dcMem; + TkWinDCState state; + BITMAPINFO *infoPtr; + HBITMAP bitmap; + char *data; + + display->request++; + + dc = TkWinGetDrawableDC(display, d, &state); + SetROP2(dc, tkpWinRopModes[gc->function]); + dcMem = CreateCompatibleDC(dc); + + if (image->bits_per_pixel == 1) { + /* + * If the image isn't in the right format, we have to copy + * it into a new buffer in MSBFirst and word-aligned format. + */ + + if ((image->bitmap_bit_order != MSBFirst) + || (image->bitmap_pad != sizeof(WORD))) { + data = TkAlignImageData(image, sizeof(WORD), MSBFirst); + bitmap = CreateBitmap(image->width, image->height, 1, 1, data); + ckfree(data); + } else { + bitmap = CreateBitmap(image->width, image->height, 1, 1, + image->data); + } + SetTextColor(dc, gc->foreground); + SetBkColor(dc, gc->background); + } else { + int i, usePalette; + + /* + * Do not use a palette for TrueColor images. + */ + + usePalette = (image->bits_per_pixel < 16); + + if (usePalette) { + infoPtr = (BITMAPINFO*) ckalloc(sizeof(BITMAPINFOHEADER) + + sizeof(RGBQUAD)*ncolors); + } else { + infoPtr = (BITMAPINFO*) ckalloc(sizeof(BITMAPINFOHEADER)); + } + + infoPtr->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + infoPtr->bmiHeader.biWidth = image->width; + + /* + * The following code works around a bug in Win32s. CreateDIBitmap + * fails under Win32s for top-down images. So we have to reverse the + * order of the scanlines. If we are not running under Win32s, we can + * just declare the image to be top-down. + */ + + if (tkpIsWin32s) { + int y; + char *srcPtr, *dstPtr, *temp; + + temp = ckalloc((unsigned) image->bytes_per_line); + srcPtr = image->data; + dstPtr = image->data+(image->bytes_per_line * (image->height - 1)); + for (y = 0; y < (image->height/2); y++) { + memcpy(temp, srcPtr, image->bytes_per_line); + memcpy(srcPtr, dstPtr, image->bytes_per_line); + memcpy(dstPtr, temp, image->bytes_per_line); + srcPtr += image->bytes_per_line; + dstPtr -= image->bytes_per_line; + } + ckfree(temp); + infoPtr->bmiHeader.biHeight = image->height; /* Bottom-up order */ + } else { + infoPtr->bmiHeader.biHeight = -image->height; /* Top-down order */ + } + infoPtr->bmiHeader.biPlanes = 1; + infoPtr->bmiHeader.biBitCount = image->bits_per_pixel; + infoPtr->bmiHeader.biCompression = BI_RGB; + infoPtr->bmiHeader.biSizeImage = 0; + infoPtr->bmiHeader.biXPelsPerMeter = 0; + infoPtr->bmiHeader.biYPelsPerMeter = 0; + infoPtr->bmiHeader.biClrImportant = 0; + + if (usePalette) { + infoPtr->bmiHeader.biClrUsed = ncolors; + for (i = 0; i < ncolors; i++) { + infoPtr->bmiColors[i].rgbBlue = GetBValue(colors[i]); + infoPtr->bmiColors[i].rgbGreen = GetGValue(colors[i]); + infoPtr->bmiColors[i].rgbRed = GetRValue(colors[i]); + infoPtr->bmiColors[i].rgbReserved = 0; + } + } else { + infoPtr->bmiHeader.biClrUsed = 0; + } + bitmap = CreateDIBitmap(dc, &infoPtr->bmiHeader, CBM_INIT, + image->data, infoPtr, DIB_RGB_COLORS); + ckfree((char *) infoPtr); + } + bitmap = SelectObject(dcMem, bitmap); + BitBlt(dc, dest_x, dest_y, width, height, dcMem, src_x, src_y, SRCCOPY); + DeleteObject(SelectObject(dcMem, bitmap)); + DeleteDC(dcMem); + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * XFillRectangles -- + * + * Fill multiple rectangular areas in the given drawable. + * + * Results: + * None. + * + * Side effects: + * Draws onto the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +XFillRectangles(display, d, gc, rectangles, nrectangles) + Display* display; + Drawable d; + GC gc; + XRectangle* rectangles; + int nrectangles; +{ + HDC dc; + int i; + RECT rect; + TkWinDCState state; + HBRUSH brush; + + if (d == None) { + return; + } + + dc = TkWinGetDrawableDC(display, d, &state); + SetROP2(dc, tkpWinRopModes[gc->function]); + brush = CreateSolidBrush(gc->foreground); + + if ((gc->fill_style == FillStippled + || gc->fill_style == FillOpaqueStippled) + && gc->stipple != None) { + TkWinDrawable *twdPtr = (TkWinDrawable *)gc->stipple; + HBRUSH oldBrush, stipple; + HBITMAP oldBitmap, bitmap; + HDC dcMem; + HBRUSH bgBrush = CreateSolidBrush(gc->background); + + if (twdPtr->type != TWD_BITMAP) { + panic("unexpected drawable type in stipple"); + } + + /* + * Select stipple pattern into destination dc. + */ + + stipple = CreatePatternBrush(twdPtr->bitmap.handle); + SetBrushOrgEx(dc, gc->ts_x_origin, gc->ts_y_origin, NULL); + oldBrush = SelectObject(dc, stipple); + dcMem = CreateCompatibleDC(dc); + + /* + * For each rectangle, create a drawing surface which is the size of + * the rectangle and fill it with the background color. Then merge the + * result with the stipple pattern. + */ + + for (i = 0; i < nrectangles; i++) { + bitmap = CreateCompatibleBitmap(dc, rectangles[i].width, + rectangles[i].height); + oldBitmap = SelectObject(dcMem, bitmap); + rect.left = 0; + rect.top = 0; + rect.right = rectangles[i].width; + rect.bottom = rectangles[i].height; + FillRect(dcMem, &rect, brush); + BitBlt(dc, rectangles[i].x, rectangles[i].y, rectangles[i].width, + rectangles[i].height, dcMem, 0, 0, COPYFG); + if (gc->fill_style == FillOpaqueStippled) { + FillRect(dcMem, &rect, bgBrush); + BitBlt(dc, rectangles[i].x, rectangles[i].y, + rectangles[i].width, rectangles[i].height, dcMem, + 0, 0, COPYBG); + } + SelectObject(dcMem, oldBitmap); + DeleteObject(bitmap); + } + + DeleteDC(dcMem); + SelectObject(dc, oldBrush); + DeleteObject(stipple); + DeleteObject(bgBrush); + } else { + for (i = 0; i < nrectangles; i++) { + TkWinFillRect(dc, rectangles[i].x, rectangles[i].y, + rectangles[i].width, rectangles[i].height, gc->foreground); + } + } + DeleteObject(brush); + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * RenderObject -- + * + * This function draws a shape using a list of points, a + * stipple pattern, and the specified drawing function. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +RenderObject(dc, gc, points, npoints, mode, pen, func) + HDC dc; + GC gc; + XPoint* points; + int npoints; + int mode; + HPEN pen; + WinDrawFunc func; +{ + RECT rect; + HPEN oldPen; + HBRUSH oldBrush; + POINT *winPoints = ConvertPoints(points, npoints, mode, &rect); + + if ((gc->fill_style == FillStippled + || gc->fill_style == FillOpaqueStippled) + && gc->stipple != None) { + + TkWinDrawable *twdPtr = (TkWinDrawable *)gc->stipple; + HDC dcMem; + LONG width, height; + HBITMAP oldBitmap; + int i; + HBRUSH oldMemBrush; + + if (twdPtr->type != TWD_BITMAP) { + panic("unexpected drawable type in stipple"); + } + + /* + * Grow the bounding box enough to account for wide lines. + */ + + if (gc->line_width > 1) { + rect.left -= gc->line_width; + rect.top -= gc->line_width; + rect.right += gc->line_width; + rect.bottom += gc->line_width; + } + + width = rect.right - rect.left; + height = rect.bottom - rect.top; + + /* + * Select stipple pattern into destination dc. + */ + + SetBrushOrgEx(dc, gc->ts_x_origin, gc->ts_y_origin, NULL); + oldBrush = SelectObject(dc, CreatePatternBrush(twdPtr->bitmap.handle)); + + /* + * Create temporary drawing surface containing a copy of the + * destination equal in size to the bounding box of the object. + */ + + dcMem = CreateCompatibleDC(dc); + oldBitmap = SelectObject(dcMem, CreateCompatibleBitmap(dc, width, + height)); + oldPen = SelectObject(dcMem, pen); + BitBlt(dcMem, 0, 0, width, height, dc, rect.left, rect.top, SRCCOPY); + + /* + * Translate the object for rendering in the temporary drawing + * surface. + */ + + for (i = 0; i < npoints; i++) { + winPoints[i].x -= rect.left; + winPoints[i].y -= rect.top; + } + + /* + * Draw the object in the foreground color and copy it to the + * destination wherever the pattern is set. + */ + + SetPolyFillMode(dcMem, (gc->fill_rule == EvenOddRule) ? ALTERNATE + : WINDING); + oldMemBrush = SelectObject(dcMem, CreateSolidBrush(gc->foreground)); + (*func)(dcMem, winPoints, npoints); + BitBlt(dc, rect.left, rect.top, width, height, dcMem, 0, 0, COPYFG); + + /* + * If we are rendering an opaque stipple, then draw the polygon in the + * background color and copy it to the destination wherever the pattern + * is clear. + */ + + if (gc->fill_style == FillOpaqueStippled) { + DeleteObject(SelectObject(dcMem, + CreateSolidBrush(gc->background))); + (*func)(dcMem, winPoints, npoints); + BitBlt(dc, rect.left, rect.top, width, height, dcMem, 0, 0, + COPYBG); + } + + SelectObject(dcMem, oldPen); + DeleteObject(SelectObject(dcMem, oldMemBrush)); + DeleteObject(SelectObject(dcMem, oldBitmap)); + DeleteDC(dcMem); + } else { + oldPen = SelectObject(dc, pen); + oldBrush = SelectObject(dc, CreateSolidBrush(gc->foreground)); + SetROP2(dc, tkpWinRopModes[gc->function]); + + SetPolyFillMode(dc, (gc->fill_rule == EvenOddRule) ? ALTERNATE + : WINDING); + + (*func)(dc, winPoints, npoints); + + SelectObject(dc, oldPen); + } + DeleteObject(SelectObject(dc, oldBrush)); +} + +/* + *---------------------------------------------------------------------- + * + * XDrawLines -- + * + * Draw connected lines. + * + * Results: + * None. + * + * Side effects: + * Renders a series of connected lines. + * + *---------------------------------------------------------------------- + */ + +void +XDrawLines(display, d, gc, points, npoints, mode) + Display* display; + Drawable d; + GC gc; + XPoint* points; + int npoints; + int mode; +{ + HPEN pen; + TkWinDCState state; + HDC dc; + + if (d == None) { + return; + } + + dc = TkWinGetDrawableDC(display, d, &state); + + if (!tkpIsWin32s && (gc->line_width > 1)) { + LOGBRUSH lb; + DWORD style; + + lb.lbStyle = BS_SOLID; + lb.lbColor = gc->foreground; + lb.lbHatch = 0; + + style = PS_GEOMETRIC|PS_COSMETIC; + switch (gc->cap_style) { + case CapNotLast: + case CapButt: + style |= PS_ENDCAP_FLAT; + break; + case CapRound: + style |= PS_ENDCAP_ROUND; + break; + default: + style |= PS_ENDCAP_SQUARE; + break; + } + switch (gc->join_style) { + case JoinMiter: + style |= PS_JOIN_MITER; + break; + case JoinRound: + style |= PS_JOIN_ROUND; + break; + default: + style |= PS_JOIN_BEVEL; + break; + } + pen = ExtCreatePen(style, gc->line_width, &lb, 0, NULL); + } else { + pen = CreatePen(PS_SOLID, gc->line_width, gc->foreground); + } + RenderObject(dc, gc, points, npoints, mode, pen, Polyline); + DeleteObject(pen); + + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * XFillPolygon -- + * + * Draws a filled polygon. + * + * Results: + * None. + * + * Side effects: + * Draws a filled polygon on the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +XFillPolygon(display, d, gc, points, npoints, shape, mode) + Display* display; + Drawable d; + GC gc; + XPoint* points; + int npoints; + int shape; + int mode; +{ + HPEN pen; + TkWinDCState state; + HDC dc; + + if (d == None) { + return; + } + + dc = TkWinGetDrawableDC(display, d, &state); + + pen = GetStockObject(NULL_PEN); + RenderObject(dc, gc, points, npoints, mode, pen, Polygon); + + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * XDrawRectangle -- + * + * Draws a rectangle. + * + * Results: + * None. + * + * Side effects: + * Draws a rectangle on the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +XDrawRectangle(display, d, gc, x, y, width, height) + Display* display; + Drawable d; + GC gc; + int x; + int y; + unsigned int width; + unsigned int height; +{ + HPEN pen, oldPen; + TkWinDCState state; + HBRUSH oldBrush; + HDC dc; + + if (d == None) { + return; + } + + dc = TkWinGetDrawableDC(display, d, &state); + + pen = CreatePen(PS_SOLID, gc->line_width, gc->foreground); + oldPen = SelectObject(dc, pen); + oldBrush = SelectObject(dc, GetStockObject(NULL_BRUSH)); + SetROP2(dc, tkpWinRopModes[gc->function]); + + Rectangle(dc, x, y, x+width+1, y+height+1); + + DeleteObject(SelectObject(dc, oldPen)); + SelectObject(dc, oldBrush); + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * XDrawArc -- + * + * Draw an arc. + * + * Results: + * None. + * + * Side effects: + * Draws an arc on the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +XDrawArc(display, d, gc, x, y, width, height, start, extent) + Display* display; + Drawable d; + GC gc; + int x; + int y; + unsigned int width; + unsigned int height; + int start; + int extent; +{ + display->request++; + + DrawOrFillArc(display, d, gc, x, y, width, height, start, extent, 0); +} + +/* + *---------------------------------------------------------------------- + * + * XFillArc -- + * + * Draw a filled arc. + * + * Results: + * None. + * + * Side effects: + * Draws a filled arc on the specified drawable. + * + *---------------------------------------------------------------------- + */ + +void +XFillArc(display, d, gc, x, y, width, height, start, extent) + Display* display; + Drawable d; + GC gc; + int x; + int y; + unsigned int width; + unsigned int height; + int start; + int extent; +{ + display->request++; + + DrawOrFillArc(display, d, gc, x, y, width, height, start, extent, 1); +} + +/* + *---------------------------------------------------------------------- + * + * DrawOrFillArc -- + * + * This procedure handles the rendering of drawn or filled + * arcs and chords. + * + * Results: + * None. + * + * Side effects: + * Renders the requested arc. + * + *---------------------------------------------------------------------- + */ + +static void +DrawOrFillArc(display, d, gc, x, y, width, height, start, extent, fill) + Display *display; + Drawable d; + GC gc; + int x, y; /* left top */ + unsigned int width, height; + int start; /* start: three-o'clock (deg*64) */ + int extent; /* extent: relative (deg*64) */ + int fill; /* ==0 draw, !=0 fill */ +{ + HDC dc; + HBRUSH brush, oldBrush; + HPEN pen, oldPen; + TkWinDCState state; + int clockwise = (extent < 0); /* non-zero if clockwise */ + int xstart, ystart, xend, yend; + double radian_start, radian_end, xr, yr; + + if (d == None) { + return; + } + + dc = TkWinGetDrawableDC(display, d, &state); + + SetROP2(dc, tkpWinRopModes[gc->function]); + + /* + * Compute the absolute starting and ending angles in normalized radians. + * Swap the start and end if drawing clockwise. + */ + + start = start % (64*360); + if (start < 0) { + start += (64*360); + } + extent = (start+extent) % (64*360); + if (extent < 0) { + extent += (64*360); + } + if (clockwise) { + int tmp = start; + start = extent; + extent = tmp; + } + radian_start = XAngleToRadians(start); + radian_end = XAngleToRadians(extent); + + /* + * Now compute points on the radial lines that define the starting and + * ending angles. Be sure to take into account that the y-coordinate + * system is inverted. + */ + + xr = x + width / 2.0; + yr = y + height / 2.0; + xstart = (int)((xr + cos(radian_start)*width/2.0) + 0.5); + ystart = (int)((yr + sin(-radian_start)*height/2.0) + 0.5); + xend = (int)((xr + cos(radian_end)*width/2.0) + 0.5); + yend = (int)((yr + sin(-radian_end)*height/2.0) + 0.5); + + /* + * Now draw a filled or open figure. Note that we have to + * increase the size of the bounding box by one to account for the + * difference in pixel definitions between X and Windows. + */ + + pen = CreatePen(PS_SOLID, gc->line_width, gc->foreground); + oldPen = SelectObject(dc, pen); + if (!fill) { + /* + * Note that this call will leave a gap of one pixel at the + * end of the arc for thin arcs. We can't use ArcTo because + * it's only supported under Windows NT. + */ + + Arc(dc, x, y, x+width+1, y+height+1, xstart, ystart, xend, yend); + } else { + brush = CreateSolidBrush(gc->foreground); + oldBrush = SelectObject(dc, brush); + if (gc->arc_mode == ArcChord) { + Chord(dc, x, y, x+width+1, y+height+1, xstart, ystart, xend, yend); + } else if ( gc->arc_mode == ArcPieSlice ) { + Pie(dc, x, y, x+width+1, y+height+1, xstart, ystart, xend, yend); + } + DeleteObject(SelectObject(dc, oldBrush)); + } + DeleteObject(SelectObject(dc, oldPen)); + TkWinReleaseDrawableDC(d, dc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * TkScrollWindow -- + * + * Scroll a rectangle of the specified window and accumulate + * a damage region. + * + * Results: + * Returns 0 if the scroll genereated no additional damage. + * Otherwise, sets the region that needs to be repainted after + * scrolling and returns 1. + * + * Side effects: + * Scrolls the bits in the window. + * + *---------------------------------------------------------------------- + */ + +int +TkScrollWindow(tkwin, gc, x, y, width, height, dx, dy, damageRgn) + Tk_Window tkwin; /* The window to be scrolled. */ + GC gc; /* GC for window to be scrolled. */ + int x, y, width, height; /* Position rectangle to be scrolled. */ + int dx, dy; /* Distance rectangle should be moved. */ + TkRegion damageRgn; /* Region to accumulate damage in. */ +{ + HWND hwnd = TkWinGetHWND(Tk_WindowId(tkwin)); + RECT scrollRect; + + scrollRect.left = x; + scrollRect.top = y; + scrollRect.right = x + width; + scrollRect.bottom = y + height; + return (ScrollWindowEx(hwnd, dx, dy, &scrollRect, NULL, (HRGN) damageRgn, + NULL, 0) == NULLREGION) ? 0 : 1; +} + +/* + *---------------------------------------------------------------------- + * + * TkWinFillRect -- + * + * This routine fills a rectangle with the foreground color + * from the specified GC ignoring all other GC values. This + * is the fastest way to fill a drawable with a solid color. + * + * Results: + * None. + * + * Side effects: + * Modifies the contents of the DC drawing surface. + * + *---------------------------------------------------------------------- + */ + +void +TkWinFillRect(dc, x, y, width, height, pixel) + HDC dc; + int x, y, width, height; + int pixel; +{ + RECT rect; + COLORREF oldColor; + + rect.left = x; + rect.top = y; + rect.right = x + width; + rect.bottom = y + height; + oldColor = SetBkColor(dc, (COLORREF)pixel); + SetBkMode(dc, OPAQUE); + ExtTextOut(dc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL); + SetBkColor(dc, oldColor); +} diff --git a/win/tkWinEmbed.c b/win/tkWinEmbed.c new file mode 100644 index 0000000..0dc4036 --- /dev/null +++ b/win/tkWinEmbed.c @@ -0,0 +1,645 @@ +/* + * tkWinEmbed.c -- + * + * This file contains platform specific procedures for Windows platforms + * to provide basic operations needed for application embedding (where + * one application can use as its main window an internal window from + * another application). + * + * Copyright (c) 1996 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinEmbed.c 1.20 97/11/05 17:47:09; + */ + +#include "tkWinInt.h" + + +/* + * One of the following structures exists for each container in this + * application. It keeps track of the container window and its + * associated embedded window. + */ + +typedef struct Container { + HWND parentHWnd; /* Windows HWND to the parent window */ + TkWindow *parentPtr; /* Tk's information about the container + * or NULL if the container isn't + * in this process. */ + HWND embeddedHWnd; /* Windows HWND to the embedded window + */ + TkWindow *embeddedPtr; /* Tk's information about the embedded + * window, or NULL if the + * embedded application isn't in + * this process. */ + struct Container *nextPtr; /* Next in list of all containers in + * this process. */ +} Container; + +static Container *firstContainerPtr = NULL; + /* First in list of all containers + * managed by this process. */ + +static void CleanupContainerList _ANSI_ARGS_(( + ClientData clientData)); +static void ContainerEventProc _ANSI_ARGS_((ClientData clientData, + XEvent *eventPtr)); +static void EmbeddedEventProc _ANSI_ARGS_(( + ClientData clientData, XEvent *eventPtr)); +static void EmbedGeometryRequest _ANSI_ARGS_(( + Container*containerPtr, int width, int height)); +static void EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr)); + +/* + *---------------------------------------------------------------------- + * + * CleanupContainerList -- + * + * Finalizes the list of containers. + * + * Results: + * None. + * + * Side effects: + * Releases memory occupied by containers of embedded windows. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +static void +CleanupContainerList(clientData) + ClientData clientData; +{ + Container *nextPtr; + + for (; + firstContainerPtr != (Container *) NULL; + firstContainerPtr = nextPtr) { + nextPtr = firstContainerPtr->nextPtr; + ckfree((char *) firstContainerPtr); + } + firstContainerPtr = (Container *) NULL; +} + +/* + *---------------------------------------------------------------------- + * + * TkpTestembedCmd -- + * + * Test command for the embedding facility. + * + * Results: + * Always returns TCL_OK. + * + * Side effects: + * Currently it does not do anything. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +int +TkpTestembedCmd(clientData, interp, argc, argv) + ClientData clientData; + Tcl_Interp *interp; + int argc; + char **argv; +{ + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpUseWindow -- + * + * This procedure causes a Tk window to use a given Windows handle + * for a window as its underlying window, rather than a new Windows + * window being created automatically. It is invoked by an embedded + * application to specify the window in which the application is + * embedded. + * + * Results: + * The return value is normally TCL_OK. If an error occurred (such as + * if the argument does not identify a legal Windows window handle), + * the return value is TCL_ERROR and an error message is left in the + * interp->result if interp is not NULL. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkpUseWindow(interp, tkwin, string) + Tcl_Interp *interp; /* If not NULL, used for error reporting + * if string is bogus. */ + Tk_Window tkwin; /* Tk window that does not yet have an + * associated X window. */ + char *string; /* String identifying an X window to use + * for tkwin; must be an integer value. */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + int id; + HWND hwnd; + Container *containerPtr; + + if (winPtr->window != None) { + panic("TkpUseWindow: Already assigned a window"); + } + + if (Tcl_GetInt(interp, string, &id) != TCL_OK) { + return TCL_ERROR; + } + hwnd = (HWND) id; + + /* + * Check if the window is a valid handle. If it is invalid, return + * TCL_ERROR and potentially leave an error message in interp->result. + */ + + if (!IsWindow(hwnd)) { + if (interp != (Tcl_Interp *) NULL) { + Tcl_AppendResult(interp, "window \"", string, + "\" doesn't exist", (char *) NULL); + } + return TCL_ERROR; + } + + /* + * Store the parent window in the platform private data slot so + * TkWmMapWindow can use it when creating the wrapper window. + */ + + winPtr->privatePtr = (struct TkWindowPrivate*) hwnd; + + /* + * Create an event handler to clean up the Container structure when + * tkwin is eventually deleted. + */ + + Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc, + (ClientData) winPtr); + + /* + * If this is the first container, register an exit handler so that + * things will get cleaned up at finalization. + */ + + if (firstContainerPtr == (Container *) NULL) { + Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL); + } + + /* + * Save information about the container and the embedded window + * in a Container structure. If there is already an existing + * Container structure, it means that both container and embedded + * app. are in the same process. + */ + + for (containerPtr = firstContainerPtr; containerPtr != NULL; + containerPtr = containerPtr->nextPtr) { + if (containerPtr->parentHWnd == hwnd) { + winPtr->flags |= TK_BOTH_HALVES; + containerPtr->parentPtr->flags |= TK_BOTH_HALVES; + break; + } + } + if (containerPtr == NULL) { + containerPtr = (Container *) ckalloc(sizeof(Container)); + containerPtr->parentPtr = NULL; + containerPtr->parentHWnd = hwnd; + containerPtr->nextPtr = firstContainerPtr; + firstContainerPtr = containerPtr; + } + + /* + * embeddedHWnd is not created yet. It will be created by TkWmMapWindow(), + * which will send a TK_ATTACHWINDOW to the container window. + * TkWinEmbeddedEventProc will process this message and set the embeddedHWnd + * variable + */ + + containerPtr->embeddedPtr = winPtr; + containerPtr->embeddedHWnd = NULL; + + winPtr->flags |= TK_EMBEDDED; + winPtr->flags &= (~(TK_MAPPED)); + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpMakeContainer -- + * + * This procedure is called to indicate that a particular window will + * be a container for an embedded application. This changes certain + * aspects of the window's behavior, such as whether it will receive + * events anymore. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkpMakeContainer(tkwin) + Tk_Window tkwin; +{ + TkWindow *winPtr = (TkWindow *) tkwin; + Container *containerPtr; + + /* + * If this is the first container, register an exit handler so that + * things will get cleaned up at finalization. + */ + + if (firstContainerPtr == (Container *) NULL) { + Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL); + } + + /* + * Register the window as a container so that, for example, we can + * find out later if the embedded app. is in the same process. + */ + + Tk_MakeWindowExist(tkwin); + containerPtr = (Container *) ckalloc(sizeof(Container)); + containerPtr->parentPtr = winPtr; + containerPtr->parentHWnd = Tk_GetHWND(Tk_WindowId(tkwin)); + containerPtr->embeddedHWnd = NULL; + containerPtr->embeddedPtr = NULL; + containerPtr->nextPtr = firstContainerPtr; + firstContainerPtr = containerPtr; + winPtr->flags |= TK_CONTAINER; + + /* + * Unlike in tkUnixEmbed.c, we don't make any requests for events + * in the embedded window here. Now we just allow the embedding + * of another TK application into TK windows. When the embedded + * window makes a request, that will be done by sending to the + * container window a WM_USER message, which will be intercepted + * by TkWinContainerProc. + * + * We need to get structure events of the container itself, though. + */ + + Tk_CreateEventHandler(tkwin, StructureNotifyMask, + ContainerEventProc, (ClientData) containerPtr); +} + +/* + *---------------------------------------------------------------------- + * + * EmbeddedEventProc -- + * + * This procedure is invoked by the Tk event dispatcher when various + * useful events are received for a window that is embedded in + * another application. + * + * Results: + * None. + * + * Side effects: + * Our internal state gets cleaned up when an embedded window is + * destroyed. + * + *---------------------------------------------------------------------- + */ + +static void +EmbeddedEventProc(clientData, eventPtr) + ClientData clientData; /* Token for container window. */ + XEvent *eventPtr; /* ResizeRequest event. */ +{ + TkWindow *winPtr = (TkWindow *) clientData; + + if (eventPtr->type == DestroyNotify) { + EmbedWindowDeleted(winPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinEmbeddedEventProc -- + * + * This procedure is invoked by the Tk event dispatcher when + * various useful events are received for the *children* of a + * container window. It forwards relevant information, such as + * geometry requests, from the events into the container's + * application. + * + * Results: + * None. + * + * Side effects: + * Depends on the event. For example, when ConfigureRequest events + * occur, geometry information gets set for the container window. + * + *---------------------------------------------------------------------- + */ + +LRESULT +TkWinEmbeddedEventProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + Container *containerPtr; + + /* + * Find the Container structure associated with the parent window. + */ + + for (containerPtr = firstContainerPtr; + containerPtr->parentHWnd != hwnd; + containerPtr = containerPtr->nextPtr) { + if (containerPtr == NULL) { + panic("TkWinContainerProc couldn't find Container record"); + } + } + + switch (message) { + case TK_ATTACHWINDOW: + /* An embedded window (either from this application or from + * another application) is trying to attach to this container. + * We attach it only if this container is not yet containing any + * window. + */ + if (containerPtr->embeddedHWnd == NULL) { + containerPtr->embeddedHWnd = (HWND)wParam; + } else { + return 0; + } + + break; + case TK_GEOMETRYREQ: + EmbedGeometryRequest(containerPtr, wParam, lParam); + break; + } + return 1; +} + +/* + *---------------------------------------------------------------------- + * + * EmbedGeometryRequest -- + * + * This procedure is invoked when an embedded application requests + * a particular size. It processes the request (which may or may + * not actually resize the window) and reflects the results back + * to the embedded application. + * + * Results: + * None. + * + * Side effects: + * If we deny the child's size change request, a Configure event + * is synthesized to let the child know that the size is the same + * as it used to be. Events get processed while we're waiting for + * the geometry managers to do their thing. + * + *---------------------------------------------------------------------- + */ + +void +EmbedGeometryRequest(containerPtr, width, height) + Container *containerPtr; /* Information about the container window. */ + int width, height; /* Size that the child has requested. */ +{ + TkWindow * winPtr = containerPtr->parentPtr; + + /* + * Forward the requested size into our geometry management hierarchy + * via the container window. We need to send a Configure event back + * to the embedded application even if we decide not to resize + * the window; to make this happen, process all idle event handlers + * synchronously here (so that the geometry managers have had a + * chance to do whatever they want to do), and if the window's size + * didn't change then generate a configure event. + */ + Tk_GeometryRequest((Tk_Window)winPtr, width, height); + + if (containerPtr->embeddedHWnd != NULL) { + while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) { + /* Empty loop body. */ + } + + SetWindowPos(containerPtr->embeddedHWnd, NULL, + 0, 0, winPtr->changes.width, winPtr->changes.height, SWP_NOZORDER); + } +} + +/* + *---------------------------------------------------------------------- + * + * ContainerEventProc -- + * + * This procedure is invoked by the Tk event dispatcher when + * various useful events are received for the container window. + * + * Results: + * None. + * + * Side effects: + * Depends on the event. For example, when ConfigureRequest events + * occur, geometry information gets set for the container window. + * + *---------------------------------------------------------------------- + */ + +static void +ContainerEventProc(clientData, eventPtr) + ClientData clientData; /* Token for container window. */ + XEvent *eventPtr; /* ResizeRequest event. */ +{ + Container *containerPtr = (Container *)clientData; + Tk_Window tkwin = (Tk_Window)containerPtr->parentPtr; + + if (eventPtr->type == ConfigureNotify) { + if (containerPtr->embeddedPtr == NULL) { + return; + } + /* Resize the embedded window, if there is any */ + if (containerPtr->embeddedHWnd) { + SetWindowPos(containerPtr->embeddedHWnd, NULL, + 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), SWP_NOZORDER); + } + } else if (eventPtr->type == DestroyNotify) { + /* The container is gone, remove it from the list */ + EmbedWindowDeleted(containerPtr->parentPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetOtherWindow -- + * + * If both the container and embedded window are in the same + * process, this procedure will return either one, given the other. + * + * Results: + * If winPtr is a container, the return value is the token for the + * embedded window, and vice versa. If the "other" window isn't in + * this process, NULL is returned. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +TkWindow * +TkpGetOtherWindow(winPtr) + TkWindow *winPtr; /* Tk's structure for a container or + * embedded window. */ +{ + Container *containerPtr; + + for (containerPtr = firstContainerPtr; containerPtr != NULL; + containerPtr = containerPtr->nextPtr) { + if (containerPtr->embeddedPtr == winPtr) { + return containerPtr->parentPtr; + } else if (containerPtr->parentPtr == winPtr) { + return containerPtr->embeddedPtr; + } + } + panic("TkpGetOtherWindow couldn't find window"); + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * TkpClaimFocus -- + * + * This procedure is invoked when someone asks or the input focus + * to be put on a window in an embedded application, but the + * application doesn't currently have the focus. It requests the + * input focus from the container application. + * + * Results: + * None. + * + * Side effects: + * The input focus may change. + * + *---------------------------------------------------------------------- + */ + +void +TkpClaimFocus(topLevelPtr, force) + TkWindow *topLevelPtr; /* Top-level window containing desired + * focus window; should be embedded. */ + int force; /* One means that the container should + * claim the focus if it doesn't + * currently have it. */ +{ + HWND hwnd = GetParent(Tk_GetHWND(topLevelPtr->window)); + SendMessage(hwnd, TK_CLAIMFOCUS, (WPARAM) force, 0); +} + +/* + *---------------------------------------------------------------------- + * + * TkpRedirectKeyEvent -- + * + * This procedure is invoked when a key press or release event + * arrives for an application that does not believe it owns the + * input focus. This can happen because of embedding; for example, + * X can send an event to an embedded application when the real + * focus window is in the container application and is an ancestor + * of the container. This procedure's job is to forward the event + * back to the application where it really belongs. + * + * Results: + * None. + * + * Side effects: + * The event may get sent to a different application. + * + *---------------------------------------------------------------------- + */ + +void +TkpRedirectKeyEvent(winPtr, eventPtr) + TkWindow *winPtr; /* Window to which the event was originally + * reported. */ + XEvent *eventPtr; /* X event to redirect (should be KeyPress + * or KeyRelease). */ +{ + /* not implemented */ +} + +/* + *---------------------------------------------------------------------- + * + * EmbedWindowDeleted -- + * + * This procedure is invoked when a window involved in embedding + * (as either the container or the embedded application) is + * destroyed. It cleans up the Container structure for the window. + * + * Results: + * None. + * + * Side effects: + * A Container structure may be freed. + * + *---------------------------------------------------------------------- + */ + +static void +EmbedWindowDeleted(winPtr) + TkWindow *winPtr; /* Tk's information about window that + * was deleted. */ +{ + Container *containerPtr, *prevPtr; + + /* + * Find the Container structure for this window work. Delete the + * information about the embedded application and free the container's + * record. + */ + + prevPtr = NULL; + containerPtr = firstContainerPtr; + while (1) { + if (containerPtr->embeddedPtr == winPtr) { + containerPtr->embeddedHWnd = NULL; + containerPtr->embeddedPtr = NULL; + break; + } + if (containerPtr->parentPtr == winPtr) { + containerPtr->parentPtr = NULL; + break; + } + prevPtr = containerPtr; + containerPtr = containerPtr->nextPtr; + if (containerPtr == NULL) { + panic("EmbedWindowDeleted couldn't find window"); + } + } + if ((containerPtr->embeddedPtr == NULL) + && (containerPtr->parentPtr == NULL)) { + if (prevPtr == NULL) { + firstContainerPtr = containerPtr->nextPtr; + } else { + prevPtr->nextPtr = containerPtr->nextPtr; + } + ckfree((char *) containerPtr); + } +} diff --git a/win/tkWinFont.c b/win/tkWinFont.c new file mode 100644 index 0000000..c1d5161 --- /dev/null +++ b/win/tkWinFont.c @@ -0,0 +1,643 @@ +/* + * tkWinFont.c -- + * + * Contains the Windows implementation of the platform-independant + * font package interface. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * Copyright (c) 1994 Software Research Associates, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinFont.c 1.20 97/05/14 15:45:30 + */ + +#include "tkWinInt.h" +#include "tkFont.h" + +/* + * The following structure represents Windows' implementation of a font. + */ + +typedef struct WinFont { + TkFont font; /* Stuff used by generic font package. Must + * be first in structure. */ + HFONT hFont; /* Windows information about font. */ + HWND hwnd; /* Toplevel window of application that owns + * this font, used for getting HDC. */ + int widths[256]; /* Widths of first 256 chars in this font. */ +} WinFont; + +/* + * The following structure is used as to map between the Tcl strings + * that represent the system fonts and the numbers used by Windows. + */ + +static TkStateMap systemMap[] = { + {ANSI_FIXED_FONT, "ansifixed"}, + {ANSI_VAR_FONT, "ansi"}, + {DEVICE_DEFAULT_FONT, "device"}, + {OEM_FIXED_FONT, "oemfixed"}, + {SYSTEM_FIXED_FONT, "systemfixed"}, + {SYSTEM_FONT, "system"}, + {-1, NULL} +}; + +#define ABS(x) (((x) < 0) ? -(x) : (x)) + +static TkFont * AllocFont _ANSI_ARGS_((TkFont *tkFontPtr, + Tk_Window tkwin, HFONT hFont)); +static char * GetProperty _ANSI_ARGS_((CONST TkFontAttributes *faPtr, + CONST char *option)); +static int CALLBACK WinFontFamilyEnumProc _ANSI_ARGS_((ENUMLOGFONT *elfPtr, + NEWTEXTMETRIC *ntmPtr, int fontType, + LPARAM lParam)); + + +/* + *--------------------------------------------------------------------------- + * + * TkpGetNativeFont -- + * + * Map a platform-specific native font name to a TkFont. + * + * Results: + * The return value is a pointer to a TkFont that represents the + * native font. If a native font by the given name could not be + * found, the return value is NULL. + * + * Every call to this procedure returns a new TkFont structure, + * even if the name has already been seen before. The caller should + * call TkpDeleteFont() when the font is no longer needed. + * + * The caller is responsible for initializing the memory associated + * with the generic TkFont when this function returns and releasing + * the contents of the generic TkFont before calling TkpDeleteFont(). + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +TkFont * +TkpGetNativeFont(tkwin, name) + Tk_Window tkwin; /* For display where font will be used. */ + CONST char *name; /* Platform-specific font name. */ +{ + int object; + HFONT hFont; + + object = TkFindStateNum(NULL, NULL, systemMap, name); + if (object < 0) { + return NULL; + } + hFont = GetStockObject(object); + if (hFont == NULL) { + panic("TkpGetNativeFont: can't allocate stock font"); + } + + return AllocFont(NULL, tkwin, hFont); +} + +/* + *--------------------------------------------------------------------------- + * + * TkpGetFontFromAttributes -- + * + * Given a desired set of attributes for a font, find a font with + * the closest matching attributes. + * + * Results: + * The return value is a pointer to a TkFont that represents the + * font with the desired attributes. If a font with the desired + * attributes could not be constructed, some other font will be + * substituted automatically. NULL is never returned. + * + * Every call to this procedure returns a new TkFont structure, + * even if the specified attributes have already been seen before. + * The caller should call TkpDeleteFont() to free the platform- + * specific data when the font is no longer needed. + * + * The caller is responsible for initializing the memory associated + * with the generic TkFont when this function returns and releasing + * the contents of the generic TkFont before calling TkpDeleteFont(). + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +TkFont * +TkpGetFontFromAttributes(tkFontPtr, tkwin, faPtr) + TkFont *tkFontPtr; /* If non-NULL, store the information in + * this existing TkFont structure, rather than + * allocating a new structure to hold the + * font; the existing contents of the font + * will be released. If NULL, a new TkFont + * structure is allocated. */ + Tk_Window tkwin; /* For display where font will be used. */ + CONST TkFontAttributes *faPtr; /* Set of attributes to match. */ +{ + LOGFONT lf; + HFONT hFont; + Window window; + HWND hwnd; + HDC hdc; + + window = Tk_WindowId(((TkWindow *) tkwin)->mainPtr->winPtr); + hwnd = (window == None) ? NULL : TkWinGetHWND(window); + + hdc = GetDC(hwnd); + lf.lfHeight = -faPtr->pointsize; + if (lf.lfHeight < 0) { + lf.lfHeight = MulDiv(lf.lfHeight, + 254 * WidthOfScreen(Tk_Screen(tkwin)), + 720 * WidthMMOfScreen(Tk_Screen(tkwin))); + } + lf.lfWidth = 0; + lf.lfEscapement = 0; + lf.lfOrientation = 0; + lf.lfWeight = (faPtr->weight == TK_FW_NORMAL) ? FW_NORMAL : FW_BOLD; + lf.lfItalic = faPtr->slant; + lf.lfUnderline = faPtr->underline; + lf.lfStrikeOut = faPtr->overstrike; + lf.lfCharSet = DEFAULT_CHARSET; + lf.lfOutPrecision = OUT_DEFAULT_PRECIS; + lf.lfClipPrecision = CLIP_DEFAULT_PRECIS; + lf.lfQuality = DEFAULT_QUALITY; + lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; + if (faPtr->family == NULL) { + lf.lfFaceName[0] = '\0'; + } else { + lstrcpyn(lf.lfFaceName, faPtr->family, sizeof(lf.lfFaceName)); + } + ReleaseDC(hwnd, hdc); + + /* + * Replace the standard X and Mac family names with the names that + * Windows likes. + */ + + if ((stricmp(lf.lfFaceName, "Times") == 0) + || (stricmp(lf.lfFaceName, "New York") == 0)) { + strcpy(lf.lfFaceName, "Times New Roman"); + } else if ((stricmp(lf.lfFaceName, "Courier") == 0) + || (stricmp(lf.lfFaceName, "Monaco") == 0)) { + strcpy(lf.lfFaceName, "Courier New"); + } else if ((stricmp(lf.lfFaceName, "Helvetica") == 0) + || (stricmp(lf.lfFaceName, "Geneva") == 0)) { + strcpy(lf.lfFaceName, "Arial"); + } + + hFont = CreateFontIndirect(&lf); + if (hFont == NULL) { + hFont = GetStockObject(SYSTEM_FONT); + if (hFont == NULL) { + panic("TkpGetFontFromAttributes: cannot get system font"); + } + } + return AllocFont(tkFontPtr, tkwin, hFont); +} + +/* + *--------------------------------------------------------------------------- + * + * TkpDeleteFont -- + * + * Called to release a font allocated by TkpGetNativeFont() or + * TkpGetFontFromAttributes(). The caller should have already + * released the fields of the TkFont that are used exclusively by + * the generic TkFont code. + * + * Results: + * None. + * + * Side effects: + * TkFont is deallocated. + * + *--------------------------------------------------------------------------- + */ + +void +TkpDeleteFont(tkFontPtr) + TkFont *tkFontPtr; /* Token of font to be deleted. */ +{ + WinFont *fontPtr; + + fontPtr = (WinFont *) tkFontPtr; + DeleteObject(fontPtr->hFont); + ckfree((char *) fontPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * TkpGetFontFamilies, WinFontEnumFamilyProc -- + * + * Return information about the font families that are available + * on the display of the given window. + * + * Results: + * interp->result is modified to hold a list of all the available + * font families. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +void +TkpGetFontFamilies(interp, tkwin) + Tcl_Interp *interp; /* Interp to hold result. */ + Tk_Window tkwin; /* For display to query. */ +{ + Window window; + HWND hwnd; + HDC hdc; + + window = Tk_WindowId(tkwin); + hwnd = (window == (Window) NULL) ? NULL : TkWinGetHWND(window); + + hdc = GetDC(hwnd); + EnumFontFamilies(hdc, NULL, (FONTENUMPROC) WinFontFamilyEnumProc, + (LPARAM) interp); + ReleaseDC(hwnd, hdc); +} + +/* ARGSUSED */ + +static int CALLBACK +WinFontFamilyEnumProc(elfPtr, ntmPtr, fontType, lParam) + ENUMLOGFONT *elfPtr; /* Logical-font data. */ + NEWTEXTMETRIC *ntmPtr; /* Physical-font data (not used). */ + int fontType; /* Type of font (not used). */ + LPARAM lParam; /* Interp to hold result. */ +{ + Tcl_Interp *interp; + + interp = (Tcl_Interp *) lParam; + Tcl_AppendElement(interp, elfPtr->elfLogFont.lfFaceName); + return 1; +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_MeasureChars -- + * + * Determine the number of characters from the string that will fit + * in the given horizontal span. The measurement is done under the + * assumption that Tk_DrawChars() will be used to actually display + * the characters. + * + * Results: + * The return value is the number of characters from source that + * fit into the span that extends from 0 to maxLength. *lengthPtr is + * filled with the x-coordinate of the right edge of the last + * character that did fit. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Tk_MeasureChars(tkfont, source, numChars, maxLength, flags, lengthPtr) + Tk_Font tkfont; /* Font in which characters will be drawn. */ + CONST char *source; /* Characters to be displayed. Need not be + * '\0' terminated. */ + int numChars; /* Maximum number of characters to consider + * from source string. */ + int maxLength; /* If > 0, maxLength specifies the longest + * permissible line length; don't consider any + * character that would cross this + * x-position. If <= 0, then line length is + * unbounded and the flags argument is + * ignored. */ + int flags; /* Various flag bits OR-ed together: + * TK_PARTIAL_OK means include the last char + * which only partially fit on this line. + * TK_WHOLE_WORDS means stop on a word + * boundary, if possible. + * TK_AT_LEAST_ONE means return at least one + * character even if no characters fit. */ + int *lengthPtr; /* Filled with x-location just after the + * terminating character. */ +{ + WinFont *fontPtr; + HDC hdc; + HFONT hFont; + int curX, curIdx; + + /* + * On the authority of the Gates Empire, Windows does not use kerning + * or fractional character widths when displaying text on the screen. + * So that means we can safely measure individual characters or spans + * of characters and add up the widths w/o any "off-by-one pixel" + * errors. + */ + + fontPtr = (WinFont *) tkfont; + + hdc = GetDC(fontPtr->hwnd); + hFont = SelectObject(hdc, fontPtr->hFont); + + if (numChars == 0) { + curX = 0; + curIdx = 0; + } else if (maxLength <= 0) { + SIZE size; + + GetTextExtentPoint(hdc, source, numChars, &size); + curX = size.cx; + curIdx = numChars; + } else { + int newX, termX, sawNonSpace; + CONST char *term, *end, *p; + int ch; + + ch = UCHAR(*source); + newX = curX = termX = 0; + + term = source; + end = source + numChars; + + sawNonSpace = !isspace(ch); + for (p = source; ; ) { + newX += fontPtr->widths[ch]; + if (newX > maxLength) { + break; + } + curX = newX; + p++; + if (p >= end) { + term = end; + termX = curX; + break; + } + + ch = UCHAR(*p); + if (isspace(ch)) { + if (sawNonSpace) { + term = p; + termX = curX; + sawNonSpace = 0; + } + } else { + sawNonSpace = 1; + } + } + + /* + * P points to the first character that doesn't fit in the desired + * span. Use the flags to figure out what to return. + */ + + if ((flags & TK_PARTIAL_OK) && (p < end) && (curX < maxLength)) { + /* + * Include the first character that didn't quite fit in the desired + * span. The width returned will include the width of that extra + * character. + */ + + curX = newX; + p++; + } + if ((flags & TK_AT_LEAST_ONE) && (term == source) && (p < end)) { + term = p; + termX = curX; + if (term == source) { + term++; + termX = newX; + } + } else if ((p >= end) || !(flags & TK_WHOLE_WORDS)) { + term = p; + termX = curX; + } + + curX = termX; + curIdx = term - source; + } + + SelectObject(hdc, hFont); + ReleaseDC(fontPtr->hwnd, hdc); + + *lengthPtr = curX; + return curIdx; +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_DrawChars -- + * + * Draw a string of characters on the screen. + * + * Results: + * None. + * + * Side effects: + * Information gets drawn on the screen. + * + *--------------------------------------------------------------------------- + */ + +void +Tk_DrawChars(display, drawable, gc, tkfont, source, numChars, x, y) + Display *display; /* Display on which to draw. */ + Drawable drawable; /* Window or pixmap in which to draw. */ + GC gc; /* Graphics context for drawing characters. */ + Tk_Font tkfont; /* Font in which characters will be drawn; + * must be the same as font used in GC. */ + CONST char *source; /* Characters to be displayed. Need not be + * '\0' terminated. All Tk meta-characters + * (tabs, control characters, and newlines) + * should be stripped out of the string that + * is passed to this function. If they are + * not stripped out, they will be displayed as + * regular printing characters. */ + int numChars; /* Number of characters in string. */ + int x, y; /* Coordinates at which to place origin of + * string when drawing. */ +{ + HDC dc; + HFONT hFont; + TkWinDCState state; + WinFont *fontPtr; + + fontPtr = (WinFont *) gc->font; + display->request++; + + if (drawable == None) { + return; + } + + dc = TkWinGetDrawableDC(display, drawable, &state); + + SetROP2(dc, tkpWinRopModes[gc->function]); + + if ((gc->fill_style == FillStippled + || gc->fill_style == FillOpaqueStippled) + && gc->stipple != None) { + TkWinDrawable *twdPtr = (TkWinDrawable *)gc->stipple; + HBRUSH oldBrush, stipple; + HBITMAP oldBitmap, bitmap; + HDC dcMem; + TEXTMETRIC tm; + SIZE size; + + if (twdPtr->type != TWD_BITMAP) { + panic("unexpected drawable type in stipple"); + } + + /* + * Select stipple pattern into destination dc. + */ + + dcMem = CreateCompatibleDC(dc); + + stipple = CreatePatternBrush(twdPtr->bitmap.handle); + SetBrushOrgEx(dc, gc->ts_x_origin, gc->ts_y_origin, NULL); + oldBrush = SelectObject(dc, stipple); + + SetTextAlign(dcMem, TA_LEFT | TA_TOP); + SetTextColor(dcMem, gc->foreground); + SetBkMode(dcMem, TRANSPARENT); + SetBkColor(dcMem, RGB(0, 0, 0)); + + hFont = SelectObject(dcMem, fontPtr->hFont); + + /* + * Compute the bounding box and create a compatible bitmap. + */ + + GetTextExtentPoint(dcMem, source, numChars, &size); + GetTextMetrics(dcMem, &tm); + size.cx -= tm.tmOverhang; + bitmap = CreateCompatibleBitmap(dc, size.cx, size.cy); + oldBitmap = SelectObject(dcMem, bitmap); + + /* + * The following code is tricky because fonts are rendered in multiple + * colors. First we draw onto a black background and copy the white + * bits. Then we draw onto a white background and copy the black bits. + * Both the foreground and background bits of the font are ANDed with + * the stipple pattern as they are copied. + */ + + PatBlt(dcMem, 0, 0, size.cx, size.cy, BLACKNESS); + TextOut(dcMem, 0, 0, source, numChars); + BitBlt(dc, x, y - tm.tmAscent, size.cx, size.cy, dcMem, + 0, 0, 0xEA02E9); + PatBlt(dcMem, 0, 0, size.cx, size.cy, WHITENESS); + TextOut(dcMem, 0, 0, source, numChars); + BitBlt(dc, x, y - tm.tmAscent, size.cx, size.cy, dcMem, + 0, 0, 0x8A0E06); + + /* + * Destroy the temporary bitmap and restore the device context. + */ + + SelectObject(dcMem, hFont); + SelectObject(dcMem, oldBitmap); + DeleteObject(bitmap); + DeleteDC(dcMem); + SelectObject(dc, oldBrush); + DeleteObject(stipple); + } else { + SetTextAlign(dc, TA_LEFT | TA_BASELINE); + SetTextColor(dc, gc->foreground); + SetBkMode(dc, TRANSPARENT); + hFont = SelectObject(dc, fontPtr->hFont); + TextOut(dc, x, y, source, numChars); + SelectObject(dc, hFont); + } + TkWinReleaseDrawableDC(drawable, dc, &state); +} + +/* + *--------------------------------------------------------------------------- + * + * AllocFont -- + * + * Helper for TkpGetNativeFont() and TkpGetFontFromAttributes(). + * Allocates and intializes the memory for a new TkFont that + * wraps the platform-specific data. + * + * Results: + * Returns pointer to newly constructed TkFont. + * + * The caller is responsible for initializing the fields of the + * TkFont that are used exclusively by the generic TkFont code, and + * for releasing those fields before calling TkpDeleteFont(). + * + * Side effects: + * Memory allocated. + * + *--------------------------------------------------------------------------- + */ + +static TkFont * +AllocFont(tkFontPtr, tkwin, hFont) + TkFont *tkFontPtr; /* If non-NULL, store the information in + * this existing TkFont structure, rather than + * allocating a new structure to hold the + * font; the existing contents of the font + * will be released. If NULL, a new TkFont + * structure is allocated. */ + Tk_Window tkwin; /* For display where font will be used. */ + HFONT hFont; /* Windows information about font. */ +{ + HWND hwnd; + WinFont *fontPtr; + HDC hdc; + TEXTMETRIC tm; + Window window; + char buf[LF_FACESIZE]; + TkFontAttributes *faPtr; + + if (tkFontPtr != NULL) { + fontPtr = (WinFont *) tkFontPtr; + DeleteObject(fontPtr->hFont); + } else { + fontPtr = (WinFont *) ckalloc(sizeof(WinFont)); + } + + window = Tk_WindowId(((TkWindow *) tkwin)->mainPtr->winPtr); + hwnd = (window == None) ? NULL : TkWinGetHWND(window); + + hdc = GetDC(hwnd); + hFont = SelectObject(hdc, hFont); + GetTextFace(hdc, sizeof(buf), buf); + GetTextMetrics(hdc, &tm); + GetCharWidth(hdc, 0, 255, fontPtr->widths); + + fontPtr->font.fid = (Font) fontPtr; + + faPtr = &fontPtr->font.fa; + faPtr->family = Tk_GetUid(buf); + faPtr->pointsize = MulDiv(tm.tmHeight - tm.tmInternalLeading, + 720 * WidthMMOfScreen(Tk_Screen(tkwin)), + 254 * WidthOfScreen(Tk_Screen(tkwin))); + faPtr->weight = (tm.tmWeight > FW_MEDIUM) ? TK_FW_BOLD : TK_FW_NORMAL; + faPtr->slant = (tm.tmItalic != 0) ? TK_FS_ITALIC : TK_FS_ROMAN; + faPtr->underline = (tm.tmUnderlined != 0) ? 1 : 0; + faPtr->overstrike = (tm.tmStruckOut != 0) ? 1 : 0; + + fontPtr->font.fm.ascent = tm.tmAscent; + fontPtr->font.fm.descent = tm.tmDescent; + fontPtr->font.fm.maxWidth = tm.tmMaxCharWidth; + fontPtr->font.fm.fixed = !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH); + + hFont = SelectObject(hdc, hFont); + ReleaseDC(hwnd, hdc); + + fontPtr->hFont = hFont; + fontPtr->hwnd = hwnd; + + return (TkFont *) fontPtr; +} + diff --git a/win/tkWinImage.c b/win/tkWinImage.c new file mode 100644 index 0000000..388a58a --- /dev/null +++ b/win/tkWinImage.c @@ -0,0 +1,329 @@ +/* + * tkWinImage.c -- + * + * This file contains routines for manipulation full-color images. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinImage.c 1.13 97/07/07 11:19:45 + */ + +#include "tkWinInt.h" + +static int DestroyImage _ANSI_ARGS_((XImage* data)); +static unsigned long ImageGetPixel _ANSI_ARGS_((XImage *image, int x, int y)); +static int PutPixel _ANSI_ARGS_((XImage *image, int x, int y, + unsigned long pixel)); + +/* + *---------------------------------------------------------------------- + * + * DestroyImage -- + * + * This is a trivial wrapper around ckfree to make it possible to + * pass ckfree as a pointer. + * + * Results: + * None. + * + * Side effects: + * Deallocates the image. + * + *---------------------------------------------------------------------- + */ + +int +DestroyImage(imagePtr) + XImage *imagePtr; /* image to free */ +{ + if (imagePtr) { + if (imagePtr->data) { + ckfree((char*)imagePtr->data); + } + ckfree((char*)imagePtr); + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * ImageGetPixel -- + * + * Get a single pixel from an image. + * + * Results: + * Returns the 32 bit pixel value. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +unsigned long +ImageGetPixel(image, x, y) + XImage *image; + int x, y; +{ + unsigned long pixel = 0; + unsigned char *srcPtr = &(image->data[(y * image->bytes_per_line) + + ((x * image->bits_per_pixel) / NBBY)]); + + switch (image->bits_per_pixel) { + case 32: + case 24: + pixel = RGB(srcPtr[2], srcPtr[1], srcPtr[0]); + break; + case 16: + pixel = RGB(((((WORD*)srcPtr)[0]) >> 7) & 0xf8, + ((((WORD*)srcPtr)[0]) >> 2) & 0xf8, + ((((WORD*)srcPtr)[0]) << 3) & 0xf8); + break; + case 8: + pixel = srcPtr[0]; + break; + case 4: + pixel = ((x%2) ? (*srcPtr) : ((*srcPtr) >> 4)) & 0x0f; + break; + case 1: + pixel = ((*srcPtr) & (0x80 >> (x%8))) ? 1 : 0; + break; + } + return pixel; +} + +/* + *---------------------------------------------------------------------- + * + * PutPixel -- + * + * Set a single pixel in an image. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +PutPixel(image, x, y, pixel) + XImage *image; + int x, y; + unsigned long pixel; +{ + unsigned char *destPtr = &(image->data[(y * image->bytes_per_line) + + ((x * image->bits_per_pixel) / NBBY)]); + + switch (image->bits_per_pixel) { + case 32: + /* + * Pixel is DWORD: 0x00BBGGRR + */ + + destPtr[3] = 0; + case 24: + /* + * Pixel is triplet: 0xBBGGRR. + */ + + destPtr[0] = (unsigned char) GetBValue(pixel); + destPtr[1] = (unsigned char) GetGValue(pixel); + destPtr[2] = (unsigned char) GetRValue(pixel); + break; + case 16: + /* + * Pixel is WORD: 5-5-5 (R-G-B) + */ + + (*(WORD*)destPtr) = + ((GetRValue(pixel) & 0xf8) << 7) + | ((GetGValue(pixel) & 0xf8) <<2) + | ((GetBValue(pixel) & 0xf8) >> 3); + break; + case 8: + /* + * Pixel is 8-bit index into color table. + */ + + (*destPtr) = (unsigned char) pixel; + break; + case 4: + /* + * Pixel is 4-bit index in MSBFirst order. + */ + if (x%2) { + (*destPtr) = (unsigned char) (((*destPtr) & 0xf0) + | (pixel & 0x0f)); + } else { + (*destPtr) = (unsigned char) (((*destPtr) & 0x0f) + | ((pixel << 4) & 0xf0)); + } + break; + case 1: { + /* + * Pixel is bit in MSBFirst order. + */ + + int mask = (0x80 >> (x%8)); + if (pixel) { + (*destPtr) |= mask; + } else { + (*destPtr) &= ~mask; + } + } + break; + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * XCreateImage -- + * + * Allocates storage for a new XImage. + * + * Results: + * Returns a newly allocated XImage. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +XImage * +XCreateImage(display, visual, depth, format, offset, data, width, height, + bitmap_pad, bytes_per_line) + Display* display; + Visual* visual; + unsigned int depth; + int format; + int offset; + char* data; + unsigned int width; + unsigned int height; + int bitmap_pad; + int bytes_per_line; +{ + XImage* imagePtr = (XImage *) ckalloc(sizeof(XImage)); + imagePtr->width = width; + imagePtr->height = height; + imagePtr->xoffset = offset; + imagePtr->format = format; + imagePtr->data = data; + imagePtr->byte_order = LSBFirst; + imagePtr->bitmap_unit = 8; + imagePtr->bitmap_bit_order = MSBFirst; + imagePtr->bitmap_pad = bitmap_pad; + imagePtr->bits_per_pixel = depth; + imagePtr->depth = depth; + + /* + * Under Windows, bitmap_pad must be on an LONG data-type boundary. + */ + +#define LONGBITS (sizeof(LONG) * 8) + + bitmap_pad = (bitmap_pad + LONGBITS - 1) / LONGBITS * LONGBITS; + + /* + * Round to the nearest bitmap_pad boundary. + */ + + if (bytes_per_line) { + imagePtr->bytes_per_line = bytes_per_line; + } else { + imagePtr->bytes_per_line = (((depth * width) + + (bitmap_pad - 1)) >> 3) & ~((bitmap_pad >> 3) - 1); + } + + imagePtr->red_mask = 0; + imagePtr->green_mask = 0; + imagePtr->blue_mask = 0; + + imagePtr->f.put_pixel = PutPixel; + imagePtr->f.get_pixel = ImageGetPixel; + imagePtr->f.destroy_image = DestroyImage; + imagePtr->f.create_image = NULL; + imagePtr->f.sub_image = NULL; + imagePtr->f.add_pixel = NULL; + + return imagePtr; +} + +/* + *---------------------------------------------------------------------- + * + * XGetImage -- + * + * This function copies data from a pixmap or window into an + * XImage. + * + * Results: + * Returns a newly allocated image containing the data from the + * given rectangle of the given drawable. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +XImage * +XGetImage(display, d, x, y, width, height, plane_mask, format) + Display* display; + Drawable d; + int x; + int y; + unsigned int width; + unsigned int height; + unsigned long plane_mask; + int format; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *)d; + XImage *imagePtr; + HDC dc; + char infoBuf[sizeof(BITMAPINFO) + sizeof(RGBQUAD)]; + BITMAPINFO *infoPtr = (BITMAPINFO*)infoBuf; + + if ((twdPtr->type != TWD_BITMAP) || (twdPtr->bitmap.handle == NULL) + || (format != XYPixmap) || (plane_mask != 1)) { + panic("XGetImage: not implemented"); + } + + + imagePtr = XCreateImage(display, NULL, 1, XYBitmap, 0, NULL, + width, height, 32, 0); + imagePtr->data = ckalloc(imagePtr->bytes_per_line * imagePtr->height); + + dc = GetDC(NULL); + + GetDIBits(dc, twdPtr->bitmap.handle, 0, height, NULL, + infoPtr, DIB_RGB_COLORS); + + infoPtr->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + infoPtr->bmiHeader.biWidth = width; + infoPtr->bmiHeader.biHeight = -(LONG)height; + infoPtr->bmiHeader.biPlanes = 1; + infoPtr->bmiHeader.biBitCount = 1; + infoPtr->bmiHeader.biCompression = BI_RGB; + infoPtr->bmiHeader.biCompression = 0; + infoPtr->bmiHeader.biXPelsPerMeter = 0; + infoPtr->bmiHeader.biYPelsPerMeter = 0; + infoPtr->bmiHeader.biClrUsed = 0; + infoPtr->bmiHeader.biClrImportant = 0; + + GetDIBits(dc, twdPtr->bitmap.handle, 0, height, imagePtr->data, + infoPtr, DIB_RGB_COLORS); + ReleaseDC(NULL, dc); + + return imagePtr; +} diff --git a/win/tkWinInit.c b/win/tkWinInit.c new file mode 100644 index 0000000..400f693 --- /dev/null +++ b/win/tkWinInit.c @@ -0,0 +1,121 @@ +/* + * tkWinInit.c -- + * + * This file contains Windows-specific interpreter initialization + * functions. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinInit.c 1.29 97/07/24 14:46:35 + */ + +#include "tkWinInt.h" + +/* + * The Init script (common to Windows and Unix platforms) is + * defined in tkInitScript.h + */ +#include "tkInitScript.h" + + +/* + *---------------------------------------------------------------------- + * + * TkpInit -- + * + * Performs Windows-specific interpreter initialization related to the + * tk_library variable. + * + * Results: + * A standard Tcl completion code (TCL_OK or TCL_ERROR). Also + * leaves information in interp->result. + * + * Side effects: + * Sets "tk_library" Tcl variable, runs "tk.tcl" script. + * + *---------------------------------------------------------------------- + */ + +int +TkpInit(interp) + Tcl_Interp *interp; +{ + return Tcl_Eval(interp, initScript); +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetAppName -- + * + * Retrieves the name of the current application from a platform + * specific location. For Windows, the application name is the + * root of the tail of the path contained in the tcl variable argv0. + * + * Results: + * Returns the application name in the given Tcl_DString. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkpGetAppName(interp, namePtr) + Tcl_Interp *interp; + Tcl_DString *namePtr; /* A previously initialized Tcl_DString. */ +{ + int argc; + char **argv = NULL, *name, *p; + + name = Tcl_GetVar(interp, "argv0", TCL_GLOBAL_ONLY); + if (name != NULL) { + Tcl_SplitPath(name, &argc, &argv); + if (argc > 0) { + name = argv[argc-1]; + p = strrchr(name, '.'); + if (p != NULL) { + *p = '\0'; + } + } else { + name = NULL; + } + } + if ((name == NULL) || (*name == 0)) { + name = "tk"; + } + Tcl_DStringAppend(namePtr, name, -1); + if (argv != NULL) { + ckfree((char *)argv); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpDisplayWarning -- + * + * This routines is called from Tk_Main to display warning + * messages that occur during startup. + * + * Results: + * None. + * + * Side effects: + * Displays a message box. + * + *---------------------------------------------------------------------- + */ + +void +TkpDisplayWarning(msg, title) + char *msg; /* Message to be displayed. */ + char *title; /* Title of warning. */ +{ + MessageBox(NULL, msg, title, MB_OK | MB_ICONEXCLAMATION | MB_SYSTEMMODAL + | MB_SETFOREGROUND | MB_TOPMOST); +} diff --git a/win/tkWinInt.h b/win/tkWinInt.h new file mode 100644 index 0000000..f3bca19 --- /dev/null +++ b/win/tkWinInt.h @@ -0,0 +1,194 @@ +/* + * tkWinInt.h -- + * + * This file contains declarations that are shared among the + * Windows-specific parts of Tk, but aren't used by the rest of + * Tk. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinInt.h 1.34 97/09/02 13:06:20 + */ + +#ifndef _TKWININT +#define _TKWININT + +#ifndef _TKINT +#include "tkInt.h" +#endif + +/* + * Include platform specific public interfaces. + */ + +#ifndef _TKWIN +#include "tkWin.h" +#endif + +/* + * Define constants missing from older Win32 SDK header files. + */ + +#ifndef WS_EX_TOOLWINDOW +#define WS_EX_TOOLWINDOW 0x00000080L +#endif + +typedef struct TkFontAttributes TkFontAttributes; + +/* + * The TkWinDCState is used to save the state of a device context + * so that it can be restored later. + */ + +typedef struct TkWinDCState { + HPALETTE palette; +} TkWinDCState; + +/* + * The TkWinDrawable is the internal implementation of an X Drawable (either + * a Window or a Pixmap). The following constants define the valid Drawable + * types. + */ + +#define TWD_BITMAP 1 +#define TWD_WINDOW 2 +#define TWD_WINDC 3 + +typedef struct { + int type; + HWND handle; + TkWindow *winPtr; +} TkWinWindow; + +typedef struct { + int type; + HBITMAP handle; + Colormap colormap; + int depth; +} TkWinBitmap; + +typedef struct { + int type; + HDC hdc; +}TkWinDC; + +typedef union { + int type; + TkWinWindow window; + TkWinBitmap bitmap; + TkWinDC winDC; +} TkWinDrawable; + +/* + * The following macros are used to retrieve internal values from a Drawable. + */ + +#define TkWinGetHWND(w) (((TkWinDrawable *) w)->window.handle) +#define TkWinGetWinPtr(w) (((TkWinDrawable*)w)->window.winPtr) +#define TkWinGetHBITMAP(w) (((TkWinDrawable*)w)->bitmap.handle) +#define TkWinGetColormap(w) (((TkWinDrawable*)w)->bitmap.colormap) +#define TkWinGetHDC(w) (((TkWinDrawable *) w)->winDC.hdc) + +/* + * The following structure is used to encapsulate palette information. + */ + +typedef struct { + HPALETTE palette; /* Palette handle used when drawing. */ + UINT size; /* Number of entries in the palette. */ + int stale; /* 1 if palette needs to be realized, + * otherwise 0. If the palette is stale, + * then an idle handler is scheduled to + * realize the palette. */ + Tcl_HashTable refCounts; /* Hash table of palette entry reference counts + * indexed by pixel value. */ +} TkWinColormap; + +/* + * The following macro retrieves the Win32 palette from a colormap. + */ + +#define TkWinGetPalette(colormap) (((TkWinColormap *) colormap)->palette) + +/* + * The following macros define the class names for Tk Window types. + */ + +#define TK_WIN_TOPLEVEL_CLASS_NAME "TkTopLevel" +#define TK_WIN_CHILD_CLASS_NAME "TkChild" + +/* + * The following variable indicates whether we are restricted to Win32s + * GDI calls. + */ + +extern int tkpIsWin32s; + +/* + * The following variable is a translation table between X gc functions and + * Win32 raster op modes. + */ + +extern int tkpWinRopModes[]; + +/* + * The following defines are used with TkWinGetBorderPixels to get the + * extra 2 border colors from a Tk_3DBorder. + */ + +#define TK_3D_LIGHT2 TK_3D_DARK_GC+1 +#define TK_3D_DARK2 TK_3D_DARK_GC+2 + +/* + * Internal procedures used by more than one source file. + */ + +extern LRESULT CALLBACK TkWinChildProc _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); +extern void TkWinClipboardRender _ANSI_ARGS_((TkDisplay *dispPtr, + UINT format)); +extern LRESULT TkWinEmbeddedEventProc _ANSI_ARGS_((HWND hwnd, + UINT message, WPARAM wParam, LPARAM lParam)); +extern void TkWinFillRect _ANSI_ARGS_((HDC dc, int x, int y, + int width, int height, int pixel)); +extern COLORREF TkWinGetBorderPixels _ANSI_ARGS_((Tk_Window tkwin, + Tk_3DBorder border, int which)); +extern HDC TkWinGetDrawableDC _ANSI_ARGS_((Display *display, + Drawable d, TkWinDCState* state)); +extern int TkWinGetModifierState _ANSI_ARGS_((void)); +extern HPALETTE TkWinGetSystemPalette _ANSI_ARGS_((void)); +extern HWND TkWinGetWrapperWindow _ANSI_ARGS_((Tk_Window tkwin)); +extern int TkWinHandleMenuEvent _ANSI_ARGS_((HWND *phwnd, + UINT *pMessage, WPARAM *pwParam, LPARAM *plParam, + LRESULT *plResult)); +extern int TkWinIndexOfColor _ANSI_ARGS_((XColor *colorPtr)); +extern void TkWinPointerDeadWindow _ANSI_ARGS_((TkWindow *winPtr)); +extern void TkWinPointerEvent _ANSI_ARGS_((HWND hwnd, int x, + int y)); +extern void TkWinPointerInit _ANSI_ARGS_((void)); +extern LRESULT TkWinReflectMessage _ANSI_ARGS_((HWND hwnd, + UINT message, WPARAM wParam, LPARAM lParam)); +extern void TkWinReleaseDrawableDC _ANSI_ARGS_((Drawable d, + HDC hdc, TkWinDCState* state)); +extern LRESULT TkWinResendEvent _ANSI_ARGS_((WNDPROC wndproc, + HWND hwnd, XEvent *eventPtr)); +extern HPALETTE TkWinSelectPalette _ANSI_ARGS_((HDC dc, + Colormap colormap)); +extern void TkWinSetMenu _ANSI_ARGS_((Tk_Window tkwin, + HMENU hMenu)); +extern void TkWinSetWindowPos _ANSI_ARGS_((HWND hwnd, + HWND siblingHwnd, int pos)); +extern void TkWinUpdateCursor _ANSI_ARGS_((TkWindow *winPtr)); +extern void TkWinWmCleanup _ANSI_ARGS_((HINSTANCE hInstance)); +extern HWND TkWinWmFindEmbedAssociation _ANSI_ARGS_(( + TkWindow *winPtr)); +extern void TkWinWmStoreEmbedAssociation _ANSI_ARGS_(( + TkWindow *winPtr, HWND hwnd)); +extern void TkWinXCleanup _ANSI_ARGS_((HINSTANCE hInstance)); +extern void TkWinXInit _ANSI_ARGS_((HINSTANCE hInstance)); + +#endif /* _TKWININT */ + diff --git a/win/tkWinKey.c b/win/tkWinKey.c new file mode 100644 index 0000000..3589143 --- /dev/null +++ b/win/tkWinKey.c @@ -0,0 +1,360 @@ +/* + * tkWinKey.c -- + * + * This file contains X emulation routines for keyboard related + * functions. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinKey.c 1.9 97/06/20 15:12:39 + */ + +#include "tkWinInt.h" + +typedef struct { + unsigned int keycode; + KeySym keysym; +} Keys; + +static Keys keymap[] = { + VK_CANCEL, XK_Cancel, + VK_BACK, XK_BackSpace, + VK_TAB, XK_Tab, + VK_CLEAR, XK_Clear, + VK_RETURN, XK_Return, + VK_SHIFT, XK_Shift_L, + VK_CONTROL, XK_Control_L, + VK_MENU, XK_Alt_L, + VK_PAUSE, XK_Pause, + VK_CAPITAL, XK_Caps_Lock, + VK_ESCAPE, XK_Escape, + VK_SPACE, XK_space, + VK_PRIOR, XK_Prior, + VK_NEXT, XK_Next, + VK_END, XK_End, + VK_HOME, XK_Home, + VK_LEFT, XK_Left, + VK_UP, XK_Up, + VK_RIGHT, XK_Right, + VK_DOWN, XK_Down, + VK_SELECT, XK_Select, + VK_PRINT, XK_Print, + VK_EXECUTE, XK_Execute, + VK_INSERT, XK_Insert, + VK_DELETE, XK_Delete, + VK_HELP, XK_Help, + VK_F1, XK_F1, + VK_F2, XK_F2, + VK_F3, XK_F3, + VK_F4, XK_F4, + VK_F5, XK_F5, + VK_F6, XK_F6, + VK_F7, XK_F7, + VK_F8, XK_F8, + VK_F9, XK_F9, + VK_F10, XK_F10, + VK_F11, XK_F11, + VK_F12, XK_F12, + VK_F13, XK_F13, + VK_F14, XK_F14, + VK_F15, XK_F15, + VK_F16, XK_F16, + VK_F17, XK_F17, + VK_F18, XK_F18, + VK_F19, XK_F19, + VK_F20, XK_F20, + VK_F21, XK_F21, + VK_F22, XK_F22, + VK_F23, XK_F23, + VK_F24, XK_F24, + VK_NUMLOCK, XK_Num_Lock, + VK_SCROLL, XK_Scroll_Lock, + 0, NoSymbol +}; + + +/* + *---------------------------------------------------------------------- + * + * XLookupString -- + * + * Retrieve the string equivalent for the given keyboard event. + * + * Results: + * Returns the number of characters stored in buffer_return. + * + * Side effects: + * Retrieves the characters stored in the event and inserts them + * into buffer_return. + * + *---------------------------------------------------------------------- + */ + +int +XLookupString(event_struct, buffer_return, bytes_buffer, keysym_return, + status_in_out) + XKeyEvent* event_struct; + char* buffer_return; + int bytes_buffer; + KeySym* keysym_return; + XComposeStatus* status_in_out; +{ + int i, limit; + + if (event_struct->send_event != -1) { + /* + * This is an event generated from generic code. It has no + * nchars or trans_chars members. + */ + + int index; + KeySym keysym; + + index = 0; + if (event_struct->state & ShiftMask) { + index |= 1; + } + if (event_struct->state & Mod1Mask) { + index |= 2; + } + keysym = XKeycodeToKeysym(event_struct->display, + event_struct->keycode, index); + if (((keysym != NoSymbol) && (keysym > 0) && (keysym < 256)) + || (keysym == XK_Return) + || (keysym == XK_Tab)) { + buffer_return[0] = (char) keysym; + return 1; + } + return 0; + } + if ((event_struct->nchars <= 0) || (buffer_return == NULL)) { + return 0; + } + limit = (event_struct->nchars < bytes_buffer) ? event_struct->nchars : + bytes_buffer; + + for (i = 0; i < limit; i++) { + buffer_return[i] = event_struct->trans_chars[i]; + } + + if (keysym_return != NULL) { + *keysym_return = NoSymbol; + } + return i; +} + +/* + *---------------------------------------------------------------------- + * + * XKeycodeToKeysym -- + * + * Translate from a system-dependent keycode to a + * system-independent keysym. + * + * Results: + * Returns the translated keysym, or NoSymbol on failure. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +KeySym +XKeycodeToKeysym(display, keycode, index) + Display* display; + unsigned int keycode; + int index; +{ + Keys* key; + BYTE keys[256]; + int result; + char buf[4]; + unsigned int scancode = MapVirtualKey(keycode, 0); + + memset(keys, 0, 256); + if (index & 0x02) { + keys[VK_NUMLOCK] = 1; + } + if (index & 0x01) { + keys[VK_SHIFT] = 0x80; + } + result = ToAscii(keycode, scancode, keys, (LPWORD) buf, 0); + + /* + * Keycode mapped to a valid Latin-1 character. Since the keysyms + * for alphanumeric characters map onto Latin-1, we just return it. + */ + + if (result == 1 && buf[0] >= 0x20) { + return (KeySym) buf[0]; + } + + /* + * Keycode is a non-alphanumeric key, so we have to do the lookup. + */ + + for (key = keymap; key->keycode != 0; key++) { + if (key->keycode == keycode) { + return key->keysym; + } + } + + return NoSymbol; +} + +/* + *---------------------------------------------------------------------- + * + * XKeysymToKeycode -- + * + * Translate a keysym back into a keycode. + * + * Results: + * Returns the keycode that would generate the specified keysym. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +KeyCode +XKeysymToKeycode(display, keysym) + Display* display; + KeySym keysym; +{ + Keys* key; + SHORT result; + + if (keysym >= 0x20) { + result = VkKeyScan((char) keysym); + if (result != -1) { + return (KeyCode) (result & 0xff); + } + } + + /* + * Couldn't map the character to a virtual keycode, so do a + * table lookup. + */ + + for (key = keymap; key->keycode != 0; key++) { + if (key->keysym == keysym) { + return key->keycode; + } + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * XGetModifierMapping -- + * + * Fetch the current keycodes used as modifiers. + * + * Results: + * Returns a new modifier map. + * + * Side effects: + * Allocates a new modifier map data structure. + * + *---------------------------------------------------------------------- + */ + +XModifierKeymap * +XGetModifierMapping(display) + Display* display; +{ + XModifierKeymap *map = (XModifierKeymap *)ckalloc(sizeof(XModifierKeymap)); + + map->max_keypermod = 1; + map->modifiermap = (KeyCode *) ckalloc(sizeof(KeyCode)*8); + map->modifiermap[ShiftMapIndex] = VK_SHIFT; + map->modifiermap[LockMapIndex] = VK_CAPITAL; + map->modifiermap[ControlMapIndex] = VK_CONTROL; + map->modifiermap[Mod1MapIndex] = VK_NUMLOCK; + map->modifiermap[Mod2MapIndex] = VK_MENU; + map->modifiermap[Mod3MapIndex] = VK_SCROLL; + map->modifiermap[Mod4MapIndex] = 0; + map->modifiermap[Mod5MapIndex] = 0; + return map; +} + +/* + *---------------------------------------------------------------------- + * + * XFreeModifiermap -- + * + * Deallocate a modifier map that was created by + * XGetModifierMapping. + * + * Results: + * None. + * + * Side effects: + * Frees the datastructure referenced by modmap. + * + *---------------------------------------------------------------------- + */ + +void +XFreeModifiermap(modmap) + XModifierKeymap* modmap; +{ + ckfree((char *) modmap->modifiermap); + ckfree((char *) modmap); +} + +/* + *---------------------------------------------------------------------- + * + * XStringToKeysym -- + * + * Translate a keysym name to the matching keysym. + * + * Results: + * Returns the keysym. Since this is already handled by + * Tk's StringToKeysym function, we just return NoSymbol. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +KeySym +XStringToKeysym(string) + _Xconst char *string; +{ + return NoSymbol; +} + +/* + *---------------------------------------------------------------------- + * + * XKeysymToString -- + * + * Convert a keysym to character form. + * + * Results: + * Returns NULL, since Tk will have handled this already. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +char * +XKeysymToString(keysym) + KeySym keysym; +{ + return NULL; +} + + diff --git a/win/tkWinMenu.c b/win/tkWinMenu.c new file mode 100644 index 0000000..00e24b7 --- /dev/null +++ b/win/tkWinMenu.c @@ -0,0 +1,2646 @@ +/* + * tkWinMenu.c -- + * + * This module implements the Mac-platform specific features of menus. + * + * Copyright (c) 1996-1997 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinMenu.c 1.102 97/10/28 13:56:58 + */ + +#define OEMRESOURCE +#include <string.h> +#include "tkMenu.h" +#include "tkWinInt.h" + +/* + * The class of the window for popup menus. + */ + +#define MENU_CLASS_NAME "MenuWindowClass" + +/* + * Used to align a windows bitmap inside a rectangle + */ + +#define ALIGN_BITMAP_LEFT 0x00000001 +#define ALIGN_BITMAP_RIGHT 0x00000002 +#define ALIGN_BITMAP_TOP 0x00000004 +#define ALIGN_BITMAP_BOTTOM 0x00000008 + +/* + * Platform-specific menu flags: + * + * MENU_SYSTEM_MENU Non-zero means that the Windows menu handle + * was retrieved with GetSystemMenu and needs + * to be disposed of specially. + * MENU_RECONFIGURE_PENDING + * Non-zero means that an idle handler has + * been set up to reconfigure the Windows menu + * handle for this menu. + */ + +#define MENU_SYSTEM_MENU MENU_PLATFORM_FLAG1 +#define MENU_RECONFIGURE_PENDING MENU_PLATFORM_FLAG2 + +static int indicatorDimensions[2]; + /* The dimensions of the indicator space + * in a menu entry. Calculated at init + * time to save time. */ +static Tcl_HashTable commandTable; + /* A map of command ids to menu entries */ +static int inPostMenu; /* We cannot be re-entrant like X Windows. */ +static WORD lastCommandID; /* The last command ID we allocated. */ +static HWND menuHWND; /* A window to service popup-menu messages + * in. */ +static int oldServiceMode; /* Used while processing a menu; we need + * to set the event mode specially when we + * enter the menu processing modal loop + * and reset it when menus go away. */ +static TkMenu *modalMenuPtr; /* The menu we are processing inside the modal + * loop. We need this to reset all of the + * active items when menus go away since + * Windows does not see fit to give this + * to us when it sends its WM_MENUSELECT. */ +static OSVERSIONINFO versionInfo; + /* So we don't have to keep doing this */ +static Tcl_HashTable winMenuTable; + /* Need this to map HMENUs back to menuPtrs */ + +/* + * The following are default menu value strings. + */ + +static char borderString[5]; /* The string indicating how big the border is */ +static Tcl_DString menuFontDString; + /* A buffer to store the default menu font + * string. */ + +/* + * Forward declarations for procedures defined later in this file: + */ + +static void DrawMenuEntryAccelerator _ANSI_ARGS_(( + TkMenu *menuPtr, TkMenuEntry *mePtr, + Drawable d, GC gc, Tk_Font tkfont, + CONST Tk_FontMetrics *fmPtr, + Tk_3DBorder activeBorder, int x, int y, + int width, int height, int drawArrow)); +static void DrawMenuEntryBackground _ANSI_ARGS_(( + TkMenu *menuPtr, TkMenuEntry *mePtr, + Drawable d, Tk_3DBorder activeBorder, + Tk_3DBorder bgBorder, int x, int y, + int width, int heigth)); +static void DrawMenuEntryIndicator _ANSI_ARGS_(( + TkMenu *menuPtr, TkMenuEntry *mePtr, + Drawable d, GC gc, GC indicatorGC, + Tk_Font tkfont, + CONST Tk_FontMetrics *fmPtr, int x, int y, + int width, int height)); +static void DrawMenuEntryLabel _ANSI_ARGS_(( + TkMenu * menuPtr, TkMenuEntry *mePtr, Drawable d, + GC gc, Tk_Font tkfont, + CONST Tk_FontMetrics *fmPtr, int x, int y, + int width, int height)); +static void DrawMenuSeparator _ANSI_ARGS_((TkMenu *menuPtr, + TkMenuEntry *mePtr, Drawable d, GC gc, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, + int x, int y, int width, int height)); +static void DrawTearoffEntry _ANSI_ARGS_((TkMenu *menuPtr, + TkMenuEntry *mePtr, Drawable d, GC gc, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, + int x, int y, int width, int height)); +static void DrawMenuUnderline _ANSI_ARGS_((TkMenu *menuPtr, + TkMenuEntry *mePtr, Drawable d, GC gc, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, int x, + int y, int width, int height)); +static void DrawWindowsSystemBitmap _ANSI_ARGS_(( + Display *display, Drawable drawable, + GC gc, CONST RECT *rectPtr, int bitmapID, + int alignFlags)); +static void FreeID _ANSI_ARGS_((int commandID)); +static char * GetEntryText _ANSI_ARGS_((TkMenuEntry *mePtr)); +static void GetMenuAccelGeometry _ANSI_ARGS_((TkMenu *menuPtr, + TkMenuEntry *mePtr, Tk_Font tkfont, + CONST Tk_FontMetrics *fmPtr, int *widthPtr, + int *heightPtr)); +static void GetMenuLabelGeometry _ANSI_ARGS_((TkMenuEntry *mePtr, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, + int *widthPtr, int *heightPtr)); +static void GetMenuIndicatorGeometry _ANSI_ARGS_(( + TkMenu *menuPtr, TkMenuEntry *mePtr, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, + int *widthPtr, int *heightPtr)); +static void GetMenuSeparatorGeometry _ANSI_ARGS_(( + TkMenu *menuPtr, TkMenuEntry *mePtr, + Tk_Font tkfont, CONST Tk_FontMetrics *fmPtr, + int *widthPtr, int *heightPtr)); +static void GetTearoffEntryGeometry _ANSI_ARGS_((TkMenu *menuPtr, + TkMenuEntry *mePtr, Tk_Font tkfont, + CONST Tk_FontMetrics *fmPtr, int *widthPtr, + int *heightPtr)); +static int GetNewID _ANSI_ARGS_((TkMenuEntry *mePtr, + int *menuIDPtr)); +static void MenuExitProc _ANSI_ARGS_((ClientData clientData)); +static int MenuKeyBindProc _ANSI_ARGS_(( + ClientData clientData, + Tcl_Interp *interp, XEvent *eventPtr, + Tk_Window tkwin, KeySym keySym)); +static void MenuSelectEvent _ANSI_ARGS_((TkMenu *menuPtr)); +static void ReconfigureWindowsMenu _ANSI_ARGS_(( + ClientData clientData)); +static void RecursivelyClearActiveMenu _ANSI_ARGS_(( + TkMenu *menuPtr)); +static LRESULT CALLBACK TkWinMenuProc _ANSI_ARGS_((HWND hwnd, + UINT message, WPARAM wParam, + LPARAM lParam)); + + + +/* + *---------------------------------------------------------------------- + * + * GetNewID -- + * + * Allocates a new menu id and marks it in use. + * + * Results: + * Returns TCL_OK if succesful; TCL_ERROR if there are no more + * ids of the appropriate type to allocate. menuIDPtr contains + * the new id if succesful. + * + * Side effects: + * An entry is created for the menu in the command hash table, + * and the hash entry is stored in the appropriate field in the + * menu data structure. + * + *---------------------------------------------------------------------- + */ + +static int +GetNewID(mePtr, menuIDPtr) + TkMenuEntry *mePtr; /* The menu we are working with */ + int *menuIDPtr; /* The resulting id */ +{ + int found = 0; + int newEntry; + Tcl_HashEntry *commandEntryPtr; + WORD returnID; + + WORD curID = lastCommandID + 1; + + /* + * The following code relies on WORD wrapping when the highest value is + * incremented. + */ + + while (curID != lastCommandID) { + commandEntryPtr = Tcl_CreateHashEntry(&commandTable, + (char *) curID, &newEntry); + if (newEntry == 1) { + found = 1; + returnID = curID; + break; + } + curID++; + } + + if (found) { + Tcl_SetHashValue(commandEntryPtr, (char *) mePtr); + *menuIDPtr = (int) returnID; + lastCommandID = returnID; + return TCL_OK; + } else { + return TCL_ERROR; + } +} + +/* + *---------------------------------------------------------------------- + * + * FreeID -- + * + * Marks the itemID as free. + * + * Results: + * None. + * + * Side effects: + * The hash table entry for the ID is cleared. + * + *---------------------------------------------------------------------- + */ + +static void +FreeID(commandID) + int commandID; +{ + Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&commandTable, + (char *) commandID); + + if (entryPtr != NULL) { + Tcl_DeleteHashEntry(entryPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpNewMenu -- + * + * Gets a new blank menu. Only the platform specific options are filled + * in. + * + * Results: + * Standard TCL error. + * + * Side effects: + * Allocates a Windows menu handle and places it in the platformData + * field of the menuPtr. + * + *---------------------------------------------------------------------- + */ + +int +TkpNewMenu(menuPtr) + TkMenu *menuPtr; /* The common structure we are making the + * platform structure for. */ +{ + HMENU winMenuHdl; + Tcl_HashEntry *hashEntryPtr; + int newEntry; + + winMenuHdl = CreatePopupMenu(); + + if (winMenuHdl == NULL) { + Tcl_AppendResult(menuPtr->interp, "No more menus can be allocated.", + (char *) NULL); + return TCL_ERROR; + } + + /* + * We hash all of the HMENU's so that we can get their menu ptrs + * back when dispatch messages. + */ + + hashEntryPtr = Tcl_CreateHashEntry(&winMenuTable, (char *) winMenuHdl, + &newEntry); + Tcl_SetHashValue(hashEntryPtr, (char *) menuPtr); + + menuPtr->platformData = (TkMenuPlatformData) winMenuHdl; + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpDestroyMenu -- + * + * Destroys platform-specific menu structures. + * + * Results: + * None. + * + * Side effects: + * All platform-specific allocations are freed up. + * + *---------------------------------------------------------------------- + */ + +void +TkpDestroyMenu(menuPtr) + TkMenu *menuPtr; /* The common menu structure */ +{ + HMENU winMenuHdl = (HMENU) menuPtr->platformData; + + if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) { + Tcl_CancelIdleCall(ReconfigureWindowsMenu, (ClientData) menuPtr); + } + + if (NULL != winMenuHdl) { + if (menuPtr->menuFlags & MENU_SYSTEM_MENU) { + TkMenuEntry *searchEntryPtr; + Tcl_HashTable *tablePtr = TkGetMenuHashTable(menuPtr->interp); + char *menuName = Tcl_GetHashKey(tablePtr, + menuPtr->menuRefPtr->hashEntryPtr); + + for (searchEntryPtr = menuPtr->menuRefPtr->parentEntryPtr; + searchEntryPtr != NULL; + searchEntryPtr = searchEntryPtr->nextCascadePtr) { + if (strcmp(searchEntryPtr->name, + menuName) == 0) { + Tk_Window parentTopLevelPtr = searchEntryPtr + ->menuPtr->parentTopLevelPtr; + + if (parentTopLevelPtr != NULL) { + GetSystemMenu(TkWinGetWrapperWindow(parentTopLevelPtr), + TRUE); + } + break; + } + } + } else { + DestroyMenu(winMenuHdl); + } + menuPtr->platformData = NULL; + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpDestroyMenuEntry -- + * + * Cleans up platform-specific menu entry items. + * + * Results: + * None + * + * Side effects: + * All platform-specific allocations are freed up. + * + *---------------------------------------------------------------------- + */ + +void +TkpDestroyMenuEntry(mePtr) + TkMenuEntry *mePtr; /* The entry to destroy */ +{ + TkMenu *menuPtr = mePtr->menuPtr; + HMENU winMenuHdl = (HMENU) menuPtr->platformData; + + if (NULL != winMenuHdl) { + if (!(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) { + menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING; + Tcl_DoWhenIdle(ReconfigureWindowsMenu, (ClientData) menuPtr); + } + } + FreeID((int) mePtr->platformEntryData); + mePtr->platformEntryData = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * GetEntryText -- + * + * Given a menu entry, gives back the text that should go in it. + * Separators should be done by the caller, as they have to be + * handled specially. Allocates the memory with alloc. The caller + * should free the memory. + * + * Results: + * itemText points to the new text for the item. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static char * +GetEntryText(mePtr) + TkMenuEntry *mePtr; /* A pointer to the menu entry. */ +{ + char *itemText; + + if (mePtr->type == TEAROFF_ENTRY) { + itemText = ckalloc(sizeof("(Tear-off)")); + strcpy(itemText, "(Tear-off)"); + } else if (mePtr->imageString != NULL) { + itemText = ckalloc(sizeof("(Image)")); + strcpy(itemText, "(Image)"); + } else if (mePtr->bitmap != None) { + itemText = ckalloc(sizeof("(Pixmap)")); + strcpy(itemText, "(Pixmap)"); + } else if (mePtr->label == NULL || mePtr->labelLength == 0) { + itemText = ckalloc(sizeof("( )")); + strcpy(itemText, "( )"); + } else { + int size = mePtr->labelLength + 1; + int i, j; + + /* + * We have to construct the string with an ampersand + * preceeding the underline character, and a tab seperating + * the text and the accel text. We have to be careful with + * ampersands in the string. + */ + + for (i = 0; i < mePtr->labelLength; i++) { + if (mePtr->label[i] == '&') { + size++; + } + } + + if (mePtr->underline >= 0) { + size++; + if (mePtr->label[mePtr->underline] == '&') { + size++; + } + } + + if (mePtr->accelLength > 0) { + size += mePtr->accelLength + 1; + } + + for (i = 0; i < mePtr->accelLength; i++) { + if (mePtr->accel[i] == '&') { + size++; + } + } + + itemText = ckalloc(size); + + if (mePtr->labelLength == 0) { + itemText[0] = 0; + } else { + for (i = 0, j = 0; i < mePtr->labelLength; i++, j++) { + if (mePtr->label[i] == '&') { + itemText[j++] = '&'; + } + if (i == mePtr->underline) { + itemText[j++] = '&'; + } + itemText[j] = mePtr->label[i]; + } + itemText[j] = '\0'; + } + + if (mePtr->accelLength > 0) { + strcat(itemText, "\t"); + for (i = 0, j = strlen(itemText); i < mePtr->accelLength; + i++, j++) { + if (mePtr->accel[i] == '&') { + itemText[j++] = '&'; + } + itemText[j] = mePtr->accel[i]; + } + itemText[j] = '\0'; + } + } + return itemText; +} + +/* + *---------------------------------------------------------------------- + * + * ReconfigureWindowsMenu -- + * + * Tears down and rebuilds the platform-specific part of this menu. + * + * Results: + * None. + * + * Side effects: + * Configuration information get set for mePtr; old resources + * get freed, if any need it. + * + *---------------------------------------------------------------------- + */ + +static void +ReconfigureWindowsMenu( + ClientData clientData) /* The menu we are rebuilding */ +{ + TkMenu *menuPtr = (TkMenu *) clientData; + TkMenuEntry *mePtr; + HMENU winMenuHdl = (HMENU) menuPtr->platformData; + char *itemText = NULL; + LPCTSTR lpNewItem; + UINT flags; + UINT itemID; + int i, count, systemMenu = 0, base; + int width, height; + + if (NULL == winMenuHdl) { + return; + } + + /* + * Reconstruct the entire menu. Takes care of nasty system menu and index + * problem. + * + */ + + if ((menuPtr->menuType == MENUBAR) + && (menuPtr->parentTopLevelPtr != NULL)) { + width = Tk_Width(menuPtr->parentTopLevelPtr); + height = Tk_Width(menuPtr->parentTopLevelPtr); + } + + base = (menuPtr->menuFlags & MENU_SYSTEM_MENU) ? 7 : 0; + count = GetMenuItemCount(winMenuHdl); + for (i = base; i < count; i++) { + RemoveMenu(winMenuHdl, base, MF_BYPOSITION); + } + + count = menuPtr->numEntries; + for (i = 0; i < count; i++) { + mePtr = menuPtr->entries[i]; + lpNewItem = NULL; + flags = MF_BYPOSITION; + itemID = 0; + + if ((menuPtr->menuType == MENUBAR) && (mePtr->type == TEAROFF_ENTRY)) { + continue; + } + + if (mePtr->type == SEPARATOR_ENTRY) { + flags |= MF_SEPARATOR; + } else { + itemText = GetEntryText(mePtr); + if ((menuPtr->menuType == MENUBAR) + || (menuPtr->menuFlags & MENU_SYSTEM_MENU)) { + lpNewItem = itemText; + } else { + lpNewItem = (LPCTSTR) mePtr; + flags |= MF_OWNERDRAW; + } + + /* + * Set enabling and disabling correctly. + */ + + if (mePtr->state == tkDisabledUid) { + flags |= MF_DISABLED; + } + + /* + * Set the check mark for check entries and radio entries. + */ + + if (((mePtr->type == CHECK_BUTTON_ENTRY) + || (mePtr->type == RADIO_BUTTON_ENTRY)) + && (mePtr->entryFlags & ENTRY_SELECTED)) { + flags |= MF_CHECKED; + } + + if (mePtr->columnBreak) { + flags |= MF_MENUBREAK; + } + + itemID = (int) mePtr->platformEntryData; + if (mePtr->type == CASCADE_ENTRY) { + if ((mePtr->childMenuRefPtr != NULL) + && (mePtr->childMenuRefPtr->menuPtr != NULL)) { + HMENU childMenuHdl = + (HMENU) mePtr->childMenuRefPtr->menuPtr + ->platformData; + if (childMenuHdl != NULL) { + itemID = (UINT) childMenuHdl; + flags |= MF_POPUP; + } + if ((menuPtr->menuType == MENUBAR) + && !(mePtr->childMenuRefPtr->menuPtr->menuFlags + & MENU_SYSTEM_MENU)) { + TkMenuReferences *menuRefPtr; + TkMenu *systemMenuPtr = mePtr->childMenuRefPtr + ->menuPtr; + char *systemMenuName = ckalloc(strlen( + Tk_PathName(menuPtr->masterMenuPtr->tkwin)) + + strlen(".system") + 1); + + strcpy(systemMenuName, + Tk_PathName(menuPtr->masterMenuPtr->tkwin)); + strcat(systemMenuName, ".system"); + menuRefPtr = TkFindMenuReferences(menuPtr->interp, + systemMenuName); + if ((menuRefPtr != NULL) + && (menuRefPtr->menuPtr != NULL) + && (menuPtr->parentTopLevelPtr != NULL) + && (systemMenuPtr->masterMenuPtr + == menuRefPtr->menuPtr)) { + HMENU systemMenuHdl = + (HMENU) systemMenuPtr->platformData; + HWND wrapper = TkWinGetWrapperWindow(menuPtr + ->parentTopLevelPtr); + if (wrapper != NULL) { + DestroyMenu(systemMenuHdl); + systemMenuHdl = GetSystemMenu( + wrapper, FALSE); + systemMenuPtr->menuFlags |= MENU_SYSTEM_MENU; + systemMenuPtr->platformData = + (TkMenuPlatformData) systemMenuHdl; + if (!(systemMenuPtr->menuFlags + & MENU_RECONFIGURE_PENDING)) { + systemMenuPtr->menuFlags + |= MENU_RECONFIGURE_PENDING; + Tcl_DoWhenIdle(ReconfigureWindowsMenu, + (ClientData) systemMenuPtr); + } + } + } + ckfree(systemMenuName); + } + if (mePtr->childMenuRefPtr->menuPtr->menuFlags + & MENU_SYSTEM_MENU) { + systemMenu++; + } + } + } + } + if (!systemMenu) { + InsertMenu(winMenuHdl, 0xFFFFFFFF, flags, itemID, lpNewItem); + } + if (itemText != NULL) { + ckfree(itemText); + itemText = NULL; + } + } + + + if ((menuPtr->menuType == MENUBAR) + && (menuPtr->parentTopLevelPtr != NULL)) { + DrawMenuBar(TkWinGetWrapperWindow(menuPtr->parentTopLevelPtr)); + Tk_GeometryRequest(menuPtr->parentTopLevelPtr, width, height); + } + + menuPtr->menuFlags &= ~(MENU_RECONFIGURE_PENDING); +} + +/* + *---------------------------------------------------------------------- + * + * TkpPostMenu -- + * + * Posts a menu on the screen + * + * Results: + * None. + * + * Side effects: + * The menu is posted and handled. + * + *---------------------------------------------------------------------- + */ + +int +TkpPostMenu(interp, menuPtr, x, y) + Tcl_Interp *interp; + TkMenu *menuPtr; + int x; + int y; +{ + HMENU winMenuHdl = (HMENU) menuPtr->platformData; + int result, flags; + RECT noGoawayRect; + POINT point; + Tk_Window parentWindow = Tk_Parent(menuPtr->tkwin); + int oldServiceMode = Tcl_GetServiceMode(); + + inPostMenu++; + + if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) { + Tcl_CancelIdleCall(ReconfigureWindowsMenu, (ClientData) menuPtr); + ReconfigureWindowsMenu((ClientData) menuPtr); + } + + result = TkPreprocessMenu(menuPtr); + if (result != TCL_OK) { + inPostMenu--; + return result; + } + + /* + * The post commands could have deleted the menu, which means + * we are dead and should go away. + */ + + if (menuPtr->tkwin == NULL) { + inPostMenu--; + return TCL_OK; + } + + if (NULL == parentWindow) { + noGoawayRect.top = y - 50; + noGoawayRect.bottom = y + 50; + noGoawayRect.left = x - 50; + noGoawayRect.right = x + 50; + } else { + int left, top; + Tk_GetRootCoords(parentWindow, &left, &top); + noGoawayRect.left = left; + noGoawayRect.top = top; + noGoawayRect.bottom = noGoawayRect.top + Tk_Height(parentWindow); + noGoawayRect.right = noGoawayRect.left + Tk_Width(parentWindow); + } + + Tcl_SetServiceMode(TCL_SERVICE_NONE); + + /* + * Make an assumption here. If the right button is down, + * then we want to track it. Otherwise, track the left mouse button. + */ + + flags = TPM_LEFTALIGN; + if (GetSystemMetrics(SM_SWAPBUTTON)) { + if (GetAsyncKeyState(VK_LBUTTON) < 0) { + flags |= TPM_RIGHTBUTTON; + } else { + flags |= TPM_LEFTBUTTON; + } + } else { + if (GetAsyncKeyState(VK_RBUTTON) < 0) { + flags |= TPM_RIGHTBUTTON; + } else { + flags |= TPM_LEFTBUTTON; + } + } + + TrackPopupMenu(winMenuHdl, flags, x, y, 0, + menuHWND, &noGoawayRect); + Tcl_SetServiceMode(oldServiceMode); + + GetCursorPos(&point); + Tk_PointerEvent(NULL, point.x, point.y); + + if (inPostMenu) { + inPostMenu = 0; + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpMenuNewEntry -- + * + * Adds a pointer to a new menu entry structure with the platform- + * specific fields filled in. + * + * Results: + * Standard TCL error. + * + * Side effects: + * A new command ID is allocated and stored in the platformEntryData + * field of mePtr. + * + *---------------------------------------------------------------------- + */ + +int +TkpMenuNewEntry(mePtr) + TkMenuEntry *mePtr; +{ + int commandID; + TkMenu *menuPtr = mePtr->menuPtr; + + if (GetNewID(mePtr, &commandID) != TCL_OK) { + return TCL_ERROR; + } + + if (!(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) { + menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING; + Tcl_DoWhenIdle(ReconfigureWindowsMenu, (ClientData) menuPtr); + } + + mePtr->platformEntryData = (TkMenuPlatformEntryData) commandID; + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkWinMenuProc -- + * + * The window proc for the dummy window we put popups in. This allows + * is to post a popup whether or not we know what the parent window + * is. + * + * Results: + * Returns whatever is appropriate for the message in question. + * + * Side effects: + * Normal side-effect for windows messages. + * + *---------------------------------------------------------------------- + */ + +static LRESULT CALLBACK +TkWinMenuProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + LRESULT lResult; + + if (!TkWinHandleMenuEvent(&hwnd, &message, &wParam, &lParam, &lResult)) { + lResult = DefWindowProc(hwnd, message, wParam, lParam); + } + return lResult; +} + +/* + *---------------------------------------------------------------------- + * + * TkWinHandleMenuEvent -- + * + * Filters out menu messages from messages passed to a top-level. + * Will respond appropriately to WM_COMMAND, WM_MENUSELECT, + * WM_MEASUREITEM, WM_DRAWITEM + * + * Result: + * Returns 1 if this handled the message; 0 if it did not. + * + * Side effects: + * All of the parameters may be modified so that the caller can + * think it is getting a different message. plResult points to + * the result that should be returned to windows from this message. + * + *---------------------------------------------------------------------- + */ + +int +TkWinHandleMenuEvent(phwnd, pMessage, pwParam, plParam, plResult) + HWND *phwnd; + UINT *pMessage; + WPARAM *pwParam; + LPARAM *plParam; + LRESULT *plResult; +{ + Tcl_HashEntry *hashEntryPtr; + int returnResult = 0; + TkMenu *menuPtr; + TkMenuEntry *mePtr; + + switch (*pMessage) { + case WM_INITMENU: + TkMenuInit(); + hashEntryPtr = Tcl_FindHashEntry(&winMenuTable, (char *) *pwParam); + if (hashEntryPtr != NULL) { + oldServiceMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + menuPtr = (TkMenu *) Tcl_GetHashValue(hashEntryPtr); + modalMenuPtr = menuPtr; + if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) { + Tcl_CancelIdleCall(ReconfigureWindowsMenu, + (ClientData) menuPtr); + ReconfigureWindowsMenu((ClientData) menuPtr); + } + if (!inPostMenu) { + TkPreprocessMenu(menuPtr); + } + TkActivateMenuEntry(menuPtr, -1); + *plResult = 0; + returnResult = 1; + } else { + modalMenuPtr = NULL; + } + break; + + case WM_SYSCOMMAND: + case WM_COMMAND: { + TkMenuInit(); + if (HIWORD(*pwParam) == 0) { + hashEntryPtr = Tcl_FindHashEntry(&commandTable, + (char *)LOWORD(*pwParam)); + if (hashEntryPtr != NULL) { + mePtr = (TkMenuEntry *) Tcl_GetHashValue(hashEntryPtr); + if (mePtr != NULL) { + TkMenuReferences *menuRefPtr; + TkMenuEntry *parentEntryPtr; + + /* + * We have to set the parent of this menu to be active + * if this is a submenu so that tearoffs will get the + * correct title. + */ + + menuPtr = mePtr->menuPtr; + menuRefPtr = TkFindMenuReferences(menuPtr->interp, + Tk_PathName(menuPtr->tkwin)); + if ((menuRefPtr != NULL) && (menuRefPtr->parentEntryPtr + != NULL)) { + for (parentEntryPtr = menuRefPtr->parentEntryPtr; + strcmp(parentEntryPtr->name, + Tk_PathName(menuPtr->tkwin)) != 0; + parentEntryPtr = parentEntryPtr->nextCascadePtr) { + + /* + * Empty loop body. + */ + + } + if (parentEntryPtr->menuPtr + ->entries[parentEntryPtr->index]->state + != tkDisabledUid) { + TkActivateMenuEntry(parentEntryPtr->menuPtr, + parentEntryPtr->index); + } + } + + TkInvokeMenu(mePtr->menuPtr->interp, + menuPtr, mePtr->index); + } + *plResult = 0; + returnResult = 1; + } + } + break; + } + + + case WM_MENUCHAR: { + unsigned char menuChar = (unsigned char) LOWORD(*pwParam); + hashEntryPtr = Tcl_FindHashEntry(&winMenuTable, (char *) *plParam); + if (hashEntryPtr != NULL) { + int i; + + *plResult = 0; + menuPtr = (TkMenu *) Tcl_GetHashValue(hashEntryPtr); + for (i = 0; i < menuPtr->numEntries; i++) { + int underline = menuPtr->entries[i]->underline; + if ((-1 != underline) + && (NULL != menuPtr->entries[i]->label) + && (CharUpper((LPTSTR) menuChar) + == CharUpper((LPTSTR) (unsigned char) menuPtr + ->entries[i]->label[underline]))) { + *plResult = (2 << 16) | i; + break; + } + } + returnResult = 1; + } + break; + } + + case WM_MEASUREITEM: { + LPMEASUREITEMSTRUCT itemPtr = (LPMEASUREITEMSTRUCT) *plParam; + + if (itemPtr != NULL) { + mePtr = (TkMenuEntry *) itemPtr->itemData; + menuPtr = mePtr->menuPtr; + + TkRecomputeMenu(menuPtr); + itemPtr->itemHeight = mePtr->height; + itemPtr->itemWidth = mePtr->width; + if (mePtr->hideMargin) { + itemPtr->itemWidth += 2 - indicatorDimensions[0]; + } else { + itemPtr->itemWidth += 2 * menuPtr->activeBorderWidth; + } + *plResult = 1; + returnResult = 1; + } + break; + } + + case WM_DRAWITEM: { + TkWinDrawable *twdPtr; + LPDRAWITEMSTRUCT itemPtr = (LPDRAWITEMSTRUCT) *plParam; + Tk_FontMetrics fontMetrics; + + if (itemPtr != NULL) { + mePtr = (TkMenuEntry *) itemPtr->itemData; + menuPtr = mePtr->menuPtr; + twdPtr = (TkWinDrawable *) ckalloc(sizeof(TkWinDrawable)); + twdPtr->type = TWD_WINDC; + twdPtr->winDC.hdc = itemPtr->hDC; + + if (mePtr->state != tkDisabledUid) { + if (itemPtr->itemState & ODS_SELECTED) { + TkActivateMenuEntry(menuPtr, mePtr->index); + } else { + TkActivateMenuEntry(menuPtr, -1); + } + } + + Tk_GetFontMetrics(menuPtr->tkfont, &fontMetrics); + TkpDrawMenuEntry(mePtr, (Drawable) twdPtr, menuPtr->tkfont, + &fontMetrics, itemPtr->rcItem.left, + itemPtr->rcItem.top, itemPtr->rcItem.right + - itemPtr->rcItem.left, itemPtr->rcItem.bottom + - itemPtr->rcItem.top, 0, 0); + + ckfree((char *) twdPtr); + *plResult = 1; + returnResult = 1; + } + break; + } + + case WM_MENUSELECT: { + UINT flags = HIWORD(*pwParam); + + TkMenuInit(); + + if ((flags == 0xFFFF) && (*plParam == 0)) { + Tcl_SetServiceMode(oldServiceMode); + if (modalMenuPtr != NULL) { + RecursivelyClearActiveMenu(modalMenuPtr); + } + } else { + menuPtr = NULL; + if (*plParam != 0) { + hashEntryPtr = Tcl_FindHashEntry(&winMenuTable, + (char *) *plParam); + if (hashEntryPtr != NULL) { + menuPtr = (TkMenu *) Tcl_GetHashValue(hashEntryPtr); + } + } + + if (menuPtr != NULL) { + mePtr = NULL; + if (flags != 0xFFFF) { + if (flags & MF_POPUP) { + mePtr = menuPtr->entries[LOWORD(*pwParam)]; + } else { + hashEntryPtr = Tcl_FindHashEntry(&commandTable, + (char *) LOWORD(*pwParam)); + if (hashEntryPtr != NULL) { + mePtr = (TkMenuEntry *) Tcl_GetHashValue(hashEntryPtr); + } + } + } + + if ((mePtr == NULL) || (mePtr->state == tkDisabledUid)) { + TkActivateMenuEntry(menuPtr, -1); + } else { + TkActivateMenuEntry(menuPtr, mePtr->index); + } + MenuSelectEvent(menuPtr); + Tcl_ServiceAll(); + } + } + } + } + return returnResult; +} + +/* + *---------------------------------------------------------------------- + * + * RecursivelyClearActiveMenu -- + * + * Recursively clears the active entry in the menu's cascade hierarchy. + * + * Results: + * None. + * + * Side effects: + * Generates <<MenuSelect>> virtual events. + * + *---------------------------------------------------------------------- + */ + +void +RecursivelyClearActiveMenu( + TkMenu *menuPtr) /* The menu to reset. */ +{ + int i; + TkMenuEntry *mePtr; + + TkActivateMenuEntry(menuPtr, -1); + MenuSelectEvent(menuPtr); + for (i = 0; i < menuPtr->numEntries; i++) { + mePtr = menuPtr->entries[i]; + if (mePtr->type == CASCADE_ENTRY) { + if ((mePtr->childMenuRefPtr != NULL) + && (mePtr->childMenuRefPtr->menuPtr != NULL)) { + RecursivelyClearActiveMenu(mePtr->childMenuRefPtr->menuPtr); + } + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpSetWindowMenuBar -- + * + * Associates a given menu with a window. + * + * Results: + * None. + * + * Side effects: + * On Windows and UNIX, associates the platform menu with the + * platform window. + * + *---------------------------------------------------------------------- + */ + +void +TkpSetWindowMenuBar(tkwin, menuPtr) + Tk_Window tkwin; /* The window we are putting the menubar into.*/ + TkMenu *menuPtr; /* The menu we are inserting */ +{ + HMENU winMenuHdl; + + if (menuPtr != NULL) { + Tcl_HashEntry *hashEntryPtr; + int newEntry; + + winMenuHdl = (HMENU) menuPtr->platformData; + hashEntryPtr = Tcl_FindHashEntry(&winMenuTable, (char *) winMenuHdl); + Tcl_DeleteHashEntry(hashEntryPtr); + DestroyMenu(winMenuHdl); + winMenuHdl = CreateMenu(); + hashEntryPtr = Tcl_CreateHashEntry(&winMenuTable, (char *) winMenuHdl, + &newEntry); + Tcl_SetHashValue(hashEntryPtr, (char *) menuPtr); + menuPtr->platformData = (TkMenuPlatformData) winMenuHdl; + TkWinSetMenu(tkwin, winMenuHdl); + if (menuPtr->menuFlags & MENU_RECONFIGURE_PENDING) { + Tcl_DoWhenIdle(ReconfigureWindowsMenu, (ClientData) menuPtr); + menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING; + } + } else { + TkWinSetMenu(tkwin, NULL); + } +} + + +/* + *---------------------------------------------------------------------- + * + * TkpSetMainMenubar -- + * + * Puts the menu associated with a window into the menubar. Should + * only be called when the window is in front. + * + * Results: + * None. + * + * Side effects: + * The menubar is changed. + * + *---------------------------------------------------------------------- + */ +void +TkpSetMainMenubar( + Tcl_Interp *interp, /* The interpreter of the application */ + Tk_Window tkwin, /* The frame we are setting up */ + char *menuName) /* The name of the menu to put in front. + * If NULL, use the default menu bar. + */ +{ + /* + * Nothing to do. + */ +} + +/* + *---------------------------------------------------------------------- + * + * GetMenuIndicatorGeometry -- + * + * Gets the width and height of the indicator area of a menu. + * + * Results: + * widthPtr and heightPtr are set. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +GetMenuIndicatorGeometry ( + TkMenu *menuPtr, /* The menu we are measuring */ + TkMenuEntry *mePtr, /* The entry we are measuring */ + Tk_Font tkfont, /* Precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* Precalculated font metrics */ + int *widthPtr, /* The resulting width */ + int *heightPtr) /* The resulting height */ +{ + *heightPtr = indicatorDimensions[0]; + if (mePtr->hideMargin) { + *widthPtr = 0; + } else { + *widthPtr = indicatorDimensions[1] - menuPtr->borderWidth; + } +} + +/* + *---------------------------------------------------------------------- + * + * GetMenuAccelGeometry -- + * + * Gets the width and height of the indicator area of a menu. + * + * Results: + * widthPtr and heightPtr are set. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +GetMenuAccelGeometry ( + TkMenu *menuPtr, /* The menu we are measuring */ + TkMenuEntry *mePtr, /* The entry we are measuring */ + Tk_Font tkfont, /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* The precalculated font metrics */ + int *widthPtr, /* The resulting width */ + int *heightPtr) /* The resulting height */ +{ + *heightPtr = fmPtr->linespace; + if (mePtr->type == CASCADE_ENTRY) { + *widthPtr = 0; + } else if (mePtr->accel == NULL) { + *widthPtr = 0; + } else { + *widthPtr = Tk_TextWidth(tkfont, mePtr->accel, mePtr->accelLength); + } +} + +/* + *---------------------------------------------------------------------- + * + * GetTearoffEntryGeometry -- + * + * Gets the width and height of the indicator area of a menu. + * + * Results: + * widthPtr and heightPtr are set. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +GetTearoffEntryGeometry ( + TkMenu *menuPtr, /* The menu we are measuring */ + TkMenuEntry *mePtr, /* The entry we are measuring */ + Tk_Font tkfont, /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* The precalculated font metrics */ + int *widthPtr, /* The resulting width */ + int *heightPtr) /* The resulting height */ +{ + if (menuPtr->menuType != MASTER_MENU) { + *heightPtr = 0; + } else { + *heightPtr = fmPtr->linespace; + } + *widthPtr = 0; +} + +/* + *---------------------------------------------------------------------- + * + * GetMenuSeparatorGeometry -- + * + * Gets the width and height of the indicator area of a menu. + * + * Results: + * widthPtr and heightPtr are set. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +GetMenuSeparatorGeometry ( + TkMenu *menuPtr, /* The menu we are measuring */ + TkMenuEntry *mePtr, /* The entry we are measuring */ + Tk_Font tkfont, /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* The precalcualted font metrics */ + int *widthPtr, /* The resulting width */ + int *heightPtr) /* The resulting height */ +{ + *widthPtr = 0; + *heightPtr = fmPtr->linespace; +} + +/* + *---------------------------------------------------------------------- + * + * DrawWindowsSystemBitmap -- + * + * Draws the windows system bitmap given by bitmapID into the rect + * given by rectPtr in the drawable. The bitmap is centered in the + * rectangle. It is not clipped, so if the bitmap is bigger than + * the rect it will bleed. + * + * Results: + * None. + * + * Side effects: + * Drawing occurs. Some storage is allocated and released. + * + *---------------------------------------------------------------------- + */ + +static void +DrawWindowsSystemBitmap(display, drawable, gc, rectPtr, bitmapID, alignFlags) + Display *display; /* The display we are drawing into */ + Drawable drawable; /* The drawable we are working with */ + GC gc; /* The GC to draw with */ + CONST RECT *rectPtr; /* The rectangle to draw into */ + int bitmapID; /* The windows id of the system + * bitmap to draw. */ + int alignFlags; /* How to align the bitmap inside the + * rectangle. */ +{ + TkWinDCState state; + HDC hdc = TkWinGetDrawableDC(display, drawable, &state); + HDC scratchDC; + HBITMAP bitmap; + BITMAP bm; + POINT ptSize; + POINT ptOrg; + int topOffset, leftOffset; + + SetBkColor(hdc, gc->background); + SetTextColor(hdc, gc->foreground); + + scratchDC = CreateCompatibleDC(hdc); + bitmap = LoadBitmap(NULL, MAKEINTRESOURCE(bitmapID)); + + SelectObject(scratchDC, bitmap); + SetMapMode(scratchDC, GetMapMode(hdc)); + GetObject(bitmap, sizeof(BITMAP), &bm); + ptSize.x = bm.bmWidth; + ptSize.y = bm.bmHeight; + DPtoLP(hdc, &ptSize, 1); + + ptOrg.y = ptOrg.x = 0; + DPtoLP(hdc, &ptOrg, 1); + + if (alignFlags & ALIGN_BITMAP_TOP) { + topOffset = 0; + } else if (alignFlags & ALIGN_BITMAP_BOTTOM) { + topOffset = (rectPtr->bottom - rectPtr->top) - ptSize.y; + } else { + topOffset = (rectPtr->bottom - rectPtr->top) / 2 - (ptSize.y / 2); + } + + if (alignFlags & ALIGN_BITMAP_LEFT) { + leftOffset = 0; + } else if (alignFlags & ALIGN_BITMAP_RIGHT) { + leftOffset = (rectPtr->right - rectPtr->left) - ptSize.x; + } else { + leftOffset = (rectPtr->right - rectPtr->left) / 2 - (ptSize.x / 2); + } + + BitBlt(hdc, rectPtr->left + leftOffset, rectPtr->top + topOffset, ptSize.x, + ptSize.y, scratchDC, ptOrg.x, ptOrg.y, SRCCOPY); + DeleteDC(scratchDC); + DeleteObject(bitmap); + + TkWinReleaseDrawableDC(drawable, hdc, &state); +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuEntryIndicator -- + * + * This procedure draws the indicator part of a menu. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ +void +DrawMenuEntryIndicator(menuPtr, mePtr, d, gc, indicatorGC, tkfont, fmPtr, x, + y, width, height) + TkMenu *menuPtr; /* The menu we are drawing */ + TkMenuEntry *mePtr; /* The entry we are drawing */ + Drawable d; /* What we are drawing into */ + GC gc; /* The gc we are drawing with */ + GC indicatorGC; /* The gc for indicator objects */ + Tk_Font tkfont; /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr; /* The precalculated font metrics */ + int x; /* Left edge */ + int y; /* Top edge */ + int width; + int height; +{ + if ((mePtr->type == CHECK_BUTTON_ENTRY || + mePtr->type == RADIO_BUTTON_ENTRY) + && mePtr->indicatorOn + && mePtr->entryFlags & ENTRY_SELECTED) { + RECT rect; + GC whichGC; + + if (mePtr->state != tkNormalUid) { + whichGC = gc; + } else { + whichGC = indicatorGC; + } + + rect.top = y; + rect.bottom = y + mePtr->height; + rect.left = menuPtr->borderWidth + menuPtr->activeBorderWidth + x; + rect.right = mePtr->indicatorSpace + x; + + if ((mePtr->state == tkDisabledUid) && (menuPtr->disabledFg != NULL) + && (versionInfo.dwMajorVersion >= 4)) { + RECT hilightRect; + COLORREF oldFgColor = whichGC->foreground; + + whichGC->foreground = GetSysColor(COLOR_3DHILIGHT); + hilightRect.top = rect.top + 1; + hilightRect.bottom = rect.bottom + 1; + hilightRect.left = rect.left + 1; + hilightRect.right = rect.right + 1; + DrawWindowsSystemBitmap(menuPtr->display, d, whichGC, + &hilightRect, OBM_CHECK, 0); + whichGC->foreground = oldFgColor; + } + + DrawWindowsSystemBitmap(menuPtr->display, d, whichGC, &rect, + OBM_CHECK, 0); + + if ((mePtr->state == tkDisabledUid) + && (menuPtr->disabledImageGC != None) + && (versionInfo.dwMajorVersion < 4)) { + XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC, + rect.left, rect.top, rect.right, rect.bottom); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuEntryAccelerator -- + * + * This procedure draws the accelerator part of a menu. We + * need to decide what to draw here. Should we replace strings + * like "Control", "Command", etc? + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ + +void +DrawMenuEntryAccelerator(menuPtr, mePtr, d, gc, tkfont, fmPtr, + activeBorder, x, y, width, height, drawArrow) + TkMenu *menuPtr; /* The menu we are drawing */ + TkMenuEntry *mePtr; /* The entry we are drawing */ + Drawable d; /* What we are drawing into */ + GC gc; /* The gc we are drawing with */ + Tk_Font tkfont; /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr; /* The precalculated font metrics */ + Tk_3DBorder activeBorder; /* The border when an item is active */ + int x; /* left edge */ + int y; /* top edge */ + int width; /* Width of menu entry */ + int height; /* Height of menu entry */ + int drawArrow; /* For cascade menus, whether of not + * to draw the arraw. I cannot figure + * out Windows' algorithm for where + * to draw this. */ +{ + int baseline; + int leftEdge = x + mePtr->indicatorSpace + mePtr->labelWidth; + + baseline = y + (height + fmPtr->ascent - fmPtr->descent) / 2; + + if ((mePtr->state == tkDisabledUid) && (menuPtr->disabledFg != NULL) + && ((mePtr->accel != NULL) + || ((mePtr->type == CASCADE_ENTRY) && drawArrow))) { + if (versionInfo.dwMajorVersion >= 4) { + COLORREF oldFgColor = gc->foreground; + + gc->foreground = GetSysColor(COLOR_3DHILIGHT); + if (mePtr->accel != NULL) { + Tk_DrawChars(menuPtr->display, d, gc, tkfont, mePtr->accel, + mePtr->accelLength, leftEdge + 1, baseline + 1); + } + + if (mePtr->type == CASCADE_ENTRY) { + RECT rect; + + rect.top = y + GetSystemMetrics(SM_CYBORDER) + 1; + rect.bottom = y + height - GetSystemMetrics(SM_CYBORDER) + 1; + rect.left = x + mePtr->indicatorSpace + mePtr->labelWidth + 1; + rect.right = x + width; + DrawWindowsSystemBitmap(menuPtr->display, d, gc, &rect, + OBM_MNARROW, ALIGN_BITMAP_RIGHT); + } + gc->foreground = oldFgColor; + } + } + + if (mePtr->accel != NULL) { + Tk_DrawChars(menuPtr->display, d, gc, tkfont, mePtr->accel, + mePtr->accelLength, leftEdge, baseline); + } + + if ((mePtr->state == tkDisabledUid) + && (menuPtr->disabledImageGC != None) + && (versionInfo.dwMajorVersion < 4)) { + XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC, + leftEdge, y, width - mePtr->labelWidth + - mePtr->indicatorSpace, height); + } + + if ((mePtr->type == CASCADE_ENTRY) && drawArrow) { + RECT rect; + + rect.top = y + GetSystemMetrics(SM_CYBORDER); + rect.bottom = y + height - GetSystemMetrics(SM_CYBORDER); + rect.left = x + mePtr->indicatorSpace + mePtr->labelWidth; + rect.right = x + width - 1; + DrawWindowsSystemBitmap(menuPtr->display, d, gc, &rect, OBM_MNARROW, + ALIGN_BITMAP_RIGHT); + if ((mePtr->state == tkDisabledUid) + && (menuPtr->disabledImageGC != None) + && (versionInfo.dwMajorVersion < 4)) { + XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC, + rect.left, rect.top, rect.right, rect.bottom); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuSeparator -- + * + * The menu separator is drawn. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ +void +DrawMenuSeparator(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, y, width, height) + TkMenu *menuPtr; /* The menu we are drawing */ + TkMenuEntry *mePtr; /* The entry we are drawing */ + Drawable d; /* What we are drawing into */ + GC gc; /* The gc we are drawing with */ + Tk_Font tkfont; /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr; /* The precalculated font metrics */ + int x; /* left edge */ + int y; /* top edge */ + int width; /* width of item */ + int height; /* height of item */ +{ + XPoint points[2]; + + points[0].x = x; + points[0].y = y + height / 2; + points[1].x = x + width - 1; + points[1].y = points[0].y; + Tk_Draw3DPolygon(menuPtr->tkwin, d, + menuPtr->border, points, 2, 1, TK_RELIEF_RAISED); +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuUnderline -- + * + * On appropriate platforms, draw the underline character for the + * menu. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ +static void +DrawMenuUnderline( + TkMenu *menuPtr, /* The menu to draw into */ + TkMenuEntry *mePtr, /* The entry we are drawing */ + Drawable d, /* What we are drawing into */ + GC gc, /* The gc to draw into */ + Tk_Font tkfont, /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* The precalculated font metrics */ + int x, /* Left Edge */ + int y, /* Top Edge */ + int width, /* Width of entry */ + int height) /* Height of entry */ +{ + if (mePtr->underline >= 0) { + Tk_UnderlineChars(menuPtr->display, d, + gc, tkfont, mePtr->label, x + mePtr->indicatorSpace, + y + (height + fmPtr->ascent - fmPtr->descent) / 2, + mePtr->underline, mePtr->underline + 1); + } +} + +/* + *-------------------------------------------------------------- + * + * MenuKeyBindProc -- + * + * This procedure is invoked when keys related to pulling + * down menus is pressed. The corresponding Windows events + * are generated and passed to DefWindowProc if appropriate. + * + * Results: + * Always returns TCL_OK. + * + * Side effects: + * The menu system may take over and process user events + * for menu input. + * + *-------------------------------------------------------------- + */ + +static int +MenuKeyBindProc(clientData, interp, eventPtr, tkwin, keySym) + ClientData clientData; /* not used in this proc */ + Tcl_Interp *interp; /* The interpreter of the receiving window. */ + XEvent *eventPtr; /* The XEvent to process */ + Tk_Window tkwin; /* The window receiving the event */ + KeySym keySym; /* The key sym that is produced. */ +{ + UINT scanCode; + UINT virtualKey; + TkWindow *winPtr = (TkWindow *)tkwin; + + if (eventPtr->type == KeyPress) { + switch (keySym) { + case XK_Alt_L: + scanCode = MapVirtualKey(VK_LMENU, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYDOWN, VK_MENU, (scanCode << 16) + | (1 << 29)); + break; + case XK_Alt_R: + scanCode = MapVirtualKey(VK_RMENU, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYDOWN, VK_MENU, (scanCode << 16) + | (1 << 29) | (1 << 24)); + break; + case XK_F10: + scanCode = MapVirtualKey(VK_F10, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYDOWN, VK_F10, (scanCode << 16)); + break; + default: + virtualKey = XKeysymToKeycode(winPtr->display, keySym); + scanCode = MapVirtualKey(virtualKey, 0); + if (0 != scanCode) { + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYDOWN, virtualKey, ((scanCode << 16) + | (1 << 29))); + } + } + } else if (eventPtr->type == KeyRelease) { + switch (keySym) { + case XK_Alt_L: + scanCode = MapVirtualKey(VK_LMENU, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYUP, VK_MENU, (scanCode << 16) + | (1 << 29) | (1 << 30) | (1 << 31)); + break; + case XK_Alt_R: + scanCode = MapVirtualKey(VK_RMENU, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYUP, VK_MENU, (scanCode << 16) | (1 << 24) + | (0x111 << 29) | (1 << 30) | (1 << 31)); + break; + case XK_F10: + scanCode = MapVirtualKey(VK_F10, 0); + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYUP, VK_F10, (scanCode << 16) + | (1 << 30) | (1 << 31)); + break; + default: + virtualKey = XKeysymToKeycode(winPtr->display, keySym); + scanCode = MapVirtualKey(virtualKey, 0); + if (0 != scanCode) { + CallWindowProc(DefWindowProc, Tk_GetHWND(Tk_WindowId(tkwin)), + WM_SYSKEYUP, virtualKey, ((scanCode << 16) + | (1 << 29) | (1 << 30) | (1 << 31))); + } + } + } + return TCL_OK; +} + +/* + *-------------------------------------------------------------- + * + * TkpInitializeMenuBindings -- + * + * For every interp, initializes the bindings for Windows + * menus. Does nothing on Mac or XWindows. + * + * Results: + * None. + * + * Side effects: + * C-level bindings are setup for the interp which will + * handle Alt-key sequences for menus without beeping + * or interfering with user-defined Alt-key bindings. + * + *-------------------------------------------------------------- + */ + +void +TkpInitializeMenuBindings(interp, bindingTable) + Tcl_Interp *interp; /* The interpreter to set. */ + Tk_BindingTable bindingTable; /* The table to add to. */ +{ + Tk_Uid uid = Tk_GetUid("all"); + + /* + * We need to set up the bindings for menubars. These have to + * recreate windows events, so we need to have a C-level + * binding for this. We have to generate the WM_SYSKEYDOWNS + * and WM_SYSKEYUPs appropriately. + */ + + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<Alt_L>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<KeyRelease-Alt_L>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<Alt_R>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<KeyRelease-Alt_R>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<Alt-KeyPress>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<Alt-KeyRelease>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<KeyPress-F10>", MenuKeyBindProc, NULL, NULL); + TkCreateBindingProcedure(interp, bindingTable, (ClientData)uid, + "<KeyRelease-F10>", MenuKeyBindProc, NULL, NULL); +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuEntryLabel -- + * + * This procedure draws the label part of a menu. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ + +static void +DrawMenuEntryLabel( + TkMenu *menuPtr, /* The menu we are drawing */ + TkMenuEntry *mePtr, /* The entry we are drawing */ + Drawable d, /* What we are drawing into */ + GC gc, /* The gc we are drawing into */ + Tk_Font tkfont, /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr, /* The precalculated font metrics */ + int x, /* left edge */ + int y, /* right edge */ + int width, /* width of entry */ + int height) /* height of entry */ +{ + int baseline; + int indicatorSpace = mePtr->indicatorSpace; + int leftEdge = x + indicatorSpace + menuPtr->activeBorderWidth; + int imageHeight, imageWidth; + + /* + * Draw label or bitmap or image for entry. + */ + + baseline = y + (height + fmPtr->ascent - fmPtr->descent) / 2; + if (mePtr->image != NULL) { + Tk_SizeOfImage(mePtr->image, &imageWidth, &imageHeight); + if ((mePtr->selectImage != NULL) + && (mePtr->entryFlags & ENTRY_SELECTED)) { + Tk_RedrawImage(mePtr->selectImage, 0, 0, + imageWidth, imageHeight, d, leftEdge, + (int) (y + (mePtr->height - imageHeight)/2)); + } else { + Tk_RedrawImage(mePtr->image, 0, 0, imageWidth, + imageHeight, d, leftEdge, + (int) (y + (mePtr->height - imageHeight)/2)); + } + } else if (mePtr->bitmap != None) { + int width, height; + + Tk_SizeOfBitmap(menuPtr->display, + mePtr->bitmap, &width, &height); + XCopyPlane(menuPtr->display, + mePtr->bitmap, d, + gc, 0, 0, (unsigned) width, (unsigned) height, leftEdge, + (int) (y + (mePtr->height - height)/2), 1); + } else { + if (mePtr->labelLength > 0) { + Tk_DrawChars(menuPtr->display, d, gc, + tkfont, mePtr->label, mePtr->labelLength, + leftEdge, baseline); + DrawMenuUnderline(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, y, + width, height); + } + } + + if (mePtr->state == tkDisabledUid) { + if (menuPtr->disabledFg == NULL) { + XFillRectangle(menuPtr->display, d, menuPtr->disabledGC, x, y, + (unsigned) width, (unsigned) height); + } else if ((mePtr->image != NULL) + && (menuPtr->disabledImageGC != None)) { + XFillRectangle(menuPtr->display, d, menuPtr->disabledImageGC, + leftEdge, + (int) (y + (mePtr->height - imageHeight)/2), + (unsigned) imageWidth, (unsigned) imageHeight); + } + } +} + +/* + *-------------------------------------------------------------- + * + * TkpComputeMenubarGeometry -- + * + * This procedure is invoked to recompute the size and + * layout of a menu that is a menubar clone. + * + * Results: + * None. + * + * Side effects: + * Fields of menu entries are changed to reflect their + * current positions, and the size of the menu window + * itself may be changed. + * + *-------------------------------------------------------------- + */ + +void +TkpComputeMenubarGeometry(menuPtr) + TkMenu *menuPtr; /* Structure describing menu. */ +{ + TkpComputeStandardMenuGeometry(menuPtr); +} + +/* + *---------------------------------------------------------------------- + * + * DrawTearoffEntry -- + * + * This procedure draws the background part of a menu. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ + +void +DrawTearoffEntry(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, y, width, height) + TkMenu *menuPtr; /* The menu we are drawing */ + TkMenuEntry *mePtr; /* The entry we are drawing */ + Drawable d; /* The drawable we are drawing into */ + GC gc; /* The gc we are drawing with */ + Tk_Font tkfont; /* The font we are drawing with */ + CONST Tk_FontMetrics *fmPtr; /* The metrics we are drawing with */ + int x; + int y; + int width; + int height; +{ + XPoint points[2]; + int segmentWidth, maxX; + + if (menuPtr->menuType != MASTER_MENU) { + return; + } + + points[0].x = x; + points[0].y = y + height/2; + points[1].y = points[0].y; + segmentWidth = 6; + maxX = width - 1; + + while (points[0].x < maxX) { + points[1].x = points[0].x + segmentWidth; + if (points[1].x > maxX) { + points[1].x = maxX; + } + Tk_Draw3DPolygon(menuPtr->tkwin, d, menuPtr->border, points, 2, 1, + TK_RELIEF_RAISED); + points[0].x += 2*segmentWidth; + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpConfigureMenuEntry -- + * + * Processes configurations for menu entries. + * + * Results: + * Returns standard TCL result. If TCL_ERROR is returned, then + * interp->result contains an error message. + * + * Side effects: + * Configuration information get set for mePtr; old resources + * get freed, if any need it. + * + *---------------------------------------------------------------------- + */ + +int +TkpConfigureMenuEntry(mePtr) + register TkMenuEntry *mePtr; /* Information about menu entry; may + * or may not already have values for + * some fields. */ +{ + TkMenu *menuPtr = mePtr->menuPtr; + + if (!(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) { + menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING; + Tcl_DoWhenIdle(ReconfigureWindowsMenu, (ClientData) menuPtr); + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpDrawMenuEntry -- + * + * Draws the given menu entry at the given coordinates with the + * given attributes. + * + * Results: + * None. + * + * Side effects: + * X Server commands are executed to display the menu entry. + * + *---------------------------------------------------------------------- + */ + +void +TkpDrawMenuEntry(mePtr, d, tkfont, menuMetricsPtr, x, y, width, height, + strictMotif, drawArrow) + TkMenuEntry *mePtr; /* The entry to draw */ + Drawable d; /* What to draw into */ + Tk_Font tkfont; /* Precalculated font for menu */ + CONST Tk_FontMetrics *menuMetricsPtr; + /* Precalculated metrics for menu */ + int x; /* X-coordinate of topleft of entry */ + int y; /* Y-coordinate of topleft of entry */ + int width; /* Width of the entry rectangle */ + int height; /* Height of the current rectangle */ + int strictMotif; /* Boolean flag */ + int drawArrow; /* Whether or not to draw the cascade + * arrow for cascade items. Only applies + * to Windows. */ +{ + GC gc, indicatorGC; + TkMenu *menuPtr = mePtr->menuPtr; + Tk_3DBorder bgBorder, activeBorder; + CONST Tk_FontMetrics *fmPtr; + Tk_FontMetrics entryMetrics; + int padY = (menuPtr->menuType == MENUBAR) ? 3 : 0; + int adjustedY = y + padY; + int adjustedHeight = height - 2 * padY; + + /* + * Choose the gc for drawing the foreground part of the entry. + */ + + if ((mePtr->state == tkActiveUid) + && !strictMotif) { + gc = mePtr->activeGC; + if (gc == NULL) { + gc = menuPtr->activeGC; + } + } else { + TkMenuEntry *cascadeEntryPtr; + int parentDisabled = 0; + + for (cascadeEntryPtr = menuPtr->menuRefPtr->parentEntryPtr; + cascadeEntryPtr != NULL; + cascadeEntryPtr = cascadeEntryPtr->nextCascadePtr) { + if (strcmp(cascadeEntryPtr->name, + Tk_PathName(menuPtr->tkwin)) == 0) { + if (cascadeEntryPtr->state == tkDisabledUid) { + parentDisabled = 1; + } + break; + } + } + + if (((parentDisabled || (mePtr->state == tkDisabledUid))) + && (menuPtr->disabledFg != NULL)) { + gc = mePtr->disabledGC; + if (gc == NULL) { + gc = menuPtr->disabledGC; + } + } else { + gc = mePtr->textGC; + if (gc == NULL) { + gc = menuPtr->textGC; + } + } + } + indicatorGC = mePtr->indicatorGC; + if (indicatorGC == NULL) { + indicatorGC = menuPtr->indicatorGC; + } + + bgBorder = mePtr->border; + if (bgBorder == NULL) { + bgBorder = menuPtr->border; + } + if (strictMotif) { + activeBorder = bgBorder; + } else { + activeBorder = mePtr->activeBorder; + if (activeBorder == NULL) { + activeBorder = menuPtr->activeBorder; + } + } + + if (mePtr->tkfont == NULL) { + fmPtr = menuMetricsPtr; + } else { + tkfont = mePtr->tkfont; + Tk_GetFontMetrics(tkfont, &entryMetrics); + fmPtr = &entryMetrics; + } + + /* + * Need to draw the entire background, including padding. On Unix, + * for menubars, we have to draw the rest of the entry taking + * into account the padding. + */ + + DrawMenuEntryBackground(menuPtr, mePtr, d, activeBorder, + bgBorder, x, y, width, height); + + if (mePtr->type == SEPARATOR_ENTRY) { + DrawMenuSeparator(menuPtr, mePtr, d, gc, tkfont, + fmPtr, x, adjustedY, width, adjustedHeight); + } else if (mePtr->type == TEAROFF_ENTRY) { + DrawTearoffEntry(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY, + width, adjustedHeight); + } else { + DrawMenuEntryLabel(menuPtr, mePtr, d, gc, tkfont, fmPtr, x, adjustedY, + width, adjustedHeight); + DrawMenuEntryAccelerator(menuPtr, mePtr, d, gc, tkfont, fmPtr, + activeBorder, x, adjustedY, width, adjustedHeight, drawArrow); + if (!mePtr->hideMargin) { + DrawMenuEntryIndicator(menuPtr, mePtr, d, gc, indicatorGC, tkfont, + fmPtr, x, adjustedY, width, adjustedHeight); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * GetMenuLabelGeometry -- + * + * Figures out the size of the label portion of a menu item. + * + * Results: + * widthPtr and heightPtr are filled in with the correct geometry + * information. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +GetMenuLabelGeometry(mePtr, tkfont, fmPtr, widthPtr, heightPtr) + TkMenuEntry *mePtr; /* The entry we are computing */ + Tk_Font tkfont; /* The precalculated font */ + CONST Tk_FontMetrics *fmPtr; /* The precalculated metrics */ + int *widthPtr; /* The resulting width of the label + * portion */ + int *heightPtr; /* The resulting height of the label + * portion */ +{ + TkMenu *menuPtr = mePtr->menuPtr; + + if (mePtr->image != NULL) { + Tk_SizeOfImage(mePtr->image, widthPtr, heightPtr); + } else if (mePtr->bitmap != (Pixmap) NULL) { + Tk_SizeOfBitmap(menuPtr->display, mePtr->bitmap, widthPtr, heightPtr); + } else { + *heightPtr = fmPtr->linespace; + + if (mePtr->label != NULL) { + *widthPtr = Tk_TextWidth(tkfont, mePtr->label, mePtr->labelLength); + } else { + *widthPtr = 0; + } + } + *heightPtr += 1; +} + +/* + *---------------------------------------------------------------------- + * + * DrawMenuEntryBackground -- + * + * This procedure draws the background part of a menu. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the menu in its + * current mode. + * + *---------------------------------------------------------------------- + */ + +static void +DrawMenuEntryBackground( + TkMenu *menuPtr, /* The menu we are drawing. */ + TkMenuEntry *mePtr, /* The entry we are drawing. */ + Drawable d, /* What we are drawing into */ + Tk_3DBorder activeBorder, /* Border for active items */ + Tk_3DBorder bgBorder, /* Border for the background */ + int x, /* left edge */ + int y, /* top edge */ + int width, /* width of rectangle to draw */ + int height) /* height of rectangle to draw */ +{ + if (mePtr->state == tkActiveUid) { + bgBorder = activeBorder; + } + Tk_Fill3DRectangle(menuPtr->tkwin, d, bgBorder, + x, y, width, height, 0, TK_RELIEF_FLAT); +} + +/* + *-------------------------------------------------------------- + * + * TkpComputeStandardMenuGeometry -- + * + * This procedure is invoked to recompute the size and + * layout of a menu that is not a menubar clone. + * + * Results: + * None. + * + * Side effects: + * Fields of menu entries are changed to reflect their + * current positions, and the size of the menu window + * itself may be changed. + * + *-------------------------------------------------------------- + */ + +void +TkpComputeStandardMenuGeometry( + TkMenu *menuPtr) /* Structure describing menu. */ +{ + Tk_Font tkfont; + Tk_FontMetrics menuMetrics, entryMetrics, *fmPtr; + int x, y, height, width, indicatorSpace, labelWidth, accelWidth; + int windowWidth, windowHeight, accelSpace; + int i, j, lastColumnBreak = 0; + + if (menuPtr->tkwin == NULL) { + return; + } + + x = y = menuPtr->borderWidth; + indicatorSpace = labelWidth = accelWidth = 0; + windowHeight = 0; + + /* + * On the Mac especially, getting font metrics can be quite slow, + * so we want to do it intelligently. We are going to precalculate + * them and pass them down to all of the measuring and drawing + * routines. We will measure the font metrics of the menu once. + * If an entry does not have its own font set, then we give + * the geometry/drawing routines the menu's font and metrics. + * If an entry has its own font, we will measure that font and + * give all of the geometry/drawing the entry's font and metrics. + */ + + Tk_GetFontMetrics(menuPtr->tkfont, &menuMetrics); + accelSpace = Tk_TextWidth(menuPtr->tkfont, "M", 1); + + for (i = 0; i < menuPtr->numEntries; i++) { + tkfont = menuPtr->entries[i]->tkfont; + if (tkfont == NULL) { + tkfont = menuPtr->tkfont; + fmPtr = &menuMetrics; + } else { + Tk_GetFontMetrics(tkfont, &entryMetrics); + fmPtr = &entryMetrics; + } + + if ((i > 0) && menuPtr->entries[i]->columnBreak) { + if (accelWidth != 0) { + labelWidth += accelSpace; + } + for (j = lastColumnBreak; j < i; j++) { + menuPtr->entries[j]->indicatorSpace = indicatorSpace; + menuPtr->entries[j]->labelWidth = labelWidth; + menuPtr->entries[j]->width = indicatorSpace + labelWidth + + accelWidth + 2 * menuPtr->activeBorderWidth; + menuPtr->entries[j]->x = x; + menuPtr->entries[j]->entryFlags &= ~ENTRY_LAST_COLUMN; + } + x += indicatorSpace + labelWidth + accelWidth + + 2 * menuPtr->borderWidth; + indicatorSpace = labelWidth = accelWidth = 0; + lastColumnBreak = i; + y = menuPtr->borderWidth; + } + + if (menuPtr->entries[i]->type == SEPARATOR_ENTRY) { + GetMenuSeparatorGeometry(menuPtr, menuPtr->entries[i], tkfont, + fmPtr, &width, &height); + menuPtr->entries[i]->height = height; + } else if (menuPtr->entries[i]->type == TEAROFF_ENTRY) { + GetTearoffEntryGeometry(menuPtr, menuPtr->entries[i], tkfont, + fmPtr, &width, &height); + menuPtr->entries[i]->height = height; + } else { + + /* + * For each entry, compute the height required by that + * particular entry, plus three widths: the width of the + * label, the width to allow for an indicator to be displayed + * to the left of the label (if any), and the width of the + * accelerator to be displayed to the right of the label + * (if any). These sizes depend, of course, on the type + * of the entry. + */ + + GetMenuLabelGeometry(menuPtr->entries[i], tkfont, fmPtr, &width, + &height); + menuPtr->entries[i]->height = height; + if (width > labelWidth) { + labelWidth = width; + } + + GetMenuAccelGeometry(menuPtr, menuPtr->entries[i], tkfont, + fmPtr, &width, &height); + if (height > menuPtr->entries[i]->height) { + menuPtr->entries[i]->height = height; + } + if (width > accelWidth) { + accelWidth = width; + } + + GetMenuIndicatorGeometry(menuPtr, menuPtr->entries[i], tkfont, + fmPtr, &width, &height); + if (height > menuPtr->entries[i]->height) { + menuPtr->entries[i]->height = height; + } + if (width > indicatorSpace) { + indicatorSpace = width; + } + + menuPtr->entries[i]->height += 2 * menuPtr->activeBorderWidth + 1; + } + menuPtr->entries[i]->y = y; + y += menuPtr->entries[i]->height; + if (y > windowHeight) { + windowHeight = y; + } + } + + if (accelWidth != 0) { + labelWidth += accelSpace; + } + for (j = lastColumnBreak; j < menuPtr->numEntries; j++) { + menuPtr->entries[j]->indicatorSpace = indicatorSpace; + menuPtr->entries[j]->labelWidth = labelWidth; + menuPtr->entries[j]->width = indicatorSpace + labelWidth + + accelWidth + 2 * menuPtr->activeBorderWidth; + menuPtr->entries[j]->x = x; + menuPtr->entries[j]->entryFlags |= ENTRY_LAST_COLUMN; + } + windowWidth = x + indicatorSpace + labelWidth + accelWidth + accelSpace + + 2 * menuPtr->activeBorderWidth + + 2 * menuPtr->borderWidth; + + + windowHeight += menuPtr->borderWidth; + + /* + * The X server doesn't like zero dimensions, so round up to at least + * 1 (a zero-sized menu should never really occur, anyway). + */ + + if (windowWidth <= 0) { + windowWidth = 1; + } + if (windowHeight <= 0) { + windowHeight = 1; + } + menuPtr->totalWidth = windowWidth; + menuPtr->totalHeight = windowHeight; +} + +/* + *---------------------------------------------------------------------- + * + * MenuSelectEvent -- + * + * Generates a "MenuSelect" virtual event. This can be used to + * do context-sensitive menu help. + * + * Results: + * None. + * + * Side effects: + * Places a virtual event on the event queue. + * + *---------------------------------------------------------------------- + */ + +static void +MenuSelectEvent( + TkMenu *menuPtr) /* the menu we have selected. */ +{ + XVirtualEvent event; + POINTS rootPoint; + DWORD msgPos; + + event.type = VirtualEvent; + event.serial = menuPtr->display->request; + event.send_event = 0; + event.display = menuPtr->display; + Tk_MakeWindowExist(menuPtr->tkwin); + event.event = Tk_WindowId(menuPtr->tkwin); + event.root = XRootWindow(menuPtr->display, 0); + event.subwindow = None; + event.time = TkpGetMS(); + + msgPos = GetMessagePos(); + rootPoint = MAKEPOINTS(msgPos); + event.x_root = rootPoint.x; + event.y_root = rootPoint.y; + event.state = TkWinGetModifierState(); + event.same_screen = 1; + event.name = Tk_GetUid("MenuSelect"); + Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL); +} + +/* + *---------------------------------------------------------------------- + * + * TkpMenuNotifyToplevelCreate -- + * + * This routine reconfigures the menu and the clones indicated by + * menuName becuase a toplevel has been created and any system + * menus need to be created. + * + * Results: + * None. + * + * Side effects: + * An idle handler is set up to do the reconfiguration. + * + *---------------------------------------------------------------------- + */ + +void +TkpMenuNotifyToplevelCreate( + Tcl_Interp *interp, /* The interp the menu lives in. */ + char *menuName) /* The name of the menu to + * reconfigure. */ +{ + TkMenuReferences *menuRefPtr; + TkMenu *menuPtr; + + if ((menuName != NULL) && (menuName[0] != '\0')) { + menuRefPtr = TkFindMenuReferences(interp, menuName); + if ((menuRefPtr != NULL) && (menuRefPtr->menuPtr != NULL)) { + for (menuPtr = menuRefPtr->menuPtr->masterMenuPtr; menuPtr != NULL; + menuPtr = menuPtr->nextInstancePtr) { + if ((menuPtr->menuType == MENUBAR) + && !(menuPtr->menuFlags & MENU_RECONFIGURE_PENDING)) { + menuPtr->menuFlags |= MENU_RECONFIGURE_PENDING; + Tcl_DoWhenIdle(ReconfigureWindowsMenu, + (ClientData) menuPtr); + } + } + } + } +} + +/* + *---------------------------------------------------------------------- + * + * MenuExitHandler -- + * + * Throws away the utility window needed for menus and unregisters + * the class. + * + * Results: + * None. + * + * Side effects: + * Menus have to be reinitialized next time. + * + *---------------------------------------------------------------------- + */ + +static void +MenuExitHandler( + ClientData clientData) /* Not used */ +{ + DestroyWindow(menuHWND); + UnregisterClass(MENU_CLASS_NAME, Tk_GetHINSTANCE()); +} + +/* + *---------------------------------------------------------------------- + * + * TkpMenuInit -- + * + * Sets up the hash tables and the variables used by the menu package. + * + * Results: + * None. + * + * Side effects: + * lastMenuID gets initialized, and the parent hash and the command hash + * are allocated. + * + *---------------------------------------------------------------------- + */ + +void +TkpMenuInit() +{ + WNDCLASS wndClass; + char sizeString[4]; + char faceName[LF_FACESIZE]; + HDC scratchDC; + Tcl_DString boldItalicDString; + int bold = 0; + int italic = 0; + int i; + TEXTMETRIC tm; + + Tcl_InitHashTable(&winMenuTable, TCL_ONE_WORD_KEYS); + Tcl_InitHashTable(&commandTable, TCL_ONE_WORD_KEYS); + + wndClass.style = CS_OWNDC; + wndClass.lpfnWndProc = TkWinMenuProc; + wndClass.cbClsExtra = 0; + wndClass.cbWndExtra = 0; + wndClass.hInstance = Tk_GetHINSTANCE(); + wndClass.hIcon = NULL; + wndClass.hCursor = NULL; + wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); + wndClass.lpszMenuName = NULL; + wndClass.lpszClassName = MENU_CLASS_NAME; + RegisterClass(&wndClass); + + menuHWND = CreateWindow(MENU_CLASS_NAME, "MenuWindow", WS_POPUP, + 0, 0, 10, 10, NULL, NULL, Tk_GetHINSTANCE(), NULL); + + Tcl_CreateExitHandler(MenuExitHandler, (ClientData) NULL); + + versionInfo.dwOSVersionInfoSize = sizeof(versionInfo); + + /* + * If GetVersionEx fails, it means that the version info record + * is too big for what is compiled. Should never happen, but if + * it does, we are later than Windows 95 or NT 4.0. + */ + + if (!GetVersionEx(&versionInfo)) { + versionInfo.dwMajorVersion = 4; + } + + /* + * Set all of the default options. The loop will terminate when we run + * out of options via a break statement. + */ + + for (i = 0; ; i++) { + if (tkMenuConfigSpecs[i].type == TK_CONFIG_END) { + break; + } + + if ((strcmp(tkMenuConfigSpecs[i].dbName, + "activeBorderWidth") == 0) || + (strcmp(tkMenuConfigSpecs[i].dbName, "borderWidth") == 0)) { + int borderWidth; + + borderWidth = GetSystemMetrics(SM_CXBORDER); + if (GetSystemMetrics(SM_CYBORDER) > borderWidth) { + borderWidth = GetSystemMetrics(SM_CYBORDER); + } + sprintf(borderString, "%d", borderWidth); + tkMenuConfigSpecs[i].defValue = borderString; + } else if ((strcmp(tkMenuConfigSpecs[i].dbName, "font") == 0)) { + int pointSize; + HFONT menuFont; + + scratchDC = CreateDC("DISPLAY", NULL, NULL, NULL); + Tcl_DStringInit(&menuFontDString); + + if (versionInfo.dwMajorVersion >= 4) { + NONCLIENTMETRICS ncMetrics; + + ncMetrics.cbSize = sizeof(ncMetrics); + SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncMetrics), + &ncMetrics, 0); + menuFont = CreateFontIndirect(&ncMetrics.lfMenuFont); + } else { + menuFont = GetStockObject(SYSTEM_FONT); + } + SelectObject(scratchDC, menuFont); + GetTextMetrics(scratchDC, &tm); + GetTextFace(scratchDC, sizeof(menuFontDString), faceName); + pointSize = MulDiv(tm.tmHeight - tm.tmInternalLeading, + 72, GetDeviceCaps(scratchDC, LOGPIXELSY)); + if (tm.tmWeight >= 700) { + bold = 1; + } + if (tm.tmItalic) { + italic = 1; + } + + SelectObject(scratchDC, GetStockObject(SYSTEM_FONT)); + DeleteDC(scratchDC); + + DeleteObject(menuFont); + + Tcl_DStringAppendElement(&menuFontDString, faceName); + sprintf(sizeString, "%d", pointSize); + Tcl_DStringAppendElement(&menuFontDString, sizeString); + + if (bold == 1 || italic == 1) { + Tcl_DStringInit(&boldItalicDString); + if (bold == 1) { + Tcl_DStringAppendElement(&boldItalicDString, "bold"); + } + if (italic == 1) { + Tcl_DStringAppendElement(&boldItalicDString, "italic"); + } + Tcl_DStringAppendElement(&menuFontDString, + Tcl_DStringValue(&boldItalicDString)); + } + + tkMenuConfigSpecs[i].defValue = Tcl_DStringValue(&menuFontDString); + } + } + + /* + * Now we go ahead and get the dimensions of the check mark and the + * appropriate margins. Since this is fairly hairy, we do it here + * to save time when traversing large sets of menu items. + * + * The code below was given to me by Microsoft over the phone. It + * is the only way to insure menu items lining up, and is not + * documented. + */ + + if (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) { + indicatorDimensions[0] = GetSystemMetrics(SM_CYMENUCHECK); + indicatorDimensions[1] = ((GetSystemMetrics(SM_CXFIXEDFRAME) + + GetSystemMetrics(SM_CXBORDER) + + GetSystemMetrics(SM_CXMENUCHECK) + 7) & 0xFFF8) + - GetSystemMetrics(SM_CXFIXEDFRAME); + } else { + DWORD dimensions = GetMenuCheckMarkDimensions(); + indicatorDimensions[0] = HIWORD(dimensions); + indicatorDimensions[1] = LOWORD(dimensions); + } + +} diff --git a/win/tkWinPixmap.c b/win/tkWinPixmap.c new file mode 100644 index 0000000..1ca2d7e --- /dev/null +++ b/win/tkWinPixmap.c @@ -0,0 +1,184 @@ +/* + * tkWinPixmap.c -- + * + * This file contains the Xlib emulation functions pertaining to + * creating and destroying pixmaps. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinPixmap.c 1.18 97/08/06 15:36:23 + */ + +#include "tkWinInt.h" + + +/* + *---------------------------------------------------------------------- + * + * Tk_GetPixmap -- + * + * Creates an in memory drawing surface. + * + * Results: + * Returns a handle to a new pixmap. + * + * Side effects: + * Allocates a new Win32 bitmap. + * + *---------------------------------------------------------------------- + */ + +Pixmap +Tk_GetPixmap(display, d, width, height, depth) + Display* display; + Drawable d; + int width; + int height; + int depth; +{ + TkWinDrawable *newTwdPtr, *twdPtr; + int planes; + Screen *screen; + + display->request++; + + newTwdPtr = (TkWinDrawable*) ckalloc(sizeof(TkWinDrawable)); + newTwdPtr->type = TWD_BITMAP; + newTwdPtr->bitmap.depth = depth; + twdPtr = (TkWinDrawable *)d; + if (twdPtr->type != TWD_BITMAP) { + if (twdPtr->window.winPtr == NULL) { + newTwdPtr->bitmap.colormap = DefaultColormap(display, + DefaultScreen(display)); + } else { + newTwdPtr->bitmap.colormap = twdPtr->window.winPtr->atts.colormap; + } + } else { + newTwdPtr->bitmap.colormap = twdPtr->bitmap.colormap; + } + screen = &display->screens[0]; + planes = 1; + if (depth == screen->root_depth) { + planes = (int) screen->ext_data; + depth /= planes; + } + newTwdPtr->bitmap.handle = CreateBitmap(width, height, planes, depth, NULL); + + if (newTwdPtr->bitmap.handle == NULL) { + ckfree((char *) newTwdPtr); + return None; + } + + return (Pixmap)newTwdPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_FreePixmap -- + * + * Release the resources associated with a pixmap. + * + * Results: + * None. + * + * Side effects: + * Deletes the bitmap created by Tk_GetPixmap. + * + *---------------------------------------------------------------------- + */ + +void +Tk_FreePixmap(display, pixmap) + Display* display; + Pixmap pixmap; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *) pixmap; + + display->request++; + if (twdPtr != NULL) { + DeleteObject(twdPtr->bitmap.handle); + ckfree((char *)twdPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkSetPixmapColormap -- + * + * The following function is a hack used by the photo widget to + * explicitly set the colormap slot of a Pixmap. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkSetPixmapColormap(pixmap, colormap) + Pixmap pixmap; + Colormap colormap; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *)pixmap; + twdPtr->bitmap.colormap = colormap; +} + +/* + *---------------------------------------------------------------------- + * + * XGetGeometry -- + * + * Retrieve the geometry of the given drawable. Note that + * this is a degenerate implementation that only returns the + * size of a pixmap. + * + * Results: + * Returns 0. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +XGetGeometry(display, d, root_return, x_return, y_return, width_return, + height_return, border_width_return, depth_return) + Display* display; + Drawable d; + Window* root_return; + int* x_return; + int* y_return; + unsigned int* width_return; + unsigned int* height_return; + unsigned int* border_width_return; + unsigned int* depth_return; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *)d; + HDC dc; + BITMAPINFO info; + + if ((twdPtr->type != TWD_BITMAP) || (twdPtr->bitmap.handle == NULL)) { + panic("XGetGeometry: invalid pixmap"); + } + dc = GetDC(NULL); + info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + info.bmiHeader.biBitCount = 0; + if (!GetDIBits(dc, twdPtr->bitmap.handle, 0, 0, NULL, &info, + DIB_RGB_COLORS)) { + panic("XGetGeometry: unable to get bitmap size"); + } + ReleaseDC(NULL, dc); + + *width_return = info.bmiHeader.biWidth; + *height_return = info.bmiHeader.biHeight; + return 1; +} diff --git a/win/tkWinPointer.c b/win/tkWinPointer.c new file mode 100644 index 0000000..96661ae --- /dev/null +++ b/win/tkWinPointer.c @@ -0,0 +1,457 @@ +/* + * tkWinPointer.c -- + * + * Windows specific mouse tracking code. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinPointer.c 1.28 97/10/31 08:40:07 + */ + +#include "tkWinInt.h" + +/* + * Check for enter/leave events every MOUSE_TIMER_INTERVAL milliseconds. + */ + +#define MOUSE_TIMER_INTERVAL 250 + +/* + * Declarations of static variables used in this file. + */ + +static int captured = 0; /* 1 if mouse is currently captured. */ +static TkWindow *keyboardWinPtr = NULL; /* Current keyboard grab window. */ +static Tcl_TimerToken mouseTimer; /* Handle to the latest mouse timer. */ +static int mouseTimerSet = 0; /* 1 if the mouse timer is active. */ + +/* + * Forward declarations of procedures used in this file. + */ + +static void MouseTimerProc _ANSI_ARGS_((ClientData clientData)); + +/* + *---------------------------------------------------------------------- + * + * TkWinGetModifierState -- + * + * Return the modifier state as of the last message. + * + * Results: + * Returns the X modifier mask. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkWinGetModifierState() +{ + int state = 0; + + if (GetKeyState(VK_SHIFT) & 0x8000) { + state |= ShiftMask; + } + if (GetKeyState(VK_CONTROL) & 0x8000) { + state |= ControlMask; + } + if (GetKeyState(VK_MENU) & 0x8000) { + state |= Mod2Mask; + } + if (GetKeyState(VK_CAPITAL) & 0x0001) { + state |= LockMask; + } + if (GetKeyState(VK_NUMLOCK) & 0x0001) { + state |= Mod1Mask; + } + if (GetKeyState(VK_SCROLL) & 0x0001) { + state |= Mod3Mask; + } + if (GetKeyState(VK_LBUTTON) & 0x8000) { + state |= Button1Mask; + } + if (GetKeyState(VK_MBUTTON) & 0x8000) { + state |= Button2Mask; + } + if (GetKeyState(VK_RBUTTON) & 0x8000) { + state |= Button3Mask; + } + return state; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_PointerEvent -- + * + * This procedure is called for each pointer-related event. + * It converts the position to root coords and updates the + * global pointer state machine. It also ensures that the + * mouse timer is scheduled. + * + * Results: + * None. + * + * Side effects: + * May queue events and change the grab state. + * + *---------------------------------------------------------------------- + */ + +void +Tk_PointerEvent(hwnd, x, y) + HWND hwnd; /* Window for coords, or NULL for + * the root window. */ + int x, y; /* Coords relative to hwnd, or screen + * if hwnd is NULL. */ +{ + POINT pos; + int state; + Tk_Window tkwin; + + pos.x = x; + pos.y = y; + + /* + * Convert client coords to root coords if we were given a window. + */ + + if (hwnd) { + ClientToScreen(hwnd, &pos); + } + + /* + * If the mouse is captured, Windows will report all pointer + * events to the capture window. So, we need to determine which + * window the mouse is really over and change the event. Note + * that the computed hwnd may point to a window not owned by Tk, + * or a toplevel decorative frame, so tkwin can be NULL. + */ + + if (captured || hwnd == NULL) { + hwnd = WindowFromPoint(pos); + } + tkwin = Tk_HWNDToWindow(hwnd); + + state = TkWinGetModifierState(); + + Tk_UpdatePointer(tkwin, pos.x, pos.y, state); + + if ((captured || tkwin) && !mouseTimerSet) { + mouseTimerSet = 1; + mouseTimer = Tcl_CreateTimerHandler(MOUSE_TIMER_INTERVAL, + MouseTimerProc, NULL); + } +} + +/* + *---------------------------------------------------------------------- + * + * XGrabKeyboard -- + * + * Simulates a keyboard grab by setting the focus. + * + * Results: + * Always returns GrabSuccess. + * + * Side effects: + * Sets the keyboard focus to the specified window. + * + *---------------------------------------------------------------------- + */ + +int +XGrabKeyboard(display, grab_window, owner_events, pointer_mode, + keyboard_mode, time) + Display* display; + Window grab_window; + Bool owner_events; + int pointer_mode; + int keyboard_mode; + Time time; +{ + keyboardWinPtr = TkWinGetWinPtr(grab_window); + return GrabSuccess; +} + +/* + *---------------------------------------------------------------------- + * + * XUngrabKeyboard -- + * + * Releases the simulated keyboard grab. + * + * Results: + * None. + * + * Side effects: + * Sets the keyboard focus back to the value before the grab. + * + *---------------------------------------------------------------------- + */ + +void +XUngrabKeyboard(display, time) + Display* display; + Time time; +{ + keyboardWinPtr = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * MouseTimerProc -- + * + * Check the current mouse position and look for enter/leave + * events. + * + * Results: + * None. + * + * Side effects: + * May schedule a new timer and/or generate enter/leave events. + * + *---------------------------------------------------------------------- + */ + +void +MouseTimerProc(clientData) + ClientData clientData; +{ + POINT pos; + + mouseTimerSet = 0; + + /* + * Get the current mouse position and window. Don't do anything + * if the mouse hasn't moved since the last time we looked. + */ + + GetCursorPos(&pos); + Tk_PointerEvent(NULL, pos.x, pos.y); +} + +/* + *---------------------------------------------------------------------- + * + * TkGetPointerCoords -- + * + * Fetch the position of the mouse pointer. + * + * Results: + * *xPtr and *yPtr are filled in with the root coordinates + * of the mouse pointer for the display. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkGetPointerCoords(tkwin, xPtr, yPtr) + Tk_Window tkwin; /* Window that identifies screen on which + * lookup is to be done. */ + int *xPtr, *yPtr; /* Store pointer coordinates here. */ +{ + POINT point; + + GetCursorPos(&point); + *xPtr = point.x; + *yPtr = point.y; +} + +/* + *---------------------------------------------------------------------- + * + * XQueryPointer -- + * + * Check the current state of the mouse. This is not a complete + * implementation of this function. It only computes the root + * coordinates and the current mask. + * + * Results: + * Sets root_x_return, root_y_return, and mask_return. Returns + * true on success. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Bool +XQueryPointer(display, w, root_return, child_return, root_x_return, + root_y_return, win_x_return, win_y_return, mask_return) + Display* display; + Window w; + Window* root_return; + Window* child_return; + int* root_x_return; + int* root_y_return; + int* win_x_return; + int* win_y_return; + unsigned int* mask_return; +{ + display->request++; + TkGetPointerCoords(NULL, root_x_return, root_y_return); + *mask_return = TkWinGetModifierState(); + return True; +} + +/* + *---------------------------------------------------------------------- + * + * XGetInputFocus -- + * + * Retrieves the current keyboard focus window. + * + * Results: + * Returns the current focus window. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +XGetInputFocus(display, focus_return, revert_to_return) + Display *display; + Window *focus_return; + int *revert_to_return; +{ + Tk_Window tkwin = Tk_HWNDToWindow(GetFocus()); + *focus_return = tkwin ? Tk_WindowId(tkwin) : None; + *revert_to_return = RevertToParent; + display->request++; +} + +/* + *---------------------------------------------------------------------- + * + * XSetInputFocus -- + * + * Set the current focus window. + * + * Results: + * None. + * + * Side effects: + * Changes the keyboard focus and causes the selected window to + * be activated. + * + *---------------------------------------------------------------------- + */ + +void +XSetInputFocus(display, focus, revert_to, time) + Display* display; + Window focus; + int revert_to; + Time time; +{ + display->request++; + if (focus != None) { + SetFocus(Tk_GetHWND(focus)); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpChangeFocus -- + * + * This procedure is invoked to move the system focus from + * one window to another. + * + * Results: + * The return value is the serial number of the command that + * changed the focus. It may be needed by the caller to filter + * out focus change events that were queued before the command. + * If the procedure doesn't actually change the focus then + * it returns 0. + * + * Side effects: + * The official Windows focus window changes; the application's focus + * window isn't changed by this procedure. + * + *---------------------------------------------------------------------- + */ + +int +TkpChangeFocus(winPtr, force) + TkWindow *winPtr; /* Window that is to receive the X focus. */ + int force; /* Non-zero means claim the focus even + * if it didn't originally belong to + * topLevelPtr's application. */ +{ + TkDisplay *dispPtr = winPtr->dispPtr; + Window focusWindow; + int dummy, serial; + TkWindow *winPtr2; + + if (!force) { + XGetInputFocus(dispPtr->display, &focusWindow, &dummy); + winPtr2 = (TkWindow *) Tk_IdToWindow(dispPtr->display, focusWindow); + if ((winPtr2 == NULL) || (winPtr2->mainPtr != winPtr->mainPtr)) { + return 0; + } + } + + if (winPtr->window == None) { + panic("ChangeXFocus got null X window"); + } + XSetInputFocus(dispPtr->display, winPtr->window, RevertToParent, + CurrentTime); + + /* + * Remember the current serial number for the X server and issue + * a dummy server request. This marks the position at which we + * changed the focus, so we can distinguish FocusIn and FocusOut + * events on either side of the mark. + */ + + serial = NextRequest(winPtr->display); + XNoOp(winPtr->display); + return serial; +} + +/* + *---------------------------------------------------------------------- + * + * TkpSetCapture -- + * + * This function captures the mouse so that all future events + * will be reported to this window, even if the mouse is outside + * the window. If the specified window is NULL, then the mouse + * is released. + * + * Results: + * None. + * + * Side effects: + * Sets the capture flag and captures the mouse. + * + *---------------------------------------------------------------------- + */ + +void +TkpSetCapture(winPtr) + TkWindow *winPtr; /* Capture window, or NULL. */ +{ + if (winPtr) { + SetCapture(Tk_GetHWND(Tk_WindowId(winPtr))); + captured = 1; + } else { + captured = 0; + ReleaseCapture(); + } +} diff --git a/win/tkWinPort.h b/win/tkWinPort.h new file mode 100644 index 0000000..1f755a7 --- /dev/null +++ b/win/tkWinPort.h @@ -0,0 +1,117 @@ +/* + * tkWinPort.h -- + * + * This header file handles porting issues that occur because of + * differences between Windows and Unix. It should be the only + * file that contains #ifdefs to handle different flavors of OS. + * + * Copyright (c) 1995-1996 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinPort.h 1.25 97/04/21 17:08:42 + */ + +#ifndef _WINPORT +#define _WINPORT + +#include <X11/Xlib.h> +#include <X11/cursorfont.h> +#include <X11/keysym.h> +#include <X11/Xatom.h> +#include <X11/Xutil.h> + +#include <malloc.h> +#include <errno.h> +#include <ctype.h> +#include <math.h> +#include <stdlib.h> +#include <string.h> +#include <limits.h> +#include <fcntl.h> +#include <io.h> +#include <sys/stat.h> +#include <time.h> + +#ifdef _MSC_VER +# define hypot _hypot +#endif /* _MSC_VER */ + +#define strncasecmp strnicmp +#define strcasecmp stricmp + +#define NBBY 8 + +#define OPEN_MAX 32 + +/* + * The following define causes Tk to use its internal keysym hash table + */ + +#define REDO_KEYSYM_LOOKUP + +/* + * The following macro checks to see whether there is buffered + * input data available for a stdio FILE. + */ + +#ifdef _MSC_VER +# define TK_READ_DATA_PENDING(f) ((f)->_cnt > 0) +#else /* _MSC_VER */ +# define TK_READ_DATA_PENDING(f) ((f)->level > 0) +#endif /* _MSC_VER */ + +/* + * The following stubs implement various calls that don't do anything + * under Windows. + */ + +#define TkFreeWindowId(dispPtr,w) +#define TkInitXId(dispPtr) +#define TkpCmapStressed(tkwin,colormap) (0) +#define XFlush(display) +#define XGrabServer(display) +#define XUngrabServer(display) +#define TkpSync(display) + +/* + * The following functions are implemented as macros under Windows. + */ + +#define XFree(data) {if ((data) != NULL) ckfree((char *) (data));} +#define XNoOp(display) {display->request++;} +#define XSynchronize(display, bool) {display->request++;} +#define XSync(display, bool) {display->request++;} +#define XVisualIDFromVisual(visual) (visual->visualid) + +/* + * The following Tk functions are implemented as macros under Windows. + */ + +#define TkGetNativeProlog(interp) TkGetProlog(interp) +#define TkpGetPixel(p) (((((p)->red >> 8) & 0xff) \ + | ((p)->green & 0xff00) | (((p)->blue << 8) & 0xff0000)) | 0x20000000) + +/* + * These calls implement native bitmaps which are not currently + * supported under Windows. The macros eliminate the calls. + */ + +#define TkpDefineNativeBitmaps() +#define TkpCreateNativeBitmap(display, source) None +#define TkpGetNativeAppBitmap(display, name, w, h) None + +/* + * Define timezone for gettimeofday. + */ + +struct timezone { + int tz_minuteswest; + int tz_dsttime; +}; + +extern int gettimeofday(struct timeval *, struct timezone *); +EXTERN void panic _ANSI_ARGS_(TCL_VARARGS(char *,format)); + +#endif /* _WINPORT */ diff --git a/win/tkWinRegion.c b/win/tkWinRegion.c new file mode 100644 index 0000000..3303022 --- /dev/null +++ b/win/tkWinRegion.c @@ -0,0 +1,179 @@ +/* + * tkWinRegion.c -- + * + * Tk Region emulation code. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinRegion.c 1.7 96/05/03 11:05:54 + */ + +#include "tkWinInt.h" + + +/* + *---------------------------------------------------------------------- + * + * TkCreateRegion -- + * + * Construct an empty region. + * + * Results: + * Returns a new region handle. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +TkRegion +TkCreateRegion() +{ + RECT rect; + memset(&rect, 0, sizeof(RECT)); + return (TkRegion) CreateRectRgnIndirect(&rect); +} + +/* + *---------------------------------------------------------------------- + * + * TkDestroyRegion -- + * + * Destroy the specified region. + * + * Results: + * None. + * + * Side effects: + * Frees the storage associated with the specified region. + * + *---------------------------------------------------------------------- + */ + +void +TkDestroyRegion(r) + TkRegion r; +{ + DeleteObject((HRGN) r); +} + +/* + *---------------------------------------------------------------------- + * + * TkClipBox -- + * + * Computes the bounding box of a region. + * + * Results: + * Sets rect_return to the bounding box of the region. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkClipBox(r, rect_return) + TkRegion r; + XRectangle* rect_return; +{ + RECT rect; + GetRgnBox((HRGN)r, &rect); + rect_return->x = (short) rect.left; + rect_return->y = (short) rect.top; + rect_return->width = (short) (rect.right - rect.left); + rect_return->height = (short) (rect.bottom - rect.top); +} + +/* + *---------------------------------------------------------------------- + * + * TkIntersectRegion -- + * + * Compute the intersection of two regions. + * + * Results: + * Returns the result in the dr_return region. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkIntersectRegion(sra, srb, dr_return) + TkRegion sra; + TkRegion srb; + TkRegion dr_return; +{ + CombineRgn((HRGN) dr_return, (HRGN) sra, (HRGN) srb, RGN_AND); +} + +/* + *---------------------------------------------------------------------- + * + * TkUnionRectWithRegion -- + * + * Create the union of a source region and a rectangle. + * + * Results: + * Returns the result in the dr_return region. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkUnionRectWithRegion(rectangle, src_region, dest_region_return) + XRectangle* rectangle; + TkRegion src_region; + TkRegion dest_region_return; +{ + HRGN rectRgn = CreateRectRgn(rectangle->x, rectangle->y, + rectangle->x + rectangle->width, rectangle->y + rectangle->height); + CombineRgn((HRGN) dest_region_return, (HRGN) src_region, + (HRGN) rectRgn, RGN_OR); + DeleteObject(rectRgn); +} + +/* + *---------------------------------------------------------------------- + * + * TkRectInRegion -- + * + * Test whether a given rectangle overlaps with a region. + * + * Results: + * Returns RectanglePart or RectangleOut. Note that this is + * not a complete implementation since it doesn't test for + * RectangleIn. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkRectInRegion(r, x, y, width, height) + TkRegion r; + int x; + int y; + unsigned int width; + unsigned int height; +{ + RECT rect; + rect.top = y; + rect.left = x; + rect.bottom = y+height; + rect.right = x+width; + return RectInRegion((HRGN)r, &rect) ? RectanglePart : RectangleOut; +} diff --git a/win/tkWinScrlbr.c b/win/tkWinScrlbr.c new file mode 100644 index 0000000..6c1a664 --- /dev/null +++ b/win/tkWinScrlbr.c @@ -0,0 +1,745 @@ +/* + * tkWinScrollbar.c -- + * + * This file implements the Windows specific portion of the scrollbar + * widget. + * + * Copyright (c) 1996 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinScrlbr.c 1.19 97/08/13 17:37:49 + */ + +#include "tkWinInt.h" +#include "tkScrollbar.h" + + +/* + * The following constant is used to specify the maximum scroll position. + * This value is limited by the Win32 API to either 16-bits or 32-bits, + * depending on the context. For now we'll just use a value small + * enough to fit in 16-bits, but which gives us 4-digits of precision. + */ + +#define MAX_SCROLL 10000 + +/* + * Declaration of Windows specific scrollbar structure. + */ + +typedef struct WinScrollbar { + TkScrollbar info; /* Generic scrollbar info. */ + WNDPROC oldProc; /* Old window procedure. */ + int lastVertical; /* 1 if was vertical at last refresh. */ + HWND hwnd; /* Current window handle. */ + int winFlags; /* Various flags; see below. */ +} WinScrollbar; + +/* + * Flag bits for native scrollbars: + * + * IN_MODAL_LOOP: Non-zero means this scrollbar is in the middle + * of a modal loop. + * ALREADY_DEAD: Non-zero means this scrollbar has been + * destroyed, but has not been cleaned up. + */ + +#define IN_MODAL_LOOP 1 +#define ALREADY_DEAD 2 + +/* + * Cached system metrics used to determine scrollbar geometry. + */ + +static int initialized = 0; +static int hArrowWidth, hThumb; /* Horizontal control metrics. */ +static int vArrowWidth, vArrowHeight, vThumb; /* Vertical control metrics. */ + +/* + * This variable holds the default width for a scrollbar in string + * form for use in a Tk_ConfigSpec. + */ + +static char defWidth[8]; + +/* + * Declarations for functions defined in this file. + */ + +static Window CreateProc _ANSI_ARGS_((Tk_Window tkwin, + Window parent, ClientData instanceData)); +static void ModalLoopProc _ANSI_ARGS_((Tk_Window tkwin, + XEvent *eventPtr)); +static int ScrollbarBindProc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, XEvent *eventPtr, + Tk_Window tkwin, KeySym keySym)); +static LRESULT CALLBACK ScrollbarProc _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); +static void UpdateScrollbar _ANSI_ARGS_(( + WinScrollbar *scrollPtr)); +static void UpdateScrollbarMetrics _ANSI_ARGS_((void)); + +/* + * The class procedure table for the scrollbar widget. + */ + +TkClassProcs tkpScrollbarProcs = { + CreateProc, /* createProc */ + NULL, /* geometryProc */ + ModalLoopProc, /* modalProc */ +}; + + +/* + *---------------------------------------------------------------------- + * + * TkpCreateScrollbar -- + * + * Allocate a new TkScrollbar structure. + * + * Results: + * Returns a newly allocated TkScrollbar structure. + * + * Side effects: + * Registers an event handler for the widget. + * + *---------------------------------------------------------------------- + */ + +TkScrollbar * +TkpCreateScrollbar(tkwin) + Tk_Window tkwin; +{ + WinScrollbar *scrollPtr; + TkWindow *winPtr = (TkWindow *)tkwin; + + if (!initialized) { + UpdateScrollbarMetrics(); + initialized = 1; + } + + scrollPtr = (WinScrollbar *) ckalloc(sizeof(WinScrollbar)); + scrollPtr->winFlags = 0; + scrollPtr->hwnd = NULL; + + Tk_CreateEventHandler(tkwin, + ExposureMask|StructureNotifyMask|FocusChangeMask, + TkScrollbarEventProc, (ClientData) scrollPtr); + + if (!Tcl_GetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL)) { + Tcl_SetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL, + (ClientData)1); + TkCreateBindingProcedure(winPtr->mainPtr->interp, + winPtr->mainPtr->bindingTable, + (ClientData)Tk_GetUid("Scrollbar"), "<ButtonPress>", + ScrollbarBindProc, NULL, NULL); + } + + return (TkScrollbar*) scrollPtr; +} + +/* + *---------------------------------------------------------------------- + * + * UpdateScrollbar -- + * + * This function updates the position and size of the scrollbar + * thumb based on the current settings. + * + * Results: + * None. + * + * Side effects: + * Moves the thumb. + * + *---------------------------------------------------------------------- + */ + +static void +UpdateScrollbar(scrollPtr) + WinScrollbar *scrollPtr; +{ + SCROLLINFO scrollInfo; + double thumbSize; + + /* + * Update the current scrollbar position and shape. + */ + + scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE; + scrollInfo.cbSize = sizeof(scrollInfo); + scrollInfo.nMin = 0; + scrollInfo.nMax = MAX_SCROLL; + thumbSize = (scrollPtr->info.lastFraction - scrollPtr->info.firstFraction); + if (tkpIsWin32s) { + scrollInfo.nPage = 0; + } else { + scrollInfo.nPage = ((UINT) (thumbSize * (double) MAX_SCROLL)) + 1; + } + if (thumbSize < 1.0) { + scrollInfo.nPos = (int) + ((scrollPtr->info.firstFraction / (1.0-thumbSize)) + * (MAX_SCROLL - (scrollInfo.nPage - 1))); + } else { + scrollInfo.nPos = 0; + } + SetScrollInfo(scrollPtr->hwnd, SB_CTL, &scrollInfo, TRUE); +} + +/* + *---------------------------------------------------------------------- + * + * CreateProc -- + * + * This function creates a new Scrollbar control, subclasses + * the instance, and generates a new Window object. + * + * Results: + * Returns the newly allocated Window object, or None on failure. + * + * Side effects: + * Causes a new Scrollbar control to come into existence. + * + *---------------------------------------------------------------------- + */ + +static Window +CreateProc(tkwin, parentWin, instanceData) + Tk_Window tkwin; /* Token for window. */ + Window parentWin; /* Parent of new window. */ + ClientData instanceData; /* Scrollbar instance data. */ +{ + DWORD style; + Window window; + HWND parent; + TkWindow *winPtr; + WinScrollbar *scrollPtr = (WinScrollbar *)instanceData; + + parent = Tk_GetHWND(parentWin); + + if (scrollPtr->info.vertical) { + style = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS + | SBS_VERT | SBS_RIGHTALIGN; + } else { + style = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS + | SBS_HORZ | SBS_BOTTOMALIGN; + } + + scrollPtr->hwnd = CreateWindow("SCROLLBAR", NULL, style, + Tk_X(tkwin), Tk_Y(tkwin), Tk_Width(tkwin), Tk_Height(tkwin), + parent, NULL, Tk_GetHINSTANCE(), NULL); + + /* + * Ensure new window is inserted into the stacking order at the correct + * place. + */ + + SetWindowPos(scrollPtr->hwnd, HWND_TOP, 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); + + for (winPtr = ((TkWindow*)tkwin)->nextPtr; winPtr != NULL; + winPtr = winPtr->nextPtr) { + if ((winPtr->window != None) && !(winPtr->flags & TK_TOP_LEVEL)) { + TkWinSetWindowPos(scrollPtr->hwnd, Tk_GetHWND(winPtr->window), + Below); + break; + } + } + + scrollPtr->lastVertical = scrollPtr->info.vertical; + scrollPtr->oldProc = (WNDPROC)SetWindowLong(scrollPtr->hwnd, GWL_WNDPROC, + (DWORD) ScrollbarProc); + window = Tk_AttachHWND(tkwin, scrollPtr->hwnd); + + UpdateScrollbar(scrollPtr); + return window; +} + +/* + *-------------------------------------------------------------- + * + * TkpDisplayScrollbar -- + * + * This procedure redraws the contents of a scrollbar window. + * It is invoked as a do-when-idle handler, so it only runs + * when there's nothing else for the application to do. + * + * Results: + * None. + * + * Side effects: + * Information appears on the screen. + * + *-------------------------------------------------------------- + */ + +void +TkpDisplayScrollbar(clientData) + ClientData clientData; /* Information about window. */ +{ + WinScrollbar *scrollPtr = (WinScrollbar *) clientData; + Tk_Window tkwin = scrollPtr->info.tkwin; + + scrollPtr->info.flags &= ~REDRAW_PENDING; + if ((tkwin == NULL) || !Tk_IsMapped(tkwin)) { + return; + } + + /* + * Destroy and recreate the scrollbar control if the orientation + * has changed. + */ + + if (scrollPtr->lastVertical != scrollPtr->info.vertical) { + HWND hwnd = Tk_GetHWND(Tk_WindowId(tkwin)); + + SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) scrollPtr->oldProc); + DestroyWindow(hwnd); + + CreateProc(tkwin, Tk_WindowId(Tk_Parent(tkwin)), + (ClientData) scrollPtr); + } else { + UpdateScrollbar(scrollPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpDestroyScrollbar -- + * + * Free data structures associated with the scrollbar control. + * + * Results: + * None. + * + * Side effects: + * Restores the default control state. + * + *---------------------------------------------------------------------- + */ + +void +TkpDestroyScrollbar(scrollPtr) + TkScrollbar *scrollPtr; +{ + WinScrollbar *winScrollPtr = (WinScrollbar *)scrollPtr; + HWND hwnd = winScrollPtr->hwnd; + if (hwnd) { + SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) winScrollPtr->oldProc); + if (winScrollPtr->winFlags & IN_MODAL_LOOP) { + ((TkWindow *)scrollPtr->tkwin)->flags |= TK_DONT_DESTROY_WINDOW; + SetParent(hwnd, NULL); + } + } + winScrollPtr->winFlags |= ALREADY_DEAD; +} + +/* + *---------------------------------------------------------------------- + * + * UpdateScrollbarMetrics -- + * + * This function retrieves the current system metrics for a + * scrollbar. + * + * Results: + * None. + * + * Side effects: + * Updates the geometry cache info for all scrollbars. + * + *---------------------------------------------------------------------- + */ + +void +UpdateScrollbarMetrics() +{ + Tk_ConfigSpec *specPtr; + + hArrowWidth = GetSystemMetrics(SM_CXHSCROLL); + hThumb = GetSystemMetrics(SM_CXHTHUMB); + vArrowWidth = GetSystemMetrics(SM_CXVSCROLL); + vArrowHeight = GetSystemMetrics(SM_CYVSCROLL); + vThumb = GetSystemMetrics(SM_CYVTHUMB); + + sprintf(defWidth, "%d", vArrowWidth); + for (specPtr = tkpScrollbarConfigSpecs; specPtr->type != TK_CONFIG_END; + specPtr++) { + if (specPtr->offset == Tk_Offset(TkScrollbar, width)) { + specPtr->defValue = defWidth; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkpComputeScrollbarGeometry -- + * + * After changes in a scrollbar's size or configuration, this + * procedure recomputes various geometry information used in + * displaying the scrollbar. + * + * Results: + * None. + * + * Side effects: + * The scrollbar will be displayed differently. + * + *---------------------------------------------------------------------- + */ + +void +TkpComputeScrollbarGeometry(scrollPtr) + register TkScrollbar *scrollPtr; /* Scrollbar whose geometry may + * have changed. */ +{ + int fieldLength, minThumbSize; + + /* + * Windows doesn't use focus rings on scrollbars, but we still + * perform basic sanity checks to appease backwards compatibility. + */ + + if (scrollPtr->highlightWidth < 0) { + scrollPtr->highlightWidth = 0; + } + + if (scrollPtr->vertical) { + scrollPtr->arrowLength = vArrowHeight; + fieldLength = Tk_Height(scrollPtr->tkwin); + minThumbSize = vThumb; + } else { + scrollPtr->arrowLength = hArrowWidth; + fieldLength = Tk_Width(scrollPtr->tkwin); + minThumbSize = hThumb; + } + fieldLength -= 2*scrollPtr->arrowLength; + if (fieldLength < 0) { + fieldLength = 0; + } + scrollPtr->sliderFirst = (int) ((double)fieldLength + * scrollPtr->firstFraction); + scrollPtr->sliderLast = (int) ((double)fieldLength + * scrollPtr->lastFraction); + + /* + * Adjust the slider so that some piece of it is always + * displayed in the scrollbar and so that it has at least + * a minimal width (so it can be grabbed with the mouse). + */ + + if (scrollPtr->sliderFirst > fieldLength) { + scrollPtr->sliderFirst = fieldLength; + } + if (scrollPtr->sliderFirst < 0) { + scrollPtr->sliderFirst = 0; + } + if (scrollPtr->sliderLast < (scrollPtr->sliderFirst + + minThumbSize)) { + scrollPtr->sliderLast = scrollPtr->sliderFirst + minThumbSize; + } + if (scrollPtr->sliderLast > fieldLength) { + scrollPtr->sliderLast = fieldLength; + } + scrollPtr->sliderFirst += scrollPtr->arrowLength; + scrollPtr->sliderLast += scrollPtr->arrowLength; + + /* + * Register the desired geometry for the window (leave enough space + * for the two arrows plus a minimum-size slider, plus border around + * the whole window, if any). Then arrange for the window to be + * redisplayed. + */ + + if (scrollPtr->vertical) { + Tk_GeometryRequest(scrollPtr->tkwin, + scrollPtr->width, 2*scrollPtr->arrowLength + minThumbSize); + } else { + Tk_GeometryRequest(scrollPtr->tkwin, + 2*scrollPtr->arrowLength + minThumbSize, scrollPtr->width); + } + Tk_SetInternalBorder(scrollPtr->tkwin, 0); +} + +/* + *---------------------------------------------------------------------- + * + * ScrollbarProc -- + * + * This function is call by Windows whenever an event occurs on + * a scrollbar control created by Tk. + * + * Results: + * Standard Windows return value. + * + * Side effects: + * May generate events. + * + *---------------------------------------------------------------------- + */ + +static LRESULT CALLBACK +ScrollbarProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + LRESULT result; + POINT point; + WinScrollbar *scrollPtr; + Tk_Window tkwin = Tk_HWNDToWindow(hwnd); + + if (tkwin == NULL) { + panic("ScrollbarProc called on an invalid HWND"); + } + scrollPtr = (WinScrollbar *)((TkWindow*)tkwin)->instanceData; + + switch(message) { + case WM_HSCROLL: + case WM_VSCROLL: { + Tcl_Interp *interp; + Tcl_DString cmdString; + int command = LOWORD(wParam); + int code; + + GetCursorPos(&point); + Tk_TranslateWinEvent(NULL, WM_MOUSEMOVE, 0, + MAKELPARAM(point.x, point.y), &result); + + if (command == SB_ENDSCROLL) { + return 0; + } + + /* + * Bail out immediately if there isn't a command to invoke. + */ + + if (scrollPtr->info.commandSize == 0) { + Tcl_ServiceAll(); + return 0; + } + + Tcl_DStringInit(&cmdString); + Tcl_DStringAppend(&cmdString, scrollPtr->info.command, + scrollPtr->info.commandSize); + + if (command == SB_LINELEFT || command == SB_LINERIGHT) { + Tcl_DStringAppendElement(&cmdString, "scroll"); + Tcl_DStringAppendElement(&cmdString, + (command == SB_LINELEFT ) ? "-1" : "1"); + Tcl_DStringAppendElement(&cmdString, "units"); + } else if (command == SB_PAGELEFT || command == SB_PAGERIGHT) { + Tcl_DStringAppendElement(&cmdString, "scroll"); + Tcl_DStringAppendElement(&cmdString, + (command == SB_PAGELEFT ) ? "-1" : "1"); + Tcl_DStringAppendElement(&cmdString, "pages"); + } else { + char valueString[TCL_DOUBLE_SPACE]; + double pos = 0.0; + switch (command) { + case SB_THUMBPOSITION: + pos = ((double)HIWORD(wParam)) / MAX_SCROLL; + break; + + case SB_THUMBTRACK: + pos = ((double)HIWORD(wParam)) / MAX_SCROLL; + break; + + case SB_TOP: + pos = 0.0; + break; + + case SB_BOTTOM: + pos = 1.0; + break; + } + sprintf(valueString, "%g", pos); + Tcl_DStringAppendElement(&cmdString, "moveto"); + Tcl_DStringAppendElement(&cmdString, valueString); + } + + interp = scrollPtr->info.interp; + code = Tcl_GlobalEval(interp, cmdString.string); + if (code != TCL_OK && code != TCL_CONTINUE && code != TCL_BREAK) { + Tcl_AddErrorInfo(interp, "\n (scrollbar command)"); + Tcl_BackgroundError(interp); + } + Tcl_DStringFree(&cmdString); + + Tcl_ServiceAll(); + return 0; + } + + default: + if (Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) { + return result; + } + } + return CallWindowProc(scrollPtr->oldProc, hwnd, message, wParam, lParam); +} + +/* + *---------------------------------------------------------------------- + * + * TkpConfigureScrollbar -- + * + * This procedure is called after the generic code has finished + * processing configuration options, in order to configure + * platform specific options. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkpConfigureScrollbar(scrollPtr) + register TkScrollbar *scrollPtr; /* Information about widget; may or + * may not already have values for + * some fields. */ +{ +} + +/* + *-------------------------------------------------------------- + * + * ScrollbarBindProc -- + * + * This procedure is invoked when the default <ButtonPress> + * binding on the Scrollbar bind tag fires. + * + * Results: + * None. + * + * Side effects: + * The event enters a modal loop. + * + *-------------------------------------------------------------- + */ + +static int +ScrollbarBindProc(clientData, interp, eventPtr, tkwin, keySym) + ClientData clientData; + Tcl_Interp *interp; + XEvent *eventPtr; + Tk_Window tkwin; + KeySym keySym; +{ + TkWindow *winPtr = (TkWindow*)tkwin; + if (eventPtr->type == ButtonPress) { + winPtr->flags |= TK_DEFER_MODAL; + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * ModalLoopProc -- + * + * This function is invoked at the end of the event processing + * whenever the ScrollbarBindProc has been invoked for a ButtonPress + * event. + * + * Results: + * None. + * + * Side effects: + * Enters a modal loop. + * + *---------------------------------------------------------------------- + */ + +static void +ModalLoopProc(tkwin, eventPtr) + Tk_Window tkwin; + XEvent *eventPtr; +{ + TkWindow *winPtr = (TkWindow*)tkwin; + WinScrollbar *scrollPtr = (WinScrollbar *) winPtr->instanceData; + int oldMode; + + Tcl_Preserve((ClientData)scrollPtr); + scrollPtr->winFlags |= IN_MODAL_LOOP; + oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + TkWinResendEvent(scrollPtr->oldProc, scrollPtr->hwnd, eventPtr); + (void) Tcl_SetServiceMode(oldMode); + scrollPtr->winFlags &= ~IN_MODAL_LOOP; + if (scrollPtr->hwnd && scrollPtr->winFlags & ALREADY_DEAD) { + DestroyWindow(scrollPtr->hwnd); + } + Tcl_Release((ClientData)scrollPtr); +} + +/* + *-------------------------------------------------------------- + * + * TkpScrollbarPosition -- + * + * Determine the scrollbar element corresponding to a + * given position. + * + * Results: + * One of TOP_ARROW, TOP_GAP, etc., indicating which element + * of the scrollbar covers the position given by (x, y). If + * (x,y) is outside the scrollbar entirely, then OUTSIDE is + * returned. + * + * Side effects: + * None. + * + *-------------------------------------------------------------- + */ + +int +TkpScrollbarPosition(scrollPtr, x, y) + register TkScrollbar *scrollPtr; /* Scrollbar widget record. */ + int x, y; /* Coordinates within scrollPtr's + * window. */ +{ + int length, width, tmp; + + if (scrollPtr->vertical) { + length = Tk_Height(scrollPtr->tkwin); + width = Tk_Width(scrollPtr->tkwin); + } else { + tmp = x; + x = y; + y = tmp; + length = Tk_Width(scrollPtr->tkwin); + width = Tk_Height(scrollPtr->tkwin); + } + + if ((x < scrollPtr->inset) || (x >= (width - scrollPtr->inset)) + || (y < scrollPtr->inset) || (y >= (length - scrollPtr->inset))) { + return OUTSIDE; + } + + /* + * All of the calculations in this procedure mirror those in + * TkpDisplayScrollbar. Be sure to keep the two consistent. + */ + + if (y < (scrollPtr->inset + scrollPtr->arrowLength)) { + return TOP_ARROW; + } + if (y < scrollPtr->sliderFirst) { + return TOP_GAP; + } + if (y < scrollPtr->sliderLast) { + return SLIDER; + } + if (y >= (length - (scrollPtr->arrowLength + scrollPtr->inset))) { + return BOTTOM_ARROW; + } + return BOTTOM_GAP; +} diff --git a/win/tkWinSend.c b/win/tkWinSend.c new file mode 100644 index 0000000..6d12ed4 --- /dev/null +++ b/win/tkWinSend.c @@ -0,0 +1,86 @@ +/* + * tkWinSend.c -- + * + * This file provides procedures that implement the "send" + * command, allowing commands to be passed from interpreter + * to interpreter. + * + * Copyright (c) 1997 by Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinSend.c 1.4 97/06/10 09:39:50 + */ + +#include "tkPort.h" +#include "tkInt.h" + + +/* + *-------------------------------------------------------------- + * + * Tk_SetAppName -- + * + * This procedure is called to associate an ASCII name with a Tk + * application. If the application has already been named, the + * name replaces the old one. + * + * Results: + * The return value is the name actually given to the application. + * This will normally be the same as name, but if name was already + * in use for an application then a name of the form "name #2" will + * be chosen, with a high enough number to make the name unique. + * + * Side effects: + * Registration info is saved, thereby allowing the "send" command + * to be used later to invoke commands in the application. In + * addition, the "send" command is created in the application's + * interpreter. The registration will be removed automatically + * if the interpreter is deleted or the "send" command is removed. + * + *-------------------------------------------------------------- + */ + +char * +Tk_SetAppName(tkwin, name) + Tk_Window tkwin; /* Token for any window in the application + * to be named: it is just used to identify + * the application and the display. */ + char *name; /* The name that will be used to + * refer to the interpreter in later + * "send" commands. Must be globally + * unique. */ +{ + return name; +} + +/* + *---------------------------------------------------------------------- + * + * TkGetInterpNames -- + * + * This procedure is invoked to fetch a list of all the + * interpreter names currently registered for the display + * of a particular window. + * + * Results: + * A standard Tcl return value. Interp->result will be set + * to hold a list of all the interpreter names defined for + * tkwin's display. If an error occurs, then TCL_ERROR + * is returned and interp->result will hold an error message. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkGetInterpNames(interp, tkwin) + Tcl_Interp *interp; /* Interpreter for returning a result. */ + Tk_Window tkwin; /* Window whose display is to be used + * for the lookup. */ +{ + return TCL_OK; +} diff --git a/win/tkWinWindow.c b/win/tkWinWindow.c new file mode 100644 index 0000000..2b8eb41 --- /dev/null +++ b/win/tkWinWindow.c @@ -0,0 +1,796 @@ +/* + * tkWinWindow.c -- + * + * Xlib emulation routines for Windows related to creating, + * displaying and destroying windows. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinWindow.c 1.23 97/07/01 18:14:13 + */ + +#include "tkWinInt.h" + +/* + * The windowTable maps from HWND to Tk_Window handles. + */ + +static Tcl_HashTable windowTable; + +/* + * Have statics in this module been initialized? + */ + +static int initialized = 0; + +/* + * Forward declarations for procedures defined in this file: + */ + +static void NotifyVisibility _ANSI_ARGS_((XEvent *eventPtr, + TkWindow *winPtr)); +static void StackWindow _ANSI_ARGS_((Window w, Window sibling, + int stack_mode)); + +/* + *---------------------------------------------------------------------- + * + * Tk_AttachHWND -- + * + * This function binds an HWND and a reflection procedure to + * the specified Tk_Window. + * + * Results: + * Returns an X Window that encapsulates the HWND. + * + * Side effects: + * May allocate a new X Window. Also enters the HWND into the + * global window table. + * + *---------------------------------------------------------------------- + */ + +Window +Tk_AttachHWND(tkwin, hwnd) + Tk_Window tkwin; + HWND hwnd; +{ + int new; + Tcl_HashEntry *entryPtr; + TkWinDrawable *twdPtr = (TkWinDrawable *) Tk_WindowId(tkwin); + + if (!initialized) { + Tcl_InitHashTable(&windowTable, TCL_ONE_WORD_KEYS); + initialized = 1; + } + + /* + * Allocate a new drawable if necessary. Otherwise, remove the + * previous HWND from from the window table. + */ + + if (twdPtr == NULL) { + twdPtr = (TkWinDrawable*) ckalloc(sizeof(TkWinDrawable)); + twdPtr->type = TWD_WINDOW; + twdPtr->window.winPtr = (TkWindow *) tkwin; + } else if (twdPtr->window.handle != NULL) { + entryPtr = Tcl_FindHashEntry(&windowTable, + (char *)twdPtr->window.handle); + Tcl_DeleteHashEntry(entryPtr); + } + + /* + * Insert the new HWND into the window table. + */ + + twdPtr->window.handle = hwnd; + entryPtr = Tcl_CreateHashEntry(&windowTable, (char *)hwnd, &new); + Tcl_SetHashValue(entryPtr, (ClientData)tkwin); + + return (Window)twdPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_HWNDToWindow -- + * + * This function retrieves a Tk_Window from the window table + * given an HWND. + * + * Results: + * Returns the matching Tk_Window. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tk_Window +Tk_HWNDToWindow(hwnd) + HWND hwnd; +{ + Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(&windowTable, (char*)hwnd); + if (entryPtr != NULL) { + return (Tk_Window) Tcl_GetHashValue(entryPtr); + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetHWND -- + * + * This function extracts the HWND from an X Window. + * + * Results: + * Returns the HWND associated with the Window. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +HWND +Tk_GetHWND(window) + Window window; +{ + TkWinDrawable *twdPtr = (TkWinDrawable *) window; + return twdPtr->window.handle; +} + +/* + *---------------------------------------------------------------------- + * + * TkpPrintWindowId -- + * + * This routine stores the string representation of the + * platform dependent window handle for an X Window in the + * given buffer. + * + * Results: + * Returns the result in the specified buffer. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkpPrintWindowId(buf, window) + char *buf; /* Pointer to string large enough to hold + * the hex representation of a pointer. */ + Window window; /* Window to be printed into buffer. */ +{ + HWND hwnd = (window) ? Tk_GetHWND(window) : 0; + sprintf(buf, "0x%x", (unsigned int) hwnd); +} + +/* + *---------------------------------------------------------------------- + * + * TkpScanWindowId -- + * + * Given a string which represents the platform dependent window + * handle, produce the X Window id for the window. + * + * Results: + * The return value is normally TCL_OK; in this case *idPtr + * will be set to the X Window id equivalent to string. If + * string is improperly formed then TCL_ERROR is returned and + * an error message will be left in interp->result. If the + * number does not correspond to a Tk Window, then *idPtr will + * be set to None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkpScanWindowId(interp, string, idPtr) + Tcl_Interp *interp; /* Interpreter to use for error reporting. */ + char *string; /* String containing a (possibly signed) + * integer in a form acceptable to strtol. */ + int *idPtr; /* Place to store converted result. */ +{ + int number; + Tk_Window tkwin; + + if (Tcl_GetInt(interp, string, &number) != TCL_OK) { + return TCL_ERROR; + } + tkwin = Tk_HWNDToWindow((HWND)number); + if (tkwin) { + *idPtr = Tk_WindowId(tkwin); + } else { + *idPtr = None; + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * TkpMakeWindow -- + * + * Creates a Windows window object based on the current attributes + * of the specified TkWindow. + * + * Results: + * Returns a pointer to a new TkWinDrawable cast to a Window. + * + * Side effects: + * Creates a new window. + * + *---------------------------------------------------------------------- + */ + +Window +TkpMakeWindow(winPtr, parent) + TkWindow *winPtr; + Window parent; +{ + HWND parentWin; + int style; + HWND hwnd; + + if (parent != None) { + parentWin = Tk_GetHWND(parent); + style = WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; + } else { + parentWin = NULL; + style = WS_POPUP | WS_CLIPCHILDREN; + } + + /* + * Create the window, then ensure that it is at the top of the + * stacking order. + */ + + hwnd = CreateWindow(TK_WIN_CHILD_CLASS_NAME, NULL, style, + Tk_X(winPtr), Tk_Y(winPtr), Tk_Width(winPtr), Tk_Height(winPtr), + parentWin, NULL, Tk_GetHINSTANCE(), NULL); + SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); + return Tk_AttachHWND((Tk_Window)winPtr, hwnd); +} + +/* + *---------------------------------------------------------------------- + * + * XDestroyWindow -- + * + * Destroys the given window. + * + * Results: + * None. + * + * Side effects: + * Sends the WM_DESTROY message to the window and then destroys + * it the Win32 resources associated with the window. + * + *---------------------------------------------------------------------- + */ + +void +XDestroyWindow(display, w) + Display* display; + Window w; +{ + Tcl_HashEntry *entryPtr; + TkWinDrawable *twdPtr = (TkWinDrawable *)w; + TkWindow *winPtr = TkWinGetWinPtr(w); + HWND hwnd = Tk_GetHWND(w); + + display->request++; + + /* + * Remove references to the window in the pointer module then + * release the drawable. + */ + + TkPointerDeadWindow(winPtr); + + entryPtr = Tcl_FindHashEntry(&windowTable, (char*)hwnd); + if (entryPtr != NULL) { + Tcl_DeleteHashEntry(entryPtr); + } + + ckfree((char *)twdPtr); + + /* + * Don't bother destroying the window if we are going to destroy + * the parent later. + */ + + if (hwnd != NULL && !(winPtr->flags & TK_DONT_DESTROY_WINDOW)) { + DestroyWindow(hwnd); + } +} + +/* + *---------------------------------------------------------------------- + * + * XMapWindow -- + * + * Cause the given window to become visible. + * + * Results: + * None + * + * Side effects: + * Causes the window state to change, and generates a MapNotify + * event. + * + *---------------------------------------------------------------------- + */ + +void +XMapWindow(display, w) + Display* display; + Window w; +{ + XEvent event; + TkWindow *parentPtr; + TkWindow *winPtr = TkWinGetWinPtr(w); + + display->request++; + + ShowWindow(TkWinGetHWND(w), SW_SHOWNORMAL); + winPtr->flags |= TK_MAPPED; + + /* + * Check to see if this window is visible now. If all of the parent + * windows up to the first toplevel are mapped, then this window and + * its mapped children have just become visible. + */ + + if (!(winPtr->flags & TK_TOP_LEVEL)) { + for (parentPtr = winPtr->parentPtr; ; + parentPtr = parentPtr->parentPtr) { + if ((parentPtr == NULL) || !(parentPtr->flags & TK_MAPPED)) { + return; + } + if (parentPtr->flags & TK_TOP_LEVEL) { + break; + } + } + } else { + event.type = MapNotify; + event.xmap.serial = display->request; + event.xmap.send_event = False; + event.xmap.display = display; + event.xmap.event = winPtr->window; + event.xmap.window = winPtr->window; + event.xmap.override_redirect = winPtr->atts.override_redirect; + Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL); + } + + /* + * Generate VisibilityNotify events for this window and its mapped + * children. + */ + + event.type = VisibilityNotify; + event.xvisibility.serial = display->request; + event.xvisibility.send_event = False; + event.xvisibility.display = display; + event.xvisibility.window = winPtr->window; + event.xvisibility.state = VisibilityUnobscured; + NotifyVisibility(&event, winPtr); +} + +/* + *---------------------------------------------------------------------- + * + * NotifyVisibility -- + * + * This function recursively notifies the mapped children of the + * specified window of a change in visibility. Note that we don't + * properly report the visibility state, since Windows does not + * provide that info. The eventPtr argument must point to an event + * that has been completely initialized except for the window slot. + * + * Results: + * None. + * + * Side effects: + * Generates lots of events. + * + *---------------------------------------------------------------------- + */ + +static void +NotifyVisibility(eventPtr, winPtr) + XEvent *eventPtr; /* Initialized VisibilityNotify event. */ + TkWindow *winPtr; /* Window to notify. */ +{ + if (winPtr->atts.event_mask & VisibilityChangeMask) { + eventPtr->xvisibility.window = winPtr->window; + Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL); + } + for (winPtr = winPtr->childList; winPtr != NULL; + winPtr = winPtr->nextPtr) { + if (winPtr->flags & TK_MAPPED) { + NotifyVisibility(eventPtr, winPtr); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * XUnmapWindow -- + * + * Cause the given window to become invisible. + * + * Results: + * None + * + * Side effects: + * Causes the window state to change, and generates an UnmapNotify + * event. + * + *---------------------------------------------------------------------- + */ + +void +XUnmapWindow(display, w) + Display* display; + Window w; +{ + XEvent event; + TkWindow *winPtr = TkWinGetWinPtr(w); + + display->request++; + + /* + * Bug fix: Don't short circuit this routine based on TK_MAPPED because + * it will be cleared before XUnmapWindow is called. + */ + + ShowWindow(TkWinGetHWND(w), SW_HIDE); + winPtr->flags &= ~TK_MAPPED; + + if (winPtr->flags & TK_TOP_LEVEL) { + event.type = UnmapNotify; + event.xunmap.serial = display->request; + event.xunmap.send_event = False; + event.xunmap.display = display; + event.xunmap.event = winPtr->window; + event.xunmap.window = winPtr->window; + event.xunmap.from_configure = False; + Tk_HandleEvent(&event); + } +} + +/* + *---------------------------------------------------------------------- + * + * XMoveResizeWindow -- + * + * Move and resize a window relative to its parent. + * + * Results: + * None. + * + * Side effects: + * Repositions and resizes the specified window. + * + *---------------------------------------------------------------------- + */ + +void +XMoveResizeWindow(display, w, x, y, width, height) + Display* display; + Window w; + int x; /* Position relative to parent. */ + int y; + unsigned int width; + unsigned int height; +{ + display->request++; + MoveWindow(TkWinGetHWND(w), x, y, width, height, TRUE); +} + +/* + *---------------------------------------------------------------------- + * + * XMoveWindow -- + * + * Move a window relative to its parent. + * + * Results: + * None. + * + * Side effects: + * Repositions the specified window. + * + *---------------------------------------------------------------------- + */ + +void +XMoveWindow(display, w, x, y) + Display* display; + Window w; + int x; + int y; +{ + TkWindow *winPtr = TkWinGetWinPtr(w); + + display->request++; + + MoveWindow(TkWinGetHWND(w), x, y, winPtr->changes.width, + winPtr->changes.height, TRUE); +} + +/* + *---------------------------------------------------------------------- + * + * XResizeWindow -- + * + * Resize a window. + * + * Results: + * None. + * + * Side effects: + * Resizes the specified window. + * + *---------------------------------------------------------------------- + */ + +void +XResizeWindow(display, w, width, height) + Display* display; + Window w; + unsigned int width; + unsigned int height; +{ + TkWindow *winPtr = TkWinGetWinPtr(w); + + display->request++; + + MoveWindow(TkWinGetHWND(w), winPtr->changes.x, winPtr->changes.y, width, + height, TRUE); +} + +/* + *---------------------------------------------------------------------- + * + * XRaiseWindow -- + * + * Change the stacking order of a window. + * + * Results: + * None. + * + * Side effects: + * Changes the stacking order of the specified window. + * + *---------------------------------------------------------------------- + */ + +void +XRaiseWindow(display, w) + Display* display; + Window w; +{ + HWND window = TkWinGetHWND(w); + + display->request++; + SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0, + SWP_NOMOVE | SWP_NOSIZE); +} + +/* + *---------------------------------------------------------------------- + * + * XConfigureWindow -- + * + * Change the size, position, stacking, or border of the specified + * window. + * + * Results: + * None. + * + * Side effects: + * Changes the attributes of the specified window. Note that we + * ignore the passed in values and use the values stored in the + * TkWindow data structure. + * + *---------------------------------------------------------------------- + */ + +void +XConfigureWindow(display, w, value_mask, values) + Display* display; + Window w; + unsigned int value_mask; + XWindowChanges* values; +{ + TkWindow *winPtr = TkWinGetWinPtr(w); + HWND hwnd = TkWinGetHWND(w); + + display->request++; + + /* + * Change the shape and/or position of the window. + */ + + if (value_mask & (CWX|CWY|CWWidth|CWHeight)) { + MoveWindow(hwnd, winPtr->changes.x, winPtr->changes.y, + winPtr->changes.width, winPtr->changes.height, TRUE); + } + + /* + * Change the stacking order of the window. + */ + + if (value_mask & CWStackMode) { + HWND sibling; + if ((value_mask & CWSibling) && (values->sibling != None)) { + sibling = Tk_GetHWND(values->sibling); + } else { + sibling = NULL; + } + TkWinSetWindowPos(hwnd, sibling, values->stack_mode); + } +} + +/* + *---------------------------------------------------------------------- + * + * XClearWindow -- + * + * Clears the entire window to the current background color. + * + * Results: + * None. + * + * Side effects: + * Erases the current contents of the window. + * + *---------------------------------------------------------------------- + */ + +void +XClearWindow(display, w) + Display* display; + Window w; +{ + RECT rc; + HBRUSH brush; + HPALETTE oldPalette, palette; + TkWindow *winPtr; + HWND hwnd = TkWinGetHWND(w); + HDC dc = GetDC(hwnd); + + palette = TkWinGetPalette(display->screens[0].cmap); + oldPalette = SelectPalette(dc, palette, FALSE); + + display->request++; + + winPtr = TkWinGetWinPtr(w); + brush = CreateSolidBrush(winPtr->atts.background_pixel); + GetWindowRect(hwnd, &rc); + rc.right = rc.right - rc.left; + rc.bottom = rc.bottom - rc.top; + rc.left = rc.top = 0; + FillRect(dc, &rc, brush); + + DeleteObject(brush); + SelectPalette(dc, oldPalette, TRUE); + ReleaseDC(hwnd, dc); +} + +/* + *---------------------------------------------------------------------- + * + * XChangeWindowAttributes -- + * + * This function is called when the attributes on a window are + * updated. Since Tk maintains all of the window state, the only + * relevant value is the cursor. + * + * Results: + * None. + * + * Side effects: + * May cause the mouse position to be updated. + * + *---------------------------------------------------------------------- + */ + +void +XChangeWindowAttributes(display, w, valueMask, attributes) + Display* display; + Window w; + unsigned long valueMask; + XSetWindowAttributes* attributes; +{ + if (valueMask & CWCursor) { + XDefineCursor(display, w, attributes->cursor); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinSetWindowPos -- + * + * Adjust the stacking order of a window relative to a second + * window (or NULL). + * + * Results: + * None. + * + * Side effects: + * Moves the specified window in the stacking order. + * + *---------------------------------------------------------------------- + */ + +void +TkWinSetWindowPos(hwnd, siblingHwnd, pos) + HWND hwnd; /* Window to restack. */ + HWND siblingHwnd; /* Sibling window. */ + int pos; /* One of Above or Below. */ +{ + HWND temp; + + /* + * Since Windows does not support Above mode, we place the + * specified window below the sibling and then swap them. + */ + + if (siblingHwnd) { + if (pos == Above) { + SetWindowPos(hwnd, siblingHwnd, 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); + temp = hwnd; + hwnd = siblingHwnd; + siblingHwnd = temp; + } + } else { + siblingHwnd = (pos == Above) ? HWND_TOP : HWND_BOTTOM; + } + + SetWindowPos(hwnd, siblingHwnd, 0, 0, 0, 0, + SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE); +} + +/* + *---------------------------------------------------------------------- + * + * TkpWindowWasRecentlyDeleted -- + * + * Determines whether we know if the window given as argument was + * recently deleted. Called by the generic code error handler to + * handle BadWindow events. + * + * Results: + * Always 0. We do not keep this information on Windows. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +TkpWindowWasRecentlyDeleted(win, dispPtr) + Window win; + TkDisplay *dispPtr; +{ + return 0; +} diff --git a/win/tkWinWm.c b/win/tkWinWm.c new file mode 100644 index 0000000..6ec1a2a --- /dev/null +++ b/win/tkWinWm.c @@ -0,0 +1,4115 @@ +/* + * tkWinWm.c -- + * + * This module takes care of the interactions between a Tk-based + * application and the window manager. Among other things, it + * implements the "wm" command and passes geometry information + * to the window manager. + * + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinWm.c 1.67 97/09/23 17:39:47 + */ + +#include "tkWinInt.h" + +/* + * A data structure of the following type holds information for + * each window manager protocol (such as WM_DELETE_WINDOW) for + * which a handler (i.e. a Tcl command) has been defined for a + * particular top-level window. + */ + +typedef struct ProtocolHandler { + Atom protocol; /* Identifies the protocol. */ + struct ProtocolHandler *nextPtr; + /* Next in list of protocol handlers for + * the same top-level window, or NULL for + * end of list. */ + Tcl_Interp *interp; /* Interpreter in which to invoke command. */ + char command[4]; /* Tcl command to invoke when a client + * message for this protocol arrives. + * The actual size of the structure varies + * to accommodate the needs of the actual + * command. THIS MUST BE THE LAST FIELD OF + * THE STRUCTURE. */ +} ProtocolHandler; + +#define HANDLER_SIZE(cmdLength) \ + ((unsigned) (sizeof(ProtocolHandler) - 3 + cmdLength)) + +/* + * A data structure of the following type holds window-manager-related + * information for each top-level window in an application. + */ + +typedef struct TkWmInfo { + TkWindow *winPtr; /* Pointer to main Tk information for + * this window. */ + HWND wrapper; /* This is the decorative frame window + * created by the window manager to wrap + * a toplevel window. This window is + * a direct child of the root window. */ + Tk_Uid titleUid; /* Title to display in window caption. If + * NULL, use name of widget. */ + Tk_Uid iconName; /* Name to display in icon. */ + TkWindow *masterPtr; /* Master window for TRANSIENT_FOR property, + * or NULL. */ + XWMHints hints; /* Various pieces of information for + * window manager. */ + char *leaderName; /* Path name of leader of window group + * (corresponds to hints.window_group). + * Malloc-ed. Note: this field doesn't + * get updated if leader is destroyed. */ + Tk_Window icon; /* Window to use as icon for this window, + * or NULL. */ + Tk_Window iconFor; /* Window for which this window is icon, or + * NULL if this isn't an icon for anyone. */ + + /* + * Information used to construct an XSizeHints structure for + * the window manager: + */ + + int defMinWidth, defMinHeight, defMaxWidth, defMaxHeight; + /* Default resize limits given by system. */ + int sizeHintsFlags; /* Flags word for XSizeHints structure. + * If the PBaseSize flag is set then the + * window is gridded; otherwise it isn't + * gridded. */ + int minWidth, minHeight; /* Minimum dimensions of window, in + * grid units, not pixels. */ + int maxWidth, maxHeight; /* Maximum dimensions of window, in + * grid units, not pixels, or 0 to default. */ + Tk_Window gridWin; /* Identifies the window that controls + * gridding for this top-level, or NULL if + * the top-level isn't currently gridded. */ + int widthInc, heightInc; /* Increments for size changes (# pixels + * per step). */ + struct { + int x; /* numerator */ + int y; /* denominator */ + } minAspect, maxAspect; /* Min/max aspect ratios for window. */ + int reqGridWidth, reqGridHeight; + /* The dimensions of the window (in + * grid units) requested through + * the geometry manager. */ + int gravity; /* Desired window gravity. */ + + /* + * Information used to manage the size and location of a window. + */ + + int width, height; /* Desired dimensions of window, specified + * in grid units. These values are + * set by the "wm geometry" command and by + * ConfigureNotify events (for when wm + * resizes window). -1 means user hasn't + * requested dimensions. */ + int x, y; /* Desired X and Y coordinates for window. + * These values are set by "wm geometry", + * plus by ConfigureNotify events (when wm + * moves window). These numbers are + * different than the numbers stored in + * winPtr->changes because (a) they could be + * measured from the right or bottom edge + * of the screen (see WM_NEGATIVE_X and + * WM_NEGATIVE_Y flags) and (b) if the window + * has been reparented then they refer to the + * parent rather than the window itself. */ + int borderWidth, borderHeight; + /* Width and height of window dressing, in + * pixels for the current style/exStyle. This + * includes the border on both sides of the + * window. */ + int configWidth, configHeight; + /* Dimensions passed to last request that we + * issued to change geometry of window. Used + * to eliminate redundant resize operations. */ + HMENU hMenu; /* the hMenu associated with this menu */ + DWORD style, exStyle; /* Style flags for the wrapper window. */ + + /* + * List of children of the toplevel which have private colormaps. + */ + + TkWindow **cmapList; /* Array of window with private colormaps. */ + int cmapCount; /* Number of windows in array. */ + + /* + * Miscellaneous information. + */ + + ProtocolHandler *protPtr; /* First in list of protocol handlers for + * this window (NULL means none). */ + int cmdArgc; /* Number of elements in cmdArgv below. */ + char **cmdArgv; /* Array of strings to store in the + * WM_COMMAND property. NULL means nothing + * available. */ + char *clientMachine; /* String to store in WM_CLIENT_MACHINE + * property, or NULL. */ + int flags; /* Miscellaneous flags, defined below. */ + struct TkWmInfo *nextPtr; /* Next in list of all top-level windows. */ +} WmInfo; + +/* + * Flag values for WmInfo structures: + * + * WM_NEVER_MAPPED - non-zero means window has never been + * mapped; need to update all info when + * window is first mapped. + * WM_UPDATE_PENDING - non-zero means a call to UpdateGeometryInfo + * has already been scheduled for this + * window; no need to schedule another one. + * WM_NEGATIVE_X - non-zero means x-coordinate is measured in + * pixels from right edge of screen, rather + * than from left edge. + * WM_NEGATIVE_Y - non-zero means y-coordinate is measured in + * pixels up from bottom of screen, rather than + * down from top. + * WM_UPDATE_SIZE_HINTS - non-zero means that new size hints need to be + * propagated to window manager. + * WM_SYNC_PENDING - set to non-zero while waiting for the window + * manager to respond to some state change. + * WM_MOVE_PENDING - non-zero means the application has requested + * a new position for the window, but it hasn't + * been reflected through the window manager + * yet. + * WM_COLORAMPS_EXPLICIT - non-zero means the colormap windows were + * set explicitly via "wm colormapwindows". + * WM_ADDED_TOPLEVEL_COLORMAP - non-zero means that when "wm colormapwindows" + * was called the top-level itself wasn't + * specified, so we added it implicitly at + * the end of the list. + */ + +#define WM_NEVER_MAPPED (1<<0) +#define WM_UPDATE_PENDING (1<<1) +#define WM_NEGATIVE_X (1<<2) +#define WM_NEGATIVE_Y (1<<3) +#define WM_UPDATE_SIZE_HINTS (1<<4) +#define WM_SYNC_PENDING (1<<5) +#define WM_CREATE_PENDING (1<<6) +#define WM_MOVE_PENDING (1<<7) +#define WM_COLORMAPS_EXPLICIT (1<<8) +#define WM_ADDED_TOPLEVEL_COLORMAP (1<<9) +#define WM_WIDTH_NOT_RESIZABLE (1<<10) +#define WM_HEIGHT_NOT_RESIZABLE (1<<11) + +/* + * Window styles for various types of toplevel windows. + */ + +#define WM_OVERRIDE_STYLE (WS_POPUP|WS_CLIPCHILDREN|CS_DBLCLKS) +#define EX_OVERRIDE_STYLE (WS_EX_TOOLWINDOW) + +#define WM_TOPLEVEL_STYLE (WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN|CS_DBLCLKS) +#define EX_TOPLEVEL_STYLE (0) + +#define WM_TRANSIENT_STYLE \ + (WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_CLIPSIBLINGS|CS_DBLCLKS) +#define EX_TRANSIENT_STYLE (WS_EX_TOOLWINDOW | WS_EX_DLGMODALFRAME) + +/* + * This module keeps a list of all top-level windows. + */ + +static WmInfo *firstWmPtr = NULL; /* Points to first top-level window. */ +static WmInfo *foregroundWmPtr = NULL; /* Points to the foreground window. */ + +/* + * The variable below is used to enable or disable tracing in this + * module. If tracing is enabled, then information is printed on + * standard output about interesting interactions with the window + * manager. + */ + +static int wmTracing = 0; + +/* + * The following structure is the official type record for geometry + * management of top-level windows. + */ + +static void TopLevelReqProc(ClientData dummy, Tk_Window tkwin); + +static Tk_GeomMgr wmMgrType = { + "wm", /* name */ + TopLevelReqProc, /* requestProc */ + (Tk_GeomLostSlaveProc *) NULL, /* lostSlaveProc */ +}; + +/* + * Global system palette. This value always refers to the currently + * installed foreground logical palette. + */ + +static HPALETTE systemPalette = NULL; + +/* + * Window that is being constructed. This value is set immediately + * before a call to CreateWindowEx, and is used by SetLimits. + * This is a gross hack needed to work around Windows brain damage + * where it sends the WM_GETMINMAXINFO message before the WM_CREATE + * window. + */ + +static TkWindow *createWindow = NULL; + +/* + * Flag indicating whether this module has been initialized yet. + */ + +static int initialized = 0; + +/* + * Class for toplevel windows. + */ + +static WNDCLASS toplevelClass; + +/* + * This flag is cleared when the first window is mapped in a non-iconic + * state. + */ + +static int firstWindow = 1; + +/* + * Forward declarations for procedures defined in this file: + */ + +static void ConfigureEvent _ANSI_ARGS_((TkWindow *winPtr, + XConfigureEvent *eventPtr)); +static void ConfigureTopLevel _ANSI_ARGS_((WINDOWPOS *pos)); +static void GenerateConfigureNotify _ANSI_ARGS_(( + TkWindow *winPtr)); +static void GetMaxSize _ANSI_ARGS_((WmInfo *wmPtr, + int *maxWidthPtr, int *maxHeightPtr)); +static void GetMinSize _ANSI_ARGS_((WmInfo *wmPtr, + int *minWidthPtr, int *minHeightPtr)); +static TkWindow * GetTopLevel _ANSI_ARGS_((HWND hwnd)); +static void InitWm _ANSI_ARGS_((void)); +static int InstallColormaps _ANSI_ARGS_((HWND hwnd, int message, + int isForemost)); +static void InvalidateSubTree _ANSI_ARGS_((TkWindow *winPtr, + Colormap colormap)); +static int ParseGeometry _ANSI_ARGS_((Tcl_Interp *interp, + char *string, TkWindow *winPtr)); +static void RefreshColormap _ANSI_ARGS_((Colormap colormap)); +static void SetLimits _ANSI_ARGS_((HWND hwnd, MINMAXINFO *info)); +static LRESULT CALLBACK TopLevelProc _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); +static void TopLevelEventProc _ANSI_ARGS_((ClientData clientData, + XEvent *eventPtr)); +static void TopLevelReqProc _ANSI_ARGS_((ClientData dummy, + Tk_Window tkwin)); +static void UpdateGeometryInfo _ANSI_ARGS_(( + ClientData clientData)); +static void UpdateWrapper _ANSI_ARGS_((TkWindow *winPtr)); +static LRESULT CALLBACK WmProc _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); + +/* + *---------------------------------------------------------------------- + * + * InitWm -- + * + * This routine creates the Wm toplevel decorative frame class. + * + * Results: + * None. + * + * Side effects: + * Registers a new window class. + * + *---------------------------------------------------------------------- + */ + +static void +InitWm(void) +{ + if (initialized) { + return; + } + initialized = 1; + + toplevelClass.style = CS_HREDRAW | CS_VREDRAW | CS_CLASSDC; + toplevelClass.cbClsExtra = 0; + toplevelClass.cbWndExtra = 0; + toplevelClass.hInstance = Tk_GetHINSTANCE(); + toplevelClass.hbrBackground = NULL; + toplevelClass.lpszMenuName = NULL; + toplevelClass.lpszClassName = TK_WIN_TOPLEVEL_CLASS_NAME; + toplevelClass.lpfnWndProc = WmProc; + toplevelClass.hIcon = LoadIcon(Tk_GetHINSTANCE(), "tk"); + toplevelClass.hCursor = LoadCursor(NULL, IDC_ARROW); + + if (!RegisterClass(&toplevelClass)) { + panic("Unable to register TkTopLevel class"); + } +} + +/* + *---------------------------------------------------------------------- + * + * GetTopLevel -- + * + * This function retrieves the TkWindow associated with the + * given HWND. + * + * Results: + * Returns the matching TkWindow. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static TkWindow * +GetTopLevel(hwnd) + HWND hwnd; +{ + /* + * If this function is called before the CreateWindowEx call + * has completed, then the user data slot will not have been + * set yet, so we use the global createWindow variable. + */ + + if (createWindow) { + return createWindow; + } + return (TkWindow *) GetWindowLong(hwnd, GWL_USERDATA); +} + +/* + *---------------------------------------------------------------------- + * + * SetLimits -- + * + * Updates the minimum and maximum window size constraints. + * + * Results: + * None. + * + * Side effects: + * Changes the values of the info pointer to reflect the current + * minimum and maximum size values. + * + *---------------------------------------------------------------------- + */ + +static void +SetLimits(hwnd, info) + HWND hwnd; + MINMAXINFO *info; +{ + register WmInfo *wmPtr; + int maxWidth, maxHeight; + int minWidth, minHeight; + int base; + TkWindow *winPtr = GetTopLevel(hwnd); + + if (winPtr == NULL) { + return; + } + + wmPtr = winPtr->wmInfoPtr; + + /* + * Copy latest constraint info. + */ + + wmPtr->defMinWidth = info->ptMinTrackSize.x; + wmPtr->defMinHeight = info->ptMinTrackSize.y; + wmPtr->defMaxWidth = info->ptMaxTrackSize.x; + wmPtr->defMaxHeight = info->ptMaxTrackSize.y; + + GetMaxSize(wmPtr, &maxWidth, &maxHeight); + GetMinSize(wmPtr, &minWidth, &minHeight); + + if (wmPtr->gridWin != NULL) { + base = winPtr->reqWidth - (wmPtr->reqGridWidth * wmPtr->widthInc); + if (base < 0) { + base = 0; + } + base += wmPtr->borderWidth; + info->ptMinTrackSize.x = base + (minWidth * wmPtr->widthInc); + info->ptMaxTrackSize.x = base + (maxWidth * wmPtr->widthInc); + + base = winPtr->reqHeight - (wmPtr->reqGridHeight * wmPtr->heightInc); + if (base < 0) { + base = 0; + } + base += wmPtr->borderHeight; + info->ptMinTrackSize.y = base + (minHeight * wmPtr->heightInc); + info->ptMaxTrackSize.y = base + (maxHeight * wmPtr->heightInc); + } else { + info->ptMaxTrackSize.x = maxWidth + wmPtr->borderWidth; + info->ptMaxTrackSize.y = maxHeight + wmPtr->borderHeight; + info->ptMinTrackSize.x = minWidth + wmPtr->borderWidth; + info->ptMinTrackSize.y = minHeight + wmPtr->borderHeight; + } + + /* + * If the window isn't supposed to be resizable, then set the + * minimum and maximum dimensions to be the same as the current size. + */ + + if (!(wmPtr->flags & WM_SYNC_PENDING)) { + if (wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) { + info->ptMinTrackSize.x = winPtr->changes.width + + wmPtr->borderWidth; + info->ptMaxTrackSize.x = info->ptMinTrackSize.x; + } + if (wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE) { + info->ptMinTrackSize.y = winPtr->changes.height + + wmPtr->borderHeight; + info->ptMaxTrackSize.y = info->ptMinTrackSize.y; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinWmCleanup -- + * + * Unregisters classes registered by the window manager. This is + * called from the DLL main entry point when the DLL is unloaded. + * + * Results: + * None. + * + * Side effects: + * The window classes are discarded. + * + *---------------------------------------------------------------------- + */ + +void +TkWinWmCleanup(hInstance) + HINSTANCE hInstance; +{ + if (!initialized) { + return; + } + initialized = 0; + + UnregisterClass(TK_WIN_TOPLEVEL_CLASS_NAME, hInstance); +} + +/* + *-------------------------------------------------------------- + * + * TkWmNewWindow -- + * + * This procedure is invoked whenever a new top-level + * window is created. Its job is to initialize the WmInfo + * structure for the window. + * + * Results: + * None. + * + * Side effects: + * A WmInfo structure gets allocated and initialized. + * + *-------------------------------------------------------------- + */ + +void +TkWmNewWindow(winPtr) + TkWindow *winPtr; /* Newly-created top-level window. */ +{ + register WmInfo *wmPtr; + + wmPtr = (WmInfo *) ckalloc(sizeof(WmInfo)); + winPtr->wmInfoPtr = wmPtr; + wmPtr->winPtr = winPtr; + wmPtr->wrapper = NULL; + wmPtr->titleUid = NULL; + wmPtr->iconName = NULL; + wmPtr->masterPtr = NULL; + wmPtr->hints.flags = InputHint | StateHint; + wmPtr->hints.input = True; + wmPtr->hints.initial_state = NormalState; + wmPtr->hints.icon_pixmap = None; + wmPtr->hints.icon_window = None; + wmPtr->hints.icon_x = wmPtr->hints.icon_y = 0; + wmPtr->hints.icon_mask = None; + wmPtr->hints.window_group = None; + wmPtr->leaderName = NULL; + wmPtr->icon = NULL; + wmPtr->iconFor = NULL; + wmPtr->sizeHintsFlags = 0; + + /* + * Default the maximum dimensions to the size of the display. + */ + + wmPtr->defMinWidth = wmPtr->defMinHeight = 0; + wmPtr->defMaxWidth = DisplayWidth(winPtr->display, + winPtr->screenNum); + wmPtr->defMaxHeight = DisplayHeight(winPtr->display, + winPtr->screenNum); + wmPtr->minWidth = wmPtr->minHeight = 1; + wmPtr->maxWidth = wmPtr->maxHeight = 0; + wmPtr->gridWin = NULL; + wmPtr->widthInc = wmPtr->heightInc = 1; + wmPtr->minAspect.x = wmPtr->minAspect.y = 1; + wmPtr->maxAspect.x = wmPtr->maxAspect.y = 1; + wmPtr->reqGridWidth = wmPtr->reqGridHeight = -1; + wmPtr->gravity = NorthWestGravity; + wmPtr->width = -1; + wmPtr->height = -1; + wmPtr->hMenu = NULL; + wmPtr->x = winPtr->changes.x; + wmPtr->y = winPtr->changes.y; + wmPtr->borderWidth = 0; + wmPtr->borderHeight = 0; + + wmPtr->cmapList = NULL; + wmPtr->cmapCount = 0; + + wmPtr->configWidth = -1; + wmPtr->configHeight = -1; + wmPtr->protPtr = NULL; + wmPtr->cmdArgv = NULL; + wmPtr->clientMachine = NULL; + wmPtr->flags = WM_NEVER_MAPPED; + wmPtr->nextPtr = firstWmPtr; + firstWmPtr = wmPtr; + + /* + * Tk must monitor structure events for top-level windows, in order + * to detect size and position changes caused by window managers. + */ + + Tk_CreateEventHandler((Tk_Window) winPtr, StructureNotifyMask, + TopLevelEventProc, (ClientData) winPtr); + + /* + * Arrange for geometry requests to be reflected from the window + * to the window manager. + */ + + Tk_ManageGeometry((Tk_Window) winPtr, &wmMgrType, (ClientData) 0); +} + +/* + *---------------------------------------------------------------------- + * + * UpdateWrapper -- + * + * This function creates the wrapper window that contains the + * window decorations and menus for a toplevel. This function + * may be called after a window is mapped to change the window + * style. + * + * Results: + * None. + * + * Side effects: + * Destroys any old wrapper window and replaces it with a newly + * created wrapper. + * + *---------------------------------------------------------------------- + */ + +static void +UpdateWrapper(winPtr) + TkWindow *winPtr; /* Top-level window to redecorate. */ +{ + register WmInfo *wmPtr = winPtr->wmInfoPtr; + HWND parentHWND = NULL, oldWrapper; + HWND child = TkWinGetHWND(winPtr->window); + int x, y, width, height, state; + WINDOWPLACEMENT place; + + parentHWND = NULL; + child = TkWinGetHWND(winPtr->window); + + if (winPtr->flags & TK_EMBEDDED) { + wmPtr->wrapper = (HWND) winPtr->privatePtr; + if (wmPtr->wrapper == NULL) { + panic("TkWmMapWindow: Cannot find container window"); + } + if (!IsWindow(wmPtr->wrapper)) { + panic("TkWmMapWindow: Container was destroyed"); + } + + } else { + /* + * Pick the decorative frame style. Override redirect windows get + * created as undecorated popups. Transient windows get a modal + * dialog frame. Neither override, nor transient windows appear in + * the Win95 taskbar. Note that a transient window does not resize + * by default, so we need to explicitly add the WS_THICKFRAME style + * if we want it to be resizeable. + */ + + if (winPtr->atts.override_redirect) { + wmPtr->style = WM_OVERRIDE_STYLE; + wmPtr->exStyle = EX_OVERRIDE_STYLE; + } else if (wmPtr->masterPtr) { + wmPtr->style = WM_TRANSIENT_STYLE; + wmPtr->exStyle = EX_TRANSIENT_STYLE; + parentHWND = Tk_GetHWND(Tk_WindowId(wmPtr->masterPtr)); + if (! ((wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) && + (wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE))) { + wmPtr->style |= WS_THICKFRAME; + } + } else { + wmPtr->style = WM_TOPLEVEL_STYLE; + wmPtr->exStyle = EX_TOPLEVEL_STYLE; + } + + /* + * Compute the geometry of the parent and child windows. + */ + + wmPtr->flags |= WM_CREATE_PENDING|WM_MOVE_PENDING; + UpdateGeometryInfo((ClientData)winPtr); + wmPtr->flags &= ~(WM_CREATE_PENDING|WM_MOVE_PENDING); + + width = wmPtr->borderWidth + winPtr->changes.width; + height = wmPtr->borderHeight + winPtr->changes.height; + + /* + * Set the initial position from the user or program specified + * location. If nothing has been specified, then let the system + * pick a location. + */ + + + if (!(wmPtr->sizeHintsFlags & (USPosition | PPosition)) + && (wmPtr->flags & WM_NEVER_MAPPED)) { + x = CW_USEDEFAULT; + y = CW_USEDEFAULT; + } else { + x = winPtr->changes.x; + y = winPtr->changes.y; + } + + /* + * Create the containing window, and set the user data to point + * to the TkWindow. + */ + + createWindow = winPtr; + wmPtr->wrapper = CreateWindowEx(wmPtr->exStyle, + TK_WIN_TOPLEVEL_CLASS_NAME, + wmPtr->titleUid, wmPtr->style, x, y, width, height, + parentHWND, NULL, Tk_GetHINSTANCE(), NULL); + SetWindowLong(wmPtr->wrapper, GWL_USERDATA, (LONG) winPtr); + createWindow = NULL; + + place.length = sizeof(WINDOWPLACEMENT); + GetWindowPlacement(wmPtr->wrapper, &place); + wmPtr->x = place.rcNormalPosition.left; + wmPtr->y = place.rcNormalPosition.top; + + TkInstallFrameMenu((Tk_Window) winPtr); + } + + /* + * Now we need to reparent the contained window and set its + * style appropriately. Be sure to update the style first so that + * Windows doesn't try to set the focus to the child window. + */ + + SetWindowLong(child, GWL_STYLE, + WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS); + if (winPtr->flags & TK_EMBEDDED) { + SetWindowLong(child, GWL_WNDPROC, (LONG) TopLevelProc); + } + oldWrapper = SetParent(child, wmPtr->wrapper); + if (oldWrapper && (oldWrapper != wmPtr->wrapper) + && (oldWrapper != GetDesktopWindow())) { + SetWindowLong(oldWrapper, GWL_USERDATA, (LONG) NULL); + DestroyWindow(oldWrapper); + } + wmPtr->flags &= ~WM_NEVER_MAPPED; + SendMessage(wmPtr->wrapper, TK_ATTACHWINDOW, (WPARAM) child, 0); + + /* + * Force an initial transition from withdrawn to the real + * initial state. + */ + + state = wmPtr->hints.initial_state; + wmPtr->hints.initial_state = WithdrawnState; + TkpWmSetState(winPtr, state); + + /* + * If we are embedded then force a mapping of the window now, + * because we do not necessarily own the wrapper and may not + * get another opportunity to map ourselves. We should not be + * in either iconified or zoomed states when we get here, so + * it is safe to just check for TK_EMBEDDED without checking + * what state we are supposed to be in (default to NormalState). + */ + + if (winPtr->flags & TK_EMBEDDED) { + XMapWindow(winPtr->display, winPtr->window); + } + + /* + * Set up menus on the wrapper if required. + */ + + if (wmPtr->hMenu != NULL) { + wmPtr->flags = WM_SYNC_PENDING; + SetMenu(wmPtr->wrapper, wmPtr->hMenu); + wmPtr->flags &= ~WM_SYNC_PENDING; + } + + /* + * If this is the first window created by the application, then + * we should activate the initial window. + */ + + if (firstWindow) { + firstWindow = 0; + SetActiveWindow(wmPtr->wrapper); + } +} + +/* + *-------------------------------------------------------------- + * + * TkWmMapWindow -- + * + * This procedure is invoked to map a top-level window. This + * module gets a chance to update all window-manager-related + * information in properties before the window manager sees + * the map event and checks the properties. It also gets to + * decide whether or not to even map the window after all. + * + * Results: + * None. + * + * Side effects: + * Properties of winPtr may get updated to provide up-to-date + * information to the window manager. The window may also get + * mapped, but it may not be if this procedure decides that + * isn't appropriate (e.g. because the window is withdrawn). + * + *-------------------------------------------------------------- + */ + +void +TkWmMapWindow(winPtr) + TkWindow *winPtr; /* Top-level window that's about to + * be mapped. */ +{ + register WmInfo *wmPtr = winPtr->wmInfoPtr; + + if (!initialized) { + InitWm(); + } + + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + if (wmPtr->hints.initial_state == WithdrawnState) { + return; + } + + /* + * Map the window in either the iconified or normal state. Note that + * we only send a map event if the window is in the normal state. + */ + + TkpWmSetState(winPtr, wmPtr->hints.initial_state); + } + + /* + * This is the first time this window has ever been mapped. + * Store all the window-manager-related information for the + * window. + */ + + if (wmPtr->titleUid == NULL) { + wmPtr->titleUid = winPtr->nameUid; + } + UpdateWrapper(winPtr); +} + +/* + *-------------------------------------------------------------- + * + * TkWmUnmapWindow -- + * + * This procedure is invoked to unmap a top-level window. The + * only thing it does special is unmap the decorative frame before + * unmapping the toplevel window. + * + * Results: + * None. + * + * Side effects: + * Unmaps the decorative frame and the window. + * + *-------------------------------------------------------------- + */ + +void +TkWmUnmapWindow(winPtr) + TkWindow *winPtr; /* Top-level window that's about to + * be unmapped. */ +{ + TkpWmSetState(winPtr, WithdrawnState); +} + +/* + *---------------------------------------------------------------------- + * + * TkpWmSetState -- + * + * Sets the window manager state for the wrapper window of a + * given toplevel window. + * + * Results: + * None. + * + * Side effects: + * May maximize, minimize, restore, or withdraw a window. + * + *---------------------------------------------------------------------- + */ + +void +TkpWmSetState(winPtr, state) + TkWindow *winPtr; /* Toplevel window to operate on. */ + int state; /* One of IconicState, ZoomState, NormalState, + * or WithdrawnState. */ +{ + WmInfo *wmPtr = winPtr->wmInfoPtr; + int cmd; + + if (wmPtr->flags & WM_NEVER_MAPPED) { + wmPtr->hints.initial_state = state; + return; + } + + wmPtr->flags |= WM_SYNC_PENDING; + if (state == WithdrawnState) { + cmd = SW_HIDE; + } else if (state == IconicState) { + cmd = SW_SHOWMINNOACTIVE; + } else if (state == NormalState) { + cmd = SW_SHOWNOACTIVATE; + } else if (state == ZoomState) { + cmd = SW_SHOWMAXIMIZED; + } + ShowWindow(wmPtr->wrapper, cmd); + wmPtr->flags &= ~WM_SYNC_PENDING; +} + +/* + *-------------------------------------------------------------- + * + * TkWmDeadWindow -- + * + * This procedure is invoked when a top-level window is + * about to be deleted. It cleans up the wm-related data + * structures for the window. + * + * Results: + * None. + * + * Side effects: + * The WmInfo structure for winPtr gets freed up. + * + *-------------------------------------------------------------- + */ + +void +TkWmDeadWindow(winPtr) + TkWindow *winPtr; /* Top-level window that's being deleted. */ +{ + register WmInfo *wmPtr = winPtr->wmInfoPtr; + WmInfo *wmPtr2; + + if (wmPtr == NULL) { + return; + } + + /* + * Clean up event related window info. + */ + + if (firstWmPtr == wmPtr) { + firstWmPtr = wmPtr->nextPtr; + } else { + register WmInfo *prevPtr; + for (prevPtr = firstWmPtr; ; prevPtr = prevPtr->nextPtr) { + if (prevPtr == NULL) { + panic("couldn't unlink window in TkWmDeadWindow"); + } + if (prevPtr->nextPtr == wmPtr) { + prevPtr->nextPtr = wmPtr->nextPtr; + break; + } + } + } + + /* + * Reset all transient windows whose master is the dead window. + */ + + for (wmPtr2 = firstWmPtr; wmPtr2 != NULL; wmPtr2 = wmPtr2->nextPtr) { + if (wmPtr2->masterPtr == winPtr) { + wmPtr2->masterPtr = NULL; + if ((wmPtr2->wrapper != None) + && !(wmPtr2->flags & (WM_NEVER_MAPPED))) { + UpdateWrapper(wmPtr2->winPtr); + } + } + } + + if (wmPtr->hints.flags & IconPixmapHint) { + Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_pixmap); + } + if (wmPtr->hints.flags & IconMaskHint) { + Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_mask); + } + if (wmPtr->leaderName != NULL) { + ckfree(wmPtr->leaderName); + } + if (wmPtr->icon != NULL) { + wmPtr2 = ((TkWindow *) wmPtr->icon)->wmInfoPtr; + wmPtr2->iconFor = NULL; + } + if (wmPtr->iconFor != NULL) { + wmPtr2 = ((TkWindow *) wmPtr->iconFor)->wmInfoPtr; + wmPtr2->icon = NULL; + wmPtr2->hints.flags &= ~IconWindowHint; + } + while (wmPtr->protPtr != NULL) { + ProtocolHandler *protPtr; + + protPtr = wmPtr->protPtr; + wmPtr->protPtr = protPtr->nextPtr; + Tcl_EventuallyFree((ClientData) protPtr, TCL_DYNAMIC); + } + if (wmPtr->cmdArgv != NULL) { + ckfree((char *) wmPtr->cmdArgv); + } + if (wmPtr->clientMachine != NULL) { + ckfree((char *) wmPtr->clientMachine); + } + if (wmPtr->flags & WM_UPDATE_PENDING) { + Tcl_CancelIdleCall(UpdateGeometryInfo, (ClientData) winPtr); + } + + /* + * Destroy the decorative frame window. + */ + + if (!(winPtr->flags & TK_EMBEDDED)) { + if (wmPtr->wrapper != NULL) { + DestroyWindow(wmPtr->wrapper); + } else { + DestroyWindow(Tk_GetHWND(winPtr->window)); + } + } + ckfree((char *) wmPtr); + winPtr->wmInfoPtr = NULL; +} + +/* + *-------------------------------------------------------------- + * + * TkWmSetClass -- + * + * This procedure is invoked whenever a top-level window's + * class is changed. If the window has been mapped then this + * procedure updates the window manager property for the + * class. If the window hasn't been mapped, the update is + * deferred until just before the first mapping. + * + * Results: + * None. + * + * Side effects: + * A window property may get updated. + * + *-------------------------------------------------------------- + */ + +void +TkWmSetClass(winPtr) + TkWindow *winPtr; /* Newly-created top-level window. */ +{ + return; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_WmCmd -- + * + * This procedure is invoked to process the "wm" Tcl command. + * See the user documentation for details on what it does. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * See the user documentation. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +int +Tk_WmCmd(clientData, interp, argc, argv) + ClientData clientData; /* Main window associated with + * interpreter. */ + Tcl_Interp *interp; /* Current interpreter. */ + int argc; /* Number of arguments. */ + char **argv; /* Argument strings. */ +{ + Tk_Window tkwin = (Tk_Window) clientData; + TkWindow *winPtr; + register WmInfo *wmPtr; + int c; + size_t length; + + if (argc < 2) { + wrongNumArgs: + Tcl_AppendResult(interp, "wrong # args: should be \"", + argv[0], " option window ?arg ...?\"", (char *) NULL); + return TCL_ERROR; + } + c = argv[1][0]; + length = strlen(argv[1]); + if ((c == 't') && (strncmp(argv[1], "tracing", length) == 0) + && (length >= 3)) { + if ((argc != 2) && (argc != 3)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " tracing ?boolean?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 2) { + interp->result = (wmTracing) ? "on" : "off"; + return TCL_OK; + } + return Tcl_GetBoolean(interp, argv[2], &wmTracing); + } + + if (argc < 3) { + goto wrongNumArgs; + } + winPtr = (TkWindow *) Tk_NameToWindow(interp, argv[2], tkwin); + if (winPtr == NULL) { + return TCL_ERROR; + } + if (!(winPtr->flags & TK_TOP_LEVEL)) { + Tcl_AppendResult(interp, "window \"", winPtr->pathName, + "\" isn't a top-level window", (char *) NULL); + return TCL_ERROR; + } + wmPtr = winPtr->wmInfoPtr; + if ((c == 'a') && (strncmp(argv[1], "aspect", length) == 0)) { + int numer1, denom1, numer2, denom2; + + if ((argc != 3) && (argc != 7)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " aspect window ?minNumer minDenom ", + "maxNumer maxDenom?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->sizeHintsFlags & PAspect) { + sprintf(interp->result, "%d %d %d %d", wmPtr->minAspect.x, + wmPtr->minAspect.y, wmPtr->maxAspect.x, + wmPtr->maxAspect.y); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->sizeHintsFlags &= ~PAspect; + } else { + if ((Tcl_GetInt(interp, argv[3], &numer1) != TCL_OK) + || (Tcl_GetInt(interp, argv[4], &denom1) != TCL_OK) + || (Tcl_GetInt(interp, argv[5], &numer2) != TCL_OK) + || (Tcl_GetInt(interp, argv[6], &denom2) != TCL_OK)) { + return TCL_ERROR; + } + if ((numer1 <= 0) || (denom1 <= 0) || (numer2 <= 0) || + (denom2 <= 0)) { + interp->result = "aspect number can't be <= 0"; + return TCL_ERROR; + } + wmPtr->minAspect.x = numer1; + wmPtr->minAspect.y = denom1; + wmPtr->maxAspect.x = numer2; + wmPtr->maxAspect.y = denom2; + wmPtr->sizeHintsFlags |= PAspect; + } + goto updateGeom; + } else if ((c == 'c') && (strncmp(argv[1], "client", length) == 0) + && (length >= 2)) { + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " client window ?name?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->clientMachine != NULL) { + interp->result = wmPtr->clientMachine; + } + return TCL_OK; + } + if (argv[3][0] == 0) { + if (wmPtr->clientMachine != NULL) { + ckfree((char *) wmPtr->clientMachine); + wmPtr->clientMachine = NULL; + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + XDeleteProperty(winPtr->display, winPtr->window, + Tk_InternAtom((Tk_Window) winPtr, + "WM_CLIENT_MACHINE")); + } + } + return TCL_OK; + } + if (wmPtr->clientMachine != NULL) { + ckfree((char *) wmPtr->clientMachine); + } + wmPtr->clientMachine = (char *) + ckalloc((unsigned) (strlen(argv[3]) + 1)); + strcpy(wmPtr->clientMachine, argv[3]); + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + XTextProperty textProp; + if (XStringListToTextProperty(&wmPtr->clientMachine, 1, &textProp) + != 0) { + XSetWMClientMachine(winPtr->display, winPtr->window, + &textProp); + XFree((char *) textProp.value); + } + } + } else if ((c == 'c') && (strncmp(argv[1], "colormapwindows", length) == 0) + && (length >= 3)) { + TkWindow **cmapList; + TkWindow *winPtr2; + int i, windowArgc, gotToplevel; + char **windowArgv; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " colormapwindows window ?windowList?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + Tk_MakeWindowExist((Tk_Window) winPtr); + for (i = 0; i < wmPtr->cmapCount; i++) { + if ((i == (wmPtr->cmapCount-1)) + && (wmPtr->flags & WM_ADDED_TOPLEVEL_COLORMAP)) { + break; + } + Tcl_AppendElement(interp, wmPtr->cmapList[i]->pathName); + } + return TCL_OK; + } + if (Tcl_SplitList(interp, argv[3], &windowArgc, &windowArgv) + != TCL_OK) { + return TCL_ERROR; + } + cmapList = (TkWindow **) ckalloc((unsigned) + ((windowArgc+1)*sizeof(TkWindow*))); + for (i = 0; i < windowArgc; i++) { + winPtr2 = (TkWindow *) Tk_NameToWindow(interp, windowArgv[i], + tkwin); + if (winPtr2 == NULL) { + ckfree((char *) cmapList); + ckfree((char *) windowArgv); + return TCL_ERROR; + } + if (winPtr2 == winPtr) { + gotToplevel = 1; + } + if (winPtr2->window == None) { + Tk_MakeWindowExist((Tk_Window) winPtr2); + } + cmapList[i] = winPtr2; + } + if (!gotToplevel) { + wmPtr->flags |= WM_ADDED_TOPLEVEL_COLORMAP; + cmapList[windowArgc] = winPtr; + windowArgc++; + } else { + wmPtr->flags &= ~WM_ADDED_TOPLEVEL_COLORMAP; + } + wmPtr->flags |= WM_COLORMAPS_EXPLICIT; + if (wmPtr->cmapList != NULL) { + ckfree((char *)wmPtr->cmapList); + } + wmPtr->cmapList = cmapList; + wmPtr->cmapCount = windowArgc; + ckfree((char *) windowArgv); + + /* + * Now we need to force the updated colormaps to be installed. + */ + + if (wmPtr == foregroundWmPtr) { + InstallColormaps(wmPtr->wrapper, WM_QUERYNEWPALETTE, 1); + } else { + InstallColormaps(wmPtr->wrapper, WM_PALETTECHANGED, 0); + } + return TCL_OK; + } else if ((c == 'c') && (strncmp(argv[1], "command", length) == 0) + && (length >= 3)) { + int cmdArgc; + char **cmdArgv; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " command window ?value?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->cmdArgv != NULL) { + interp->result = Tcl_Merge(wmPtr->cmdArgc, wmPtr->cmdArgv); + interp->freeProc = TCL_DYNAMIC; + } + return TCL_OK; + } + if (argv[3][0] == 0) { + if (wmPtr->cmdArgv != NULL) { + ckfree((char *) wmPtr->cmdArgv); + wmPtr->cmdArgv = NULL; + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + XDeleteProperty(winPtr->display, winPtr->window, + Tk_InternAtom((Tk_Window) winPtr, "WM_COMMAND")); + } + } + return TCL_OK; + } + if (Tcl_SplitList(interp, argv[3], &cmdArgc, &cmdArgv) != TCL_OK) { + return TCL_ERROR; + } + if (wmPtr->cmdArgv != NULL) { + ckfree((char *) wmPtr->cmdArgv); + } + wmPtr->cmdArgc = cmdArgc; + wmPtr->cmdArgv = cmdArgv; + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + XSetCommand(winPtr->display, winPtr->window, cmdArgv, cmdArgc); + } + } else if ((c == 'd') && (strncmp(argv[1], "deiconify", length) == 0)) { + if (argc != 3) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " deiconify window\"", (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->iconFor != NULL) { + Tcl_AppendResult(interp, "can't deiconify ", argv[2], + ": it is an icon for ", winPtr->pathName, (char *) NULL); + return TCL_ERROR; + } + if (winPtr->flags & TK_EMBEDDED) { + Tcl_AppendResult(interp, "can't deiconify ", winPtr->pathName, + ": it is an embedded window", (char *) NULL); + return TCL_ERROR; + } + TkpWmSetState(winPtr, NormalState); + } else if ((c == 'f') && (strncmp(argv[1], "focusmodel", length) == 0) + && (length >= 2)) { + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " focusmodel window ?active|passive?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + interp->result = wmPtr->hints.input ? "passive" : "active"; + return TCL_OK; + } + c = argv[3][0]; + length = strlen(argv[3]); + if ((c == 'a') && (strncmp(argv[3], "active", length) == 0)) { + wmPtr->hints.input = False; + } else if ((c == 'p') && (strncmp(argv[3], "passive", length) == 0)) { + wmPtr->hints.input = True; + } else { + Tcl_AppendResult(interp, "bad argument \"", argv[3], + "\": must be active or passive", (char *) NULL); + return TCL_ERROR; + } + } else if ((c == 'f') && (strncmp(argv[1], "frame", length) == 0) + && (length >= 2)) { + HWND hwnd; + + if (argc != 3) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " frame window\"", (char *) NULL); + return TCL_ERROR; + } + hwnd = wmPtr->wrapper; + if (hwnd == NULL) { + hwnd = Tk_GetHWND(Tk_WindowId((Tk_Window) winPtr)); + } + sprintf(interp->result, "0x%x", (unsigned int) hwnd); + } else if ((c == 'g') && (strncmp(argv[1], "geometry", length) == 0) + && (length >= 2)) { + char xSign, ySign; + int width, height; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " geometry window ?newGeometry?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + xSign = (wmPtr->flags & WM_NEGATIVE_X) ? '-' : '+'; + ySign = (wmPtr->flags & WM_NEGATIVE_Y) ? '-' : '+'; + if (wmPtr->gridWin != NULL) { + width = wmPtr->reqGridWidth + (winPtr->changes.width + - winPtr->reqWidth)/wmPtr->widthInc; + height = wmPtr->reqGridHeight + (winPtr->changes.height + - winPtr->reqHeight)/wmPtr->heightInc; + } else { + width = winPtr->changes.width; + height = winPtr->changes.height; + } + sprintf(interp->result, "%dx%d%c%d%c%d", width, height, + xSign, wmPtr->x, ySign, wmPtr->y); + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->width = -1; + wmPtr->height = -1; + goto updateGeom; + } + return ParseGeometry(interp, argv[3], winPtr); + } else if ((c == 'g') && (strncmp(argv[1], "grid", length) == 0) + && (length >= 3)) { + int reqWidth, reqHeight, widthInc, heightInc; + + if ((argc != 3) && (argc != 7)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " grid window ?baseWidth baseHeight ", + "widthInc heightInc?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->sizeHintsFlags & PBaseSize) { + sprintf(interp->result, "%d %d %d %d", wmPtr->reqGridWidth, + wmPtr->reqGridHeight, wmPtr->widthInc, + wmPtr->heightInc); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + /* + * Turn off gridding and reset the width and height + * to make sense as ungridded numbers. + */ + + wmPtr->sizeHintsFlags &= ~(PBaseSize|PResizeInc); + if (wmPtr->width != -1) { + wmPtr->width = winPtr->reqWidth + (wmPtr->width + - wmPtr->reqGridWidth)*wmPtr->widthInc; + wmPtr->height = winPtr->reqHeight + (wmPtr->height + - wmPtr->reqGridHeight)*wmPtr->heightInc; + } + wmPtr->widthInc = 1; + wmPtr->heightInc = 1; + } else { + if ((Tcl_GetInt(interp, argv[3], &reqWidth) != TCL_OK) + || (Tcl_GetInt(interp, argv[4], &reqHeight) != TCL_OK) + || (Tcl_GetInt(interp, argv[5], &widthInc) != TCL_OK) + || (Tcl_GetInt(interp, argv[6], &heightInc) != TCL_OK)) { + return TCL_ERROR; + } + if (reqWidth < 0) { + interp->result = "baseWidth can't be < 0"; + return TCL_ERROR; + } + if (reqHeight < 0) { + interp->result = "baseHeight can't be < 0"; + return TCL_ERROR; + } + if (widthInc < 0) { + interp->result = "widthInc can't be < 0"; + return TCL_ERROR; + } + if (heightInc < 0) { + interp->result = "heightInc can't be < 0"; + return TCL_ERROR; + } + Tk_SetGrid((Tk_Window) winPtr, reqWidth, reqHeight, widthInc, + heightInc); + } + goto updateGeom; + } else if ((c == 'g') && (strncmp(argv[1], "group", length) == 0) + && (length >= 3)) { + Tk_Window tkwin2; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " group window ?pathName?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->hints.flags & WindowGroupHint) { + interp->result = wmPtr->leaderName; + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->hints.flags &= ~WindowGroupHint; + if (wmPtr->leaderName != NULL) { + ckfree(wmPtr->leaderName); + } + wmPtr->leaderName = NULL; + } else { + tkwin2 = Tk_NameToWindow(interp, argv[3], tkwin); + if (tkwin2 == NULL) { + return TCL_ERROR; + } + Tk_MakeWindowExist(tkwin2); + wmPtr->hints.window_group = Tk_WindowId(tkwin2); + wmPtr->hints.flags |= WindowGroupHint; + wmPtr->leaderName = ckalloc((unsigned) (strlen(argv[3])+1)); + strcpy(wmPtr->leaderName, argv[3]); + } + } else if ((c == 'i') && (strncmp(argv[1], "iconbitmap", length) == 0) + && (length >= 5)) { + Pixmap pixmap; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconbitmap window ?bitmap?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->hints.flags & IconPixmapHint) { + interp->result = Tk_NameOfBitmap(winPtr->display, + wmPtr->hints.icon_pixmap); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + if (wmPtr->hints.icon_pixmap != None) { + Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_pixmap); + } + wmPtr->hints.flags &= ~IconPixmapHint; + } else { + pixmap = Tk_GetBitmap(interp, (Tk_Window) winPtr, + Tk_GetUid(argv[3])); + if (pixmap == None) { + return TCL_ERROR; + } + wmPtr->hints.icon_pixmap = pixmap; + wmPtr->hints.flags |= IconPixmapHint; + } + } else if ((c == 'i') && (strncmp(argv[1], "iconify", length) == 0) + && (length >= 5)) { + if (argc != 3) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconify window\"", (char *) NULL); + return TCL_ERROR; + } + if (Tk_Attributes((Tk_Window) winPtr)->override_redirect) { + Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName, + "\": override-redirect flag is set", (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->masterPtr != NULL) { + Tcl_AppendResult(interp, "can't iconify \"", winPtr->pathName, + "\": it is a transient", (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->iconFor != NULL) { + Tcl_AppendResult(interp, "can't iconify ", argv[2], + ": it is an icon for ", winPtr->pathName, (char *) NULL); + return TCL_ERROR; + } + if (winPtr->flags & TK_EMBEDDED) { + Tcl_AppendResult(interp, "can't iconify ", winPtr->pathName, + ": it is an embedded window", (char *) NULL); + return TCL_ERROR; + } + TkpWmSetState(winPtr, IconicState); + } else if ((c == 'i') && (strncmp(argv[1], "iconmask", length) == 0) + && (length >= 5)) { + Pixmap pixmap; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconmask window ?bitmap?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->hints.flags & IconMaskHint) { + interp->result = Tk_NameOfBitmap(winPtr->display, + wmPtr->hints.icon_mask); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + if (wmPtr->hints.icon_mask != None) { + Tk_FreeBitmap(winPtr->display, wmPtr->hints.icon_mask); + } + wmPtr->hints.flags &= ~IconMaskHint; + } else { + pixmap = Tk_GetBitmap(interp, tkwin, Tk_GetUid(argv[3])); + if (pixmap == None) { + return TCL_ERROR; + } + wmPtr->hints.icon_mask = pixmap; + wmPtr->hints.flags |= IconMaskHint; + } + } else if ((c == 'i') && (strncmp(argv[1], "iconname", length) == 0) + && (length >= 5)) { + if (argc > 4) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconname window ?newName?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + interp->result = (wmPtr->iconName != NULL) ? wmPtr->iconName : ""; + return TCL_OK; + } else { + wmPtr->iconName = Tk_GetUid(argv[3]); + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + XSetIconName(winPtr->display, winPtr->window, wmPtr->iconName); + } + } + } else if ((c == 'i') && (strncmp(argv[1], "iconposition", length) == 0) + && (length >= 5)) { + int x, y; + + if ((argc != 3) && (argc != 5)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconposition window ?x y?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->hints.flags & IconPositionHint) { + sprintf(interp->result, "%d %d", wmPtr->hints.icon_x, + wmPtr->hints.icon_y); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->hints.flags &= ~IconPositionHint; + } else { + if ((Tcl_GetInt(interp, argv[3], &x) != TCL_OK) + || (Tcl_GetInt(interp, argv[4], &y) != TCL_OK)){ + return TCL_ERROR; + } + wmPtr->hints.icon_x = x; + wmPtr->hints.icon_y = y; + wmPtr->hints.flags |= IconPositionHint; + } + } else if ((c == 'i') && (strncmp(argv[1], "iconwindow", length) == 0) + && (length >= 5)) { + Tk_Window tkwin2; + WmInfo *wmPtr2; + XSetWindowAttributes atts; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " iconwindow window ?pathName?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->icon != NULL) { + interp->result = Tk_PathName(wmPtr->icon); + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->hints.flags &= ~IconWindowHint; + if (wmPtr->icon != NULL) { + /* + * Let the window use button events again, then remove + * it as icon window. + */ + + atts.event_mask = Tk_Attributes(wmPtr->icon)->event_mask + | ButtonPressMask; + Tk_ChangeWindowAttributes(wmPtr->icon, CWEventMask, &atts); + wmPtr2 = ((TkWindow *) wmPtr->icon)->wmInfoPtr; + wmPtr2->iconFor = NULL; + wmPtr2->hints.initial_state = WithdrawnState; + } + wmPtr->icon = NULL; + } else { + tkwin2 = Tk_NameToWindow(interp, argv[3], tkwin); + if (tkwin2 == NULL) { + return TCL_ERROR; + } + if (!Tk_IsTopLevel(tkwin2)) { + Tcl_AppendResult(interp, "can't use ", argv[3], + " as icon window: not at top level", (char *) NULL); + return TCL_ERROR; + } + wmPtr2 = ((TkWindow *) tkwin2)->wmInfoPtr; + if (wmPtr2->iconFor != NULL) { + Tcl_AppendResult(interp, argv[3], " is already an icon for ", + Tk_PathName(wmPtr2->iconFor), (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->icon != NULL) { + WmInfo *wmPtr3 = ((TkWindow *) wmPtr->icon)->wmInfoPtr; + wmPtr3->iconFor = NULL; + + /* + * Let the window use button events again. + */ + + atts.event_mask = Tk_Attributes(wmPtr->icon)->event_mask + | ButtonPressMask; + Tk_ChangeWindowAttributes(wmPtr->icon, CWEventMask, &atts); + } + + /* + * Disable button events in the icon window: some window + * managers (like olvwm) want to get the events themselves, + * but X only allows one application at a time to receive + * button events for a window. + */ + + atts.event_mask = Tk_Attributes(tkwin2)->event_mask + & ~ButtonPressMask; + Tk_ChangeWindowAttributes(tkwin2, CWEventMask, &atts); + Tk_MakeWindowExist(tkwin2); + wmPtr->hints.icon_window = Tk_WindowId(tkwin2); + wmPtr->hints.flags |= IconWindowHint; + wmPtr->icon = tkwin2; + wmPtr2->iconFor = (Tk_Window) winPtr; + if (!(wmPtr2->flags & WM_NEVER_MAPPED)) { + if (XWithdrawWindow(Tk_Display(tkwin2), Tk_WindowId(tkwin2), + Tk_ScreenNumber(tkwin2)) == 0) { + interp->result = + "couldn't send withdraw message to window manager"; + return TCL_ERROR; + } + } + } + } else if ((c == 'm') && (strncmp(argv[1], "maxsize", length) == 0) + && (length >= 2)) { + int width, height; + if ((argc != 3) && (argc != 5)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " maxsize window ?width height?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + GetMaxSize(wmPtr, &width, &height); + sprintf(interp->result, "%d %d", width, height); + return TCL_OK; + } + if ((Tcl_GetInt(interp, argv[3], &width) != TCL_OK) + || (Tcl_GetInt(interp, argv[4], &height) != TCL_OK)) { + return TCL_ERROR; + } + wmPtr->maxWidth = width; + wmPtr->maxHeight = height; + goto updateGeom; + } else if ((c == 'm') && (strncmp(argv[1], "minsize", length) == 0) + && (length >= 2)) { + int width, height; + if ((argc != 3) && (argc != 5)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " minsize window ?width height?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + GetMinSize(wmPtr, &width, &height); + sprintf(interp->result, "%d %d", width, height); + return TCL_OK; + } + if ((Tcl_GetInt(interp, argv[3], &width) != TCL_OK) + || (Tcl_GetInt(interp, argv[4], &height) != TCL_OK)) { + return TCL_ERROR; + } + wmPtr->minWidth = width; + wmPtr->minHeight = height; + goto updateGeom; + } else if ((c == 'o') + && (strncmp(argv[1], "overrideredirect", length) == 0)) { + int boolean; + XSetWindowAttributes atts; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " overrideredirect window ?boolean?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (Tk_Attributes((Tk_Window) winPtr)->override_redirect) { + interp->result = "1"; + } else { + interp->result = "0"; + } + return TCL_OK; + } + if (Tcl_GetBoolean(interp, argv[3], &boolean) != TCL_OK) { + return TCL_ERROR; + } + atts.override_redirect = (boolean) ? True : False; + Tk_ChangeWindowAttributes((Tk_Window) winPtr, CWOverrideRedirect, + &atts); + if (!(wmPtr->flags & (WM_NEVER_MAPPED) + && !(winPtr->flags & TK_EMBEDDED))) { + UpdateWrapper(winPtr); + } + } else if ((c == 'p') && (strncmp(argv[1], "positionfrom", length) == 0) + && (length >= 2)) { + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " positionfrom window ?user/program?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->sizeHintsFlags & USPosition) { + interp->result = "user"; + } else if (wmPtr->sizeHintsFlags & PPosition) { + interp->result = "program"; + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->sizeHintsFlags &= ~(USPosition|PPosition); + } else { + c = argv[3][0]; + length = strlen(argv[3]); + if ((c == 'u') && (strncmp(argv[3], "user", length) == 0)) { + wmPtr->sizeHintsFlags &= ~PPosition; + wmPtr->sizeHintsFlags |= USPosition; + } else if ((c == 'p') + && (strncmp(argv[3], "program", length) == 0)) { + wmPtr->sizeHintsFlags &= ~USPosition; + wmPtr->sizeHintsFlags |= PPosition; + } else { + Tcl_AppendResult(interp, "bad argument \"", argv[3], + "\": must be program or user", (char *) NULL); + return TCL_ERROR; + } + } + goto updateGeom; + } else if ((c == 'p') && (strncmp(argv[1], "protocol", length) == 0) + && (length >= 2)) { + register ProtocolHandler *protPtr, *prevPtr; + Atom protocol; + int cmdLength; + + if ((argc < 3) || (argc > 5)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " protocol window ?name? ?command?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + /* + * Return a list of all defined protocols for the window. + */ + for (protPtr = wmPtr->protPtr; protPtr != NULL; + protPtr = protPtr->nextPtr) { + Tcl_AppendElement(interp, + Tk_GetAtomName((Tk_Window) winPtr, protPtr->protocol)); + } + return TCL_OK; + } + protocol = Tk_InternAtom((Tk_Window) winPtr, argv[3]); + if (argc == 4) { + /* + * Return the command to handle a given protocol. + */ + for (protPtr = wmPtr->protPtr; protPtr != NULL; + protPtr = protPtr->nextPtr) { + if (protPtr->protocol == protocol) { + interp->result = protPtr->command; + return TCL_OK; + } + } + return TCL_OK; + } + + /* + * Delete any current protocol handler, then create a new + * one with the specified command, unless the command is + * empty. + */ + + for (protPtr = wmPtr->protPtr, prevPtr = NULL; protPtr != NULL; + prevPtr = protPtr, protPtr = protPtr->nextPtr) { + if (protPtr->protocol == protocol) { + if (prevPtr == NULL) { + wmPtr->protPtr = protPtr->nextPtr; + } else { + prevPtr->nextPtr = protPtr->nextPtr; + } + Tcl_EventuallyFree((ClientData) protPtr, TCL_DYNAMIC); + break; + } + } + cmdLength = strlen(argv[4]); + if (cmdLength > 0) { + protPtr = (ProtocolHandler *) ckalloc(HANDLER_SIZE(cmdLength)); + protPtr->protocol = protocol; + protPtr->nextPtr = wmPtr->protPtr; + wmPtr->protPtr = protPtr; + protPtr->interp = interp; + strcpy(protPtr->command, argv[4]); + } + } else if ((c == 'r') && (strncmp(argv[1], "resizable", length) == 0)) { + int width, height; + + if ((argc != 3) && (argc != 5)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " resizable window ?width height?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + sprintf(interp->result, "%d %d", + (wmPtr->flags & WM_WIDTH_NOT_RESIZABLE) ? 0 : 1, + (wmPtr->flags & WM_HEIGHT_NOT_RESIZABLE) ? 0 : 1); + return TCL_OK; + } + if ((Tcl_GetBoolean(interp, argv[3], &width) != TCL_OK) + || (Tcl_GetBoolean(interp, argv[4], &height) != TCL_OK)) { + return TCL_ERROR; + } + if (width) { + wmPtr->flags &= ~WM_WIDTH_NOT_RESIZABLE; + } else { + wmPtr->flags |= WM_WIDTH_NOT_RESIZABLE; + } + if (height) { + wmPtr->flags &= ~WM_HEIGHT_NOT_RESIZABLE; + } else { + wmPtr->flags |= WM_HEIGHT_NOT_RESIZABLE; + } + wmPtr->flags |= WM_UPDATE_SIZE_HINTS; + goto updateGeom; + } else if ((c == 's') && (strncmp(argv[1], "sizefrom", length) == 0) + && (length >= 2)) { + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " sizefrom window ?user|program?\"", + (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->sizeHintsFlags & USSize) { + interp->result = "user"; + } else if (wmPtr->sizeHintsFlags & PSize) { + interp->result = "program"; + } + return TCL_OK; + } + if (*argv[3] == '\0') { + wmPtr->sizeHintsFlags &= ~(USSize|PSize); + } else { + c = argv[3][0]; + length = strlen(argv[3]); + if ((c == 'u') && (strncmp(argv[3], "user", length) == 0)) { + wmPtr->sizeHintsFlags &= ~PSize; + wmPtr->sizeHintsFlags |= USSize; + } else if ((c == 'p') + && (strncmp(argv[3], "program", length) == 0)) { + wmPtr->sizeHintsFlags &= ~USSize; + wmPtr->sizeHintsFlags |= PSize; + } else { + Tcl_AppendResult(interp, "bad argument \"", argv[3], + "\": must be program or user", (char *) NULL); + return TCL_ERROR; + } + } + goto updateGeom; + } else if ((c == 's') && (strncmp(argv[1], "state", length) == 0) + && (length >= 2)) { + if (argc != 3) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " state window\"", (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->iconFor != NULL) { + interp->result = "icon"; + } else { + switch (wmPtr->hints.initial_state) { + case NormalState: + interp->result = "normal"; + break; + case IconicState: + interp->result = "iconic"; + break; + case WithdrawnState: + interp->result = "withdrawn"; + break; + case ZoomState: + interp->result = "zoomed"; + break; + } + } + } else if ((c == 't') && (strncmp(argv[1], "title", length) == 0) + && (length >= 2)) { + if (argc > 4) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " title window ?newTitle?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + interp->result = (wmPtr->titleUid != NULL) ? wmPtr->titleUid + : winPtr->nameUid; + return TCL_OK; + } else { + wmPtr->titleUid = Tk_GetUid(argv[3]); + if (!(wmPtr->flags & WM_NEVER_MAPPED) && wmPtr->wrapper != NULL) { + SetWindowText(wmPtr->wrapper, wmPtr->titleUid); + } + } + } else if ((c == 't') && (strncmp(argv[1], "transient", length) == 0) + && (length >= 3)) { + TkWindow *masterPtr; + + if ((argc != 3) && (argc != 4)) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " transient window ?master?\"", (char *) NULL); + return TCL_ERROR; + } + if (argc == 3) { + if (wmPtr->masterPtr != NULL) { + Tcl_SetResult(interp, Tk_PathName(wmPtr->masterPtr), + TCL_STATIC); + } + return TCL_OK; + } + if (argv[3][0] == '\0') { + wmPtr->masterPtr = NULL; + } else { + masterPtr = (TkWindow*) Tk_NameToWindow(interp, argv[3], tkwin); + if (masterPtr == NULL) { + return TCL_ERROR; + } + if (masterPtr == winPtr) { + wmPtr->masterPtr = NULL; + } else { + Tk_MakeWindowExist((Tk_Window)masterPtr); + + /* + * Ensure that the master window is actually a Tk toplevel. + */ + + while (!(masterPtr->flags & TK_TOP_LEVEL)) { + masterPtr = masterPtr->parentPtr; + } + wmPtr->masterPtr = masterPtr; + + /* + * Ensure that the transient window is either mapped or + * unmapped like its master. + */ + + TkpWmSetState(winPtr, NormalState); + } + } + if (!(wmPtr->flags & (WM_NEVER_MAPPED) + && !(winPtr->flags & TK_EMBEDDED))) { + UpdateWrapper(winPtr); + } + } else if ((c == 'w') && (strncmp(argv[1], "withdraw", length) == 0)) { + if (argc != 3) { + Tcl_AppendResult(interp, "wrong # arguments: must be \"", + argv[0], " withdraw window\"", (char *) NULL); + return TCL_ERROR; + } + if (wmPtr->iconFor != NULL) { + Tcl_AppendResult(interp, "can't withdraw ", argv[2], + ": it is an icon for ", Tk_PathName(wmPtr->iconFor), + (char *) NULL); + return TCL_ERROR; + } + TkpWmSetState(winPtr, WithdrawnState); + } else { + Tcl_AppendResult(interp, "unknown or ambiguous option \"", argv[1], + "\": must be aspect, client, command, deiconify, ", + "focusmodel, frame, geometry, grid, group, iconbitmap, ", + "iconify, iconmask, iconname, iconposition, ", + "iconwindow, maxsize, minsize, overrideredirect, ", + "positionfrom, protocol, resizable, sizefrom, state, title, ", + "transient, or withdraw", + (char *) NULL); + return TCL_ERROR; + } + return TCL_OK; + + updateGeom: + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_SetGrid -- + * + * This procedure is invoked by a widget when it wishes to set a grid + * coordinate system that controls the size of a top-level window. + * It provides a C interface equivalent to the "wm grid" command and + * is usually asscoiated with the -setgrid option. + * + * Results: + * None. + * + * Side effects: + * Grid-related information will be passed to the window manager, so + * that the top-level window associated with tkwin will resize on + * even grid units. If some other window already controls gridding + * for the top-level window then this procedure call has no effect. + * + *---------------------------------------------------------------------- + */ + +void +Tk_SetGrid(tkwin, reqWidth, reqHeight, widthInc, heightInc) + Tk_Window tkwin; /* Token for window. New window mgr info + * will be posted for the top-level window + * associated with this window. */ + int reqWidth; /* Width (in grid units) corresponding to + * the requested geometry for tkwin. */ + int reqHeight; /* Height (in grid units) corresponding to + * the requested geometry for tkwin. */ + int widthInc, heightInc; /* Pixel increments corresponding to a + * change of one grid unit. */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + register WmInfo *wmPtr; + + /* + * Find the top-level window for tkwin, plus the window manager + * information. + */ + + while (!(winPtr->flags & TK_TOP_LEVEL)) { + winPtr = winPtr->parentPtr; + } + wmPtr = winPtr->wmInfoPtr; + + if ((wmPtr->gridWin != NULL) && (wmPtr->gridWin != tkwin)) { + return; + } + + if ((wmPtr->reqGridWidth == reqWidth) + && (wmPtr->reqGridHeight == reqHeight) + && (wmPtr->widthInc == widthInc) + && (wmPtr->heightInc == heightInc) + && ((wmPtr->sizeHintsFlags & (PBaseSize|PResizeInc)) + == PBaseSize|PResizeInc)) { + return; + } + + /* + * If gridding was previously off, then forget about any window + * size requests made by the user or via "wm geometry": these are + * in pixel units and there's no easy way to translate them to + * grid units since the new requested size of the top-level window in + * pixels may not yet have been registered yet (it may filter up + * the hierarchy in DoWhenIdle handlers). However, if the window + * has never been mapped yet then just leave the window size alone: + * assume that it is intended to be in grid units but just happened + * to have been specified before this procedure was called. + */ + + if ((wmPtr->gridWin == NULL) && !(wmPtr->flags & WM_NEVER_MAPPED)) { + wmPtr->width = -1; + wmPtr->height = -1; + } + + /* + * Set the new gridding information, and start the process of passing + * all of this information to the window manager. + */ + + wmPtr->gridWin = tkwin; + wmPtr->reqGridWidth = reqWidth; + wmPtr->reqGridHeight = reqHeight; + wmPtr->widthInc = widthInc; + wmPtr->heightInc = heightInc; + wmPtr->sizeHintsFlags |= PBaseSize|PResizeInc; + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } +} + +/* + *---------------------------------------------------------------------- + * + * Tk_UnsetGrid -- + * + * This procedure cancels the effect of a previous call + * to Tk_SetGrid. + * + * Results: + * None. + * + * Side effects: + * If tkwin currently controls gridding for its top-level window, + * gridding is cancelled for that top-level window; if some other + * window controls gridding then this procedure has no effect. + * + *---------------------------------------------------------------------- + */ + +void +Tk_UnsetGrid(tkwin) + Tk_Window tkwin; /* Token for window that is currently + * controlling gridding. */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + register WmInfo *wmPtr; + + /* + * Find the top-level window for tkwin, plus the window manager + * information. + */ + + while (!(winPtr->flags & TK_TOP_LEVEL)) { + winPtr = winPtr->parentPtr; + } + wmPtr = winPtr->wmInfoPtr; + if (tkwin != wmPtr->gridWin) { + return; + } + + wmPtr->gridWin = NULL; + wmPtr->sizeHintsFlags &= ~(PBaseSize|PResizeInc); + if (wmPtr->width != -1) { + wmPtr->width = winPtr->reqWidth + (wmPtr->width + - wmPtr->reqGridWidth)*wmPtr->widthInc; + wmPtr->height = winPtr->reqHeight + (wmPtr->height + - wmPtr->reqGridHeight)*wmPtr->heightInc; + } + wmPtr->widthInc = 1; + wmPtr->heightInc = 1; + + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } +} + +/* + *---------------------------------------------------------------------- + * + * TopLevelEventProc -- + * + * This procedure is invoked when a top-level (or other externally- + * managed window) is restructured in any way. + * + * Results: + * None. + * + * Side effects: + * Tk's internal data structures for the window get modified to + * reflect the structural change. + * + *---------------------------------------------------------------------- + */ + +static void +TopLevelEventProc(clientData, eventPtr) + ClientData clientData; /* Window for which event occurred. */ + XEvent *eventPtr; /* Event that just happened. */ +{ + register TkWindow *winPtr = (TkWindow *) clientData; + + if (eventPtr->type == DestroyNotify) { + Tk_ErrorHandler handler; + + if (!(winPtr->flags & TK_ALREADY_DEAD)) { + /* + * A top-level window was deleted externally (e.g., by the window + * manager). This is probably not a good thing, but cleanup as + * best we can. The error handler is needed because + * Tk_DestroyWindow will try to destroy the window, but of course + * it's already gone. + */ + + handler = Tk_CreateErrorHandler(winPtr->display, -1, -1, -1, + (Tk_ErrorProc *) NULL, (ClientData) NULL); + Tk_DestroyWindow((Tk_Window) winPtr); + Tk_DeleteErrorHandler(handler); + } + } + else if (eventPtr->type == ConfigureNotify) { + WmInfo *wmPtr; + wmPtr = winPtr->wmInfoPtr; + + if (winPtr->flags & TK_EMBEDDED) { + Tk_Window tkwin = (Tk_Window)winPtr; + SendMessage(wmPtr->wrapper, TK_GEOMETRYREQ, Tk_ReqWidth(tkwin), + Tk_ReqHeight(tkwin)); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TopLevelReqProc -- + * + * This procedure is invoked by the geometry manager whenever + * the requested size for a top-level window is changed. + * + * Results: + * None. + * + * Side effects: + * Arrange for the window to be resized to satisfy the request + * (this happens as a when-idle action). + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +static void +TopLevelReqProc(dummy, tkwin) + ClientData dummy; /* Not used. */ + Tk_Window tkwin; /* Information about window. */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + WmInfo *wmPtr; + + wmPtr = winPtr->wmInfoPtr; + if (winPtr->flags & TK_EMBEDDED) { + SendMessage(wmPtr->wrapper, TK_GEOMETRYREQ, Tk_ReqWidth(tkwin), + Tk_ReqHeight(tkwin)); + } + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } +} + +/* + *---------------------------------------------------------------------- + * + * UpdateGeometryInfo -- + * + * This procedure is invoked when a top-level window is first + * mapped, and also as a when-idle procedure, to bring the + * geometry and/or position of a top-level window back into + * line with what has been requested by the user and/or widgets. + * This procedure doesn't return until the system has + * responded to the geometry change. + * + * Results: + * None. + * + * Side effects: + * The window's size and location may change, unless the WM prevents + * that from happening. + * + *---------------------------------------------------------------------- + */ + +static void +UpdateGeometryInfo(clientData) + ClientData clientData; /* Pointer to the window's record. */ +{ + int x, y; /* Position of border on desktop. */ + int width, height; /* Size of client area. */ + RECT rect; + register TkWindow *winPtr = (TkWindow *) clientData; + register WmInfo *wmPtr = winPtr->wmInfoPtr; + + wmPtr->flags &= ~WM_UPDATE_PENDING; + + /* + * If the window is minimized or maximized, we should not update + * our geometry since it will end up with the wrong values. + * ConfigureToplevel will reschedule UpdateGeometryInfo when the + * state of the window changes. + */ + + if (IsIconic(wmPtr->wrapper) || IsZoomed(wmPtr->wrapper)) { + return; + } + + /* + * Compute the border size for the current window style. This + * size will include the resize handles, the title bar and the + * menubar. Note that this size will not be correct if the + * menubar spans multiple lines. The height will be off by a + * multiple of the menubar height. It really only measures the + * minimum size of the border. + */ + + rect.left = rect.right = rect.top = rect.bottom = 0; + AdjustWindowRectEx(&rect, wmPtr->style, wmPtr->hMenu != NULL, + wmPtr->exStyle); + wmPtr->borderWidth = rect.right - rect.left; + wmPtr->borderHeight = rect.bottom - rect.top; + + /* + * Compute the new size for the top-level window. See the + * user documentation for details on this, but the size + * requested depends on (a) the size requested internally + * by the window's widgets, (b) the size requested by the + * user in a "wm geometry" command or via wm-based interactive + * resizing (if any), and (c) whether or not the window is + * gridded. Don't permit sizes <= 0 because this upsets + * the X server. + */ + + if (wmPtr->width == -1) { + width = winPtr->reqWidth; + } else if (wmPtr->gridWin != NULL) { + width = winPtr->reqWidth + + (wmPtr->width - wmPtr->reqGridWidth)*wmPtr->widthInc; + } else { + width = wmPtr->width; + } + if (width <= 0) { + width = 1; + } + if (wmPtr->height == -1) { + height = winPtr->reqHeight; + } else if (wmPtr->gridWin != NULL) { + height = winPtr->reqHeight + + (wmPtr->height - wmPtr->reqGridHeight)*wmPtr->heightInc; + } else { + height = wmPtr->height; + } + if (height <= 0) { + height = 1; + } + + /* + * Compute the new position for the upper-left pixel of the window's + * decorative frame. This is tricky, because we need to include the + * border widths supplied by a reparented parent in this calculation, + * but can't use the parent's current overall size since that may + * change as a result of this code. + */ + + if (wmPtr->flags & WM_NEGATIVE_X) { + x = DisplayWidth(winPtr->display, winPtr->screenNum) - wmPtr->x + - (width + wmPtr->borderWidth); + } else { + x = wmPtr->x; + } + if (wmPtr->flags & WM_NEGATIVE_Y) { + y = DisplayHeight(winPtr->display, winPtr->screenNum) - wmPtr->y + - (height + wmPtr->borderHeight); + } else { + y = wmPtr->y; + } + + /* + * If this window is embedded and the container is also in this + * process, we don't need to do anything special about the + * geometry, except to make sure that the desired size is known + * by the container. Also, zero out any position information, + * since embedded windows are not allowed to move. + */ + + if (winPtr->flags & TK_BOTH_HALVES) { + wmPtr->x = wmPtr->y = 0; + wmPtr->flags &= ~(WM_NEGATIVE_X|WM_NEGATIVE_Y); + Tk_GeometryRequest((Tk_Window) TkpGetOtherWindow(winPtr), + width, height); + return; + } + + /* + * Reconfigure the window if it isn't already configured correctly. Base + * the size check on what we *asked for* last time, not what we got. + * Return immediately if there have been no changes in the requested + * geometry of the toplevel. + */ + /* TODO: need to add flag for possible menu size change */ + + if (!((wmPtr->flags & WM_MOVE_PENDING) + || (width != wmPtr->configWidth) + || (height != wmPtr->configHeight))) { + return; + } + wmPtr->flags &= ~WM_MOVE_PENDING; + + wmPtr->configWidth = width; + wmPtr->configHeight = height; + + /* + * Don't bother moving the window if we are in the process of + * creating it. Just update the geometry info based on what + * we asked for. + */ + + if (wmPtr->flags & WM_CREATE_PENDING) { + winPtr->changes.x = x; + winPtr->changes.y = y; + winPtr->changes.width = width; + winPtr->changes.height = height; + return; + } + + wmPtr->flags |= WM_SYNC_PENDING; + if (winPtr->flags & TK_EMBEDDED) { + /* + * The wrapper window is in a different process, so we need + * to send it a geometry request. This protocol assumes that + * the other process understands this Tk message, otherwise + * our requested geometry will be ignored. + */ + + SendMessage(wmPtr->wrapper, TK_GEOMETRYREQ, width, height); + } else { + int reqHeight, reqWidth; + RECT windowRect; + int menuInc = GetSystemMetrics(SM_CYMENU); + int newHeight; + + /* + * We have to keep resizing the window until we get the + * requested height in the client area. If the client + * area has zero height, then the window rect is too + * small by definition. Try increasing the border height + * and try again. Once we have a positive size, then + * we can adjust the height exactly. If the window + * rect comes back smaller than we requested, we have + * hit the maximum constraints that Windows imposes. + * Once we find a positive client size, the next size + * is the one we try no matter what. + */ + + reqHeight = height + wmPtr->borderHeight; + reqWidth = width + wmPtr->borderWidth; + + while (1) { + MoveWindow(wmPtr->wrapper, x, y, reqWidth, reqHeight, TRUE); + GetWindowRect(wmPtr->wrapper, &windowRect); + newHeight = windowRect.bottom - windowRect.top; + + /* + * If the request wasn't satisfied, we have hit an external + * constraint and must stop. + */ + + if (newHeight < reqHeight) { + break; + } + + /* + * Now check the size of the client area against our ideal. + */ + + GetClientRect(wmPtr->wrapper, &windowRect); + newHeight = windowRect.bottom - windowRect.top; + + if (newHeight == height) { + /* + * We're done. + */ + break; + } else if (newHeight > height) { + /* + * One last resize to get rid of the extra space. + */ + menuInc = newHeight - height; + reqHeight -= menuInc; + if (wmPtr->flags & WM_NEGATIVE_Y) { + y += menuInc; + } + MoveWindow(wmPtr->wrapper, x, y, reqWidth, reqHeight, TRUE); + break; + } + + /* + * We didn't get enough space to satisfy our requested + * height, so the menu must have wrapped. Increase the + * size of the window by one menu height and move the + * window if it is positioned relative to the lower right + * corner of the screen. + */ + + reqHeight += menuInc; + if (wmPtr->flags & WM_NEGATIVE_Y) { + y -= menuInc; + } + } + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + DrawMenuBar(wmPtr->wrapper); + } + } + wmPtr->flags &= ~WM_SYNC_PENDING; +} + +/* + *-------------------------------------------------------------- + * + * ParseGeometry -- + * + * This procedure parses a geometry string and updates + * information used to control the geometry of a top-level + * window. + * + * Results: + * A standard Tcl return value, plus an error message in + * interp->result if an error occurs. + * + * Side effects: + * The size and/or location of winPtr may change. + * + *-------------------------------------------------------------- + */ + +static int +ParseGeometry(interp, string, winPtr) + Tcl_Interp *interp; /* Used for error reporting. */ + char *string; /* String containing new geometry. Has the + * standard form "=wxh+x+y". */ + TkWindow *winPtr; /* Pointer to top-level window whose + * geometry is to be changed. */ +{ + register WmInfo *wmPtr = winPtr->wmInfoPtr; + int x, y, width, height, flags; + char *end; + register char *p = string; + + /* + * The leading "=" is optional. + */ + + if (*p == '=') { + p++; + } + + /* + * Parse the width and height, if they are present. Don't + * actually update any of the fields of wmPtr until we've + * successfully parsed the entire geometry string. + */ + + width = wmPtr->width; + height = wmPtr->height; + x = wmPtr->x; + y = wmPtr->y; + flags = wmPtr->flags; + if (isdigit(UCHAR(*p))) { + width = strtoul(p, &end, 10); + p = end; + if (*p != 'x') { + goto error; + } + p++; + if (!isdigit(UCHAR(*p))) { + goto error; + } + height = strtoul(p, &end, 10); + p = end; + } + + /* + * Parse the X and Y coordinates, if they are present. + */ + + if (*p != '\0') { + flags &= ~(WM_NEGATIVE_X | WM_NEGATIVE_Y); + if (*p == '-') { + flags |= WM_NEGATIVE_X; + } else if (*p != '+') { + goto error; + } + p++; + if (!isdigit(UCHAR(*p)) && (*p != '-')) { + goto error; + } + x = strtol(p, &end, 10); + p = end; + if (*p == '-') { + flags |= WM_NEGATIVE_Y; + } else if (*p != '+') { + goto error; + } + p++; + if (!isdigit(UCHAR(*p)) && (*p != '-')) { + goto error; + } + y = strtol(p, &end, 10); + if (*end != '\0') { + goto error; + } + + /* + * Assume that the geometry information came from the user, + * unless an explicit source has been specified. Otherwise + * most window managers assume that the size hints were + * program-specified and they ignore them. + */ + + if ((wmPtr->sizeHintsFlags & (USPosition|PPosition)) == 0) { + wmPtr->sizeHintsFlags |= USPosition; + } + } + + /* + * Everything was parsed OK. Update the fields of *wmPtr and + * arrange for the appropriate information to be percolated out + * to the window manager at the next idle moment. + */ + + wmPtr->width = width; + wmPtr->height = height; + wmPtr->x = x; + wmPtr->y = y; + flags |= WM_MOVE_PENDING; + wmPtr->flags = flags; + + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } + return TCL_OK; + + error: + Tcl_AppendResult(interp, "bad geometry specifier \"", + string, "\"", (char *) NULL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetRootCoords -- + * + * Given a token for a window, this procedure traces through the + * window's lineage to find the (virtual) root-window coordinates + * corresponding to point (0,0) in the window. + * + * Results: + * The locations pointed to by xPtr and yPtr are filled in with + * the root coordinates of the (0,0) point in tkwin. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Tk_GetRootCoords(tkwin, xPtr, yPtr) + Tk_Window tkwin; /* Token for window. */ + int *xPtr; /* Where to store x-displacement of (0,0). */ + int *yPtr; /* Where to store y-displacement of (0,0). */ +{ + register TkWindow *winPtr = (TkWindow *) tkwin; + + /* + * If the window is mapped, let Windows figure out the translation. + */ + + if (winPtr->window != None) { + HWND hwnd = Tk_GetHWND(winPtr->window); + POINT point; + + point.x = 0; + point.y = 0; + + ClientToScreen(hwnd, &point); + + *xPtr = point.x; + *yPtr = point.y; + } else { + *xPtr = 0; + *yPtr = 0; + } +} + +/* + *---------------------------------------------------------------------- + * + * Tk_CoordsToWindow -- + * + * Given the (virtual) root coordinates of a point, this procedure + * returns the token for the top-most window covering that point, + * if there exists such a window in this application. + * + * Results: + * The return result is either a token for the window corresponding + * to rootX and rootY, or else NULL to indicate that there is no such + * window. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tk_Window +Tk_CoordsToWindow(rootX, rootY, tkwin) + int rootX, rootY; /* Coordinates of point in root window. If + * a virtual-root window manager is in use, + * these coordinates refer to the virtual + * root, not the real root. */ + Tk_Window tkwin; /* Token for any window in application; + * used to identify the display. */ +{ + POINT pos; + HWND hwnd; + TkWindow *winPtr; + + pos.x = rootX; + pos.y = rootY; + hwnd = WindowFromPoint(pos); + + winPtr = (TkWindow *) Tk_HWNDToWindow(hwnd); + if (winPtr && (winPtr->mainPtr == ((TkWindow *) tkwin)->mainPtr)) { + return (Tk_Window) winPtr; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetVRootGeometry -- + * + * This procedure returns information about the virtual root + * window corresponding to a particular Tk window. + * + * Results: + * The values at xPtr, yPtr, widthPtr, and heightPtr are set + * with the offset and dimensions of the root window corresponding + * to tkwin. If tkwin is being managed by a virtual root window + * manager these values correspond to the virtual root window being + * used for tkwin; otherwise the offsets will be 0 and the + * dimensions will be those of the screen. + * + * Side effects: + * Vroot window information is refreshed if it is out of date. + * + *---------------------------------------------------------------------- + */ + +void +Tk_GetVRootGeometry(tkwin, xPtr, yPtr, widthPtr, heightPtr) + Tk_Window tkwin; /* Window whose virtual root is to be + * queried. */ + int *xPtr, *yPtr; /* Store x and y offsets of virtual root + * here. */ + int *widthPtr, *heightPtr; /* Store dimensions of virtual root here. */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + + *xPtr = 0; + *yPtr = 0; + *widthPtr = DisplayWidth(winPtr->display, winPtr->screenNum); + *heightPtr = DisplayHeight(winPtr->display, winPtr->screenNum); +} + +/* + *---------------------------------------------------------------------- + * + * Tk_MoveToplevelWindow -- + * + * This procedure is called instead of Tk_MoveWindow to adjust + * the x-y location of a top-level window. It delays the actual + * move to a later time and keeps window-manager information + * up-to-date with the move + * + * Results: + * None. + * + * Side effects: + * The window is eventually moved so that its upper-left corner + * (actually, the upper-left corner of the window's decorative + * frame, if there is one) is at (x,y). + * + *---------------------------------------------------------------------- + */ + +void +Tk_MoveToplevelWindow(tkwin, x, y) + Tk_Window tkwin; /* Window to move. */ + int x, y; /* New location for window (within + * parent). */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + register WmInfo *wmPtr = winPtr->wmInfoPtr; + + if (!(winPtr->flags & TK_TOP_LEVEL)) { + panic("Tk_MoveToplevelWindow called with non-toplevel window"); + } + wmPtr->x = x; + wmPtr->y = y; + wmPtr->flags |= WM_MOVE_PENDING; + wmPtr->flags &= ~(WM_NEGATIVE_X|WM_NEGATIVE_Y); + if ((wmPtr->sizeHintsFlags & (USPosition|PPosition)) == 0) { + wmPtr->sizeHintsFlags |= USPosition; + } + + /* + * If the window has already been mapped, must bring its geometry + * up-to-date immediately, otherwise an event might arrive from the + * server that would overwrite wmPtr->x and wmPtr->y and lose the + * new position. + */ + + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + if (wmPtr->flags & WM_UPDATE_PENDING) { + Tcl_CancelIdleCall(UpdateGeometryInfo, (ClientData) winPtr); + } + UpdateGeometryInfo((ClientData) winPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWmProtocolEventProc -- + * + * This procedure is called by the Tk_HandleEvent whenever a + * ClientMessage event arrives whose type is "WM_PROTOCOLS". + * This procedure handles the message from the window manager + * in an appropriate fashion. + * + * Results: + * None. + * + * Side effects: + * Depends on what sort of handler, if any, was set up for the + * protocol. + * + *---------------------------------------------------------------------- + */ + +void +TkWmProtocolEventProc(winPtr, eventPtr) + TkWindow *winPtr; /* Window to which the event was sent. */ + XEvent *eventPtr; /* X event. */ +{ + WmInfo *wmPtr; + register ProtocolHandler *protPtr; + Atom protocol; + int result; + Tcl_Interp *interp; + + wmPtr = winPtr->wmInfoPtr; + if (wmPtr == NULL) { + return; + } + protocol = (Atom) eventPtr->xclient.data.l[0]; + for (protPtr = wmPtr->protPtr; protPtr != NULL; + protPtr = protPtr->nextPtr) { + if (protocol == protPtr->protocol) { + Tcl_Preserve((ClientData) protPtr); + interp = protPtr->interp; + Tcl_Preserve((ClientData) interp); + result = Tcl_GlobalEval(interp, protPtr->command); + if (result != TCL_OK) { + Tcl_AddErrorInfo(interp, "\n (command for \""); + Tcl_AddErrorInfo(interp, + Tk_GetAtomName((Tk_Window) winPtr, protocol)); + Tcl_AddErrorInfo(interp, "\" window manager protocol)"); + Tcl_BackgroundError(interp); + } + Tcl_Release((ClientData) interp); + Tcl_Release((ClientData) protPtr); + return; + } + } + + /* + * No handler was present for this protocol. If this is a + * WM_DELETE_WINDOW message then just destroy the window. + */ + + if (protocol == Tk_InternAtom((Tk_Window) winPtr, "WM_DELETE_WINDOW")) { + Tk_DestroyWindow((Tk_Window) winPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWmRestackToplevel -- + * + * This procedure restacks a top-level window. + * + * Results: + * None. + * + * Side effects: + * WinPtr gets restacked as specified by aboveBelow and otherPtr. + * This procedure doesn't return until the restack has taken + * effect and the ConfigureNotify event for it has been received. + * + *---------------------------------------------------------------------- + */ + +void +TkWmRestackToplevel(winPtr, aboveBelow, otherPtr) + TkWindow *winPtr; /* Window to restack. */ + int aboveBelow; /* Gives relative position for restacking; + * must be Above or Below. */ + TkWindow *otherPtr; /* Window relative to which to restack; + * if NULL, then winPtr gets restacked + * above or below *all* siblings. */ +{ + HWND hwnd, insertAfter; + + /* + * Can't set stacking order properly until the window is on the + * screen (mapping it may give it a reparent window). + */ + + if (winPtr->window == None) { + Tk_MakeWindowExist((Tk_Window) winPtr); + } + if (winPtr->wmInfoPtr->flags & WM_NEVER_MAPPED) { + TkWmMapWindow(winPtr); + } + hwnd = (winPtr->wmInfoPtr->wrapper != NULL) + ? winPtr->wmInfoPtr->wrapper : Tk_GetHWND(winPtr->window); + + + if (otherPtr != NULL) { + if (otherPtr->window == None) { + Tk_MakeWindowExist((Tk_Window) otherPtr); + } + if (otherPtr->wmInfoPtr->flags & WM_NEVER_MAPPED) { + TkWmMapWindow(otherPtr); + } + insertAfter = (otherPtr->wmInfoPtr->wrapper != NULL) + ? otherPtr->wmInfoPtr->wrapper : Tk_GetHWND(otherPtr->window); + } else { + insertAfter = NULL; + } + + TkWinSetWindowPos(hwnd, insertAfter, aboveBelow); +} + +/* + *---------------------------------------------------------------------- + * + * TkWmAddToColormapWindows -- + * + * This procedure is called to add a given window to the + * WM_COLORMAP_WINDOWS property for its top-level, if it + * isn't already there. It is invoked by the Tk code that + * creates a new colormap, in order to make sure that colormap + * information is propagated to the window manager by default. + * + * Results: + * None. + * + * Side effects: + * WinPtr's window gets added to the WM_COLORMAP_WINDOWS + * property of its nearest top-level ancestor, unless the + * colormaps have been set explicitly with the + * "wm colormapwindows" command. + * + *---------------------------------------------------------------------- + */ + +void +TkWmAddToColormapWindows(winPtr) + TkWindow *winPtr; /* Window with a non-default colormap. + * Should not be a top-level window. */ +{ + TkWindow *topPtr; + TkWindow **oldPtr, **newPtr; + int count, i; + + if (winPtr->window == None) { + return; + } + + for (topPtr = winPtr->parentPtr; ; topPtr = topPtr->parentPtr) { + if (topPtr == NULL) { + /* + * Window is being deleted. Skip the whole operation. + */ + + return; + } + if (topPtr->flags & TK_TOP_LEVEL) { + break; + } + } + if (topPtr->wmInfoPtr->flags & WM_COLORMAPS_EXPLICIT) { + return; + } + + /* + * Make sure that the window isn't already in the list. + */ + + count = topPtr->wmInfoPtr->cmapCount; + oldPtr = topPtr->wmInfoPtr->cmapList; + + for (i = 0; i < count; i++) { + if (oldPtr[i] == winPtr) { + return; + } + } + + /* + * Make a new bigger array and use it to reset the property. + * Automatically add the toplevel itself as the last element + * of the list. + */ + + newPtr = (TkWindow **) ckalloc((unsigned) ((count+2)*sizeof(TkWindow*))); + if (count > 0) { + memcpy(newPtr, oldPtr, count * sizeof(TkWindow*)); + } + if (count == 0) { + count++; + } + newPtr[count-1] = winPtr; + newPtr[count] = topPtr; + if (oldPtr != NULL) { + ckfree((char *) oldPtr); + } + + topPtr->wmInfoPtr->cmapList = newPtr; + topPtr->wmInfoPtr->cmapCount = count+1; + + /* + * Now we need to force the updated colormaps to be installed. + */ + + if (topPtr->wmInfoPtr == foregroundWmPtr) { + InstallColormaps(topPtr->wmInfoPtr->wrapper, WM_QUERYNEWPALETTE, 1); + } else { + InstallColormaps(topPtr->wmInfoPtr->wrapper, WM_PALETTECHANGED, 0); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWmRemoveFromColormapWindows -- + * + * This procedure is called to remove a given window from the + * WM_COLORMAP_WINDOWS property for its top-level. It is invoked + * when windows are deleted. + * + * Results: + * None. + * + * Side effects: + * WinPtr's window gets removed from the WM_COLORMAP_WINDOWS + * property of its nearest top-level ancestor, unless the + * top-level itself is being deleted too. + * + *---------------------------------------------------------------------- + */ + +void +TkWmRemoveFromColormapWindows(winPtr) + TkWindow *winPtr; /* Window that may be present in + * WM_COLORMAP_WINDOWS property for its + * top-level. Should not be a top-level + * window. */ +{ + TkWindow *topPtr; + TkWindow **oldPtr; + int count, i, j; + + for (topPtr = winPtr->parentPtr; ; topPtr = topPtr->parentPtr) { + if (topPtr == NULL) { + /* + * Ancestors have been deleted, so skip the whole operation. + * Seems like this can't ever happen? + */ + + return; + } + if (topPtr->flags & TK_TOP_LEVEL) { + break; + } + } + if (topPtr->flags & TK_ALREADY_DEAD) { + /* + * Top-level is being deleted, so there's no need to cleanup + * the WM_COLORMAP_WINDOWS property. + */ + + return; + } + + /* + * Find the window and slide the following ones down to cover + * it up. + */ + + count = topPtr->wmInfoPtr->cmapCount; + oldPtr = topPtr->wmInfoPtr->cmapList; + for (i = 0; i < count; i++) { + if (oldPtr[i] == winPtr) { + for (j = i ; j < count-1; j++) { + oldPtr[j] = oldPtr[j+1]; + } + topPtr->wmInfoPtr->cmapCount = count-1; + break; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinSetMenu-- + * + * Associcates a given HMENU to a window. + * + * Results: + * None. + * + * Side effects: + * The menu will end up being drawn in the window, and the geometry + * of the window will have to be changed. + * + *---------------------------------------------------------------------- + */ + +void +TkWinSetMenu(tkwin, hMenu) + Tk_Window tkwin; /* the window to put the menu in */ + HMENU hMenu; /* the menu to set */ +{ + TkWindow *winPtr = (TkWindow *) tkwin; + WmInfo *wmPtr = winPtr->wmInfoPtr; + + wmPtr->hMenu = hMenu; + + if (!(wmPtr->flags & TK_EMBEDDED)) { + if (!(wmPtr->flags & WM_NEVER_MAPPED)) { + int syncPending = wmPtr->flags & WM_SYNC_PENDING; + + wmPtr->flags |= WM_SYNC_PENDING; + SetMenu(wmPtr->wrapper, hMenu); + if (!syncPending) { + wmPtr->flags &= ~WM_SYNC_PENDING; + } + } + if (!(wmPtr->flags & (WM_UPDATE_PENDING|WM_NEVER_MAPPED))) { + Tcl_DoWhenIdle(UpdateGeometryInfo, (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING|WM_MOVE_PENDING; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * ConfigureTopLevel -- + * + * Generate a ConfigureNotify event based on the current position + * information. This procedure is called by TopLevelProc. + * + * Results: + * None. + * + * Side effects: + * Queues a new event. + * + *---------------------------------------------------------------------- + */ + +static void +ConfigureTopLevel(pos) + WINDOWPOS *pos; +{ + TkWindow *winPtr = GetTopLevel(pos->hwnd); + WmInfo *wmPtr; + int state; /* Current window state. */ + RECT rect; + WINDOWPLACEMENT windowPos; + + if (winPtr == NULL) { + return; + } + + wmPtr = winPtr->wmInfoPtr; + + /* + * Determine the current window state. + */ + + if (!IsWindowVisible(wmPtr->wrapper)) { + state = WithdrawnState; + } else { + windowPos.length = sizeof(WINDOWPLACEMENT); + GetWindowPlacement(wmPtr->wrapper, &windowPos); + switch (windowPos.showCmd) { + case SW_SHOWMAXIMIZED: + state = ZoomState; + break; + case SW_SHOWMINIMIZED: + state = IconicState; + break; + case SW_SHOWNORMAL: + state = NormalState; + break; + } + } + + /* + * If the state of the window just changed, be sure to update the + * child window information. + */ + + if (wmPtr->hints.initial_state != state) { + wmPtr->hints.initial_state = state; + switch (state) { + case WithdrawnState: + case IconicState: + XUnmapWindow(winPtr->display, winPtr->window); + break; + + case NormalState: + /* + * Schedule a geometry update. Since we ignore geometry + * requests while in any other state, the geometry info + * may be stale. + */ + + if (!(wmPtr->flags & WM_UPDATE_PENDING)) { + Tcl_DoWhenIdle(UpdateGeometryInfo, + (ClientData) winPtr); + wmPtr->flags |= WM_UPDATE_PENDING; + } + /* fall through */ + case ZoomState: + XMapWindow(winPtr->display, winPtr->window); + pos->flags |= SWP_NOMOVE | SWP_NOSIZE; + break; + } + } + + /* + * Don't report geometry changes in the Iconic or Withdrawn states. + */ + + if (state == WithdrawnState || state == IconicState) { + return; + } + + + /* + * Compute the current geometry of the client area, reshape the + * Tk window and generate a ConfigureNotify event. + */ + + GetClientRect(wmPtr->wrapper, &rect); + winPtr->changes.x = pos->x; + winPtr->changes.y = pos->y; + winPtr->changes.width = rect.right - rect.left; + winPtr->changes.height = rect.bottom - rect.top; + wmPtr->borderHeight = pos->cy - winPtr->changes.height; + MoveWindow(Tk_GetHWND(winPtr->window), 0, 0, + winPtr->changes.width, winPtr->changes.height, TRUE); + GenerateConfigureNotify(winPtr); + + /* + * Update window manager geometry info if needed. + */ + + if (state == NormalState) { + + /* + * Update size information from the event. There are a couple of + * tricky points here: + * + * 1. If the user changed the size externally then set wmPtr->width + * and wmPtr->height just as if a "wm geometry" command had been + * invoked with the same information. + * 2. However, if the size is changing in response to a request + * coming from us (sync is set), then don't set + * wmPtr->width or wmPtr->height (otherwise the window will stop + * tracking geometry manager requests). + */ + + if (!(wmPtr->flags & WM_SYNC_PENDING)) { + if (!(pos->flags & SWP_NOSIZE)) { + if ((wmPtr->width == -1) + && (winPtr->changes.width == winPtr->reqWidth)) { + /* + * Don't set external width, since the user didn't + * change it from what the widgets asked for. + */ + } else { + if (wmPtr->gridWin != NULL) { + wmPtr->width = wmPtr->reqGridWidth + + (winPtr->changes.width - winPtr->reqWidth) + / wmPtr->widthInc; + if (wmPtr->width < 0) { + wmPtr->width = 0; + } + } else { + wmPtr->width = winPtr->changes.width; + } + } + if ((wmPtr->height == -1) + && (winPtr->changes.height == winPtr->reqHeight)) { + /* + * Don't set external height, since the user didn't change + * it from what the widgets asked for. + */ + } else { + if (wmPtr->gridWin != NULL) { + wmPtr->height = wmPtr->reqGridHeight + + (winPtr->changes.height - winPtr->reqHeight) + / wmPtr->heightInc; + if (wmPtr->height < 0) { + wmPtr->height = 0; + } + } else { + wmPtr->height = winPtr->changes.height; + } + } + wmPtr->configWidth = winPtr->changes.width; + wmPtr->configHeight = winPtr->changes.height; + } + /* + * If the user moved the window, we should switch back + * to normal coordinates. + */ + + if (!(pos->flags & SWP_NOMOVE)) { + wmPtr->flags &= ~(WM_NEGATIVE_X | WM_NEGATIVE_Y); + } + } + + /* + * Update the wrapper window location information. + */ + + if (wmPtr->flags & WM_NEGATIVE_X) { + wmPtr->x = DisplayWidth(winPtr->display, winPtr->screenNum) + - winPtr->changes.x - (winPtr->changes.width + + wmPtr->borderWidth); + } else { + wmPtr->x = winPtr->changes.x; + } + if (wmPtr->flags & WM_NEGATIVE_Y) { + wmPtr->y = DisplayHeight(winPtr->display, winPtr->screenNum) + - winPtr->changes.y - (winPtr->changes.height + + wmPtr->borderHeight); + } else { + wmPtr->y = winPtr->changes.y; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * GenerateConfigureNotify -- + * + * Generate a ConfigureNotify event from the current geometry + * information for the specified toplevel window. + * + * Results: + * None. + * + * Side effects: + * Sends an X event. + * + *---------------------------------------------------------------------- + */ + +static void +GenerateConfigureNotify(winPtr) + TkWindow *winPtr; +{ + XEvent event; + + /* + * Generate a ConfigureNotify event. + */ + + event.type = ConfigureNotify; + event.xconfigure.serial = winPtr->display->request; + event.xconfigure.send_event = False; + event.xconfigure.display = winPtr->display; + event.xconfigure.event = winPtr->window; + event.xconfigure.window = winPtr->window; + event.xconfigure.border_width = winPtr->changes.border_width; + event.xconfigure.override_redirect = winPtr->atts.override_redirect; + event.xconfigure.x = winPtr->changes.x; + event.xconfigure.y = winPtr->changes.y; + event.xconfigure.width = winPtr->changes.width; + event.xconfigure.height = winPtr->changes.height; + event.xconfigure.above = None; + Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL); +} + +/* + *---------------------------------------------------------------------- + * + * InstallColormaps -- + * + * Installs the colormaps associated with the toplevel which is + * currently active. + * + * Results: + * None. + * + * Side effects: + * May change the system palette and generate damage. + * + *---------------------------------------------------------------------- + */ + +static int +InstallColormaps(hwnd, message, isForemost) + HWND hwnd; /* Toplevel wrapper window whose colormaps + * should be installed. */ + int message; /* Either WM_PALETTECHANGED or + * WM_QUERYNEWPALETTE */ + int isForemost; /* 1 if window is foremost, else 0 */ +{ + int i; + HDC dc; + HPALETTE oldPalette; + TkWindow *winPtr = GetTopLevel(hwnd); + WmInfo *wmPtr; + + if (winPtr == NULL) { + return 0; + } + + wmPtr = winPtr->wmInfoPtr; + + if (message == WM_QUERYNEWPALETTE) { + /* + * Case 1: This window is about to become the foreground window, so we + * need to install the primary palette. If the system palette was + * updated, then Windows will generate a WM_PALETTECHANGED message. + * Otherwise, we have to synthesize one in order to ensure that the + * secondary palettes are installed properly. + */ + + foregroundWmPtr = wmPtr; + + if (wmPtr->cmapCount > 0) { + winPtr = wmPtr->cmapList[0]; + } + + systemPalette = TkWinGetPalette(winPtr->atts.colormap); + dc = GetDC(hwnd); + oldPalette = SelectPalette(dc, systemPalette, FALSE); + if (RealizePalette(dc)) { + RefreshColormap(winPtr->atts.colormap); + } else if (wmPtr->cmapCount > 1) { + SelectPalette(dc, oldPalette, TRUE); + RealizePalette(dc); + ReleaseDC(hwnd, dc); + SendMessage(hwnd, WM_PALETTECHANGED, (WPARAM)hwnd, + (LPARAM)NULL); + return TRUE; + } + + } else { + /* + * Window is being notified of a change in the system palette. + * If this window is the foreground window, then we should only + * install the secondary palettes, since the primary was installed + * in response to the WM_QUERYPALETTE message. Otherwise, install + * all of the palettes. + */ + + + if (!isForemost) { + if (wmPtr->cmapCount > 0) { + winPtr = wmPtr->cmapList[0]; + } + i = 1; + } else { + if (wmPtr->cmapCount <= 1) { + return TRUE; + } + winPtr = wmPtr->cmapList[1]; + i = 2; + } + dc = GetDC(hwnd); + oldPalette = SelectPalette(dc, + TkWinGetPalette(winPtr->atts.colormap), TRUE); + if (RealizePalette(dc)) { + RefreshColormap(winPtr->atts.colormap); + } + for (; i < wmPtr->cmapCount; i++) { + winPtr = wmPtr->cmapList[i]; + SelectPalette(dc, TkWinGetPalette(winPtr->atts.colormap), TRUE); + if (RealizePalette(dc)) { + RefreshColormap(winPtr->atts.colormap); + } + } + } + + SelectPalette(dc, oldPalette, TRUE); + RealizePalette(dc); + ReleaseDC(hwnd, dc); + return TRUE; +} + +/* + *---------------------------------------------------------------------- + * + * RefreshColormap -- + * + * This function is called to force all of the windows that use + * a given colormap to redraw themselves. The quickest way to + * do this is to iterate over the toplevels, looking in the + * cmapList for matches. This will quickly eliminate subtrees + * that don't use a given colormap. + * + * Results: + * None. + * + * Side effects: + * Causes damage events to be generated. + * + *---------------------------------------------------------------------- + */ + +static void +RefreshColormap(colormap) + Colormap colormap; +{ + WmInfo *wmPtr; + int i; + + for (wmPtr = firstWmPtr; wmPtr != NULL; wmPtr = wmPtr->nextPtr) { + if (wmPtr->cmapCount > 0) { + for (i = 0; i < wmPtr->cmapCount; i++) { + if ((wmPtr->cmapList[i]->atts.colormap == colormap) + && Tk_IsMapped(wmPtr->cmapList[i])) { + InvalidateSubTree(wmPtr->cmapList[i], colormap); + } + } + } else if ((wmPtr->winPtr->atts.colormap == colormap) + && Tk_IsMapped(wmPtr->winPtr)) { + InvalidateSubTree(wmPtr->winPtr, colormap); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * InvalidateSubTree -- + * + * This function recursively generates damage for a window and + * all of its mapped children that belong to the same toplevel and + * are using the specified colormap. + * + * Results: + * None. + * + * Side effects: + * Generates damage for the specified subtree. + * + *---------------------------------------------------------------------- + */ + +static void +InvalidateSubTree(winPtr, colormap) + TkWindow *winPtr; + Colormap colormap; +{ + TkWindow *childPtr; + + /* + * Generate damage for the current window if it is using the + * specified colormap. + */ + + if (winPtr->atts.colormap == colormap) { + InvalidateRect(Tk_GetHWND(winPtr->window), NULL, FALSE); + } + + for (childPtr = winPtr->childList; childPtr != NULL; + childPtr = childPtr->nextPtr) { + /* + * We can stop the descent when we hit an unmapped or + * toplevel window. + */ + + if (!Tk_IsTopLevel(childPtr) && Tk_IsMapped(childPtr)) { + InvalidateSubTree(childPtr, colormap); + } + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinGetSystemPalette -- + * + * Retrieves the currently installed foreground palette. + * + * Results: + * Returns the global foreground palette, if there is one. + * Otherwise, returns NULL. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +HPALETTE +TkWinGetSystemPalette() +{ + return systemPalette; +} + +/* + *---------------------------------------------------------------------- + * + * GetMinSize -- + * + * This procedure computes the current minWidth and minHeight + * values for a window, taking into account the possibility + * that they may be defaulted. + * + * Results: + * The values at *minWidthPtr and *minHeightPtr are filled + * in with the minimum allowable dimensions of wmPtr's window, + * in grid units. If the requested minimum is smaller than the + * system required minimum, then this procedure computes the + * smallest size that will satisfy both the system and the + * grid constraints. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +GetMinSize(wmPtr, minWidthPtr, minHeightPtr) + WmInfo *wmPtr; /* Window manager information for the + * window. */ + int *minWidthPtr; /* Where to store the current minimum + * width of the window. */ + int *minHeightPtr; /* Where to store the current minimum + * height of the window. */ +{ + int tmp, base; + TkWindow *winPtr = wmPtr->winPtr; + + /* + * Compute the minimum width by taking the default client size + * and rounding it up to the nearest grid unit. Return the greater + * of the default minimum and the specified minimum. + */ + + tmp = wmPtr->defMinWidth - wmPtr->borderWidth; + if (tmp < 0) { + tmp = 0; + } + if (wmPtr->gridWin != NULL) { + base = winPtr->reqWidth - (wmPtr->reqGridWidth * wmPtr->widthInc); + if (base < 0) { + base = 0; + } + tmp = ((tmp - base) + wmPtr->widthInc - 1)/wmPtr->widthInc; + } + if (tmp < wmPtr->minWidth) { + tmp = wmPtr->minWidth; + } + *minWidthPtr = tmp; + + /* + * Compute the minimum height in a similar fashion. + */ + + tmp = wmPtr->defMinHeight - wmPtr->borderHeight; + if (tmp < 0) { + tmp = 0; + } + if (wmPtr->gridWin != NULL) { + base = winPtr->reqHeight - (wmPtr->reqGridHeight * wmPtr->heightInc); + if (base < 0) { + base = 0; + } + tmp = ((tmp - base) + wmPtr->heightInc - 1)/wmPtr->heightInc; + } + if (tmp < wmPtr->minHeight) { + tmp = wmPtr->minHeight; + } + *minHeightPtr = tmp; +} + +/* + *---------------------------------------------------------------------- + * + * GetMaxSize -- + * + * This procedure computes the current maxWidth and maxHeight + * values for a window, taking into account the possibility + * that they may be defaulted. + * + * Results: + * The values at *maxWidthPtr and *maxHeightPtr are filled + * in with the maximum allowable dimensions of wmPtr's window, + * in grid units. If no maximum has been specified for the + * window, then this procedure computes the largest sizes that + * will fit on the screen. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +GetMaxSize(wmPtr, maxWidthPtr, maxHeightPtr) + WmInfo *wmPtr; /* Window manager information for the + * window. */ + int *maxWidthPtr; /* Where to store the current maximum + * width of the window. */ + int *maxHeightPtr; /* Where to store the current maximum + * height of the window. */ +{ + int tmp; + + if (wmPtr->maxWidth > 0) { + *maxWidthPtr = wmPtr->maxWidth; + } else { + /* + * Must compute a default width. Fill up the display, leaving a + * bit of extra space for the window manager's borders. + */ + + tmp = wmPtr->defMaxWidth - wmPtr->borderWidth; + if (wmPtr->gridWin != NULL) { + /* + * Gridding is turned on; convert from pixels to grid units. + */ + + tmp = wmPtr->reqGridWidth + + (tmp - wmPtr->winPtr->reqWidth)/wmPtr->widthInc; + } + *maxWidthPtr = tmp; + } + if (wmPtr->maxHeight > 0) { + *maxHeightPtr = wmPtr->maxHeight; + } else { + tmp = wmPtr->defMaxHeight - wmPtr->borderHeight; + if (wmPtr->gridWin != NULL) { + tmp = wmPtr->reqGridHeight + + (tmp - wmPtr->winPtr->reqHeight)/wmPtr->heightInc; + } + *maxHeightPtr = tmp; + } +} + +/* + *---------------------------------------------------------------------- + * + * TopLevelProc -- + * + * Callback from Windows whenever an event occurs on a top level + * window. + * + * Results: + * Standard Windows return value. + * + * Side effects: + * Default window behavior. + * + *---------------------------------------------------------------------- + */ + +static LRESULT CALLBACK +TopLevelProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + if (message == WM_WINDOWPOSCHANGED) { + WINDOWPOS *pos = (WINDOWPOS *) lParam; + TkWindow *winPtr = (TkWindow *) Tk_HWNDToWindow(pos->hwnd); + + if (winPtr == NULL) { + return 0; + } + + /* + * Update the shape of the contained window. + */ + + if (!(pos->flags & SWP_NOSIZE)) { + winPtr->changes.width = pos->cx; + winPtr->changes.height = pos->cy; + } + if (!(pos->flags & SWP_NOMOVE)) { + winPtr->changes.x = pos->x; + winPtr->changes.y = pos->y; + } + + GenerateConfigureNotify(winPtr); + + Tcl_ServiceAll(); + return 0; + } + return TkWinChildProc(hwnd, message, wParam, lParam); +} + +/* + *---------------------------------------------------------------------- + * + * WmProc -- + * + * Callback from Windows whenever an event occurs on the decorative + * frame. + * + * Results: + * Standard Windows return value. + * + * Side effects: + * Default window behavior. + * + *---------------------------------------------------------------------- + */ + +static LRESULT CALLBACK +WmProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + static int inMoveSize = 0; + static oldMode; /* This static is set upon entering move/size mode + * and is used to reset the service mode after + * leaving move/size mode. Note that this mechanism + * assumes move/size is only one level deep. */ + LRESULT result; + TkWindow *winPtr; + + if (TkWinHandleMenuEvent(&hwnd, &message, &wParam, &lParam, &result)) { + goto done; + } + + switch (message) { + case WM_KILLFOCUS: + case WM_ERASEBKGND: + result = 0; + goto done; + + case WM_ENTERSIZEMOVE: + inMoveSize = 1; + oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL); + break; + + case WM_ACTIVATE: + case WM_EXITSIZEMOVE: + if (inMoveSize) { + inMoveSize = 0; + Tcl_SetServiceMode(oldMode); + } + break; + + case WM_GETMINMAXINFO: + SetLimits(hwnd, (MINMAXINFO *) lParam); + result = 0; + goto done; + + case WM_PALETTECHANGED: + result = InstallColormaps(hwnd, WM_PALETTECHANGED, + hwnd == (HWND)wParam); + goto done; + + case WM_QUERYNEWPALETTE: + result = InstallColormaps(hwnd, WM_QUERYNEWPALETTE, TRUE); + goto done; + + case WM_WINDOWPOSCHANGED: + ConfigureTopLevel((WINDOWPOS *) lParam); + result = 0; + goto done; + + default: + break; + } + + winPtr = GetTopLevel(hwnd); + if (winPtr && winPtr->window) { + HWND child = Tk_GetHWND(winPtr->window); + if (message == WM_SETFOCUS) { + SetFocus(child); + result = 0; + } else if (!Tk_TranslateWinEvent(child, message, wParam, lParam, + &result)) { + result = DefWindowProc(hwnd, message, wParam, lParam); + } + } else { + result = DefWindowProc(hwnd, message, wParam, lParam); + } + + done: + Tcl_ServiceAll(); + return result; +} + +/* + *---------------------------------------------------------------------- + * + * TkpMakeMenuWindow -- + * + * Configure the window to be either a pull-down (or pop-up) + * menu, or as a toplevel (torn-off) menu or palette. + * + * Results: + * None. + * + * Side effects: + * Changes the style bit used to create a new Mac toplevel. + * + *---------------------------------------------------------------------- + */ + +void +TkpMakeMenuWindow(tkwin, transient) + Tk_Window tkwin; /* New window. */ + int transient; /* 1 means menu is only posted briefly as + * a popup or pulldown or cascade. 0 means + * menu is always visible, e.g. as a torn-off + * menu. Determines whether save_under and + * override_redirect should be set. */ +{ + XSetWindowAttributes atts; + + if (transient) { + atts.override_redirect = True; + atts.save_under = True; + } else { + atts.override_redirect = False; + atts.save_under = False; + } + + if ((atts.override_redirect != Tk_Attributes(tkwin)->override_redirect) + || (atts.save_under != Tk_Attributes(tkwin)->save_under)) { + Tk_ChangeWindowAttributes(tkwin, + CWOverrideRedirect|CWSaveUnder, &atts); + } + +} + +/* + *---------------------------------------------------------------------- + * + * TkWinGetWrapperWindow -- + * + * Gets the Windows HWND for a given window. + * + * Results: + * Returns the wrapper window for a Tk window. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +HWND +TkWinGetWrapperWindow( + Tk_Window tkwin) /* The window we need the wrapper from */ +{ + TkWindow *winPtr = (TkWindow *)tkwin; + return (winPtr->wmInfoPtr->wrapper); +} + + +/* + *---------------------------------------------------------------------- + * + * TkWmFocusToplevel -- + * + * This is a utility procedure invoked by focus-management code. It + * exists because of the extra wrapper windows that exist under + * Unix; its job is to map from wrapper windows to the + * corresponding toplevel windows. On PCs and Macs there are no + * wrapper windows so no mapping is necessary; this procedure just + * determines whether a window is a toplevel or not. + * + * Results: + * If winPtr is a toplevel window, returns the pointer to the + * window; otherwise returns NULL. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +TkWindow * +TkWmFocusToplevel(winPtr) + TkWindow *winPtr; /* Window that received a focus-related + * event. */ +{ + if (!(winPtr->flags & TK_TOP_LEVEL)) { + return NULL; + } + return winPtr; +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetWrapperWindow -- + * + * This is a utility procedure invoked by focus-management code. It + * maps to the wrapper for a top-level, which is just the same + * as the top-level on Macs and PCs. + * + * Results: + * If winPtr is a toplevel window, returns the pointer to the + * window; otherwise returns NULL. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +TkWindow * +TkpGetWrapperWindow( + TkWindow *winPtr) /* Window that received a focus-related + * event. */ +{ + if (!(winPtr->flags & TK_TOP_LEVEL)) { + return NULL; + } + return winPtr; +} diff --git a/win/tkWinX.c b/win/tkWinX.c new file mode 100644 index 0000000..0b00186 --- /dev/null +++ b/win/tkWinX.c @@ -0,0 +1,1020 @@ +/* + * tkWinX.c -- + * + * This file contains Windows emulation procedures for X routines. + * + * Copyright (c) 1995-1996 Sun Microsystems, Inc. + * Copyright (c) 1994 Software Research Associates, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) tkWinX.c 1.51 97/09/02 13:06:57 + */ + +#include "tkInt.h" +#include "tkWinInt.h" + +/* + * Definitions of extern variables supplied by this file. + */ + +int tkpIsWin32s = -1; + +/* + * Declarations of static variables used in this file. + */ + +static HINSTANCE tkInstance = (HINSTANCE) NULL; + /* Global application instance handle. */ +static TkDisplay *winDisplay; /* Display that represents Windows screen. */ +static char winScreenName[] = ":0"; + /* Default name of windows display. */ +static WNDCLASS childClass; /* Window class for child windows. */ +static childClassInitialized = 0; /* Registered child class? */ + +/* + * Forward declarations of procedures used in this file. + */ + +static void GenerateXEvent _ANSI_ARGS_((HWND hwnd, UINT message, + WPARAM wParam, LPARAM lParam)); +static unsigned int GetState _ANSI_ARGS_((UINT message, WPARAM wParam, + LPARAM lParam)); +static void GetTranslatedKey _ANSI_ARGS_((XKeyEvent *xkey)); + +/* + *---------------------------------------------------------------------- + * + * TkGetServerInfo -- + * + * Given a window, this procedure returns information about + * the window server for that window. This procedure provides + * the guts of the "winfo server" command. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +TkGetServerInfo(interp, tkwin) + Tcl_Interp *interp; /* The server information is returned in + * this interpreter's result. */ + Tk_Window tkwin; /* Token for window; this selects a + * particular display and server. */ +{ + char buffer[50]; + OSVERSIONINFO info; + + info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&info); + sprintf(buffer, "Windows %d.%d %d ", info.dwMajorVersion, + info.dwMinorVersion, info.dwBuildNumber); + Tcl_AppendResult(interp, buffer, + (info.dwPlatformId == VER_PLATFORM_WIN32s) ? "Win32s" : "Win32", + (char *) NULL); +} + +/* + *---------------------------------------------------------------------- + * + * Tk_GetHINSTANCE -- + * + * Retrieves the global instance handle used by the Tk library. + * + * Results: + * Returns the global instance handle. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +HINSTANCE +Tk_GetHINSTANCE() +{ + return tkInstance; +} + +/* + *---------------------------------------------------------------------- + * + * TkWinXInit -- + * + * Initialize Xlib emulation layer. + * + * Results: + * None. + * + * Side effects: + * Sets up various data structures. + * + *---------------------------------------------------------------------- + */ + +void +TkWinXInit(hInstance) + HINSTANCE hInstance; +{ + OSVERSIONINFO info; + + info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&info); + tkpIsWin32s = (info.dwPlatformId == VER_PLATFORM_WIN32s); + + if (childClassInitialized != 0) { + return; + } + childClassInitialized = 1; + + tkInstance = hInstance; + + childClass.style = CS_HREDRAW | CS_VREDRAW | CS_CLASSDC; + childClass.cbClsExtra = 0; + childClass.cbWndExtra = 0; + childClass.hInstance = hInstance; + childClass.hbrBackground = NULL; + childClass.lpszMenuName = NULL; + + /* + * Register the Child window class. + */ + + childClass.lpszClassName = TK_WIN_CHILD_CLASS_NAME; + childClass.lpfnWndProc = TkWinChildProc; + childClass.hIcon = NULL; + childClass.hCursor = NULL; + + if (!RegisterClass(&childClass)) { + panic("Unable to register TkChild class"); + } +} + +/* + *---------------------------------------------------------------------- + * + * TkWinXCleanup -- + * + * Removes the registered classes for Tk. + * + * Results: + * None. + * + * Side effects: + * Removes window classes from the system. + * + *---------------------------------------------------------------------- + */ + +void +TkWinXCleanup(hInstance) + HINSTANCE hInstance; +{ + /* + * Clean up our own class. + */ + + if (childClassInitialized) { + childClassInitialized = 0; + UnregisterClass(TK_WIN_CHILD_CLASS_NAME, hInstance); + } + + /* + * And let the window manager clean up its own class(es). + */ + + TkWinWmCleanup(hInstance); +} + +/* + *---------------------------------------------------------------------- + * + * TkGetDefaultScreenName -- + * + * Returns the name of the screen that Tk should use during + * initialization. + * + * Results: + * Returns a statically allocated string. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +char * +TkGetDefaultScreenName(interp, screenName) + Tcl_Interp *interp; /* Not used. */ + char *screenName; /* If NULL, use default string. */ +{ + if ((screenName == NULL) || (screenName[0] == '\0')) { + screenName = winScreenName; + } + return screenName; +} + +/* + *---------------------------------------------------------------------- + * + * TkpOpenDisplay -- + * + * Create the Display structure and fill it with device + * specific information. + * + * Results: + * Returns a Display structure on success or NULL on failure. + * + * Side effects: + * Allocates a new Display structure. + * + *---------------------------------------------------------------------- + */ + +TkDisplay * +TkpOpenDisplay(display_name) + char *display_name; +{ + Screen *screen; + HDC dc; + TkWinDrawable *twdPtr; + Display *display; + + if (winDisplay != NULL) { + if (strcmp(winDisplay->display->display_name, display_name) == 0) { + return winDisplay; + } else { + return NULL; + } + } + + display = (Display *) ckalloc(sizeof(Display)); + display->display_name = (char *) ckalloc(strlen(display_name)+1); + strcpy(display->display_name, display_name); + + display->cursor_font = 1; + display->nscreens = 1; + display->request = 1; + display->qlen = 0; + + screen = (Screen *) ckalloc(sizeof(Screen)); + screen->display = display; + + dc = GetDC(NULL); + screen->width = GetDeviceCaps(dc, HORZRES); + screen->height = GetDeviceCaps(dc, VERTRES); + screen->mwidth = MulDiv(screen->width, 254, + GetDeviceCaps(dc, LOGPIXELSX) * 10); + screen->mheight = MulDiv(screen->height, 254, + GetDeviceCaps(dc, LOGPIXELSY) * 10); + + /* + * Set up the root window. + */ + + twdPtr = (TkWinDrawable*) ckalloc(sizeof(TkWinDrawable)); + if (twdPtr == NULL) { + return None; + } + twdPtr->type = TWD_WINDOW; + twdPtr->window.winPtr = NULL; + twdPtr->window.handle = NULL; + screen->root = (Window)twdPtr; + + /* + * On windows, when creating a color bitmap, need two pieces of + * information: the number of color planes and the number of + * pixels per plane. Need to remember both quantities so that + * when constructing an HBITMAP for offscreen rendering, we can + * specify the correct value for the number of planes. Otherwise + * the HBITMAP won't be compatible with the HWND and we'll just + * get blank spots copied onto the screen. + */ + + screen->ext_data = (XExtData *) GetDeviceCaps(dc, PLANES); + screen->root_depth = GetDeviceCaps(dc, BITSPIXEL) * (int) screen->ext_data; + + screen->root_visual = (Visual *) ckalloc(sizeof(Visual)); + screen->root_visual->visualid = 0; + if (GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE) { + screen->root_visual->map_entries = GetDeviceCaps(dc, SIZEPALETTE); + screen->root_visual->class = PseudoColor; + screen->root_visual->red_mask = 0x0; + screen->root_visual->green_mask = 0x0; + screen->root_visual->blue_mask = 0x0; + } else { + if (screen->root_depth == 4) { + screen->root_visual->class = StaticColor; + screen->root_visual->map_entries = 16; + } else if (screen->root_depth == 8) { + screen->root_visual->class = StaticColor; + screen->root_visual->map_entries = 256; + } else if (screen->root_depth == 12) { + screen->root_visual->class = TrueColor; + screen->root_visual->map_entries = 32; + screen->root_visual->red_mask = 0xf0; + screen->root_visual->green_mask = 0xf000; + screen->root_visual->blue_mask = 0xf00000; + } else if (screen->root_depth == 16) { + screen->root_visual->class = TrueColor; + screen->root_visual->map_entries = 64; + screen->root_visual->red_mask = 0xf8; + screen->root_visual->green_mask = 0xfc00; + screen->root_visual->blue_mask = 0xf80000; + } else if (screen->root_depth >= 24) { + screen->root_visual->class = TrueColor; + screen->root_visual->map_entries = 256; + screen->root_visual->red_mask = 0xff; + screen->root_visual->green_mask = 0xff00; + screen->root_visual->blue_mask = 0xff0000; + } + } + screen->root_visual->bits_per_rgb = screen->root_depth; + ReleaseDC(NULL, dc); + + /* + * Note that these pixel values are not palette relative. + */ + + screen->white_pixel = RGB(255, 255, 255); + screen->black_pixel = RGB(0, 0, 0); + + display->screens = screen; + display->nscreens = 1; + display->default_screen = 0; + screen->cmap = XCreateColormap(display, None, screen->root_visual, + AllocNone); + winDisplay = (TkDisplay *) ckalloc(sizeof(TkDisplay)); + winDisplay->display = display; + return winDisplay; +} + +/* + *---------------------------------------------------------------------- + * + * TkpCloseDisplay -- + * + * Closes and deallocates a Display structure created with the + * TkpOpenDisplay function. + * + * Results: + * None. + * + * Side effects: + * Frees up memory. + * + *---------------------------------------------------------------------- + */ + +void +TkpCloseDisplay(dispPtr) + TkDisplay *dispPtr; +{ + Display *display = dispPtr->display; + HWND hwnd; + + if (dispPtr != winDisplay) { + panic("TkpCloseDisplay: tried to call TkpCloseDisplay on another display"); + return; + } + + /* + * Force the clipboard to be rendered if we are the clipboard owner. + */ + + if (dispPtr->clipWindow) { + hwnd = Tk_GetHWND(Tk_WindowId(dispPtr->clipWindow)); + if (GetClipboardOwner() == hwnd) { + OpenClipboard(hwnd); + EmptyClipboard(); + TkWinClipboardRender(dispPtr, CF_TEXT); + CloseClipboard(); + } + } + + winDisplay = NULL; + + if (display->display_name != (char *) NULL) { + ckfree(display->display_name); + } + if (display->screens != (Screen *) NULL) { + if (display->screens->root_visual != NULL) { + ckfree((char *) display->screens->root_visual); + } + if (display->screens->root != None) { + ckfree((char *) display->screens->root); + } + if (display->screens->cmap != None) { + XFreeColormap(display, display->screens->cmap); + } + ckfree((char *) display->screens); + } + ckfree((char *) display); + ckfree((char *) dispPtr); +} + +/* + *---------------------------------------------------------------------- + * + * XBell -- + * + * Generate a beep. + * + * Results: + * None. + * + * Side effects: + * Plays a sounds out the system speakers. + * + *---------------------------------------------------------------------- + */ + +void +XBell(display, percent) + Display* display; + int percent; +{ + MessageBeep(MB_OK); +} + +/* + *---------------------------------------------------------------------- + * + * TkWinChildProc -- + * + * Callback from Windows whenever an event occurs on a child + * window. + * + * Results: + * Standard Windows return value. + * + * Side effects: + * May process events off the Tk event queue. + * + *---------------------------------------------------------------------- + */ + +LRESULT CALLBACK +TkWinChildProc(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + LRESULT result; + + switch (message) { + case WM_SETCURSOR: + /* + * Short circuit the WM_SETCURSOR message since we set + * the cursor elsewhere. + */ + + result = TRUE; + break; + + case WM_CREATE: + case WM_ERASEBKGND: + case WM_WINDOWPOSCHANGED: + result = 0; + break; + + case WM_PAINT: + GenerateXEvent(hwnd, message, wParam, lParam); + result = DefWindowProc(hwnd, message, wParam, lParam); + break; + + case TK_CLAIMFOCUS: + case TK_GEOMETRYREQ: + case TK_ATTACHWINDOW: + case TK_DETACHWINDOW: + result = TkWinEmbeddedEventProc(hwnd, message, wParam, lParam); + break; + + default: + if (!Tk_TranslateWinEvent(hwnd, message, wParam, lParam, + &result)) { + result = DefWindowProc(hwnd, message, wParam, lParam); + } + break; + } + + /* + * Handle any newly queued events before returning control to Windows. + */ + + Tcl_ServiceAll(); + return result; +} + +/* + *---------------------------------------------------------------------- + * + * Tk_TranslateWinEvent -- + * + * This function is called by widget window procedures to handle + * the translation from Win32 events to Tk events. + * + * Results: + * Returns 1 if the event was handled, else 0. + * + * Side effects: + * Depends on the event. + * + *---------------------------------------------------------------------- + */ + +int +Tk_TranslateWinEvent(hwnd, message, wParam, lParam, resultPtr) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; + LRESULT *resultPtr; +{ + *resultPtr = 0; + switch (message) { + case WM_RENDERFORMAT: { + TkWindow *winPtr = (TkWindow *) Tk_HWNDToWindow(hwnd); + if (winPtr) { + TkWinClipboardRender(winPtr->dispPtr, wParam); + } + return 1; + } + + case WM_COMMAND: + case WM_NOTIFY: + case WM_VSCROLL: + case WM_HSCROLL: { + /* + * Reflect these messages back to the sender so that they + * can be handled by the window proc for the control. Note + * that we need to be careful not to reflect a message that + * is targeted to this window, or we will loop. + */ + + HWND target = (message == WM_NOTIFY) + ? ((NMHDR*)lParam)->hwndFrom : (HWND) lParam; + if (target && target != hwnd) { + *resultPtr = SendMessage(target, message, wParam, lParam); + return 1; + } + break; + } + + case WM_LBUTTONDOWN: + case WM_LBUTTONDBLCLK: + case WM_MBUTTONDOWN: + case WM_MBUTTONDBLCLK: + case WM_RBUTTONDOWN: + case WM_RBUTTONDBLCLK: + case WM_LBUTTONUP: + case WM_MBUTTONUP: + case WM_RBUTTONUP: + case WM_MOUSEMOVE: + Tk_PointerEvent(hwnd, (short) LOWORD(lParam), + (short) HIWORD(lParam)); + return 1; + + case WM_CLOSE: + case WM_SETFOCUS: + case WM_KILLFOCUS: + case WM_DESTROYCLIPBOARD: + case WM_CHAR: + case WM_SYSKEYDOWN: + case WM_SYSKEYUP: + case WM_KEYDOWN: + case WM_KEYUP: + GenerateXEvent(hwnd, message, wParam, lParam); + return 1; + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * GenerateXEvent -- + * + * This routine generates an X event from the corresponding + * Windows event. + * + * Results: + * None. + * + * Side effects: + * Queues one or more X events. + * + *---------------------------------------------------------------------- + */ + +static void +GenerateXEvent(hwnd, message, wParam, lParam) + HWND hwnd; + UINT message; + WPARAM wParam; + LPARAM lParam; +{ + XEvent event; + TkWindow *winPtr = (TkWindow *)Tk_HWNDToWindow(hwnd); + + if (!winPtr || winPtr->window == None) { + return; + } + + event.xany.serial = winPtr->display->request++; + event.xany.send_event = False; + event.xany.display = winPtr->display; + event.xany.window = winPtr->window; + + switch (message) { + case WM_PAINT: { + PAINTSTRUCT ps; + + event.type = Expose; + BeginPaint(hwnd, &ps); + event.xexpose.x = ps.rcPaint.left; + event.xexpose.y = ps.rcPaint.top; + event.xexpose.width = ps.rcPaint.right - ps.rcPaint.left; + event.xexpose.height = ps.rcPaint.bottom - ps.rcPaint.top; + EndPaint(hwnd, &ps); + event.xexpose.count = 0; + break; + } + + case WM_CLOSE: + event.type = ClientMessage; + event.xclient.message_type = + Tk_InternAtom((Tk_Window) winPtr, "WM_PROTOCOLS"); + event.xclient.format = 32; + event.xclient.data.l[0] = + Tk_InternAtom((Tk_Window) winPtr, "WM_DELETE_WINDOW"); + break; + + case WM_SETFOCUS: + case WM_KILLFOCUS: { + TkWindow *otherWinPtr = (TkWindow *)Tk_HWNDToWindow((HWND) wParam); + + /* + * Compare toplevel windows to avoid reporting focus + * changes within the same toplevel. + */ + + while (!(winPtr->flags & TK_TOP_LEVEL)) { + winPtr = winPtr->parentPtr; + if (winPtr == NULL) { + return; + } + } + while (otherWinPtr && !(otherWinPtr->flags & TK_TOP_LEVEL)) { + otherWinPtr = otherWinPtr->parentPtr; + } + if (otherWinPtr == winPtr) { + return; + } + + event.xany.window = winPtr->window; + event.type = (message == WM_SETFOCUS) ? FocusIn : FocusOut; + event.xfocus.mode = NotifyNormal; + event.xfocus.detail = NotifyNonlinear; + break; + } + + case WM_DESTROYCLIPBOARD: + event.type = SelectionClear; + event.xselectionclear.selection = + Tk_InternAtom((Tk_Window)winPtr, "CLIPBOARD"); + event.xselectionclear.time = TkpGetMS(); + break; + + case WM_CHAR: + case WM_SYSKEYDOWN: + case WM_SYSKEYUP: + case WM_KEYDOWN: + case WM_KEYUP: { + unsigned int state = GetState(message, wParam, lParam); + Time time = TkpGetMS(); + POINT clientPoint; + POINTS rootPoint; /* Note: POINT and POINTS are different */ + DWORD msgPos; + + /* + * Compute the screen and window coordinates of the event. + */ + + msgPos = GetMessagePos(); + rootPoint = MAKEPOINTS(msgPos); + clientPoint.x = rootPoint.x; + clientPoint.y = rootPoint.y; + ScreenToClient(hwnd, &clientPoint); + + /* + * Set up the common event fields. + */ + + event.xbutton.root = RootWindow(winPtr->display, + winPtr->screenNum); + event.xbutton.subwindow = None; + event.xbutton.x = clientPoint.x; + event.xbutton.y = clientPoint.y; + event.xbutton.x_root = rootPoint.x; + event.xbutton.y_root = rootPoint.y; + event.xbutton.state = state; + event.xbutton.time = time; + event.xbutton.same_screen = True; + + /* + * Now set up event specific fields. + */ + + switch (message) { + case WM_SYSKEYDOWN: + case WM_KEYDOWN: + /* + * Check for translated characters in the event queue. + * Setting xany.send_event to -1 indicates to the + * Windows implementation of XLookupString that this + * event was generated by windows and that the Windows + * extension xkey.trans_chars is filled with the + * characters that came from the TranslateMessage + * call. If it is not -1, xkey.keycode is the + * virtual key being sent programmatically by generic + * code. + */ + + event.type = KeyPress; + event.xany.send_event = -1; + event.xkey.keycode = wParam; + GetTranslatedKey(&event.xkey); + break; + + case WM_SYSKEYUP: + case WM_KEYUP: + /* + * We don't check for translated characters on keyup + * because Tk won't know what to do with them. Instead, we + * wait for the WM_CHAR messages which will follow. + */ + event.type = KeyRelease; + event.xkey.keycode = wParam; + event.xkey.nchars = 0; + break; + + case WM_CHAR: + /* + * Synthesize both a KeyPress and a KeyRelease. + */ + + event.type = KeyPress; + event.xany.send_event = -1; + event.xkey.keycode = 0; + event.xkey.nchars = 1; + event.xkey.trans_chars[0] = (char) wParam; + Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL); + event.type = KeyRelease; + break; + } + break; + } + + default: + return; + } + Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL); +} + +/* + *---------------------------------------------------------------------- + * + * GetState -- + * + * This function constructs a state mask for the mouse buttons + * and modifier keys as they were before the event occured. + * + * Results: + * Returns a composite value of all the modifier and button state + * flags that were set at the time the event occurred. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static unsigned int +GetState(message, wParam, lParam) + UINT message; /* Win32 message type */ + WPARAM wParam; /* wParam of message, used if key message */ + LPARAM lParam; /* lParam of message, used if key message */ +{ + int mask; + int prevState; /* 1 if key was previously down */ + unsigned int state = TkWinGetModifierState(); + + /* + * If the event is a key press or release, we check for modifier + * keys so we can report the state of the world before the event. + */ + + if (message == WM_SYSKEYDOWN || message == WM_KEYDOWN + || message == WM_SYSKEYUP || message == WM_KEYUP) { + mask = 0; + prevState = HIWORD(lParam) & KF_REPEAT; + switch(wParam) { + case VK_SHIFT: + mask = ShiftMask; + break; + case VK_CONTROL: + mask = ControlMask; + break; + case VK_MENU: + mask = Mod2Mask; + break; + case VK_CAPITAL: + if (message == WM_SYSKEYDOWN || message == WM_KEYDOWN) { + mask = LockMask; + prevState = ((state & mask) ^ prevState) ? 0 : 1; + } + break; + case VK_NUMLOCK: + if (message == WM_SYSKEYDOWN || message == WM_KEYDOWN) { + mask = Mod1Mask; + prevState = ((state & mask) ^ prevState) ? 0 : 1; + } + break; + case VK_SCROLL: + if (message == WM_SYSKEYDOWN || message == WM_KEYDOWN) { + mask = Mod3Mask; + prevState = ((state & mask) ^ prevState) ? 0 : 1; + } + break; + } + if (prevState) { + state |= mask; + } else { + state &= ~mask; + } + } + return state; +} + +/* + *---------------------------------------------------------------------- + * + * GetTranslatedKey -- + * + * Retrieves WM_CHAR messages that are placed on the system queue + * by the TranslateMessage system call and places them in the + * given KeyPress event. + * + * Results: + * Sets the trans_chars and nchars member of the key event. + * + * Side effects: + * Removes any WM_CHAR messages waiting on the top of the system + * event queue. + * + *---------------------------------------------------------------------- + */ + +static void +GetTranslatedKey(xkey) + XKeyEvent *xkey; +{ + MSG msg; + + xkey->nchars = 0; + + while (xkey->nchars < XMaxTransChars + && PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) { + if (msg.message == WM_CHAR) { + xkey->trans_chars[xkey->nchars] = (char) msg.wParam; + xkey->nchars++; + GetMessage(&msg, NULL, 0, 0); + if ((msg.message == WM_CHAR) && (msg.lParam & 0x20000000)) { + xkey->state = 0; + } + } else { + break; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * Tk_FreeXId -- + * + * This inteface is not needed under Windows. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Tk_FreeXId(display, xid) + Display *display; + XID xid; +{ +} + +/* + *---------------------------------------------------------------------- + * + * TkWinResendEvent -- + * + * This function converts an X event into a Windows event and + * invokes the specified windo procedure. + * + * Results: + * A standard Windows result. + * + * Side effects: + * Invokes the window procedure + * + *---------------------------------------------------------------------- + */ + +LRESULT +TkWinResendEvent(wndproc, hwnd, eventPtr) + WNDPROC wndproc; + HWND hwnd; + XEvent *eventPtr; +{ + UINT msg; + WPARAM wparam; + LPARAM lparam; + + if (eventPtr->type == ButtonPress) { + switch (eventPtr->xbutton.button) { + case Button1: + msg = WM_LBUTTONDOWN; + wparam = MK_LBUTTON; + break; + case Button2: + msg = WM_MBUTTONDOWN; + wparam = MK_MBUTTON; + break; + case Button3: + msg = WM_RBUTTONDOWN; + wparam = MK_RBUTTON; + break; + default: + return 0; + } + if (eventPtr->xbutton.state & Button1Mask) { + wparam |= MK_LBUTTON; + } + if (eventPtr->xbutton.state & Button2Mask) { + wparam |= MK_MBUTTON; + } + if (eventPtr->xbutton.state & Button3Mask) { + wparam |= MK_RBUTTON; + } + if (eventPtr->xbutton.state & ShiftMask) { + wparam |= MK_SHIFT; + } + if (eventPtr->xbutton.state & ControlMask) { + wparam |= MK_CONTROL; + } + lparam = MAKELPARAM((short) eventPtr->xbutton.x, + (short) eventPtr->xbutton.y); + } else { + return 0; + } + return CallWindowProc(wndproc, hwnd, msg, wparam, lparam); +} + +/* + *---------------------------------------------------------------------- + * + * TkpGetMS -- + * + * Return a relative time in milliseconds. It doesn't matter + * when the epoch was. + * + * Results: + * Number of milliseconds. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +unsigned long +TkpGetMS() +{ + return GetCurrentTime(); +} diff --git a/win/winMain.c b/win/winMain.c new file mode 100644 index 0000000..f263339 --- /dev/null +++ b/win/winMain.c @@ -0,0 +1,323 @@ +/* + * winMain.c -- + * + * Main entry point for wish and other Tk-based applications. + * + * Copyright (c) 1995 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * SCCS: @(#) winMain.c 1.33 96/12/17 12:56:14 + */ + +#include <tk.h> +#define WIN32_LEAN_AND_MEAN +#include <windows.h> +#undef WIN32_LEAN_AND_MEAN +#include <malloc.h> +#include <locale.h> + +/* + * The following declarations refer to internal Tk routines. These + * interfaces are available for use, but are not supported. + */ + +EXTERN void TkConsoleCreate(void); +EXTERN int TkConsoleInit(Tcl_Interp *interp); + +/* + * Forward declarations for procedures defined later in this file: + */ + +static void setargv _ANSI_ARGS_((int *argcPtr, char ***argvPtr)); +static void WishPanic _ANSI_ARGS_(TCL_VARARGS(char *,format)); + +#ifdef TK_TEST +EXTERN int Tktest_Init(Tcl_Interp *interp); +#endif /* TK_TEST */ + + +/* + *---------------------------------------------------------------------- + * + * WinMain -- + * + * Main entry point from Windows. + * + * Results: + * Returns false if initialization fails, otherwise it never + * returns. + * + * Side effects: + * Just about anything, since from here we call arbitrary Tcl code. + * + *---------------------------------------------------------------------- + */ + +int APIENTRY +WinMain(hInstance, hPrevInstance, lpszCmdLine, nCmdShow) + HINSTANCE hInstance; + HINSTANCE hPrevInstance; + LPSTR lpszCmdLine; + int nCmdShow; +{ + char **argv, *p; + int argc; + char buffer[MAX_PATH]; + + Tcl_SetPanicProc(WishPanic); + + /* + * Set up the default locale to be standard "C" locale so parsing + * is performed correctly. + */ + + setlocale(LC_ALL, "C"); + + + /* + * Increase the application queue size from default value of 8. + * At the default value, cross application SendMessage of WM_KILLFOCUS + * will fail because the handler will not be able to do a PostMessage! + * This is only needed for Windows 3.x, since NT dynamically expands + * the queue. + */ + SetMessageQueue(64); + + /* + * Create the console channels and install them as the standard + * channels. All I/O will be discarded until TkConsoleInit is + * called to attach the console to a text widget. + */ + + TkConsoleCreate(); + + setargv(&argc, &argv); + + /* + * Replace argv[0] with full pathname of executable, and forward + * slashes substituted for backslashes. + */ + + GetModuleFileName(NULL, buffer, sizeof(buffer)); + argv[0] = buffer; + for (p = buffer; *p != '\0'; p++) { + if (*p == '\\') { + *p = '/'; + } + } + + Tk_Main(argc, argv, Tcl_AppInit); + return 1; +} + + +/* + *---------------------------------------------------------------------- + * + * Tcl_AppInit -- + * + * This procedure performs application-specific initialization. + * Most applications, especially those that incorporate additional + * packages, will have their own version of this procedure. + * + * Results: + * Returns a standard Tcl completion code, and leaves an error + * message in interp->result if an error occurs. + * + * Side effects: + * Depends on the startup script. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_AppInit(interp) + Tcl_Interp *interp; /* Interpreter for application. */ +{ + if (Tcl_Init(interp) == TCL_ERROR) { + goto error; + } + if (Tk_Init(interp) == TCL_ERROR) { + goto error; + } + Tcl_StaticPackage(interp, "Tk", Tk_Init, Tk_SafeInit); + + /* + * Initialize the console only if we are running as an interactive + * application. + */ + + if (TkConsoleInit(interp) == TCL_ERROR) { + goto error; + } + +#ifdef TK_TEST + if (Tktest_Init(interp) == TCL_ERROR) { + goto error; + } + Tcl_StaticPackage(interp, "Tktest", Tktest_Init, + (Tcl_PackageInitProc *) NULL); +#endif /* TK_TEST */ + + Tcl_SetVar(interp, "tcl_rcFileName", "~/wishrc.tcl", TCL_GLOBAL_ONLY); + return TCL_OK; + +error: + WishPanic(interp->result); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * WishPanic -- + * + * Display a message and exit. + * + * Results: + * None. + * + * Side effects: + * Exits the program. + * + *---------------------------------------------------------------------- + */ + +void +WishPanic TCL_VARARGS_DEF(char *,arg1) +{ + va_list argList; + char buf[1024]; + char *format; + + format = TCL_VARARGS_START(char *,arg1,argList); + vsprintf(buf, format, argList); + + MessageBeep(MB_ICONEXCLAMATION); + MessageBox(NULL, buf, "Fatal Error in Wish", + MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND); +#ifdef _MSC_VER + _asm { + int 3 + } +#endif + ExitProcess(1); +} +/* + *------------------------------------------------------------------------- + * + * setargv -- + * + * Parse the Windows command line string into argc/argv. Done here + * because we don't trust the builtin argument parser in crt0. + * Windows applications are responsible for breaking their command + * line into arguments. + * + * 2N backslashes + quote -> N backslashes + begin quoted string + * 2N + 1 backslashes + quote -> literal + * N backslashes + non-quote -> literal + * quote + quote in a quoted string -> single quote + * quote + quote not in quoted string -> empty string + * quote -> begin quoted string + * + * Results: + * Fills argcPtr with the number of arguments and argvPtr with the + * array of arguments. + * + * Side effects: + * Memory allocated. + * + *-------------------------------------------------------------------------- + */ + +static void +setargv(argcPtr, argvPtr) + int *argcPtr; /* Filled with number of argument strings. */ + char ***argvPtr; /* Filled with argument strings (malloc'd). */ +{ + char *cmdLine, *p, *arg, *argSpace; + char **argv; + int argc, size, inquote, copy, slashes; + + cmdLine = GetCommandLine(); + + /* + * Precompute an overly pessimistic guess at the number of arguments + * in the command line by counting non-space spans. + */ + + size = 2; + for (p = cmdLine; *p != '\0'; p++) { + if (isspace(*p)) { + size++; + while (isspace(*p)) { + p++; + } + if (*p == '\0') { + break; + } + } + } + argSpace = (char *) ckalloc((unsigned) (size * sizeof(char *) + + strlen(cmdLine) + 1)); + argv = (char **) argSpace; + argSpace += size * sizeof(char *); + size--; + + p = cmdLine; + for (argc = 0; argc < size; argc++) { + argv[argc] = arg = argSpace; + while (isspace(*p)) { + p++; + } + if (*p == '\0') { + break; + } + + inquote = 0; + slashes = 0; + while (1) { + copy = 1; + while (*p == '\\') { + slashes++; + p++; + } + if (*p == '"') { + if ((slashes & 1) == 0) { + copy = 0; + if ((inquote) && (p[1] == '"')) { + p++; + copy = 1; + } else { + inquote = !inquote; + } + } + slashes >>= 1; + } + + while (slashes) { + *arg = '\\'; + arg++; + slashes--; + } + + if ((*p == '\0') || (!inquote && isspace(*p))) { + break; + } + if (copy != 0) { + *arg = *p; + arg++; + } + p++; + } + *arg = '\0'; + argSpace = arg + 1; + } + argv[argc] = NULL; + + *argcPtr = argc; + *argvPtr = argv; +} + |
