home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xt / Display.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  15.0 KB  |  572 lines
  1. /* $XConsortium: Display.c,v 1.89 93/03/15 15:27:35 converse Exp $ */
  2.  
  3. /***********************************************************
  4. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  5. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  6.  
  7.                         All Rights Reserved
  8.  
  9. Permission to use, copy, modify, and distribute this software and its 
  10. documentation for any purpose and without fee is hereby granted, 
  11. provided that the above copyright notice appear in all copies and that
  12. both that copyright notice and this permission notice appear in 
  13. supporting documentation, and that the names of Digital or MIT not be
  14. used in advertising or publicity pertaining to distribution of the
  15. software without specific, written prior permission.  
  16.  
  17. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  19. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  20. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23. SOFTWARE.
  24.  
  25. ******************************************************************/
  26.  
  27. #include "IntrinsicI.h"
  28.  
  29. #ifndef X_NOT_STDC_ENV
  30. #include <stdlib.h>
  31. #else
  32. extern char* getenv();
  33. #endif
  34.  
  35. static String XtNnoPerDisplay = "noPerDisplay";
  36.  
  37. extern void _XtHeapInit();
  38. extern void _XtHeapFree();
  39. extern XrmDatabase _XtPreparseCommandLine();
  40.  
  41. ProcessContext _XtGetProcessContext()
  42. {
  43.     static ProcessContextRec processContextRec = {
  44.     (XtAppContext)NULL,
  45.     (XtAppContext)NULL,
  46.     (ConverterTable)NULL,
  47.     {(XtLanguageProc)NULL, (XtPointer)NULL}
  48.     };
  49.  
  50.     return &processContextRec;
  51. }
  52.  
  53.  
  54. XtAppContext _XtDefaultAppContext()
  55. {
  56.     register ProcessContext process = _XtGetProcessContext();
  57.     if (process->defaultAppContext == NULL) {
  58.     process->defaultAppContext = XtCreateApplicationContext();
  59.     }
  60.     return process->defaultAppContext;
  61. }
  62.  
  63. static void XtAddToAppContext(d, app)
  64.     Display *d;
  65.     XtAppContext app;
  66. {
  67. #define DISPLAYS_TO_ADD 4
  68.  
  69.     if (app->count >= app->max) {
  70.         app->max += DISPLAYS_TO_ADD;
  71.         app->list = (Display **) XtRealloc((char *)app->list,
  72.             (unsigned) app->max * sizeof(Display *));
  73.     }
  74.  
  75.     app->list[app->count++] = d;
  76.     if (ConnectionNumber(d) + 1 > app->fds.nfds) {
  77.         app->fds.nfds = ConnectionNumber(d) + 1;
  78.     }
  79. #undef DISPLAYS_TO_ADD
  80. }
  81.  
  82. static void XtDeleteFromAppContext(d, app)
  83.     Display *d;
  84.     register XtAppContext app;
  85. {
  86.     register int i;
  87.  
  88.     for (i = 0; i < app->count; i++) if (app->list[i] == d) break;
  89.  
  90.     if (i < app->count) {
  91.         if (i <= app->last && app->last > 0) app->last--;
  92.         for (i++; i < app->count; i++) app->list[i-1] = app->list[i];
  93.         app->count--;
  94.     }
  95. }
  96.  
  97. static XtPerDisplay NewPerDisplay();
  98.  
  99. static XtPerDisplay InitPerDisplay(dpy, app, name, classname)
  100.     Display *dpy;
  101.     XtAppContext app;
  102.     String name;
  103.     String classname;
  104. {
  105.     XtPerDisplay pd;
  106.     extern void _XtAllocWWTable(), _XtAllocTMContext();
  107.  
  108.     XtAddToAppContext(dpy, app);
  109.  
  110.     pd = NewPerDisplay(dpy);
  111.     _XtHeapInit(&pd->heap);
  112.     pd->destroy_callbacks = NULL;
  113.     pd->region = XCreateRegion();
  114.     pd->case_cvt = NULL;
  115.     pd->defaultKeycodeTranslator = XtTranslateKey;
  116.     pd->keysyms_serial = 0;
  117.     pd->keysyms = NULL;
  118.     XDisplayKeycodes(dpy, &pd->min_keycode, &pd->max_keycode);
  119.     pd->modKeysyms = NULL;
  120.     pd->modsToKeysyms = NULL;
  121.     pd->appContext = app;
  122.     pd->name = XrmStringToName(name);
  123.     pd->class = XrmStringToClass(classname);
  124.     pd->being_destroyed = False;
  125.     pd->GClist = NULL;
  126.     pd->pixmap_tab = NULL;
  127.     pd->language = NULL;
  128.     pd->rv = False;
  129.     pd->last_timestamp = 0;
  130.     _XtAllocTMContext(pd);
  131.     pd->mapping_callbacks = NULL;
  132.  
  133.     pd->pdi.grabList = NULL;
  134.     pd->pdi.trace = NULL;
  135.     pd->pdi.traceDepth = 0;
  136.     pd->pdi.traceMax = 0;
  137.     pd->pdi.focusWidget = NULL;
  138.     pd->pdi.activatingKey = 0;
  139.     pd->pdi.keyboard.grabType = XtNoServerGrab;
  140.     pd->pdi.pointer.grabType  = XtNoServerGrab;
  141.     _XtAllocWWTable(pd);
  142.     pd->per_screen_db = (XrmDatabase *)XtCalloc(ScreenCount(dpy),
  143.                         sizeof(XrmDatabase));
  144.     pd->cmd_db = (XrmDatabase)NULL;
  145.     pd->server_db = (XrmDatabase)NULL;
  146.     return pd;
  147. }
  148.  
  149. /* kludge, for private communication to _XtAppInit */
  150. static char display_name_tried[100];
  151.  
  152. #if NeedFunctionPrototypes
  153. Display *XtOpenDisplay(
  154.     XtAppContext app,
  155.     _Xconst char* displayName,
  156.     _Xconst char* applName,
  157.     _Xconst char* className,
  158.     XrmOptionDescRec *urlist,
  159.     Cardinal num_urs,
  160.     int *argc,
  161.     String *argv
  162.     )
  163. #else
  164. Display *XtOpenDisplay(app, displayName, applName, className,
  165.         urlist, num_urs, argc, argv)
  166.     XtAppContext app;
  167.     String displayName, applName, className;
  168.     XrmOptionDescRec *urlist;
  169.     Cardinal num_urs;
  170.     int *argc;
  171.     String *argv;
  172. #endif
  173. {
  174.     Display *d;
  175.     XrmDatabase db = 0;
  176.     XtPerDisplay pd;
  177.     String language = NULL;
  178.  
  179.     /* parse the command line for name, display, and/or language */
  180.     db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv, &applName,
  181.                     (displayName ? NULL : &displayName),
  182.                     (app->process->globalLangProcRec.proc ?
  183.                      &language : NULL));
  184.     d = XOpenDisplay(displayName);
  185.  
  186.     if (! applName && !(applName = getenv("RESOURCE_NAME"))) {
  187.         if (*argc > 0 && argv[0] && *argv[0]) {
  188.         char *ptr = rindex(argv[0], '/');
  189.         if (ptr) applName = ++ptr;
  190.         else applName = argv[0];
  191.         } else
  192.         applName = "main";
  193.     }
  194.  
  195.     if (d) {
  196.         pd = InitPerDisplay(d, app, applName, className);
  197.         pd->language = language;
  198.         _XtDisplayInitialize(d, pd, applName, urlist, num_urs, argc, argv);
  199.     } else {
  200.         displayName = XDisplayName(displayName);
  201.         strncpy(display_name_tried, displayName,
  202.             sizeof(display_name_tried));
  203.         display_name_tried[sizeof(display_name_tried)-1] = '\0';
  204.     }
  205.     if (db) XrmDestroyDatabase(db);
  206.     return d;
  207. }
  208.  
  209. Display *
  210. _XtAppInit(app_context_return, application_class, options, num_options,
  211.        argc_in_out, argv_in_out, fallback_resources)
  212. XtAppContext * app_context_return;
  213. String application_class;
  214. XrmOptionDescRec *options;
  215. Cardinal num_options;
  216. int *argc_in_out;
  217. String **argv_in_out, * fallback_resources;
  218. {
  219.     String *saved_argv;
  220.     int i;
  221.     Display *dpy;
  222.  
  223. /*
  224.  * Save away argv and argc so we can set the properties later 
  225.  */
  226.     
  227.     saved_argv = (String *)
  228.     XtMalloc( (Cardinal)((*argc_in_out + 1) * sizeof(String)) );
  229.  
  230.     for (i = 0 ; i < *argc_in_out ; i++) saved_argv[i] = (*argv_in_out)[i];
  231.     saved_argv[i] = NULL;    /* NULL terminate that sucker. */
  232.  
  233.  
  234.     *app_context_return = XtCreateApplicationContext();
  235.  
  236.     if (fallback_resources) /* save a procedure call */
  237.     XtAppSetFallbackResources(*app_context_return, fallback_resources);
  238.  
  239.     dpy = XtOpenDisplay(*app_context_return, (String) NULL, NULL,
  240.             application_class,
  241.             options, num_options, argc_in_out, *argv_in_out);
  242.  
  243.     if (!dpy) {
  244.     String param = display_name_tried;
  245.     Cardinal param_count = 1;
  246.     XtErrorMsg("invalidDisplay","xtInitialize",XtCXtToolkitError,
  247.                    "Can't open display: %s", ¶m, ¶m_count);
  248.     }
  249.     *argv_in_out = saved_argv;
  250.     return dpy;
  251. }
  252.  
  253. #if NeedFunctionPrototypes
  254. void
  255. XtDisplayInitialize(
  256.     XtAppContext app,
  257.     Display *dpy,
  258.     _Xconst char* name,
  259.     _Xconst char* classname,
  260.     XrmOptionDescRec *urlist,
  261.     Cardinal num_urs,
  262.     int *argc,
  263.     String *argv
  264.     )
  265. #else
  266. void
  267. XtDisplayInitialize(app, dpy, name, classname, urlist, num_urs, argc, argv)
  268.     XtAppContext app;
  269.     Display *dpy;
  270.     String name, classname;
  271.     XrmOptionDescRec *urlist;
  272.     Cardinal num_urs;
  273.     int *argc;
  274.     String *argv;
  275. #endif
  276. {
  277.     XtPerDisplay pd;
  278.     XrmDatabase db = 0;
  279.  
  280.     pd = InitPerDisplay(dpy, app, name, classname);
  281.     if (app->process->globalLangProcRec.proc)
  282.     /* pre-parse the command line for the language resource */
  283.     db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv, NULL, NULL,
  284.                     &pd->language);
  285.     _XtDisplayInitialize(dpy, pd, name, urlist, num_urs, argc, argv);
  286.     if (db) XrmDestroyDatabase(db);
  287. }
  288.  
  289. XtAppContext XtCreateApplicationContext()
  290. {
  291.     XtAppContext app = XtNew(XtAppStruct);
  292.  
  293.     app->process = _XtGetProcessContext();
  294.     app->next = app->process->appContextList;
  295.     app->process->appContextList = app;
  296.     app->langProcRec.proc = app->process->globalLangProcRec.proc;
  297.     app->langProcRec.closure = app->process->globalLangProcRec.closure;
  298.     app->destroy_callbacks = NULL;
  299.     app->list = NULL;
  300.     app->count = app->max = app->last = 0;
  301.     app->timerQueue = NULL;
  302.     app->workQueue = NULL;
  303.     app->input_list = NULL;
  304.     app->outstandingQueue = NULL;
  305.     app->errorDB = NULL;
  306.     _XtSetDefaultErrorHandlers(&app->errorMsgHandler, 
  307.         &app->warningMsgHandler, &app->errorHandler, 
  308.         &app->warningHandler);
  309.     app->action_table = NULL;
  310.     _XtSetDefaultSelectionTimeout(&app->selectionTimeout);
  311.     _XtSetDefaultConverterTable(&app->converterTable);
  312.     app->sync = app->being_destroyed = app->error_inited = FALSE;
  313.     app->in_phase2_destroy = NULL;
  314.     app->fds.nfds = app->fds.count = 0;
  315.     FD_ZERO(&app->fds.rmask);
  316.     FD_ZERO(&app->fds.wmask);
  317.     FD_ZERO(&app->fds.emask);
  318.     app->input_max = 0;
  319.     _XtHeapInit(&app->heap);
  320.     app->fallback_resources = NULL;
  321.     _XtPopupInitialize(app);
  322.     app->action_hook_list = NULL;
  323.     app->destroy_list_size = app->destroy_count = app->dispatch_level = 0;
  324.     app->destroy_list = NULL;
  325. #ifndef NO_IDENTIFY_WINDOWS
  326.     app->identify_windows = False;
  327. #endif
  328.     return app;
  329. }
  330.  
  331. static XtAppContext *appDestroyList = NULL;
  332. int _XtAppDestroyCount = 0;
  333.  
  334. static void DestroyAppContext(app)
  335.     XtAppContext app;
  336. {
  337.     XtAppContext* prev_app = &app->process->appContextList;
  338.     while (app->count-- > 0) XtCloseDisplay(app->list[app->count]);
  339.     if (app->list != NULL) XtFree((char *)app->list);
  340.     _XtFreeConverterTable(app->converterTable);
  341.     _XtCacheFlushTag(app, (XtPointer)&app->heap);
  342.     _XtFreeActions(app->action_table);
  343.     if (app->destroy_callbacks != NULL) {
  344.         XtCallCallbackList((Widget) NULL,
  345.                    (XtCallbackList)app->destroy_callbacks, 
  346.                    (XtPointer)app);
  347.         _XtRemoveAllCallbacks(&app->destroy_callbacks);
  348.     }
  349.     while (app->timerQueue) XtRemoveTimeOut((XtIntervalId)app->timerQueue);
  350.     while (app->workQueue) XtRemoveWorkProc((XtWorkProcId)app->workQueue);
  351.     if (app->input_list) _XtRemoveAllInputs(app);
  352.     XtFree((char*)app->destroy_list);
  353.     _XtHeapFree(&app->heap);
  354.     while (*prev_app != app) prev_app = &(*prev_app)->next;
  355.     *prev_app = app->next;
  356.     if (app->process->defaultAppContext == app)
  357.         app->process->defaultAppContext = NULL;
  358.     XtFree((char *)app);
  359. }
  360.  
  361. void XtDestroyApplicationContext(app)
  362.     XtAppContext app;
  363. {
  364.     if (app->being_destroyed) return;
  365.  
  366.     if (_XtSafeToDestroy(app)) DestroyAppContext(app);
  367.     else {
  368.         app->being_destroyed = TRUE;
  369.         _XtAppDestroyCount++;
  370.         appDestroyList =
  371.             (XtAppContext *) XtRealloc((char *) appDestroyList,
  372.             (unsigned) (_XtAppDestroyCount * sizeof(XtAppContext)));
  373.         appDestroyList[_XtAppDestroyCount-1] = app;
  374.     }
  375. }
  376.  
  377. void _XtDestroyAppContexts()
  378. {
  379.     int i;
  380.  
  381.     for (i = 0; i < _XtAppDestroyCount; i++) {
  382.         DestroyAppContext(appDestroyList[i]);
  383.     }
  384.     _XtAppDestroyCount = 0;
  385.     XtFree((char *) appDestroyList);
  386.     appDestroyList = NULL;
  387. }
  388.  
  389. XrmDatabase XtDatabase(dpy)
  390.     Display *dpy;
  391. {
  392.     return XrmGetDatabase(dpy);
  393. }
  394.  
  395. PerDisplayTablePtr _XtperDisplayList = NULL;
  396.  
  397. XtPerDisplay _XtSortPerDisplayList(dpy)
  398.     Display *dpy;
  399. {
  400.     register PerDisplayTablePtr pd, opd;
  401.  
  402. #ifdef lint
  403.     opd = NULL;
  404. #endif
  405.  
  406.     for (pd = _XtperDisplayList;
  407.          pd != NULL && pd->dpy != dpy;
  408.          pd = pd->next) {
  409.         opd = pd;
  410.     }
  411.  
  412.     if (pd == NULL) {
  413.         XtErrorMsg(XtNnoPerDisplay, "getPerDisplay", XtCXtToolkitError,
  414.             "Couldn't find per display information",
  415.             (String *) NULL, (Cardinal *)NULL);
  416.     }
  417.  
  418.     if (pd != _XtperDisplayList) {    /* move it to the front */
  419.         /* opd points to the previous one... */
  420.  
  421.         opd->next = pd->next;
  422.         pd->next = _XtperDisplayList;
  423.         _XtperDisplayList = pd;
  424.     }
  425.  
  426.     return &(pd->perDpy);
  427. }
  428.  
  429. XtAppContext XtDisplayToApplicationContext(dpy)
  430.     Display *dpy;
  431. {
  432.     return _XtGetPerDisplay(dpy)->appContext;
  433. }
  434.  
  435. static XtPerDisplay NewPerDisplay(dpy)
  436.     Display *dpy;
  437. {
  438.     PerDisplayTablePtr pd;
  439.  
  440.     pd = XtNew(PerDisplayTable);
  441.  
  442.     pd->dpy = dpy;
  443.     pd->next = _XtperDisplayList;
  444.     _XtperDisplayList = pd;
  445.  
  446.     return &(pd->perDpy);
  447. }
  448.  
  449. static Display **dpyDestroyList = NULL;
  450. int _XtDpyDestroyCount = 0;
  451.  
  452. static void CloseDisplay(dpy)
  453.     Display *dpy;
  454. {
  455.         register XtPerDisplay xtpd;
  456.     register PerDisplayTablePtr pd, opd;
  457.     XrmDatabase db;
  458.     int i;
  459.     
  460. #ifdef lint
  461.     opd = NULL;
  462. #endif
  463.  
  464.     for (pd = _XtperDisplayList;
  465.          pd != NULL && pd->dpy != dpy;
  466.          pd = pd->next){
  467.         opd = pd;
  468.     }
  469.  
  470.     if (pd == NULL) {
  471.         XtErrorMsg(XtNnoPerDisplay, "closeDisplay", XtCXtToolkitError,
  472.             "Couldn't find per display information",
  473.             (String *) NULL, (Cardinal *)NULL);
  474.     }
  475.  
  476.     if (pd == _XtperDisplayList) _XtperDisplayList = pd->next;
  477.     else opd->next = pd->next;
  478.  
  479.     xtpd = &(pd->perDpy);
  480.  
  481.         if (xtpd != NULL) {
  482.         extern void _XtGClistFree(), _XtFreeWWTable();
  483.         if (xtpd->destroy_callbacks != NULL) {
  484.         XtCallCallbackList((Widget) NULL,
  485.                    (XtCallbackList)xtpd->destroy_callbacks,
  486.                    (XtPointer)xtpd);
  487.         _XtRemoveAllCallbacks(&xtpd->destroy_callbacks);
  488.         }
  489.         if (xtpd->mapping_callbacks != NULL)
  490.         _XtRemoveAllCallbacks(&xtpd->mapping_callbacks);
  491.         XtDeleteFromAppContext(dpy, xtpd->appContext);
  492.         if (xtpd->keysyms)
  493.         XFree((char *) xtpd->keysyms);
  494.             XtFree((char *) xtpd->modKeysyms);
  495.             XtFree((char *) xtpd->modsToKeysyms);
  496.             xtpd->keysyms_per_keycode = 0;
  497.             xtpd->being_destroyed = FALSE;
  498.             xtpd->keysyms = NULL;
  499.             xtpd->modKeysyms = NULL;
  500.             xtpd->modsToKeysyms = NULL;
  501.         XDestroyRegion(xtpd->region);
  502.         _XtCacheFlushTag(xtpd->appContext, (XtPointer)&xtpd->heap);
  503.         _XtGClistFree(dpy, xtpd);
  504.         XtFree((char*)xtpd->pdi.trace);
  505.         _XtHeapFree(&xtpd->heap);
  506.         _XtFreeWWTable(xtpd);
  507.         xtpd->per_screen_db[DefaultScreen(dpy)] = (XrmDatabase)NULL;
  508.         for (i = ScreenCount(dpy); --i >= 0; ) {
  509.         db = xtpd->per_screen_db[i];
  510.         if (db)
  511.             XrmDestroyDatabase(db);
  512.         }
  513.         XtFree((char *)xtpd->per_screen_db);
  514.         if (db = XrmGetDatabase(dpy))
  515.         XrmDestroyDatabase(db);
  516.         if (xtpd->cmd_db)
  517.         XrmDestroyDatabase(xtpd->cmd_db);
  518.         if (xtpd->server_db)
  519.         XrmDestroyDatabase(xtpd->server_db);
  520.         XtFree(xtpd->language);
  521.         }
  522.     XtFree((char*)pd);
  523.     XrmSetDatabase(dpy, (XrmDatabase)NULL);
  524.     XCloseDisplay(dpy);
  525. }
  526.  
  527. void XtCloseDisplay(dpy)
  528.     Display *dpy;
  529. {
  530.     XtPerDisplay pd = _XtGetPerDisplay(dpy);
  531.     
  532.     if (pd->being_destroyed) return;
  533.  
  534.     if (_XtSafeToDestroy(pd->appContext)) CloseDisplay(dpy);
  535.     else {
  536.         pd->being_destroyed = TRUE;
  537.         _XtDpyDestroyCount++;
  538.         dpyDestroyList = (Display **) XtRealloc((char *) dpyDestroyList,
  539.             (unsigned) (_XtDpyDestroyCount * sizeof(Display *)));
  540.         dpyDestroyList[_XtDpyDestroyCount-1] = dpy;
  541.     }
  542. }
  543.  
  544. void _XtCloseDisplays()
  545. {
  546.     int i;
  547.  
  548.     for (i = 0; i < _XtDpyDestroyCount; i++) {
  549.         CloseDisplay(dpyDestroyList[i]);
  550.     }
  551.     _XtDpyDestroyCount = 0;
  552.     XtFree((char *) dpyDestroyList);
  553.     dpyDestroyList = NULL;
  554. }
  555.  
  556. XtAppContext XtWidgetToApplicationContext(w)
  557.     Widget w;
  558. {
  559.     return _XtGetPerDisplay(XtDisplayOfObject(w))->appContext;
  560. }
  561.  
  562.  
  563. void XtGetApplicationNameAndClass(dpy, name_return, class_return)
  564.     Display *dpy;
  565.     String *name_return;
  566.     String *class_return;
  567. {
  568.     XtPerDisplay pd = _XtGetPerDisplay(dpy);
  569.     *name_return = XrmQuarkToString(pd->name);
  570.     *class_return = XrmQuarkToString(pd->class);
  571. }
  572.