shared_source/c_tk_base_7_5_w_mods/tkwinwindow.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwinwindow.c,v 1.1.1.1 2001/06/13 05:14:28 dtashley Exp $ */

/* 
 * tkWinWindow.c --
 *
 *      Xlib emulation routines for Windows related to creating,
 *      displaying and destroying windows.
 *
 * 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.
 *
 * RCS: @(#) $Id: tkwinwindow.c,v 1.1.1.1 2001/06/13 05:14:28 dtashley Exp $
 */

#include "tkWinInt.h"

typedef struct ThreadSpecificData {
    int initialized;            /* 0 means table below needs initializing. */
    Tcl_HashTable windowTable;  /* The windowTable maps from HWND to 
                                 * Tk_Window handles. */
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;

/*
 * 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);
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    if (!tsdPtr->initialized) {
        Tcl_InitHashTable(&tsdPtr->windowTable, TCL_ONE_WORD_KEYS);
        tsdPtr->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(&tsdPtr->windowTable,
                (char *)twdPtr->window.handle);
        Tcl_DeleteHashEntry(entryPtr);
    }

    /*
     * Insert the new HWND into the window table.
     */

    twdPtr->window.handle = hwnd;
    entryPtr = Tcl_CreateHashEntry(&tsdPtr->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;
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    if (!tsdPtr->initialized) {
        Tcl_InitHashTable(&tsdPtr->windowTable, TCL_ONE_WORD_KEYS);
        tsdPtr->initialized = 1;
    }
    entryPtr = Tcl_FindHashEntry(&tsdPtr->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 the interp's 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 = CreateWindowEx(WS_EX_NOPARENTNOTIFY, 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);
    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));

    display->request++;

    /*
     * Remove references to the window in the pointer module then
     * release the drawable.
     */

    TkPointerDeadWindow(winPtr);

    entryPtr = Tcl_FindHashEntry(&tsdPtr->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;
}


/* $History: tkWinWindow.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 3:18a
 * Created in $/IjuScripter, IjuConsole/Source/Tk Base
 * Initial check-in.
 */

/* End of TKWINWINDOW.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwinwindow.c,v 1.1.1.1 2001/06/13 05:14:28 dtashley Exp $ */
2
3			/*
4			* tkWinWindow.c --
5			*
6			* Xlib emulation routines for Windows related to creating,
7			* displaying and destroying windows.
8			*
9			* Copyright (c) 1995-1997 Sun Microsystems, Inc.
10			*
11			* See the file "license.terms" for information on usage and redistribution
12			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13			*
14			* RCS: @(#) $Id: tkwinwindow.c,v 1.1.1.1 2001/06/13 05:14:28 dtashley Exp $
15			*/
16
17			#include "tkWinInt.h"
18
19			typedef struct ThreadSpecificData {
20			int initialized; /* 0 means table below needs initializing. */
21			Tcl_HashTable windowTable; /* The windowTable maps from HWND to
22			* Tk_Window handles. */
23			} ThreadSpecificData;
24			static Tcl_ThreadDataKey dataKey;
25
26			/*
27			* Forward declarations for procedures defined in this file:
28			*/
29
30			static void NotifyVisibility _ANSI_ARGS_((XEvent *eventPtr,
31			TkWindow *winPtr));
32			static void StackWindow _ANSI_ARGS_((Window w, Window sibling,
33			int stack_mode));
34
35			/*
36			*----------------------------------------------------------------------
37			*
38			* Tk_AttachHWND --
39			*
40			* This function binds an HWND and a reflection procedure to
41			* the specified Tk_Window.
42			*
43			* Results:
44			* Returns an X Window that encapsulates the HWND.
45			*
46			* Side effects:
47			* May allocate a new X Window. Also enters the HWND into the
48			* global window table.
49			*
50			*----------------------------------------------------------------------
51			*/
52
53			Window
54			Tk_AttachHWND(tkwin, hwnd)
55			Tk_Window tkwin;
56			HWND hwnd;
57			{
58			int new;
59			Tcl_HashEntry *entryPtr;
60			TkWinDrawable twdPtr = (TkWinDrawable ) Tk_WindowId(tkwin);
61			ThreadSpecificData tsdPtr = (ThreadSpecificData )
62			Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
63
64			if (!tsdPtr->initialized) {
65			Tcl_InitHashTable(&tsdPtr->windowTable, TCL_ONE_WORD_KEYS);
66			tsdPtr->initialized = 1;
67			}
68
69			/*
70			* Allocate a new drawable if necessary. Otherwise, remove the
71			* previous HWND from from the window table.
72			*/
73
74			if (twdPtr == NULL) {
75			twdPtr = (TkWinDrawable*) ckalloc(sizeof(TkWinDrawable));
76			twdPtr->type = TWD_WINDOW;
77			twdPtr->window.winPtr = (TkWindow *) tkwin;
78			} else if (twdPtr->window.handle != NULL) {
79			entryPtr = Tcl_FindHashEntry(&tsdPtr->windowTable,
80			(char *)twdPtr->window.handle);
81			Tcl_DeleteHashEntry(entryPtr);
82			}
83
84			/*
85			* Insert the new HWND into the window table.
86			*/
87
88			twdPtr->window.handle = hwnd;
89			entryPtr = Tcl_CreateHashEntry(&tsdPtr->windowTable, (char *)hwnd, &new);
90			Tcl_SetHashValue(entryPtr, (ClientData)tkwin);
91
92			return (Window)twdPtr;
93			}
94
95			/*
96			*----------------------------------------------------------------------
97			*
98			* Tk_HWNDToWindow --
99			*
100			* This function retrieves a Tk_Window from the window table
101			* given an HWND.
102			*
103			* Results:
104			* Returns the matching Tk_Window.
105			*
106			* Side effects:
107			* None.
108			*
109			*----------------------------------------------------------------------
110			*/
111
112			Tk_Window
113			Tk_HWNDToWindow(hwnd)
114			HWND hwnd;
115			{
116			Tcl_HashEntry *entryPtr;
117			ThreadSpecificData tsdPtr = (ThreadSpecificData )
118			Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
119
120			if (!tsdPtr->initialized) {
121			Tcl_InitHashTable(&tsdPtr->windowTable, TCL_ONE_WORD_KEYS);
122			tsdPtr->initialized = 1;
123			}
124			entryPtr = Tcl_FindHashEntry(&tsdPtr->windowTable, (char*)hwnd);
125			if (entryPtr != NULL) {
126			return (Tk_Window) Tcl_GetHashValue(entryPtr);
127			}
128			return NULL;
129			}
130
131			/*
132			*----------------------------------------------------------------------
133			*
134			* Tk_GetHWND --
135			*
136			* This function extracts the HWND from an X Window.
137			*
138			* Results:
139			* Returns the HWND associated with the Window.
140			*
141			* Side effects:
142			* None.
143			*
144			*----------------------------------------------------------------------
145			*/
146
147			HWND
148			Tk_GetHWND(window)
149			Window window;
150			{
151			TkWinDrawable twdPtr = (TkWinDrawable ) window;
152			return twdPtr->window.handle;
153			}
154
155			/*
156			*----------------------------------------------------------------------
157			*
158			* TkpPrintWindowId --
159			*
160			* This routine stores the string representation of the
161			* platform dependent window handle for an X Window in the
162			* given buffer.
163			*
164			* Results:
165			* Returns the result in the specified buffer.
166			*
167			* Side effects:
168			* None.
169			*
170			*----------------------------------------------------------------------
171			*/
172
173			void
174			TkpPrintWindowId(buf, window)
175			char buf; / Pointer to string large enough to hold
176			* the hex representation of a pointer. */
177			Window window; /* Window to be printed into buffer. */
178			{
179			HWND hwnd = (window) ? Tk_GetHWND(window) : 0;
180			sprintf(buf, "0x%x", (unsigned int) hwnd);
181			}
182
183			/*
184			*----------------------------------------------------------------------
185			*
186			* TkpScanWindowId --
187			*
188			* Given a string which represents the platform dependent window
189			* handle, produce the X Window id for the window.
190			*
191			* Results:
192			* The return value is normally TCL_OK; in this case *idPtr
193			* will be set to the X Window id equivalent to string. If
194			* string is improperly formed then TCL_ERROR is returned and
195			* an error message will be left in the interp's result. If the
196			* number does not correspond to a Tk Window, then *idPtr will
197			* be set to None.
198			*
199			* Side effects:
200			* None.
201			*
202			*----------------------------------------------------------------------
203			*/
204
205			int
206			TkpScanWindowId(interp, string, idPtr)
207			Tcl_Interp interp; / Interpreter to use for error reporting. */
208			char string; / String containing a (possibly signed)
209			* integer in a form acceptable to strtol. */
210			int idPtr; / Place to store converted result. */
211			{
212			int number;
213			Tk_Window tkwin;
214
215			if (Tcl_GetInt(interp, string, &number) != TCL_OK) {
216			return TCL_ERROR;
217			}
218			tkwin = Tk_HWNDToWindow((HWND)number);
219			if (tkwin) {
220			*idPtr = Tk_WindowId(tkwin);
221			} else {
222			*idPtr = None;
223			}
224			return TCL_OK;
225			}
226
227			/*
228			*----------------------------------------------------------------------
229			*
230			* TkpMakeWindow --
231			*
232			* Creates a Windows window object based on the current attributes
233			* of the specified TkWindow.
234			*
235			* Results:
236			* Returns a pointer to a new TkWinDrawable cast to a Window.
237			*
238			* Side effects:
239			* Creates a new window.
240			*
241			*----------------------------------------------------------------------
242			*/
243
244			Window
245			TkpMakeWindow(winPtr, parent)
246			TkWindow *winPtr;
247			Window parent;
248			{
249			HWND parentWin;
250			int style;
251			HWND hwnd;
252
253			if (parent != None) {
254			parentWin = Tk_GetHWND(parent);
255			style = WS_CHILD \| WS_CLIPCHILDREN \| WS_CLIPSIBLINGS;
256			} else {
257			parentWin = NULL;
258			style = WS_POPUP \| WS_CLIPCHILDREN;
259			}
260
261			/*
262			* Create the window, then ensure that it is at the top of the
263			* stacking order.
264			*/
265
266			hwnd = CreateWindowEx(WS_EX_NOPARENTNOTIFY, TK_WIN_CHILD_CLASS_NAME, NULL,
267			style, Tk_X(winPtr), Tk_Y(winPtr), Tk_Width(winPtr),
268			Tk_Height(winPtr), parentWin, NULL, Tk_GetHINSTANCE(), NULL);
269			SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
270			SWP_NOACTIVATE \| SWP_NOMOVE \| SWP_NOSIZE);
271			return Tk_AttachHWND((Tk_Window)winPtr, hwnd);
272			}
273
274			/*
275			*----------------------------------------------------------------------
276			*
277			* XDestroyWindow --
278			*
279			* Destroys the given window.
280			*
281			* Results:
282			* None.
283			*
284			* Side effects:
285			* Sends the WM_DESTROY message to the window and then destroys
286			* it the Win32 resources associated with the window.
287			*
288			*----------------------------------------------------------------------
289			*/
290
291			void
292			XDestroyWindow(display, w)
293			Display* display;
294			Window w;
295			{
296			Tcl_HashEntry *entryPtr;
297			TkWinDrawable twdPtr = (TkWinDrawable )w;
298			TkWindow *winPtr = TkWinGetWinPtr(w);
299			HWND hwnd = Tk_GetHWND(w);
300			ThreadSpecificData tsdPtr = (ThreadSpecificData )
301			Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
302
303			display->request++;
304
305			/*
306			* Remove references to the window in the pointer module then
307			* release the drawable.
308			*/
309
310			TkPointerDeadWindow(winPtr);
311
312			entryPtr = Tcl_FindHashEntry(&tsdPtr->windowTable, (char*)hwnd);
313			if (entryPtr != NULL) {
314			Tcl_DeleteHashEntry(entryPtr);
315			}
316
317			ckfree((char *)twdPtr);
318
319			/*
320			* Don't bother destroying the window if we are going to destroy
321			* the parent later.
322			*/
323
324			if (hwnd != NULL && !(winPtr->flags & TK_DONT_DESTROY_WINDOW)) {
325			DestroyWindow(hwnd);
326			}
327			}
328
329			/*
330			*----------------------------------------------------------------------
331			*
332			* XMapWindow --
333			*
334			* Cause the given window to become visible.
335			*
336			* Results:
337			* None
338			*
339			* Side effects:
340			* Causes the window state to change, and generates a MapNotify
341			* event.
342			*
343			*----------------------------------------------------------------------
344			*/
345
346			void
347			XMapWindow(display, w)
348			Display* display;
349			Window w;
350			{
351			XEvent event;
352			TkWindow *parentPtr;
353			TkWindow *winPtr = TkWinGetWinPtr(w);
354
355			display->request++;
356
357			ShowWindow(TkWinGetHWND(w), SW_SHOWNORMAL);
358			winPtr->flags \|= TK_MAPPED;
359
360			/*
361			* Check to see if this window is visible now. If all of the parent
362			* windows up to the first toplevel are mapped, then this window and
363			* its mapped children have just become visible.
364			*/
365
366			if (!(winPtr->flags & TK_TOP_LEVEL)) {
367			for (parentPtr = winPtr->parentPtr; ;
368			parentPtr = parentPtr->parentPtr) {
369			if ((parentPtr == NULL) \|\| !(parentPtr->flags & TK_MAPPED)) {
370			return;
371			}
372			if (parentPtr->flags & TK_TOP_LEVEL) {
373			break;
374			}
375			}
376			} else {
377			event.type = MapNotify;
378			event.xmap.serial = display->request;
379			event.xmap.send_event = False;
380			event.xmap.display = display;
381			event.xmap.event = winPtr->window;
382			event.xmap.window = winPtr->window;
383			event.xmap.override_redirect = winPtr->atts.override_redirect;
384			Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
385			}
386
387			/*
388			* Generate VisibilityNotify events for this window and its mapped
389			* children.
390			*/
391
392			event.type = VisibilityNotify;
393			event.xvisibility.serial = display->request;
394			event.xvisibility.send_event = False;
395			event.xvisibility.display = display;
396			event.xvisibility.window = winPtr->window;
397			event.xvisibility.state = VisibilityUnobscured;
398			NotifyVisibility(&event, winPtr);
399			}
400
401			/*
402			*----------------------------------------------------------------------
403			*
404			* NotifyVisibility --
405			*
406			* This function recursively notifies the mapped children of the
407			* specified window of a change in visibility. Note that we don't
408			* properly report the visibility state, since Windows does not
409			* provide that info. The eventPtr argument must point to an event
410			* that has been completely initialized except for the window slot.
411			*
412			* Results:
413			* None.
414			*
415			* Side effects:
416			* Generates lots of events.
417			*
418			*----------------------------------------------------------------------
419			*/
420
421			static void
422			NotifyVisibility(eventPtr, winPtr)
423			XEvent eventPtr; / Initialized VisibilityNotify event. */
424			TkWindow winPtr; / Window to notify. */
425			{
426			if (winPtr->atts.event_mask & VisibilityChangeMask) {
427			eventPtr->xvisibility.window = winPtr->window;
428			Tk_QueueWindowEvent(eventPtr, TCL_QUEUE_TAIL);
429			}
430			for (winPtr = winPtr->childList; winPtr != NULL;
431			winPtr = winPtr->nextPtr) {
432			if (winPtr->flags & TK_MAPPED) {
433			NotifyVisibility(eventPtr, winPtr);
434			}
435			}
436			}
437
438			/*
439			*----------------------------------------------------------------------
440			*
441			* XUnmapWindow --
442			*
443			* Cause the given window to become invisible.
444			*
445			* Results:
446			* None
447			*
448			* Side effects:
449			* Causes the window state to change, and generates an UnmapNotify
450			* event.
451			*
452			*----------------------------------------------------------------------
453			*/
454
455			void
456			XUnmapWindow(display, w)
457			Display* display;
458			Window w;
459			{
460			XEvent event;
461			TkWindow *winPtr = TkWinGetWinPtr(w);
462
463			display->request++;
464
465			/*
466			* Bug fix: Don't short circuit this routine based on TK_MAPPED because
467			* it will be cleared before XUnmapWindow is called.
468			*/
469
470			ShowWindow(TkWinGetHWND(w), SW_HIDE);
471			winPtr->flags &= ~TK_MAPPED;
472
473			if (winPtr->flags & TK_TOP_LEVEL) {
474			event.type = UnmapNotify;
475			event.xunmap.serial = display->request;
476			event.xunmap.send_event = False;
477			event.xunmap.display = display;
478			event.xunmap.event = winPtr->window;
479			event.xunmap.window = winPtr->window;
480			event.xunmap.from_configure = False;
481			Tk_HandleEvent(&event);
482			}
483			}
484
485			/*
486			*----------------------------------------------------------------------
487			*
488			* XMoveResizeWindow --
489			*
490			* Move and resize a window relative to its parent.
491			*
492			* Results:
493			* None.
494			*
495			* Side effects:
496			* Repositions and resizes the specified window.
497			*
498			*----------------------------------------------------------------------
499			*/
500
501			void
502			XMoveResizeWindow(display, w, x, y, width, height)
503			Display* display;
504			Window w;
505			int x; /* Position relative to parent. */
506			int y;
507			unsigned int width;
508			unsigned int height;
509			{
510			display->request++;
511			MoveWindow(TkWinGetHWND(w), x, y, width, height, TRUE);
512			}
513
514			/*
515			*----------------------------------------------------------------------
516			*
517			* XMoveWindow --
518			*
519			* Move a window relative to its parent.
520			*
521			* Results:
522			* None.
523			*
524			* Side effects:
525			* Repositions the specified window.
526			*
527			*----------------------------------------------------------------------
528			*/
529
530			void
531			XMoveWindow(display, w, x, y)
532			Display* display;
533			Window w;
534			int x;
535			int y;
536			{
537			TkWindow *winPtr = TkWinGetWinPtr(w);
538
539			display->request++;
540
541			MoveWindow(TkWinGetHWND(w), x, y, winPtr->changes.width,
542			winPtr->changes.height, TRUE);
543			}
544
545			/*
546			*----------------------------------------------------------------------
547			*
548			* XResizeWindow --
549			*
550			* Resize a window.
551			*
552			* Results:
553			* None.
554			*
555			* Side effects:
556			* Resizes the specified window.
557			*
558			*----------------------------------------------------------------------
559			*/
560
561			void
562			XResizeWindow(display, w, width, height)
563			Display* display;
564			Window w;
565			unsigned int width;
566			unsigned int height;
567			{
568			TkWindow *winPtr = TkWinGetWinPtr(w);
569
570			display->request++;
571
572			MoveWindow(TkWinGetHWND(w), winPtr->changes.x, winPtr->changes.y, width,
573			height, TRUE);
574			}
575
576			/*
577			*----------------------------------------------------------------------
578			*
579			* XRaiseWindow --
580			*
581			* Change the stacking order of a window.
582			*
583			* Results:
584			* None.
585			*
586			* Side effects:
587			* Changes the stacking order of the specified window.
588			*
589			*----------------------------------------------------------------------
590			*/
591
592			void
593			XRaiseWindow(display, w)
594			Display* display;
595			Window w;
596			{
597			HWND window = TkWinGetHWND(w);
598
599			display->request++;
600			SetWindowPos(window, HWND_TOPMOST, 0, 0, 0, 0,
601			SWP_NOMOVE \| SWP_NOSIZE);
602			}
603
604			/*
605			*----------------------------------------------------------------------
606			*
607			* XConfigureWindow --
608			*
609			* Change the size, position, stacking, or border of the specified
610			* window.
611			*
612			* Results:
613			* None.
614			*
615			* Side effects:
616			* Changes the attributes of the specified window. Note that we
617			* ignore the passed in values and use the values stored in the
618			* TkWindow data structure.
619			*
620			*----------------------------------------------------------------------
621			*/
622
623			void
624			XConfigureWindow(display, w, value_mask, values)
625			Display* display;
626			Window w;
627			unsigned int value_mask;
628			XWindowChanges* values;
629			{
630			TkWindow *winPtr = TkWinGetWinPtr(w);
631			HWND hwnd = TkWinGetHWND(w);
632
633			display->request++;
634
635			/*
636			* Change the shape and/or position of the window.
637			*/
638
639			if (value_mask & (CWX\|CWY\|CWWidth\|CWHeight)) {
640			MoveWindow(hwnd, winPtr->changes.x, winPtr->changes.y,
641			winPtr->changes.width, winPtr->changes.height, TRUE);
642			}
643
644			/*
645			* Change the stacking order of the window.
646			*/
647
648			if (value_mask & CWStackMode) {
649			HWND sibling;
650			if ((value_mask & CWSibling) && (values->sibling != None)) {
651			sibling = Tk_GetHWND(values->sibling);
652			} else {
653			sibling = NULL;
654			}
655			TkWinSetWindowPos(hwnd, sibling, values->stack_mode);
656			}
657			}
658
659			/*
660			*----------------------------------------------------------------------
661			*
662			* XClearWindow --
663			*
664			* Clears the entire window to the current background color.
665			*
666			* Results:
667			* None.
668			*
669			* Side effects:
670			* Erases the current contents of the window.
671			*
672			*----------------------------------------------------------------------
673			*/
674
675			void
676			XClearWindow(display, w)
677			Display* display;
678			Window w;
679			{
680			RECT rc;
681			HBRUSH brush;
682			HPALETTE oldPalette, palette;
683			TkWindow *winPtr;
684			HWND hwnd = TkWinGetHWND(w);
685			HDC dc = GetDC(hwnd);
686
687			palette = TkWinGetPalette(display->screens[0].cmap);
688			oldPalette = SelectPalette(dc, palette, FALSE);
689
690			display->request++;
691
692			winPtr = TkWinGetWinPtr(w);
693			brush = CreateSolidBrush(winPtr->atts.background_pixel);
694			GetWindowRect(hwnd, &rc);
695			rc.right = rc.right - rc.left;
696			rc.bottom = rc.bottom - rc.top;
697			rc.left = rc.top = 0;
698			FillRect(dc, &rc, brush);
699
700			DeleteObject(brush);
701			SelectPalette(dc, oldPalette, TRUE);
702			ReleaseDC(hwnd, dc);
703			}
704
705			/*
706			*----------------------------------------------------------------------
707			*
708			* XChangeWindowAttributes --
709			*
710			* This function is called when the attributes on a window are
711			* updated. Since Tk maintains all of the window state, the only
712			* relevant value is the cursor.
713			*
714			* Results:
715			* None.
716			*
717			* Side effects:
718			* May cause the mouse position to be updated.
719			*
720			*----------------------------------------------------------------------
721			*/
722
723			void
724			XChangeWindowAttributes(display, w, valueMask, attributes)
725			Display* display;
726			Window w;
727			unsigned long valueMask;
728			XSetWindowAttributes* attributes;
729			{
730			if (valueMask & CWCursor) {
731			XDefineCursor(display, w, attributes->cursor);
732			}
733			}
734
735			/*
736			*----------------------------------------------------------------------
737			*
738			* TkWinSetWindowPos --
739			*
740			* Adjust the stacking order of a window relative to a second
741			* window (or NULL).
742			*
743			* Results:
744			* None.
745			*
746			* Side effects:
747			* Moves the specified window in the stacking order.
748			*
749			*----------------------------------------------------------------------
750			*/
751
752			void
753			TkWinSetWindowPos(hwnd, siblingHwnd, pos)
754			HWND hwnd; /* Window to restack. */
755			HWND siblingHwnd; /* Sibling window. */
756			int pos; /* One of Above or Below. */
757			{
758			HWND temp;
759
760			/*
761			* Since Windows does not support Above mode, we place the
762			* specified window below the sibling and then swap them.
763			*/
764
765			if (siblingHwnd) {
766			if (pos == Above) {
767			SetWindowPos(hwnd, siblingHwnd, 0, 0, 0, 0,
768			SWP_NOACTIVATE \| SWP_NOMOVE \| SWP_NOSIZE);
769			temp = hwnd;
770			hwnd = siblingHwnd;
771			siblingHwnd = temp;
772			}
773			} else {
774			siblingHwnd = (pos == Above) ? HWND_TOP : HWND_BOTTOM;
775			}
776
777			SetWindowPos(hwnd, siblingHwnd, 0, 0, 0, 0,
778			SWP_NOACTIVATE \| SWP_NOMOVE \| SWP_NOSIZE);
779			}
780
781			/*
782			*----------------------------------------------------------------------
783			*
784			* TkpWindowWasRecentlyDeleted --
785			*
786			* Determines whether we know if the window given as argument was
787			* recently deleted. Called by the generic code error handler to
788			* handle BadWindow events.
789			*
790			* Results:
791			* Always 0. We do not keep this information on Windows.
792			*
793			* Side effects:
794			* None.
795			*
796			*----------------------------------------------------------------------
797			*/
798
799			int
800			TkpWindowWasRecentlyDeleted(win, dispPtr)
801			Window win;
802			TkDisplay *dispPtr;
803			{
804			return 0;
805			}
806
807
808			/* $History: tkWinWindow.c $
809			*
810			* *************** Version 1 ***************
811			* User: Dtashley Date: 1/02/01 Time: 3:18a
812			* Created in $/IjuScripter, IjuConsole/Source/Tk Base
813			* Initial check-in.
814			*/
815
816			/* End of TKWINWINDOW.C */