home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / XfeWidgets / Xfe / ChildrenUtil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  8.9 KB  |  360 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /*-----------------------------------------*/
  19. /*                                                                        */
  20. /* Name:        <Xfe/ChildrenUtil.c>                                    */
  21. /* Description:    Children misc utilities source.                            */
  22. /* Author:        Ramiro Estrugo <ramiro@netscape.com>                    */
  23. /*                                                                        */
  24. /*----------------------------------------------------------------------*/
  25.  
  26.  
  27. #include <Xfe/XfeP.h>
  28.  
  29. #include <Xfe/PrimitiveP.h>
  30. #include <Xfe/ManagerP.h>
  31.  
  32.  
  33. /*----------------------------------------------------------------------*/
  34. /*                                                                        */
  35. /* Children access                                                        */
  36. /*                                                                        */
  37. /*----------------------------------------------------------------------*/
  38. /* extern */ Cardinal
  39. XfeNumChildren(Widget w)
  40. {
  41.     assert( XtIsComposite(w) );
  42.  
  43.     return _XfemNumChildren(w);
  44. }
  45. /*----------------------------------------------------------------------*/
  46. /* extern */ WidgetList
  47. XfeChildren(Widget w)
  48. {
  49.     assert( XtIsComposite(w) );
  50.  
  51.     return _XfemChildren(w);
  52. }
  53. /*----------------------------------------------------------------------*/
  54. /* extern */ Widget
  55. XfeChildrenIndex(Widget w,Cardinal i)
  56. {
  57.     assert( XtIsComposite(w) );
  58.  
  59.     return _XfeChildrenIndex(w,i);
  60. }
  61. /*----------------------------------------------------------------------*/
  62. /* extern */ Cardinal
  63. XfeChildrenCountAlive(Widget w)
  64. {
  65.     Cardinal    num_alive = 0;
  66.     Cardinal    i;
  67.  
  68.     assert( w != NULL );
  69.  
  70.     for (i = 0; i < _XfemNumChildren(w); i ++)
  71.     {
  72.         if (_XfeIsAlive(_XfeChildrenIndex(w,i)))
  73.         {
  74.             num_alive++;
  75.         }
  76.     }        
  77.  
  78.     return num_alive;
  79. }
  80. /*----------------------------------------------------------------------*/
  81.  
  82. /*----------------------------------------------------------------------*/
  83. /*                                                                        */
  84. /* Popup children access                                                */
  85. /*                                                                        */
  86. /*----------------------------------------------------------------------*/
  87. /* extern */ Cardinal
  88. XfeNumPopups(Widget w)
  89. {
  90.     return _XfeNumPopups(w);
  91. }
  92. /*----------------------------------------------------------------------*/
  93. /* extern */ WidgetList
  94. XfePopupList(Widget w)
  95. {
  96.     return _XfePopupList(w);
  97. }
  98. /*----------------------------------------------------------------------*/
  99. /* extern */ Widget
  100. XfePopupListIndex(Widget w,Cardinal i)
  101. {
  102.     return _XfePopupListIndex(w,i);
  103. }
  104. /*----------------------------------------------------------------------*/
  105. /* extern */ Cardinal
  106. XfePopupListCountAlive(Widget w)
  107. {
  108.     Cardinal    num_alive = 0;
  109.     Cardinal    i;
  110.  
  111.     assert( w != NULL );
  112.  
  113.     for (i = 0; i < _XfeNumPopups(w); i ++)
  114.     {
  115.         if (_XfeIsAlive(_XfePopupListIndex(w,i)))
  116.         {
  117.             num_alive++;
  118.         }
  119.     }        
  120.  
  121.     return num_alive;
  122. }
  123. /*----------------------------------------------------------------------*/
  124.  
  125. /*----------------------------------------------------------------------*/
  126. /*                                                                        */
  127. /* Children access                                                        */
  128. /*                                                                        */
  129. /*----------------------------------------------------------------------*/
  130. /* extern */ void
  131. XfeChildrenGet(Widget w,WidgetList * children,Cardinal * num_children)
  132. {
  133.     assert( _XfeIsAlive(w) );
  134.     assert( XtIsComposite(w) );
  135.     assert( (children != NULL) || (num_children != NULL) );
  136.  
  137.     if (children)
  138.     {
  139.         *children        = _XfemChildren(w);
  140.     }
  141.  
  142.     if (num_children)
  143.     {
  144.         *num_children    = _XfemNumChildren(w);
  145.     }
  146. }
  147. /*----------------------------------------------------------------------*/
  148. /* extern */ Cardinal
  149. XfeChildrenGetNumManaged(Widget w)
  150. {
  151.     Cardinal i;
  152.     Cardinal num_managed = 0;
  153.  
  154.     assert( _XfeIsAlive(w) );
  155.     assert( XtIsComposite(w) );
  156.  
  157.     for (i = 0; i < _XfemNumChildren(w); i++)
  158.     {
  159.          if (_XfeIsManaged(_XfeChildrenIndex(w,i)))
  160.         {
  161.             num_managed++;
  162.         }
  163.     }
  164.  
  165.     return num_managed;
  166. }
  167. /*----------------------------------------------------------------------*/
  168. /* extern */ Widget
  169. XfeChildrenGetLast(Widget w)
  170. {
  171.     assert( _XfeIsAlive(w) );
  172.     assert( XtIsComposite(w) );
  173.  
  174.     if (_XfemChildren(w) && _XfemNumChildren(w))
  175.     {
  176.         return _XfemChildren(w)[ _XfemNumChildren(w) - 1 ];
  177.     }
  178.  
  179.     return NULL;
  180. }
  181. /*----------------------------------------------------------------------*/
  182. /* extern */ int
  183. XfeChildGetIndex(Widget w)
  184. {
  185.     Widget parent = XtParent(w);
  186.  
  187.     assert( _XfeIsAlive(w) );
  188.  
  189.     parent = XtParent(w);
  190.  
  191.     assert( _XfeIsAlive(parent) );
  192.     
  193.     if (_XfemNumChildren(parent) && _XfemChildren(parent))
  194.     {
  195.         Cardinal    i = 0;
  196.  
  197.         for (i = 0; i < _XfemNumChildren(parent); i++)
  198.         {
  199.             if (_XfemChildren(parent)[i] == w)
  200.             {
  201.                 return i;
  202.             }
  203.         }
  204.     }
  205.  
  206.     return -1;
  207. }
  208. /*----------------------------------------------------------------------*/
  209.  
  210. /*----------------------------------------------------------------------*/
  211. /*                                                                        */
  212. /* Destroy                                                                */
  213. /*                                                                        */
  214. /*----------------------------------------------------------------------*/
  215. /* extern */ void
  216. XfeChildrenDestroy(Widget w)
  217. {
  218.     Widget *        children;
  219.     Cardinal        i;
  220.  
  221.     assert( _XfeIsAlive(w) );
  222.     assert( XtIsComposite(w) );
  223.  
  224.     /* Make sure the widget has children */
  225.     if (!_XfemNumChildren(w))
  226.     {
  227.         return;
  228.     }
  229.  
  230.     /* Allocate space for a temporary children array */
  231.     children = (Widget *) XtMalloc(sizeof(Widget) * _XfemNumChildren(w));
  232.  
  233.     /* Copy the widget ids */
  234.     for (i = 0; i < _XfemNumChildren(w); i++)
  235.     {
  236.         children[i] = _XfemChildren(w)[i];
  237.     }
  238.  
  239.     /* Destroy the children */
  240.     for (i = 0; i < _XfemNumChildren(w); i++)
  241.     {
  242.         if (_XfeIsAlive(children[i]))
  243.         {
  244.             XtDestroyWidget(children[i]);
  245.         }
  246.     }
  247.  
  248.     XtFree((char *) children);
  249.  
  250.     /* Update an flush in case the destruction takes a long time */
  251.     XmUpdateDisplay(w);
  252.     XFlush(XtDisplay(w));
  253. }
  254. /*----------------------------------------------------------------------*/
  255.  
  256.  
  257. /*----------------------------------------------------------------------*/
  258. /*                                                                        */
  259. /* Callbacks / Event handlers                                            */
  260. /*                                                                        */
  261. /*----------------------------------------------------------------------*/
  262. /* extern */ void
  263. XfeChildrenAddCallback(Widget            w,
  264.                        String            callback_name,
  265.                        XtCallbackProc    callback,
  266.                        XtPointer        data)
  267. {
  268.     Widget *        children;
  269.     Cardinal        num_children;
  270.     Cardinal        i;
  271.  
  272.     assert( _XfeIsAlive(w) );
  273.     assert( XtIsComposite(w) );
  274.  
  275.     XfeChildrenGet(w,&children,&num_children);
  276.  
  277.     for (i = 0; i < num_children; i++)
  278.     {
  279.         assert( _XfeIsAlive(children[i]) );
  280.  
  281.         XtAddCallback(children[i],callback_name,callback,data);
  282.     }
  283. }
  284. /*----------------------------------------------------------------------*/
  285. /* extern */ void
  286. XfeChildrenAddEventHandler(Widget            w,
  287.                            EventMask        event_mask,
  288.                            Boolean            nonmaskable,
  289.                            XtEventHandler    proc,
  290.                            XtPointer        data)
  291. {
  292.     Widget *        children;
  293.     Cardinal        num_children;
  294.     Cardinal        i;
  295.  
  296.     assert( _XfeIsAlive(w) );
  297.     assert( XtIsComposite(w) );
  298.  
  299.     XfeChildrenGet(w,&children,&num_children);
  300.  
  301.     for (i = 0; i < num_children; i++)
  302.     {
  303.         assert( _XfeIsAlive(children[i]) );
  304.  
  305.         XtAddEventHandler(children[i],event_mask,nonmaskable,proc,data);
  306.     }
  307. }
  308. /*----------------------------------------------------------------------*/
  309. /* extern */ void
  310. XfeChildrenRemoveCallback(Widget            w,
  311.                           String            callback_name,
  312.                           XtCallbackProc    callback,
  313.                           XtPointer            data)
  314. {
  315.     Widget *        children;
  316.     Cardinal        num_children;
  317.     Cardinal        i;
  318.  
  319.     assert( _XfeIsAlive(w) );
  320.     assert( XtIsComposite(w) );
  321.  
  322.     XfeChildrenGet(w,&children,&num_children);
  323.  
  324.     for (i = 0; i < num_children; i++)
  325.     {
  326.         assert( _XfeIsAlive(children[i]) );
  327.  
  328.         XtRemoveCallback(children[i],callback_name,callback,data);
  329.     }
  330. }
  331. /*----------------------------------------------------------------------*/
  332. /* extern */ void
  333. XfeChildrenRemoveEventHandler(Widget            w,
  334.                               EventMask            event_mask,
  335.                               Boolean            nonmaskable,
  336.                               XtEventHandler    proc,
  337.                               XtPointer            data)
  338. {
  339.     Widget *        children;
  340.     Cardinal        num_children;
  341.     Cardinal        i;
  342.  
  343.     assert( _XfeIsAlive(w) );
  344.     assert( XtIsComposite(w) );
  345.  
  346.     XfeChildrenGet(w,&children,&num_children);
  347.  
  348.     for (i = 0; i < num_children; i++)
  349.     {
  350.         if (_XfeIsAlive(w))
  351.         {
  352.             XtRemoveEventHandler(children[i],event_mask,nonmaskable,proc,data);
  353.         }
  354.  
  355.         XtRemoveEventHandler(children[i],event_mask,nonmaskable,proc,data);
  356.     }
  357. }
  358. /*----------------------------------------------------------------------*/
  359.  
  360.