/[dtapublic]/projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkwinembed.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkwinembed.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 44 - (hide annotations) (download)
Fri Oct 14 02:09:58 2016 UTC (7 years, 9 months ago) by dashley
File MIME type: text/plain
File size: 20616 byte(s)
Rename for reorganization.
1 dashley 25 /* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwinembed.c,v 1.1.1.1 2001/06/13 05:13:10 dtashley Exp $ */
2    
3     /*
4     * tkWinEmbed.c --
5     *
6     * This file contains platform specific procedures for Windows platforms
7     * to provide basic operations needed for application embedding (where
8     * one application can use as its main window an internal window from
9     * another application).
10     *
11     * Copyright (c) 1996-1997 Sun Microsystems, Inc.
12     *
13     * See the file "license.terms" for information on usage and redistribution
14     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
15     *
16     * RCS: @(#) $Id: tkwinembed.c,v 1.1.1.1 2001/06/13 05:13:10 dtashley Exp $
17     */
18    
19     #include "tkWinInt.h"
20    
21    
22     /*
23     * One of the following structures exists for each container in this
24     * application. It keeps track of the container window and its
25     * associated embedded window.
26     */
27    
28     typedef struct Container {
29     HWND parentHWnd; /* Windows HWND to the parent window */
30     TkWindow *parentPtr; /* Tk's information about the container
31     * or NULL if the container isn't
32     * in this process. */
33     HWND embeddedHWnd; /* Windows HWND to the embedded window
34     */
35     TkWindow *embeddedPtr; /* Tk's information about the embedded
36     * window, or NULL if the
37     * embedded application isn't in
38     * this process. */
39     struct Container *nextPtr; /* Next in list of all containers in
40     * this process. */
41     } Container;
42    
43     typedef struct ThreadSpecificData {
44     Container *firstContainerPtr; /* First in list of all containers
45     * managed by this process. */
46     } ThreadSpecificData;
47     static Tcl_ThreadDataKey dataKey;
48    
49     static void CleanupContainerList _ANSI_ARGS_((
50     ClientData clientData));
51     static void ContainerEventProc _ANSI_ARGS_((ClientData clientData,
52     XEvent *eventPtr));
53     static void EmbeddedEventProc _ANSI_ARGS_((
54     ClientData clientData, XEvent *eventPtr));
55     static void EmbedGeometryRequest _ANSI_ARGS_((
56     Container*containerPtr, int width, int height));
57     static void EmbedWindowDeleted _ANSI_ARGS_((TkWindow *winPtr));
58    
59     /*
60     *----------------------------------------------------------------------
61     *
62     * CleanupContainerList --
63     *
64     * Finalizes the list of containers.
65     *
66     * Results:
67     * None.
68     *
69     * Side effects:
70     * Releases memory occupied by containers of embedded windows.
71     *
72     *----------------------------------------------------------------------
73     */
74    
75     /* ARGSUSED */
76     static void
77     CleanupContainerList(clientData)
78     ClientData clientData;
79     {
80     Container *nextPtr;
81     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
82     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
83    
84     for (;
85     tsdPtr->firstContainerPtr != (Container *) NULL;
86     tsdPtr->firstContainerPtr = nextPtr) {
87     nextPtr = tsdPtr->firstContainerPtr->nextPtr;
88     ckfree((char *) tsdPtr->firstContainerPtr);
89     }
90     tsdPtr->firstContainerPtr = (Container *) NULL;
91     }
92    
93     /*
94     *----------------------------------------------------------------------
95     *
96     * TkpTestembedCmd --
97     *
98     * Test command for the embedding facility.
99     *
100     * Results:
101     * Always returns TCL_OK.
102     *
103     * Side effects:
104     * Currently it does not do anything.
105     *
106     *----------------------------------------------------------------------
107     */
108    
109     /* ARGSUSED */
110     int
111     TkpTestembedCmd(clientData, interp, argc, argv)
112     ClientData clientData;
113     Tcl_Interp *interp;
114     int argc;
115     char **argv;
116     {
117     return TCL_OK;
118     }
119    
120     /*
121     *----------------------------------------------------------------------
122     *
123     * TkpUseWindow --
124     *
125     * This procedure causes a Tk window to use a given Windows handle
126     * for a window as its underlying window, rather than a new Windows
127     * window being created automatically. It is invoked by an embedded
128     * application to specify the window in which the application is
129     * embedded.
130     *
131     * Results:
132     * The return value is normally TCL_OK. If an error occurred (such as
133     * if the argument does not identify a legal Windows window handle),
134     * the return value is TCL_ERROR and an error message is left in the
135     * the interp's result if interp is not NULL.
136     *
137     * Side effects:
138     * None.
139     *
140     *----------------------------------------------------------------------
141     */
142    
143     int
144     TkpUseWindow(interp, tkwin, string)
145     Tcl_Interp *interp; /* If not NULL, used for error reporting
146     * if string is bogus. */
147     Tk_Window tkwin; /* Tk window that does not yet have an
148     * associated X window. */
149     char *string; /* String identifying an X window to use
150     * for tkwin; must be an integer value. */
151     {
152     TkWindow *winPtr = (TkWindow *) tkwin;
153     int id;
154     HWND hwnd;
155     Container *containerPtr;
156     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
157     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
158    
159     if (winPtr->window != None) {
160     panic("TkpUseWindow: Already assigned a window");
161     }
162    
163     if (Tcl_GetInt(interp, string, &id) != TCL_OK) {
164     return TCL_ERROR;
165     }
166     hwnd = (HWND) id;
167    
168     /*
169     * Check if the window is a valid handle. If it is invalid, return
170     * TCL_ERROR and potentially leave an error message in the interp's
171     * result.
172     */
173    
174     if (!IsWindow(hwnd)) {
175     if (interp != (Tcl_Interp *) NULL) {
176     Tcl_AppendResult(interp, "window \"", string,
177     "\" doesn't exist", (char *) NULL);
178     }
179     return TCL_ERROR;
180     }
181    
182     /*
183     * Store the parent window in the platform private data slot so
184     * TkWmMapWindow can use it when creating the wrapper window.
185     */
186    
187     winPtr->privatePtr = (struct TkWindowPrivate*) hwnd;
188    
189     /*
190     * Create an event handler to clean up the Container structure when
191     * tkwin is eventually deleted.
192     */
193    
194     Tk_CreateEventHandler(tkwin, StructureNotifyMask, EmbeddedEventProc,
195     (ClientData) winPtr);
196    
197     /*
198     * If this is the first container, register an exit handler so that
199     * things will get cleaned up at finalization.
200     */
201    
202     if (tsdPtr->firstContainerPtr == (Container *) NULL) {
203     Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
204     }
205    
206     /*
207     * Save information about the container and the embedded window
208     * in a Container structure. If there is already an existing
209     * Container structure, it means that both container and embedded
210     * app. are in the same process.
211     */
212    
213     for (containerPtr = tsdPtr->firstContainerPtr;
214     containerPtr != NULL; containerPtr = containerPtr->nextPtr) {
215     if (containerPtr->parentHWnd == hwnd) {
216     winPtr->flags |= TK_BOTH_HALVES;
217     containerPtr->parentPtr->flags |= TK_BOTH_HALVES;
218     break;
219     }
220     }
221     if (containerPtr == NULL) {
222     containerPtr = (Container *) ckalloc(sizeof(Container));
223     containerPtr->parentPtr = NULL;
224     containerPtr->parentHWnd = hwnd;
225     containerPtr->nextPtr = tsdPtr->firstContainerPtr;
226     tsdPtr->firstContainerPtr = containerPtr;
227     }
228    
229     /*
230     * embeddedHWnd is not created yet. It will be created by TkWmMapWindow(),
231     * which will send a TK_ATTACHWINDOW to the container window.
232     * TkWinEmbeddedEventProc will process this message and set the embeddedHWnd
233     * variable
234     */
235    
236     containerPtr->embeddedPtr = winPtr;
237     containerPtr->embeddedHWnd = NULL;
238    
239     winPtr->flags |= TK_EMBEDDED;
240     winPtr->flags &= (~(TK_MAPPED));
241    
242     return TCL_OK;
243     }
244    
245     /*
246     *----------------------------------------------------------------------
247     *
248     * TkpMakeContainer --
249     *
250     * This procedure is called to indicate that a particular window will
251     * be a container for an embedded application. This changes certain
252     * aspects of the window's behavior, such as whether it will receive
253     * events anymore.
254     *
255     * Results:
256     * None.
257     *
258     * Side effects:
259     * None.
260     *
261     *----------------------------------------------------------------------
262     */
263    
264     void
265     TkpMakeContainer(tkwin)
266     Tk_Window tkwin;
267     {
268     TkWindow *winPtr = (TkWindow *) tkwin;
269     Container *containerPtr;
270     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
271     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
272    
273     /*
274     * If this is the first container, register an exit handler so that
275     * things will get cleaned up at finalization.
276     */
277    
278     if (tsdPtr->firstContainerPtr == (Container *) NULL) {
279     Tcl_CreateExitHandler(CleanupContainerList, (ClientData) NULL);
280     }
281    
282     /*
283     * Register the window as a container so that, for example, we can
284     * find out later if the embedded app. is in the same process.
285     */
286    
287     Tk_MakeWindowExist(tkwin);
288     containerPtr = (Container *) ckalloc(sizeof(Container));
289     containerPtr->parentPtr = winPtr;
290     containerPtr->parentHWnd = Tk_GetHWND(Tk_WindowId(tkwin));
291     containerPtr->embeddedHWnd = NULL;
292     containerPtr->embeddedPtr = NULL;
293     containerPtr->nextPtr = tsdPtr->firstContainerPtr;
294     tsdPtr->firstContainerPtr = containerPtr;
295     winPtr->flags |= TK_CONTAINER;
296    
297     /*
298     * Unlike in tkUnixEmbed.c, we don't make any requests for events
299     * in the embedded window here. Now we just allow the embedding
300     * of another TK application into TK windows. When the embedded
301     * window makes a request, that will be done by sending to the
302     * container window a WM_USER message, which will be intercepted
303     * by TkWinContainerProc.
304     *
305     * We need to get structure events of the container itself, though.
306     */
307    
308     Tk_CreateEventHandler(tkwin, StructureNotifyMask,
309     ContainerEventProc, (ClientData) containerPtr);
310     }
311    
312     /*
313     *----------------------------------------------------------------------
314     *
315     * EmbeddedEventProc --
316     *
317     * This procedure is invoked by the Tk event dispatcher when various
318     * useful events are received for a window that is embedded in
319     * another application.
320     *
321     * Results:
322     * None.
323     *
324     * Side effects:
325     * Our internal state gets cleaned up when an embedded window is
326     * destroyed.
327     *
328     *----------------------------------------------------------------------
329     */
330    
331     static void
332     EmbeddedEventProc(clientData, eventPtr)
333     ClientData clientData; /* Token for container window. */
334     XEvent *eventPtr; /* ResizeRequest event. */
335     {
336     TkWindow *winPtr = (TkWindow *) clientData;
337    
338     if (eventPtr->type == DestroyNotify) {
339     EmbedWindowDeleted(winPtr);
340     }
341     }
342    
343     /*
344     *----------------------------------------------------------------------
345     *
346     * TkWinEmbeddedEventProc --
347     *
348     * This procedure is invoked by the Tk event dispatcher when
349     * various useful events are received for the *children* of a
350     * container window. It forwards relevant information, such as
351     * geometry requests, from the events into the container's
352     * application.
353     *
354     * Results:
355     * None.
356     *
357     * Side effects:
358     * Depends on the event. For example, when ConfigureRequest events
359     * occur, geometry information gets set for the container window.
360     *
361     *----------------------------------------------------------------------
362     */
363    
364     LRESULT
365     TkWinEmbeddedEventProc(hwnd, message, wParam, lParam)
366     HWND hwnd;
367     UINT message;
368     WPARAM wParam;
369     LPARAM lParam;
370     {
371     Container *containerPtr;
372     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
373     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
374    
375     /*
376     * Find the Container structure associated with the parent window.
377     */
378    
379     for (containerPtr = tsdPtr->firstContainerPtr;
380     containerPtr->parentHWnd != hwnd;
381     containerPtr = containerPtr->nextPtr) {
382     if (containerPtr == NULL) {
383     panic("TkWinContainerProc couldn't find Container record");
384     }
385     }
386    
387     switch (message) {
388     case TK_ATTACHWINDOW:
389     /* An embedded window (either from this application or from
390     * another application) is trying to attach to this container.
391     * We attach it only if this container is not yet containing any
392     * window.
393     */
394     if (containerPtr->embeddedHWnd == NULL) {
395     containerPtr->embeddedHWnd = (HWND)wParam;
396     } else {
397     return 0;
398     }
399    
400     break;
401     case TK_GEOMETRYREQ:
402     EmbedGeometryRequest(containerPtr, wParam, lParam);
403     break;
404     }
405     return 1;
406     }
407    
408     /*
409     *----------------------------------------------------------------------
410     *
411     * EmbedGeometryRequest --
412     *
413     * This procedure is invoked when an embedded application requests
414     * a particular size. It processes the request (which may or may
415     * not actually resize the window) and reflects the results back
416     * to the embedded application.
417     *
418     * Results:
419     * None.
420     *
421     * Side effects:
422     * If we deny the child's size change request, a Configure event
423     * is synthesized to let the child know that the size is the same
424     * as it used to be. Events get processed while we're waiting for
425     * the geometry managers to do their thing.
426     *
427     *----------------------------------------------------------------------
428     */
429    
430     void
431     EmbedGeometryRequest(containerPtr, width, height)
432     Container *containerPtr; /* Information about the container window. */
433     int width, height; /* Size that the child has requested. */
434     {
435     TkWindow * winPtr = containerPtr->parentPtr;
436    
437     /*
438     * Forward the requested size into our geometry management hierarchy
439     * via the container window. We need to send a Configure event back
440     * to the embedded application even if we decide not to resize
441     * the window; to make this happen, process all idle event handlers
442     * synchronously here (so that the geometry managers have had a
443     * chance to do whatever they want to do), and if the window's size
444     * didn't change then generate a configure event.
445     */
446     Tk_GeometryRequest((Tk_Window)winPtr, width, height);
447    
448     if (containerPtr->embeddedHWnd != NULL) {
449     while (Tcl_DoOneEvent(TCL_IDLE_EVENTS)) {
450     /* Empty loop body. */
451     }
452    
453     SetWindowPos(containerPtr->embeddedHWnd, NULL,
454     0, 0, winPtr->changes.width, winPtr->changes.height, SWP_NOZORDER);
455     }
456     }
457    
458     /*
459     *----------------------------------------------------------------------
460     *
461     * ContainerEventProc --
462     *
463     * This procedure is invoked by the Tk event dispatcher when
464     * various useful events are received for the container window.
465     *
466     * Results:
467     * None.
468     *
469     * Side effects:
470     * Depends on the event. For example, when ConfigureRequest events
471     * occur, geometry information gets set for the container window.
472     *
473     *----------------------------------------------------------------------
474     */
475    
476     static void
477     ContainerEventProc(clientData, eventPtr)
478     ClientData clientData; /* Token for container window. */
479     XEvent *eventPtr; /* ResizeRequest event. */
480     {
481     Container *containerPtr = (Container *)clientData;
482     Tk_Window tkwin = (Tk_Window)containerPtr->parentPtr;
483    
484     if (eventPtr->type == ConfigureNotify) {
485     if (containerPtr->embeddedPtr == NULL) {
486     return;
487     }
488     /* Resize the embedded window, if there is any */
489     if (containerPtr->embeddedHWnd) {
490     SetWindowPos(containerPtr->embeddedHWnd, NULL,
491     0, 0, Tk_Width(tkwin), Tk_Height(tkwin), SWP_NOZORDER);
492     }
493     } else if (eventPtr->type == DestroyNotify) {
494     /* The container is gone, remove it from the list */
495     EmbedWindowDeleted(containerPtr->parentPtr);
496     }
497     }
498    
499     /*
500     *----------------------------------------------------------------------
501     *
502     * TkpGetOtherWindow --
503     *
504     * If both the container and embedded window are in the same
505     * process, this procedure will return either one, given the other.
506     *
507     * Results:
508     * If winPtr is a container, the return value is the token for the
509     * embedded window, and vice versa. If the "other" window isn't in
510     * this process, NULL is returned.
511     *
512     * Side effects:
513     * None.
514     *
515     *----------------------------------------------------------------------
516     */
517    
518     TkWindow *
519     TkpGetOtherWindow(winPtr)
520     TkWindow *winPtr; /* Tk's structure for a container or
521     * embedded window. */
522     {
523     Container *containerPtr;
524     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
525     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
526    
527     for (containerPtr = tsdPtr->firstContainerPtr; containerPtr != NULL;
528     containerPtr = containerPtr->nextPtr) {
529     if (containerPtr->embeddedPtr == winPtr) {
530     return containerPtr->parentPtr;
531     } else if (containerPtr->parentPtr == winPtr) {
532     return containerPtr->embeddedPtr;
533     }
534     }
535     panic("TkpGetOtherWindow couldn't find window");
536     return NULL;
537     }
538    
539     /*
540     *----------------------------------------------------------------------
541     *
542     * TkpClaimFocus --
543     *
544     * This procedure is invoked when someone asks or the input focus
545     * to be put on a window in an embedded application, but the
546     * application doesn't currently have the focus. It requests the
547     * input focus from the container application.
548     *
549     * Results:
550     * None.
551     *
552     * Side effects:
553     * The input focus may change.
554     *
555     *----------------------------------------------------------------------
556     */
557    
558     void
559     TkpClaimFocus(topLevelPtr, force)
560     TkWindow *topLevelPtr; /* Top-level window containing desired
561     * focus window; should be embedded. */
562     int force; /* One means that the container should
563     * claim the focus if it doesn't
564     * currently have it. */
565     {
566     HWND hwnd = GetParent(Tk_GetHWND(topLevelPtr->window));
567     SendMessage(hwnd, TK_CLAIMFOCUS, (WPARAM) force, 0);
568     }
569    
570     /*
571     *----------------------------------------------------------------------
572     *
573     * TkpRedirectKeyEvent --
574     *
575     * This procedure is invoked when a key press or release event
576     * arrives for an application that does not believe it owns the
577     * input focus. This can happen because of embedding; for example,
578     * X can send an event to an embedded application when the real
579     * focus window is in the container application and is an ancestor
580     * of the container. This procedure's job is to forward the event
581     * back to the application where it really belongs.
582     *
583     * Results:
584     * None.
585     *
586     * Side effects:
587     * The event may get sent to a different application.
588     *
589     *----------------------------------------------------------------------
590     */
591    
592     void
593     TkpRedirectKeyEvent(winPtr, eventPtr)
594     TkWindow *winPtr; /* Window to which the event was originally
595     * reported. */
596     XEvent *eventPtr; /* X event to redirect (should be KeyPress
597     * or KeyRelease). */
598     {
599     /* not implemented */
600     }
601    
602     /*
603     *----------------------------------------------------------------------
604     *
605     * EmbedWindowDeleted --
606     *
607     * This procedure is invoked when a window involved in embedding
608     * (as either the container or the embedded application) is
609     * destroyed. It cleans up the Container structure for the window.
610     *
611     * Results:
612     * None.
613     *
614     * Side effects:
615     * A Container structure may be freed.
616     *
617     *----------------------------------------------------------------------
618     */
619    
620     static void
621     EmbedWindowDeleted(winPtr)
622     TkWindow *winPtr; /* Tk's information about window that
623     * was deleted. */
624     {
625     Container *containerPtr, *prevPtr;
626     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
627     Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
628    
629     /*
630     * Find the Container structure for this window work. Delete the
631     * information about the embedded application and free the container's
632     * record.
633     */
634    
635     prevPtr = NULL;
636     containerPtr = tsdPtr->firstContainerPtr;
637     while (1) {
638     if (containerPtr->embeddedPtr == winPtr) {
639     containerPtr->embeddedHWnd = NULL;
640     containerPtr->embeddedPtr = NULL;
641     break;
642     }
643     if (containerPtr->parentPtr == winPtr) {
644     containerPtr->parentPtr = NULL;
645     break;
646     }
647     prevPtr = containerPtr;
648     containerPtr = containerPtr->nextPtr;
649     if (containerPtr == NULL) {
650     panic("EmbedWindowDeleted couldn't find window");
651     }
652     }
653     if ((containerPtr->embeddedPtr == NULL)
654     && (containerPtr->parentPtr == NULL)) {
655     if (prevPtr == NULL) {
656     tsdPtr->firstContainerPtr = containerPtr->nextPtr;
657     } else {
658     prevPtr->nextPtr = containerPtr->nextPtr;
659     }
660     ckfree((char *) containerPtr);
661     }
662     }
663    
664    
665     /* $History: tkWinEmbed.c $
666     *
667     * ***************** Version 1 *****************
668     * User: Dtashley Date: 1/02/01 Time: 3:16a
669     * Created in $/IjuScripter, IjuConsole/Source/Tk Base
670     * Initial check-in.
671     */
672    
673     /* End of TKWINEMBED.C */

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25