home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / liblayer / src / cl_comp.c next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  83.7 KB  |  2,450 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.  *  cl_comp.c - The compositor API
  20.  */
  21.  
  22.  
  23. /* On UNIX, child and sibling windows are always clipped, so
  24.    cutout layers are unnecessary. */
  25. #ifdef XP_UNIX
  26. #    define TRIM_UPDATE_REGION_CUTOUTS PR_FALSE
  27. #else
  28. #    define TRIM_UPDATE_REGION_CUTOUTS PR_TRUE
  29. #endif
  30.  
  31. #include "prtypes.h"
  32. #ifdef XP_MAC
  33. #include "prpriv.h"
  34. #else
  35. #include "private/prpriv.h" /* For PR_NewNamedMonitor */
  36. #endif
  37.  
  38. #include "xp_core.h"
  39. #include "xpassert.h"
  40. #include "fe_proto.h"        /* For FE_SetTimeout(), et al */
  41. #include "layers.h"
  42. #include "cl_priv.h"
  43. #ifdef CL_ADAPT_FRAME_RATE
  44. #    include "prtime.h"
  45. #endif
  46.  
  47. #ifndef ABS
  48. #    define ABS(x)  (((x) < 0) ? -(x) : (x))
  49. #endif
  50.  
  51. static void
  52. cl_compute_update_region(CL_Compositor *compositor);
  53.  
  54. static PRBool
  55. cl_composite(CL_Compositor *compositor, PRBool cutoutp);
  56.  
  57. int cl_trace_level = 0;
  58.  
  59. #if !defined(XP_MAC) && defined(DEBUG) /* FE_HighlightRegion is not currently in the mac build */
  60. void
  61. CL_HighlightRegion(CL_Compositor *compositor, FE_Region region)
  62. {
  63.     extern MWContext *LO_CompositorToContext(CL_Compositor *compositor);
  64.  
  65.     int time;
  66.     MWContext *context = LO_CompositorToContext(compositor);
  67.  
  68.     time = 200;
  69. #if defined(XP_UNIX)
  70.     if (getenv("SHOWREGIONS"))
  71.         time = atoi(getenv("SHOWREGIONS"));
  72. #endif
  73.  
  74.     FE_HighlightRegion(context, region, time);
  75. }
  76. #endif
  77.  
  78. /* Allocate and initialize a new compositor */
  79. CL_Compositor *
  80. CL_NewCompositor(CL_Drawable *primary_drawable,
  81.                  CL_Drawable *backing_store,
  82.                  int32 x_offset, int32 y_offset,
  83.                  int32 width, int32 height,
  84.                  uint32 frame_rate)
  85. {
  86.     CL_Compositor *compositor;
  87.  
  88.     compositor = XP_NEW_ZAP(CL_Compositor);
  89.  
  90.     if (compositor == NULL)
  91.         return NULL;
  92.  
  93.     CL_TRACE(0, ("Creating new compositor: %x", compositor));
  94.  
  95. #ifdef CL_THREAD_SAFE
  96.     compositor->monitor = PR_NewNamedMonitor("compositor-monitor");
  97.     if (!compositor->monitor)
  98.         return NULL;
  99. #endif
  100.  
  101.     compositor->gen_id = 0;
  102.     compositor->primary_drawable = primary_drawable;
  103.     compositor->backing_store = backing_store;
  104.     compositor->x_offset = x_offset;
  105.     compositor->y_offset = y_offset;
  106.     compositor->window_size.left = compositor->window_size.top = 0;
  107.     compositor->window_size.right = width;
  108.     compositor->window_size.bottom = height;
  109.     if (frame_rate)
  110.         compositor->frame_period = 1000000.0F / frame_rate;
  111.     else
  112.         compositor->frame_period = 0.0F;
  113.  
  114.     compositor->window_region = FE_CreateRectRegion(&compositor->window_size);
  115.     compositor->update_region = FE_CreateRegion();
  116.  
  117.     compositor->event_containment_lists[0].layer_list = 
  118.         XP_ALLOC(CL_CONTAINMENT_LIST_SIZE * sizeof(CL_Layer *));
  119.     compositor->event_containment_lists[0].list_size = 
  120.         CL_CONTAINMENT_LIST_SIZE;
  121.     compositor->event_containment_lists[0].list_head = -1;
  122.     compositor->event_containment_lists[1].layer_list = 
  123.         XP_ALLOC(CL_CONTAINMENT_LIST_SIZE * sizeof(CL_Layer *));
  124.     compositor->event_containment_lists[1].list_size = 
  125.         CL_CONTAINMENT_LIST_SIZE;
  126.     compositor->event_containment_lists[1].list_head = -1;
  127.  
  128.     compositor->backing_store_region = FE_CreateRegion();
  129.     if ((compositor->window_region == NULL) ||
  130.         (compositor->update_region == NULL) ||
  131.         (compositor->backing_store_region == NULL) ||
  132.         (compositor->event_containment_lists[0].layer_list == NULL) ||
  133.         (compositor->event_containment_lists[1].layer_list == NULL)) {
  134.         CL_DestroyCompositor(compositor);
  135.         return NULL;
  136.     }
  137.     compositor->offscreen_enabled = PR_FALSE;
  138.     compositor->back_to_front_only = PR_FALSE;
  139.  
  140.     compositor->mouse_event_grabber = NULL;
  141.     compositor->key_event_grabber = NULL;
  142.     compositor->last_mouse_event_grabber = NULL;
  143.     compositor->focus_policy = CL_FOCUS_POLICY_CLICK;
  144.  
  145.     primary_drawable->compositor = compositor;
  146.     if (backing_store)
  147.         backing_store->compositor = compositor;
  148.  
  149.     cl_InitDrawable(compositor->primary_drawable);
  150.  
  151.     return compositor;
  152. }
  153.  
  154. static int
  155. cl_group_list_destroy(PRHashEntry *he,
  156.                       int i,
  157.                       void *arg)
  158. {
  159.     XP_List *list = (XP_List *)he->value;
  160.     
  161.     XP_ListDestroy(list);
  162.     
  163.     return HT_ENUMERATE_REMOVE;
  164. }
  165.  
  166.  
  167. /* Free an existing compositor */
  168. void 
  169. CL_DestroyCompositor(CL_Compositor *compositor)
  170. {
  171.     XP_ASSERT(compositor);
  172.  
  173.     if (!compositor)
  174.         return;
  175.  
  176.     CL_TRACE(0, ("Destroying compositor: %x", compositor));
  177.  
  178.     if (compositor->composite_timeout)
  179.         FE_ClearTimeout(compositor->composite_timeout);
  180.  
  181.     if (compositor->root)
  182.         CL_DestroyLayerTree(compositor->root);
  183.  
  184.     if (compositor->window_region)
  185.         FE_DestroyRegion(compositor->window_region);
  186.   
  187.     if (compositor->update_region)
  188.         FE_DestroyRegion(compositor->update_region);
  189.  
  190.     if (compositor->backing_store_region)
  191.         FE_DestroyRegion(compositor->backing_store_region);
  192.  
  193.     if (compositor->group_table) {
  194.         /* Delete all the group lists in the table */
  195.         PR_HashTableEnumerateEntries(compositor->group_table,
  196.                                      cl_group_list_destroy,
  197.                                      NULL);
  198.         PR_HashTableDestroy(compositor->group_table);
  199.     }
  200.  
  201.     if (compositor->primary_drawable) {
  202.         cl_RelinquishDrawable(compositor->primary_drawable);
  203.         CL_DestroyDrawable(compositor->primary_drawable);
  204.     }
  205.  
  206.     if (compositor->backing_store) {
  207.         if (compositor->offscreen_initialized)
  208.             cl_RelinquishDrawable(compositor->backing_store);
  209.         CL_DestroyDrawable(compositor->backing_store);
  210.     }
  211.  
  212.     if (compositor->event_containment_lists[0].layer_list)
  213.         XP_FREE(compositor->event_containment_lists[0].layer_list);
  214.  
  215.     if (compositor->event_containment_lists[1].layer_list)
  216.         XP_FREE(compositor->event_containment_lists[1].layer_list);
  217.     
  218. #ifdef CL_THREAD_SAFE
  219.     if (compositor->monitor)
  220.         PR_DestroyMonitor(compositor->monitor);
  221. #endif
  222.   
  223.     XP_FREE(compositor);
  224. }
  225.  
  226. void
  227. CL_IncrementCompositorGeneration(CL_Compositor *compositor)
  228. {
  229.     XP_ASSERT(compositor);
  230.     
  231.     if (!compositor)
  232.         return;
  233.     
  234.     compositor->gen_id++;
  235. }
  236.  
  237. /* Find layer by name. This carries out a breadth-first search */
  238. /* of the layer tree. Returns NULL if no such layer exists.    */
  239. CL_Layer *
  240. CL_FindLayer(CL_Compositor *compositor, char *name)
  241. {
  242.     XP_List *list;
  243.     CL_Layer *layer, *child;
  244.  
  245.     XP_ASSERT(compositor);
  246.     XP_ASSERT(name);
  247.  
  248.     if (!compositor || !name || !compositor->root)
  249.         return NULL;
  250.  
  251.     /* BUGBUG This is rather an expensive way to maintain a list */
  252.     /* since a little struct is allocated for each element added */
  253.     /* to the list.                                              */
  254.     list = XP_ListNew();
  255.  
  256.     if (list == NULL)
  257.         return NULL;
  258.  
  259.     LOCK_COMPOSITOR(compositor);
  260.   
  261.     XP_ListAddObject(list, compositor->root);
  262.  
  263.     /* While the list is not empty */
  264.     while ((layer = XP_ListRemoveTopObject(list))) {
  265.     
  266.         /* Check if the name of this layer matches */
  267.         if (layer->name && strcmp(layer->name, name) == 0) {
  268.             XP_ListDestroy(list);
  269.             UNLOCK_COMPOSITOR(compositor);
  270.             return layer;
  271.         }
  272.     
  273.         /* Add each of the children to the end of the list */
  274.         for (child = layer->top_child; child; child = child->sib_below)
  275.             XP_ListAddObjectToEnd(list, child);
  276.     }
  277.  
  278.     XP_ListDestroy(list);
  279.     UNLOCK_COMPOSITOR(compositor);
  280.     return NULL;
  281. }
  282.  
  283. static void
  284. cl_refresh_window_region_common(CL_Compositor *compositor, 
  285.                                 FE_Region refresh_region,
  286.                                 PRBool copy_region)
  287. {
  288.     FE_Region draw_region, save_update_region, copy_refresh_region;
  289.     CL_Drawable *backing_store;
  290.     PRBool save_offscreen_inhibited;
  291.     
  292.     XP_ASSERT(compositor);
  293.     XP_ASSERT(refresh_region);
  294.  
  295.     if (!compositor || !refresh_region)
  296.         return;
  297.     
  298.     CL_TRACE(0, ("Refreshing window region"));
  299.  
  300.     LOCK_COMPOSITOR(compositor);
  301.  
  302. #if 0
  303.     /* Subtract out the cutout layers, since they are out-of-bounds
  304.        for compositor drawing. */
  305.     if (compositor->enabled) {
  306.     cl_prepare_to_draw(compositor, refresh_region, PR_FALSE);
  307.     }
  308. #endif
  309.  
  310. /*    if (compositor->root)
  311.         CL_HighlightRegion(compositor, refresh_region);*/
  312.  
  313.     if (compositor->enabled)
  314.         cl_compute_update_region(compositor);
  315.  
  316.    /* Invalidate any parts of the backing store for which there are
  317.        update requests. */
  318.     FE_SubtractRegion(compositor->backing_store_region,
  319.                       compositor->update_region,
  320.                       compositor->backing_store_region);
  321.  
  322.     /* Figure out what part of the refresh region has already been
  323.        composited into the backing store and blit that onto the
  324.        primary drawable. */
  325.     if (compositor->backing_store) {
  326.         backing_store = cl_LockDrawableForRead(compositor->backing_store);
  327.         if (backing_store) {
  328.             draw_region = FE_CreateRegion();
  329.             if (! draw_region) {
  330.                 UNLOCK_COMPOSITOR(compositor);
  331.                 return;
  332.             }
  333.             
  334.             FE_IntersectRegion(compositor->backing_store_region, refresh_region, draw_region);
  335.             cl_CopyPixels(backing_store, compositor->primary_drawable,
  336.                           draw_region);
  337.             FE_SubtractRegion(refresh_region, draw_region, refresh_region);
  338.             FE_DestroyRegion(draw_region);
  339.             cl_UnlockDrawable(backing_store);
  340.         }
  341.     }
  342.  
  343.     if (compositor->enabled) {
  344.         /* Save out the current update region, since we only want to draw
  345.            the area that we got a refresh request for.  We can't simply
  346.            subtract out the refresh area from the update area because
  347.            of Windows' behavior: In between the BeginPaint() and EndPaint()
  348.            calls, the clip is constrained to be that of the OS's update
  349.            region intersected with the clip that we set.  But, we don't know
  350.            what the resulting cascaded clip. */
  351.         save_update_region = compositor->update_region;
  352.  
  353.         /* We might have to copy the refresh region, since compositing will
  354.            modify it. */
  355.         if (copy_region) {
  356.             copy_refresh_region = FE_CreateRegion();
  357.             FE_CopyRegion(refresh_region, copy_refresh_region);
  358.             compositor->update_region = copy_refresh_region;
  359.         }
  360.         else
  361.             compositor->update_region = refresh_region;
  362.  
  363.         /* Subtract out the area that isn't in the composited region */
  364.         FE_IntersectRegion(compositor->window_region, 
  365.                            compositor->update_region,
  366.                            compositor->update_region);
  367.  
  368.         /* For speedier scrolling and exposures, we always composite
  369.            on-screen for refresh. */
  370.         save_offscreen_inhibited = compositor->offscreen_inhibited;
  371.         compositor->offscreen_inhibited = PR_TRUE;
  372.  
  373.         /* 
  374.          * Note that we don't subtract out the cutout region when we're
  375.          * going through this entry point, since it can be a performance
  376.          * hog, especially if we're scrolling. This works for Windows and
  377.          * X, but I'm not sure it will work across platforms.
  378.          */
  379.         cl_composite(compositor, PR_FALSE);
  380.         compositor->offscreen_inhibited = save_offscreen_inhibited;
  381.  
  382.         /* 
  383.          * If a layer has changed during the compositing, the update
  384.          * region will reflect the changes and will need to be dealt
  385.          * with in the next compositing pass. Copy it back into the
  386.          * saved update region.
  387.          */
  388.         FE_UnionRegion(save_update_region, compositor->update_region,
  389.                        save_update_region);
  390.  
  391.         if (copy_region)
  392.             FE_DestroyRegion(copy_refresh_region);
  393.  
  394.         compositor->update_region = save_update_region;
  395.     }
  396.     else
  397.         FE_UnionRegion(compositor->update_region, refresh_region,
  398.                        compositor->update_region);
  399.  
  400.     UNLOCK_COMPOSITOR(compositor);
  401. }
  402.  
  403.  
  404. /*
  405.  * Inform the compositor that some part of the window needs to be
  406.  * refreshed, e.g. in response to a window expose event.  The region
  407.  * to be refreshed is expressed in window coordinates.
  408.  */
  409. void
  410. CL_RefreshWindowRegion(CL_Compositor *compositor, FE_Region refresh_region)
  411. {
  412.     cl_refresh_window_region_common(compositor, refresh_region, PR_TRUE);
  413. }
  414.  
  415. /*
  416.  * Inform the compositor that some part of the window needs to be
  417.  * refreshed, e.g. in response to a window expose event.  The region
  418.  * to be refreshed is expressed in window coordinates.
  419.  */
  420. void
  421. CL_RefreshWindowRect(CL_Compositor *compositor, XP_Rect *refresh_rect)
  422. {
  423.     FE_Region refresh_region = FE_CreateRectRegion(refresh_rect);
  424.  
  425.     if (! refresh_region)       /* OOM */
  426.         return;
  427.     
  428.     cl_refresh_window_region_common(compositor, refresh_region, PR_FALSE);
  429.     FE_DestroyRegion(refresh_region);
  430. }
  431.  
  432. /*
  433.  * Inform the compositor that some part of a layer has changed and
  434.  * needs to be redrawn. The region to be updated is expressed in the
  435.  * layer's coordinate system. For efficiency, only the part of the
  436.  * passed in region that is not clipped by ancestor layers is actually
  437.  * updated.  If update_now is PR_TRUE, the composite is done
  438.  * synchronously. Otherwise, it is done at the next timer callback.
  439.  */
  440. void 
  441. CL_UpdateLayerRegion(CL_Compositor *compositor, CL_Layer *layer,
  442.                      FE_Region layer_region, PRBool update_now)
  443. {
  444.     int32 x_offset, y_offset;
  445.     XP_Rect win_clipped_bbox;
  446.     FE_Region update_region, win_clipped_bbox_region;
  447.     
  448.     XP_ASSERT(compositor);
  449.     XP_ASSERT(layer);
  450.     XP_ASSERT(layer_region);
  451.  
  452.     if (!compositor || !layer || !layer_region)
  453.         return;
  454.  
  455.     /* Oddball predicate below is used to combat the case where the
  456.        layer was made invisible, updated and made visible again, all
  457.        between two composite cycles.  In that case, we still want
  458.        to repaint the composited area. */
  459.     if (!layer->prev_visible && !layer->visible)
  460.         return;
  461.  
  462.     CL_TRACE(0, ("Updating layer region"));
  463.  
  464.     LOCK_COMPOSITOR(compositor);
  465.  
  466.     /* Compute offsets to convert layer coordinates to window coordinates */
  467.     x_offset = layer->x_origin - compositor->x_offset;
  468.     y_offset = layer->y_origin - compositor->y_offset;
  469.     
  470.     /* 
  471.      * If the offsets are outside the coordinate range we can express
  472.      * for regions, we can assume that the region to be updated is
  473.      * outside the window rectangle.
  474.      */
  475.     if ((ABS(x_offset) > FE_MAX_REGION_COORDINATE) ||
  476.         (ABS(y_offset) > FE_MAX_REGION_COORDINATE)) {
  477.         UNLOCK_COMPOSITOR(compositor);
  478.         return;
  479.     }
  480.     
  481.     /* Convert input region from layer coordinates into window coordinates */
  482.     update_region = FE_CreateRegion();
  483.     
  484.     XP_ASSERT(update_region);
  485.     if (! update_region) {
  486.         UNLOCK_COMPOSITOR(compositor);
  487.         return;
  488.     }
  489.     
  490.     FE_CopyRegion(layer_region, update_region);
  491.     FE_OffsetRegion(update_region, x_offset, y_offset);
  492.  
  493.     /* Convert clipping bbox of layer from document coordinates to
  494.        window coordinates and clip to window bounds. */
  495.     XP_CopyRect(&layer->clipped_bbox, &win_clipped_bbox);
  496.     XP_OffsetRect(&win_clipped_bbox,
  497.                   -compositor->x_offset, -compositor->y_offset);
  498.     XP_IntersectRect(&compositor->window_size,
  499.                      &win_clipped_bbox, 
  500.                      &win_clipped_bbox);
  501.  
  502.     /* Make the clipping bbox into a region, so we can do intersection */
  503.     win_clipped_bbox_region = FE_CreateRectRegion(&win_clipped_bbox);
  504.     XP_ASSERT(win_clipped_bbox_region);
  505.     if (! win_clipped_bbox_region) {
  506.         FE_DestroyRegion(update_region);
  507.         UNLOCK_COMPOSITOR(compositor);
  508.         return;
  509.     }
  510.  
  511.     /* Subtract out the area that isn't visible in the layer */
  512.     FE_IntersectRegion(win_clipped_bbox_region, update_region, update_region);
  513.     FE_DestroyRegion(win_clipped_bbox_region);
  514.  
  515.     if (FE_IsEmptyRegion(update_region)) {
  516.         FE_DestroyRegion(update_region);
  517.         UNLOCK_COMPOSITOR(compositor);
  518.         return;
  519.     }
  520.     
  521.     /* Add the altered region to the region to update at the next composite */
  522.     FE_UnionRegion(compositor->update_region, update_region, 
  523.                    compositor->update_region);
  524.  
  525.     FE_DestroyRegion(update_region);
  526.  
  527.     if (compositor->enabled) {
  528.         if (update_now)
  529.             cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS);
  530.         else
  531.             cl_start_compositor_timeouts(compositor);
  532.     }
  533.     UNLOCK_COMPOSITOR(compositor);
  534. }
  535.  
  536. /*
  537.  * Inform the compositor that some rectangular part of a layer has
  538.  * changed and needs to be redrawn. The region to be updated is
  539.  * expressed in the layer's coordinate system. For efficiency, only
  540.  * the part of the passed in region that is not clipped by ancestor
  541.  * layers is actually updated.  If update_now is PR_TRUE, the
  542.  * composite is done synchronously. Otherwise, it is done at the next
  543.  * timer callback.
  544.  */
  545. void
  546. CL_UpdateLayerRect(CL_Compositor *compositor, CL_Layer *layer,
  547.                    XP_Rect *layer_rect, PRBool composite_now)
  548. {
  549.     int32 x_offset, y_offset;
  550.     XP_Rect update_rect;
  551.  
  552.     XP_ASSERT(compositor);
  553.     XP_ASSERT(layer);
  554.     XP_ASSERT(layer_rect);
  555.  
  556.     if (!compositor || !layer || !layer_rect)
  557.         return;
  558.  
  559.     /* Oddball predicate below is used to combat the case where the
  560.        layer was made invisible, updated and made visible again, all
  561.        between two composite cycles.  In that case, we still want
  562.        to repaint the composited area. */
  563.     if (!layer->prev_visible && !layer->visible)
  564.         return;
  565.  
  566.     CL_TRACE(0, ("Updating layer rect"));
  567.  
  568.     XP_CopyRect(layer_rect, &update_rect);
  569.     
  570.     LOCK_COMPOSITOR(compositor);
  571.     
  572.     /* Compute offsets to convert layer coordinates to document coordinates */
  573.     x_offset = layer->x_origin;
  574.     y_offset = layer->y_origin;
  575.  
  576.     /* Convert the update_rect into document coordinates */
  577.     XP_OffsetRect(&update_rect, x_offset, y_offset);
  578.     
  579.     /* Don't update parts of the layer that are clipped by ancestor layers. */
  580.     XP_IntersectRect(&update_rect, &layer->clipped_bbox, &update_rect);
  581.  
  582.     CL_UpdateDocumentRect(compositor, &update_rect, composite_now);
  583.  
  584.     UNLOCK_COMPOSITOR(compositor);
  585. }
  586.  
  587. /*
  588.  * Inform the compositor that some rectangular part of a document has
  589.  * changed and needs to be redrawn. The region to be updated is
  590.  * expressed in the document's coordinate system.  If update_now is
  591.  * PR_TRUE, the composite is done synchronously. Otherwise, it is done
  592.  * at the next timer callback.
  593.  */
  594. void
  595. CL_UpdateDocumentRect(CL_Compositor *compositor,
  596.                       XP_Rect *doc_rect, PRBool update_now)
  597. {
  598.     int32 x_offset, y_offset;
  599.     XP_Rect update_rect;
  600.     FE_Region update_region;
  601.     
  602.     XP_ASSERT(compositor);
  603.     XP_ASSERT(doc_rect);
  604.  
  605.     if (!compositor || !doc_rect)
  606.         return;
  607.     
  608.     CL_TRACE(0, ("Updating document rect"));
  609.  
  610.     XP_CopyRect(doc_rect, &update_rect);
  611.  
  612.     LOCK_COMPOSITOR(compositor);
  613.  
  614.     /* Compute offsets to convert document coordinates to window coordinates */
  615.     x_offset = - compositor->x_offset;
  616.     y_offset = - compositor->y_offset;
  617.     
  618.     /* Convert the update_rect into window coordinates */
  619.     XP_OffsetRect(&update_rect, x_offset, y_offset);
  620.  
  621.     /* 
  622.      * If there's no overlap between the update_rect and the
  623.      * composited area, there's nothing to draw.
  624.      */
  625.     if (!XP_RectsOverlap(&compositor->window_size, &update_rect)) {
  626.         UNLOCK_COMPOSITOR(compositor);
  627.         return;
  628.     }
  629.     
  630.     /* Subtract out the area that isn't in the composited rect */
  631.     XP_IntersectRect(&compositor->window_size, &update_rect,
  632.                      &update_rect);
  633.  
  634.     update_region = FE_CreateRectRegion(&update_rect);
  635.  
  636.     XP_ASSERT(update_region);
  637.     if (!update_region) {
  638.         UNLOCK_COMPOSITOR(compositor);
  639.         return;
  640.     }
  641.     
  642.     /* 
  643.      * Add the altered region to the region to update at 
  644.      * the next composite 
  645.      */
  646.     FE_UnionRegion(compositor->update_region, update_region, 
  647.                    compositor->update_region);
  648.  
  649.     FE_DestroyRegion(update_region);
  650.  
  651.     if (compositor->enabled) {
  652.         if (update_now)
  653.             cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS);
  654.         else
  655.             cl_start_compositor_timeouts(compositor);
  656.     }
  657.     UNLOCK_COMPOSITOR(compositor);
  658. }
  659.  
  660. /* Update the entire contents of a layer and its children. */
  661. void
  662. cl_UpdateLayer(CL_Layer *layer, PRBool update_now)
  663. {
  664.     if (! layer->compositor)
  665.         return;
  666.  
  667.     /* Update the layer */
  668.     CL_UpdateDocumentRect(layer->compositor, &layer->clipped_bbox, PR_FALSE);
  669.  
  670.     /* Update the layer's children, but only if there's a possibility
  671.        that some children are not clipped by this layer, otherwise
  672.        we've already updated with the statement above. */
  673.     if (!layer->clip_children) {
  674.         CL_Layer *child;
  675.         for (child = layer->top_child; child; child = child->sib_below) {
  676.             cl_UpdateLayer(child, PR_FALSE);
  677.         }
  678.     }
  679.  
  680.     if (layer->compositor->enabled) {
  681.         if (update_now)
  682.             cl_composite(layer->compositor, TRIM_UPDATE_REGION_CUTOUTS);
  683.         else
  684.             cl_start_compositor_timeouts(layer->compositor);
  685.     }
  686. }
  687.  
  688. /*
  689. The decision whether to draw onscreen or offscreen is made once for
  690. every composite cycle using these rules:
  691.  
  692.  1) If compositor->offscreen_inhibited is set, drawing is always
  693.     done onscreen.
  694.  2) If compositor->offscreen_enabled is set, drawing is always done
  695.     offscreen.
  696.  3) Otherwise, the offscreen mode depends on the drawing-mode flags
  697.     set for all the layers that fall within the update-region.
  698.  
  699.     A layer is either neutral or biased towards drawing onscreen or
  700.     drawing offscreen, as indicated by the CL_PREFER_DRAW_ONSCREEN and
  701.     CL_PREFER_DRAW_OFFSCREEN flags.
  702.  
  703.     For rule 3, the set of all layers that falls within the bounding box
  704.     of the update-region is examined to determine the drawing mode:
  705.  
  706.     3a) If no layer has the CL_PREFER_DRAW_OFFSCREEN flag set, all drawing
  707.     is performed onscreen.
  708.     3b) Otherwise, bottom-up drawing is performed offscreen until reaching
  709.     a layer that has CL_PREFER_DRAW_ONSCREEN set.  Then the offscreen
  710.     damaged area is BLTed onscreen and remaining layers are drawn onscreen.
  711.     
  712. Top-down drawing is handled differently: It always occurs onscreen unless
  713. CL_PREFER_DRAW_OFFSCREEN is set for an individual layer.
  714. */
  715.  
  716. static void
  717. cl_setup_offscreen(CL_Compositor *compositor)
  718. {
  719.     if (!compositor->backing_store)
  720.         return;
  721.     
  722.     if (compositor->offscreen_enabled && !compositor->offscreen_inhibited) {
  723.         if (!compositor->offscreen_initialized) {
  724.             int width = compositor->window_size.right-
  725.                 compositor->window_size.left;
  726.             int height = compositor->window_size.bottom-
  727.                 compositor->window_size.top;
  728.             cl_InitDrawable(compositor->backing_store);
  729.             cl_SetDrawableDimensions(compositor->backing_store, width, height);
  730.             compositor->offscreen_initialized = PR_TRUE;
  731.         }
  732.     } else if (compositor->offscreen_initialized) {
  733. #ifdef THRASH_OFFSCREEN
  734.         cl_RelinquishDrawable(compositor->backing_store);
  735.         compositor->offscreen_initialized = PR_FALSE;
  736. #endif
  737.     }
  738. }
  739.  
  740. static void
  741. cl_compute_update_region_recurse(CL_Compositor *compositor,
  742.                                  CL_Layer *layer,
  743.                                  FE_Region update_region)
  744. {
  745.     CL_Layer *child;
  746.     int32 x_offset, y_offset;
  747.     FE_Region layer_update_region;
  748.     XP_Rect *win_clipped_bbox;
  749.     XP_Rect prev_win_clipped_bbox;
  750.     
  751.     PRBool visibility_changed, bbox_changed, position_changed;
  752.  
  753.     /* Find out what properties of the layer have changed since the
  754.        last time compositing occurred. */
  755.     visibility_changed = layer->visible != layer->prev_visible;
  756.     bbox_changed = !XP_EqualRect(&layer->clipped_bbox,
  757.                                  &layer->prev_clipped_bbox);
  758.     x_offset = layer->x_origin - layer->prev_x_origin;
  759.     y_offset = layer->y_origin - layer->prev_y_origin;
  760.     position_changed = (x_offset || y_offset);
  761.  
  762.     /* If layer bbox changed, call client-defined callback. */
  763.     if (bbox_changed && layer->vtable.bbox_changed_func) {
  764.         XP_Rect bbox_copy;
  765.         XP_CopyRect(&layer->bbox, &bbox_copy);
  766.         (*layer->vtable.bbox_changed_func)(layer, &bbox_copy);
  767.     }
  768.  
  769.     /* If visibility changed, call client-defined callback. */
  770.     if (visibility_changed && layer->vtable.visibility_changed_func)
  771.         (*layer->vtable.visibility_changed_func)(layer, layer->visible);
  772.  
  773.     /* If layer origin changed, call client-defined callback. */
  774.     if (position_changed && layer->vtable.position_changed_func)
  775.         (*layer->vtable.position_changed_func)(layer, x_offset, y_offset);
  776.  
  777.     /* Compute the bounding box, in window coordinates, of the part of
  778.        the layer that isn't clipped by ancestors and which lies within
  779.        the bounding box of the window. */
  780.     win_clipped_bbox = &layer->win_clipped_bbox;
  781.     XP_CopyRect(&layer->clipped_bbox, win_clipped_bbox);
  782.     XP_OffsetRect(win_clipped_bbox,
  783.                   -compositor->x_offset, -compositor->y_offset);
  784.     XP_IntersectRect(win_clipped_bbox, &compositor->window_size,
  785.                      win_clipped_bbox);
  786.  
  787.     XP_CopyRect(&layer->prev_clipped_bbox, &prev_win_clipped_bbox);
  788.     XP_OffsetRect(&prev_win_clipped_bbox,
  789.                   -compositor->x_offset, -compositor->y_offset);
  790.     XP_IntersectRect(&prev_win_clipped_bbox, &compositor->window_size,
  791.                      &prev_win_clipped_bbox);
  792.  
  793.     layer_update_region = FE_NULL_REGION;
  794.     if (visibility_changed) {
  795.         if (layer->visible) {
  796.             if (!layer->cutout) {
  797.                 layer_update_region = FE_CreateRectRegion(win_clipped_bbox);
  798.                 XP_ASSERT(layer_update_region);
  799.             }
  800.         } else {
  801.             layer_update_region = FE_CreateRectRegion(&prev_win_clipped_bbox);
  802.             XP_ASSERT(layer_update_region);
  803.         }
  804.  
  805.     } else if (layer->visible && (bbox_changed || position_changed)) {
  806.         FE_Region win_clipped_region, prev_win_clipped_region;
  807.  
  808.         win_clipped_region = FE_CreateRectRegion(win_clipped_bbox);
  809.         prev_win_clipped_region = FE_CreateRectRegion(&prev_win_clipped_bbox);
  810.  
  811.         if (win_clipped_region && prev_win_clipped_region) {
  812.             layer_update_region = FE_CreateRegion();
  813.  
  814.             if (layer->cutout)
  815.                 FE_SubtractRegion(prev_win_clipped_region,
  816.                                   win_clipped_region,
  817.                                   layer_update_region);
  818.             else if (bbox_changed && !position_changed)
  819.                 cl_XorRegion(win_clipped_region,
  820.                              prev_win_clipped_region,
  821.                              layer_update_region);
  822.             else
  823.                 FE_UnionRegion(win_clipped_region,
  824.                                prev_win_clipped_region,
  825.                                layer_update_region);
  826.         }
  827.                                
  828.         if (win_clipped_region)
  829.             FE_DestroyRegion(win_clipped_region);
  830.         if (prev_win_clipped_region)
  831.             FE_DestroyRegion(prev_win_clipped_region);
  832.         XP_ASSERT(layer_update_region);
  833.     }
  834.         
  835.     if (layer_update_region != FE_NULL_REGION) {
  836.         FE_UnionRegion(update_region, layer_update_region, update_region);
  837.         FE_DestroyRegion(layer_update_region);
  838.     }
  839.     
  840.     /* Set layer properties for subsequent composite cycle */
  841.     layer->prev_visible = layer->visible;
  842.     XP_CopyRect(&layer->clipped_bbox, &layer->prev_clipped_bbox);
  843.     layer->prev_x_origin = layer->x_origin;
  844.     layer->prev_y_origin = layer->y_origin;
  845.  
  846.     for (child = layer->top_child; child; child = child->sib_below)
  847.         cl_compute_update_region_recurse(compositor, child, update_region);
  848. }
  849.  
  850. static void
  851. cl_compute_update_region(CL_Compositor *compositor)
  852. {
  853.     /* We may need to recompute the update region iteratively since
  854.        layer callbacks may result in changes to layer properties, such
  855.        as bbox, visibility and position. */
  856.     while (compositor->recompute_update_region) {
  857.         compositor->recompute_update_region = PR_FALSE;
  858.         cl_compute_update_region_recurse(compositor, compositor->root,
  859.                                          compositor->update_region);
  860.     }
  861. }
  862.  
  863. /* Pre-drawing layer initialization in front-to-back order.  (This
  864.    could be folded into cl_draw_front_to_back, but then we would need
  865.    to duplicate this functionality when in back_to_front_only mode. */
  866. static int
  867. cl_prepare_to_draw_recurse(CL_Compositor *compositor,
  868.                            CL_Layer *layer, PRBool cutoutp,
  869.                            XP_Rect *update_bbox,
  870.                            PRBool *prefer_draw_offscreen_p)
  871. {
  872.     CL_Layer *child;
  873.     XP_Rect *win_clipped_bbox;
  874.     int descendant_draw_needed = 0;
  875.  
  876.     /* Debugging assert to make sure that these regions are
  877.        destroyed at the end of the composite cycle */
  878.     XP_ASSERT(layer->draw_region == FE_NULL_REGION);
  879.     
  880.     /* Check if the layer is eligible for compositing.  A layer won't
  881.        be composited if it is hidden, or it is entirely clipped by
  882.        ancestors. */
  883.     if (! layer->visible) {
  884.         layer->draw_needed = FALSE;
  885.         if (!layer->descendant_visible || layer->cutout) {
  886.             layer->descendant_draw_needed = FALSE;
  887.             return FALSE;
  888.         }
  889.     } else {
  890.         layer->draw_needed = (layer->vtable.painter_func != NULL);
  891.     }
  892.  
  893.     /* Compute the bounding box, in window coordinates, of the part of
  894.        the layer that isn't clipped by ancestors and which lies within
  895.        the bounding box of the update region. */
  896.     win_clipped_bbox = &layer->win_clipped_bbox;
  897.     XP_CopyRect(&layer->clipped_bbox, win_clipped_bbox);
  898.     XP_OffsetRect(win_clipped_bbox,
  899.                   -compositor->x_offset, -compositor->y_offset);
  900.     XP_IntersectRect(win_clipped_bbox, update_bbox, win_clipped_bbox);
  901.  
  902.     if (XP_IsEmptyRect(win_clipped_bbox)) {
  903.         layer->draw_needed = PR_FALSE;
  904.         if (!layer->descendant_visible || layer->cutout) {
  905.             layer->descendant_draw_needed = PR_FALSE;
  906.             return FALSE;
  907.         }
  908.     }
  909.  
  910.     /* If this is a cutout layer, add the layer's area to the
  911.        off-limits drawing region for the compositor */
  912.     if (layer->cutout) {
  913.         if (cutoutp) {
  914.             FE_Region win_clipped_region = FE_CreateRectRegion(win_clipped_bbox);
  915.             
  916.             if (! win_clipped_region)    /* OOM check */
  917.                 return 0;
  918.             
  919.             FE_UnionRegion(compositor->cutout_region,
  920.                            win_clipped_region,
  921.                            compositor->cutout_region);
  922.             FE_DestroyRegion(win_clipped_region);
  923.         }
  924.  
  925.         /* Cutout-layers can't have children and don't draw themselves. */
  926.         layer->draw_needed = PR_FALSE;
  927.         layer->descendant_draw_needed = PR_FALSE;
  928.         return 0;
  929.     }
  930.  
  931.     /* Recurse for children.
  932.        First get the children to draw in front to back order. */
  933.     for (child = layer->top_child; child; child = child->sib_below) {
  934.         descendant_draw_needed |=
  935.             cl_prepare_to_draw_recurse(compositor, child, cutoutp, update_bbox,
  936.                                        prefer_draw_offscreen_p);
  937.     }
  938.     layer->descendant_draw_needed = (PRBool)descendant_draw_needed;
  939.  
  940.     /* If the layer must draw offscreen then do the entire composite
  941.        offscreen. */
  942.     if ((layer->draw_needed || descendant_draw_needed) && layer->prefer_draw_offscreen)
  943.         *prefer_draw_offscreen_p = PR_TRUE;
  944.  
  945.  
  946.     return (int)layer->draw_needed | descendant_draw_needed;
  947. }
  948.  
  949. static void
  950. cl_prepare_to_draw(CL_Compositor *compositor, FE_Region update_region, 
  951.                    PRBool cutoutp, PRBool *prefer_draw_offscreen_p)
  952. {
  953.     XP_Rect update_bbox;
  954.  
  955.     compositor->cutout_region = FE_CreateRegion();
  956.     if (!compositor->cutout_region) /* OOM */
  957.     return;
  958.  
  959.     FE_GetRegionBoundingBox(update_region, &update_bbox);
  960.  
  961.     cl_prepare_to_draw_recurse(compositor, compositor->root, cutoutp,
  962.                                &update_bbox, prefer_draw_offscreen_p);
  963.     
  964.     if (cutoutp)
  965.         FE_SubtractRegion(update_region, compositor->cutout_region,
  966.                           update_region);
  967.     FE_DestroyRegion(compositor->cutout_region);
  968. }
  969.  
  970. /* The front-to-back drawing phase
  971.    Yech!  Let's get rid of all these arguments. */
  972. static PRBool
  973. cl_draw_front_to_back_recurse(CL_Compositor *compositor,
  974.                               CL_Layer *layer,
  975.                               CL_Layer **top_undrawn_layerp,
  976.                               CL_Layer **bottom_undrawn_layerp,
  977.                               CL_Drawable *backing_store,
  978.                               PRBool *offscreen_layer_drawn_above,
  979.                               FE_Region update_region,
  980.                               FE_Region transparent_above,
  981.                               FE_Region unobscured_by_opaque,
  982.                               FE_Region offscreen_region)
  983. {
  984.     FE_Region overlap;
  985.     CL_Layer *child;
  986.     PRBool layer_is_unobscured_by_transparent_layers, done;
  987.     CL_Drawable *drawable;
  988.     int32 old_x_origin, old_y_origin;
  989.  
  990.     if (layer->descendant_draw_needed) {
  991.  
  992.         /* First get the children to draw in front to back order. */
  993.         done = PR_FALSE;
  994.         for (child = layer->top_child; child && !done; child = child->sib_below) {
  995.             done = cl_draw_front_to_back_recurse(compositor, child,
  996.                                                  top_undrawn_layerp,
  997.                                                  bottom_undrawn_layerp,
  998.                                                  backing_store,
  999.                                                  offscreen_layer_drawn_above,
  1000.                                                  update_region,
  1001.                                                  transparent_above,
  1002.                                                  unobscured_by_opaque,
  1003.                                                  offscreen_region);
  1004.         }
  1005.  
  1006.         /* Have we reached the last layer in the front-to-back pass ? */
  1007.         if (done)
  1008.             return PR_TRUE;
  1009.     }
  1010.  
  1011.     if (!layer->draw_needed)
  1012.         return PR_FALSE;
  1013.  
  1014.     /* Compute the layer's clipping region for drawing. */
  1015.     layer->draw_region = FE_CreateRectRegion(&layer->win_clipped_bbox);
  1016.     FE_IntersectRegion(unobscured_by_opaque, 
  1017.                        layer->draw_region, 
  1018.                        layer->draw_region);
  1019.  
  1020.     /* If the layer is wholly obscured by opaque layers in front of it,
  1021.        there's nothing to draw. */
  1022.     if (FE_IsEmptyRegion(layer->draw_region)) {
  1023.         layer->draw_needed = PR_FALSE;
  1024.         if (layer->clip_children) {
  1025.             layer->descendant_draw_needed = PR_FALSE;
  1026.         }
  1027.         FE_DestroyRegion(layer->draw_region);
  1028.         layer->draw_region = FE_NULL_REGION;
  1029.         return PR_FALSE;
  1030.     }
  1031.  
  1032.     if (layer->opaque) {
  1033.  
  1034.         overlap = FE_CreateRegion();
  1035.         FE_IntersectRegion(transparent_above, layer->draw_region, overlap);
  1036.         layer_is_unobscured_by_transparent_layers = FE_IsEmptyRegion(overlap);
  1037.         FE_DestroyRegion(overlap);
  1038.  
  1039.         /* Are there any non-opaque layers which must draw on top of this
  1040.            layer ? */
  1041.         if (layer_is_unobscured_by_transparent_layers) {
  1042.             
  1043.             /* Figure out if we're drawing to the backing store or not */
  1044.             if (layer->prefer_draw_onscreen || !backing_store) {
  1045.                 drawable = compositor->primary_drawable;
  1046.             } else {
  1047.                 drawable = backing_store;
  1048.                 FE_UnionRegion(layer->draw_region, 
  1049.                                offscreen_region, 
  1050.                                offscreen_region);
  1051.             }
  1052.  
  1053.             /* Set the drawing origin and clip for this layer. */
  1054.             cl_GetDrawableOrigin(drawable, &old_x_origin, &old_y_origin);
  1055.             cl_SetDrawableOrigin(drawable, layer->x_origin, layer->y_origin);
  1056.             cl_SetDrawableClip(drawable, layer->draw_region);
  1057.  
  1058.             /* Draw the layer's contents */
  1059.             (*layer->vtable.painter_func)(drawable,
  1060.                                           layer, layer->draw_region);
  1061.  
  1062.             cl_SetDrawableOrigin(drawable, old_x_origin, old_y_origin);
  1063.             
  1064.             /* No other layers either above or below this one need to
  1065.                update the screen area occupied by this layer.  Any
  1066.                layers are either opaque overlapping layers that have
  1067.                already been drawn in the front-to-back phase, or they
  1068.                are below this layer and will therefore be obscured by it. */
  1069.             FE_SubtractRegion(update_region,
  1070.                               layer->draw_region, update_region);
  1071.  
  1072.             /* We don't need to draw this layer in the back-to-front phase,
  1073.                since we've already drawn it. */
  1074.             layer->draw_needed = PR_FALSE;
  1075.         } else {
  1076.  
  1077.             /* This is the bottommost layer that needs drawing, and which
  1078.                has not yet been drawn */
  1079.             *bottom_undrawn_layerp = layer;
  1080.  
  1081.             if (! *top_undrawn_layerp)
  1082.                 *top_undrawn_layerp = layer;
  1083.  
  1084.             layer->offscreen_layer_drawn_above = *offscreen_layer_drawn_above;
  1085.             *offscreen_layer_drawn_above |= (int)layer->prefer_draw_offscreen;
  1086.         }
  1087.  
  1088.         FE_SubtractRegion(unobscured_by_opaque, layer->draw_region,
  1089.                           unobscured_by_opaque);
  1090.  
  1091.         /* If we've already drawn the layer, get rid of the draw region */
  1092.         if (layer_is_unobscured_by_transparent_layers) {
  1093.             FE_DestroyRegion(layer->draw_region);
  1094.             layer->draw_region = FE_NULL_REGION;
  1095.         }
  1096.         
  1097.         /* When the entire remaining update region is obscured by
  1098.            opaque layers above it, there's nothing left to do. */
  1099.         if (FE_IsEmptyRegion(unobscured_by_opaque)) {
  1100.             return PR_TRUE;
  1101.         }
  1102.     } else {
  1103.         FE_UnionRegion(transparent_above, layer->draw_region, 
  1104.                        transparent_above);
  1105.         *bottom_undrawn_layerp = layer;
  1106.         if (! *top_undrawn_layerp)
  1107.             *top_undrawn_layerp = layer;
  1108.         layer->offscreen_layer_drawn_above = *offscreen_layer_drawn_above;
  1109.         *offscreen_layer_drawn_above |= (int)layer->prefer_draw_offscreen;
  1110.     }
  1111.  
  1112.     return PR_FALSE;
  1113. }
  1114.  
  1115. /* The front-to-back drawing phase */
  1116. static void
  1117. cl_draw_front_to_back(CL_Compositor *compositor,
  1118.                       CL_Layer **top_undrawn_layerp,
  1119.                       CL_Layer **bottom_undrawn_layerp,
  1120.                       CL_Drawable *backing_store,
  1121.                       FE_Region update_region,
  1122.                       FE_Region offscreen_region)
  1123. { 
  1124.     FE_Region transparent_above, unobscured_by_opaque;   
  1125.     PRBool offscreen_layer_drawn_above = PR_FALSE;
  1126.  
  1127.     transparent_above = FE_CreateRegion();
  1128.     if (! transparent_above) {
  1129.         XP_ASSERT(0);      /* OOM */
  1130.         return;
  1131.     }
  1132.          
  1133.     unobscured_by_opaque = FE_CopyRegion(update_region, NULL);
  1134.     if (! unobscured_by_opaque) {
  1135.         XP_ASSERT(0);      /* OOM */
  1136.         FE_DestroyRegion(transparent_above);
  1137.         return;
  1138.     }
  1139.     cl_draw_front_to_back_recurse(compositor, compositor->root,
  1140.                                   top_undrawn_layerp, bottom_undrawn_layerp,
  1141.                                   backing_store,
  1142.                                   &offscreen_layer_drawn_above,
  1143.                                   update_region,
  1144.                                   transparent_above,
  1145.                                   unobscured_by_opaque,
  1146.                                   offscreen_region);
  1147.     FE_DestroyRegion(transparent_above);
  1148.     FE_DestroyRegion(unobscured_by_opaque);
  1149. }
  1150.  
  1151. typedef struct cl_back_to_front_state 
  1152. {
  1153.     CL_Compositor *compositor;
  1154.     CL_Layer *top_undrawn_layer;
  1155.     CL_Layer *bottom_undrawn_layer;
  1156.     PRBool *onscreen_layer_drawn_below;
  1157.     FE_Region update_region;
  1158.     CL_Drawable *backing_store;
  1159.     FE_Region offscreen_region;
  1160. } cl_back_to_front_state;
  1161.  
  1162. /* The back-to-front drawing phase */
  1163. static CL_BackToFrontStatus
  1164. cl_draw_back_to_front_recurse(CL_Layer *layer,
  1165.                               cl_back_to_front_state *s,
  1166.                               CL_BackToFrontStatus status)
  1167. {
  1168.     CL_Layer *child;
  1169.     CL_Drawable *drawable;
  1170.     int32 old_x_origin, old_y_origin;
  1171.     PRBool *onscreen_layer_drawn_below = s->onscreen_layer_drawn_below;
  1172.     CL_Drawable *backing_store = s->backing_store;
  1173.     CL_Compositor *compositor = s->compositor;
  1174.  
  1175.     /* Only draw if a draw is necessary and we've already reached
  1176.      * the bottommost layer that needs to be drawn.
  1177.      */
  1178.     if (layer->draw_needed && ((status == CL_REACHED_BOTTOM_UNDRAWN) || 
  1179.                                (layer == s->bottom_undrawn_layer))) {
  1180.  
  1181.         /* Clip drawing to the bounds of itself and any ancestors */
  1182.         if (!layer->draw_region) {
  1183.             layer->draw_region = FE_CreateRectRegion(&layer->win_clipped_bbox);
  1184.             FE_IntersectRegion(s->update_region, layer->draw_region, 
  1185.                                layer->draw_region);
  1186.         }
  1187.  
  1188.         /* If any layers beneath this one were drawn onscreen, then this
  1189.            layer needs to be drawn there also. */
  1190.         if (!backing_store || *onscreen_layer_drawn_below) {
  1191.             drawable = compositor->primary_drawable;
  1192.             *onscreen_layer_drawn_below = PR_TRUE;
  1193.         } else {
  1194.             FE_Region offscreen_region = s->offscreen_region;
  1195.             
  1196.             /* If this layer and layers above this one are drawn
  1197.                onscreen, but all the layers beneath were drawn
  1198.                offscreen, we need to copy what we've painted so far
  1199.                from the backing store to the primary drawable. */
  1200.             if (layer->prefer_draw_onscreen &&
  1201.                 !layer->offscreen_layer_drawn_above &&
  1202.                 !*onscreen_layer_drawn_below) {
  1203.                 
  1204.                 /* The clip could have been modified during the
  1205.                    front-to-back phase, so clear it. */
  1206.                 cl_SetDrawableClip(compositor->primary_drawable, NULL);
  1207.                 cl_CopyPixels(backing_store, compositor->primary_drawable,
  1208.                               offscreen_region);
  1209.                 FE_CLEAR_REGION(offscreen_region);
  1210.                 drawable = compositor->primary_drawable;
  1211.                 *onscreen_layer_drawn_below = PR_TRUE;
  1212.             } else {
  1213.                 drawable = backing_store;
  1214.                 FE_UnionRegion(offscreen_region, layer->draw_region, 
  1215.                                offscreen_region);
  1216.             }
  1217.         }
  1218.  
  1219.         /* Set the drawing origin and clip for this layer. */
  1220.         cl_GetDrawableOrigin(drawable, &old_x_origin, &old_y_origin);
  1221.         cl_SetDrawableOrigin(drawable, layer->x_origin, layer->y_origin);
  1222.         cl_SetDrawableClip(drawable, layer->draw_region);
  1223.  
  1224.         /* Draw the layer */
  1225.         (*layer->vtable.painter_func)(drawable, layer, layer->draw_region);
  1226.  
  1227.         cl_SetDrawableOrigin(drawable, old_x_origin, old_y_origin);
  1228.  
  1229.         FE_DestroyRegion(layer->draw_region);
  1230.         layer->draw_region = FE_NULL_REGION;
  1231.  
  1232.         /* If this layer is uniformly-colored, push it on the
  1233.            front-to-back stack of uniformly-colored layers. */
  1234.         if (layer->uniform_color) {
  1235.             XP_ASSERT(layer->opaque);
  1236.             layer->uniformly_colored_layer_below = 
  1237.                 compositor->uniformly_colored_layer_stack;
  1238.             compositor->uniformly_colored_layer_stack = layer;
  1239.         }
  1240.         
  1241.         /* If we've reached the last layer that couldn't draw in the
  1242.            front to back phase, it's time to stop.              */
  1243.         if (layer == s->top_undrawn_layer)
  1244.             return CL_REACHED_TOP_UNDRAWN;
  1245.  
  1246.         /* If we've reached the bottommost (first) layer that needs to be
  1247.          * drawn, the rest of the layers can start drawing. */
  1248.         if (layer == s->bottom_undrawn_layer)
  1249.             status = CL_REACHED_BOTTOM_UNDRAWN;
  1250.     }
  1251.  
  1252.     if (layer->descendant_draw_needed) {
  1253.         
  1254.         /* Get the children to draw in back to front order. 
  1255.            Stop if we've reached the last layer to draw.      */
  1256.         for (child = layer->bottom_child; 
  1257.              child && (status != CL_REACHED_TOP_UNDRAWN) ; 
  1258.              child = child->sib_above) {
  1259.             status = cl_draw_back_to_front_recurse(child, s, status);
  1260.         }
  1261.         return status;
  1262.     }
  1263.     
  1264.     return status;
  1265. }
  1266.  
  1267. /* The back-to-front drawing phase */
  1268. static void
  1269. cl_draw_back_to_front(CL_Compositor *compositor, 
  1270.                       CL_Layer *top_undrawn_layer,
  1271.                       CL_Layer *bottom_undrawn_layer,
  1272.                       FE_Region update_region,
  1273.                       CL_Drawable *backing_store,
  1274.                       FE_Region offscreen_region)
  1275. {
  1276.     PRBool onscreen_layer_drawn_below = PR_FALSE;
  1277.     
  1278.     cl_back_to_front_state state;
  1279.     
  1280.     state.compositor = compositor;
  1281.     state.top_undrawn_layer = top_undrawn_layer;
  1282.     state.bottom_undrawn_layer = bottom_undrawn_layer;
  1283.     state.onscreen_layer_drawn_below = &onscreen_layer_drawn_below;
  1284.     state.update_region = update_region;
  1285.     state.backing_store = backing_store;
  1286.     state.offscreen_region = offscreen_region;
  1287.  
  1288.     if (compositor->back_to_front_only)
  1289.     cl_draw_back_to_front_recurse(compositor->root, &state, 
  1290.                                   CL_REACHED_BOTTOM_UNDRAWN);
  1291.     else
  1292.         cl_draw_back_to_front_recurse(compositor->root, &state, CL_REACHED_NOTHING);
  1293. }
  1294.     
  1295.  
  1296. /* Redraws all regions changed since last call to cl_composite().
  1297.  * This is called by the timer callback. It can be also be directly
  1298.  * called to force a synchronous composite.
  1299.  */
  1300. static PRBool
  1301. cl_composite(CL_Compositor *compositor, PRBool cutoutp)
  1302. {
  1303.     CL_Layer *top_undrawn_layer, *bottom_undrawn_layer;
  1304.     CL_Drawable *backing_store;
  1305.     FE_Region offscreen_region, update_region;
  1306.     PRBool save_offscreen_enabled, prefer_draw_offscreen = PR_FALSE;
  1307.     
  1308.     XP_ASSERT(compositor);
  1309.  
  1310.     if (!compositor || !compositor->root)
  1311.         return PR_FALSE;
  1312.  
  1313.     LOCK_COMPOSITOR(compositor);
  1314.  
  1315.     /* Check if there's a region to be drawn... */
  1316.     cl_compute_update_region(compositor);
  1317.     if (FE_IsEmptyRegion(compositor->update_region)) {
  1318.         UNLOCK_COMPOSITOR(compositor);
  1319.         return PR_FALSE;
  1320.     }
  1321.  
  1322.     {
  1323.         XP_Rect bbox;
  1324.         FE_GetRegionBoundingBox(compositor->update_region, &bbox);
  1325.         CL_TRACE(0, ("Compositing rectangle [%d, %d, %d, %d]",
  1326.                      bbox.left, bbox.top, bbox.right, bbox.bottom));
  1327.     }
  1328.  
  1329.     XP_ASSERT(!compositor->composite_in_progress);
  1330.     compositor->composite_in_progress = PR_TRUE;
  1331.  
  1332.      /* 
  1333.       * Copy the current update region and then clear it out. The layer
  1334.       * painter funcs might actually perform operations that add to the
  1335.       * update regions and we don't want to lose those updates.
  1336.       */
  1337.      update_region = FE_CopyRegion(compositor->update_region, NULL);
  1338.      FE_CLEAR_REGION(compositor->update_region);
  1339.  
  1340.      /* Initialize temporary per-layer drawing variables.  Also determine
  1341.         whether this composite must be done offscreen. */
  1342.      cl_prepare_to_draw(compositor, update_region, cutoutp,
  1343.                         &prefer_draw_offscreen);
  1344.  
  1345.      if (prefer_draw_offscreen) {
  1346.          save_offscreen_enabled = compositor->offscreen_enabled;
  1347.          compositor->offscreen_enabled = PR_TRUE;
  1348.      }
  1349.      cl_setup_offscreen(compositor);
  1350.  
  1351.      /* Determine whether or not we'll use a backing store */
  1352.      if (compositor->offscreen_inhibited || !compositor->offscreen_enabled ||
  1353.          !compositor->backing_store) {
  1354.          /* FIXME - what happens if we've disabled the backing store,
  1355.             but some layers have prefer_draw_offscreen set ? */
  1356.          backing_store = NULL;
  1357.          offscreen_region = FE_NULL_REGION;
  1358.          
  1359.          /* Invalidate the parts of the backing store for which there are
  1360.             update requests. */
  1361.          FE_SubtractRegion(compositor->backing_store_region,
  1362.                            compositor->update_region,
  1363.                            compositor->backing_store_region);
  1364.      } else {
  1365.          backing_store = cl_LockDrawableForReadWrite(compositor->backing_store);
  1366.          if (!backing_store) {
  1367.              /* Couldn't read the backing store.  Invalidate its contents. */
  1368.              FE_CLEAR_REGION(compositor->backing_store_region);
  1369.              backing_store = cl_LockDrawableForWrite(compositor->backing_store);
  1370.          }
  1371.  
  1372.          /* Assume that there is a painter for every area of the drawable to 
  1373.             be updated. */
  1374.          if (backing_store)
  1375.              offscreen_region = FE_CreateRegion();
  1376.          
  1377.      }
  1378.  
  1379.      compositor->uniformly_colored_layer_stack = NULL;
  1380.      top_undrawn_layer = bottom_undrawn_layer = NULL;
  1381.  
  1382.      /* Front-to-back phase */
  1383.      if (!compositor->back_to_front_only) {
  1384.          cl_draw_front_to_back(compositor,
  1385.                                &top_undrawn_layer, &bottom_undrawn_layer,
  1386.                                backing_store,
  1387.                                update_region,
  1388.                                offscreen_region);
  1389.      }
  1390.  
  1391.      /* Back-to-front phase */
  1392.      if (top_undrawn_layer || compositor->back_to_front_only) {
  1393.          cl_draw_back_to_front(compositor,
  1394.                                top_undrawn_layer,
  1395.                                bottom_undrawn_layer,
  1396.                                update_region,
  1397.                                backing_store,
  1398.                                offscreen_region);
  1399.      }
  1400.     
  1401.      /* Transfer the composited pixels from the backing store to
  1402.         the onscreen drawable. */
  1403.      cl_SetDrawableClip(compositor->primary_drawable, NULL);
  1404.      if (backing_store) {
  1405.          if (!FE_IsEmptyRegion(offscreen_region)) {
  1406.              /* The clip could have been modified during the
  1407.                 front-to-back phase, so clear it. */
  1408.              cl_CopyPixels(backing_store, compositor->primary_drawable,
  1409.                            offscreen_region);
  1410.          }
  1411.  
  1412.          cl_UnlockDrawable(backing_store);
  1413.  
  1414.          FE_DestroyRegion(offscreen_region);
  1415.      }
  1416.  
  1417.      /* If this composite was forced offscreen, restore the previous state */
  1418.      if (prefer_draw_offscreen)
  1419.          compositor->offscreen_enabled = save_offscreen_enabled;
  1420.  
  1421.      /* Get rid of the temporary copy */
  1422.      FE_DestroyRegion(update_region);
  1423.  
  1424.      /* Set the clip region back to its old value */
  1425.      cl_RestoreDrawableClip(compositor->primary_drawable);
  1426.      
  1427.      compositor->composite_in_progress = PR_FALSE;
  1428.      
  1429.      UNLOCK_COMPOSITOR(compositor);
  1430.  
  1431.      return PR_TRUE;
  1432. }
  1433.  
  1434. /* External API */
  1435. void
  1436. CL_CompositeNow(CL_Compositor *compositor)
  1437. {
  1438.     cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS);
  1439. }
  1440.  
  1441. /* 
  1442.  * Indicates that the window the compositor is drawing to has been resized.
  1443.  * We make the assumption that any refreshing will be carried out by 
  1444.  * calling CL_RefreshWindowRect.
  1445.  */
  1446. void 
  1447. CL_ResizeCompositorWindow(CL_Compositor *compositor, int32 width, int32 height)
  1448. {
  1449.     XP_ASSERT(compositor);
  1450.   
  1451.     if (!compositor)
  1452.         return;
  1453.     
  1454.     LOCK_COMPOSITOR(compositor);
  1455.  
  1456.     compositor->window_size.right = compositor->window_size.left + width;
  1457.     compositor->window_size.bottom = compositor->window_size.top + height;
  1458.  
  1459.     if (compositor->window_region) 
  1460.         FE_DestroyRegion(compositor->window_region);
  1461.  
  1462.     compositor->window_region = FE_CreateRectRegion(&compositor->window_size);
  1463.  
  1464.     if (compositor->offscreen_initialized && compositor->backing_store)
  1465.         cl_SetDrawableDimensions(compositor->backing_store, width, height);
  1466.  
  1467.     UNLOCK_COMPOSITOR(compositor);
  1468. }
  1469.  
  1470. /* 
  1471.  * Called when the compositor's window scrolls. We make the assumption 
  1472.  * that any refreshing will be carried out by calling CL_RefreshWindowRect
  1473.  */
  1474. void 
  1475. CL_ScrollCompositorWindow(CL_Compositor *compositor, 
  1476.                           int32 x_origin, int32 y_origin)
  1477. {
  1478.     int32 delta_x, delta_y;
  1479.     
  1480.     XP_ASSERT(compositor);
  1481.     
  1482.     if (!compositor)
  1483.         return;
  1484.     
  1485.     LOCK_COMPOSITOR(compositor);
  1486.  
  1487.     if ((compositor->x_offset != x_origin) ||
  1488.         (compositor->y_offset != y_origin)) {
  1489.         
  1490.         /* Invalidate backing store.
  1491.            For better performance, perhaps we should be scrolling it, instead */
  1492.         FE_CLEAR_REGION(compositor->backing_store_region);
  1493.  
  1494.         delta_x = compositor->x_offset - x_origin;
  1495.         delta_y = compositor->y_offset - y_origin;
  1496.  
  1497.         /* Are we scrolling a small enough amount that some part of
  1498.            the current screen contents may remain onscreen ? */
  1499.         if ((ABS(delta_x) < FE_MAX_REGION_COORDINATE) &&
  1500.             (ABS(delta_y) < FE_MAX_REGION_COORDINATE)) {
  1501.             FE_Region update_region = compositor->update_region;
  1502.             FE_Region window_region = compositor->window_region;
  1503.             
  1504.             /* Scroll compositor update region */
  1505.             FE_OffsetRegion(update_region, delta_x, delta_y);
  1506.             
  1507.             FE_IntersectRegion(window_region, update_region, update_region);
  1508.         }
  1509.  
  1510.         compositor->x_offset = x_origin;
  1511.         compositor->y_offset = y_origin;
  1512.         
  1513.     }
  1514.     UNLOCK_COMPOSITOR(compositor);
  1515. }
  1516.  
  1517. /* Sets whether a compositor offscreen-drawing should occur or not */
  1518. /* If enabled is PR_TRUE, the compositor will use offscreen        */
  1519. /* drawing if applicable.                                          */
  1520. void
  1521. CL_SetCompositorOffscreenDrawing(CL_Compositor *compositor, 
  1522.                                  CL_OffscreenMode mode)
  1523. {
  1524.     XP_ASSERT(compositor);
  1525.     if (!compositor)
  1526.         return;
  1527.  
  1528.     switch (mode) {
  1529.     case CL_OFFSCREEN_ENABLED:
  1530.         compositor->offscreen_enabled = PR_TRUE;
  1531.         compositor->offscreen_inhibited = PR_FALSE;
  1532.         break;
  1533.     case CL_OFFSCREEN_DISABLED:
  1534.         compositor->offscreen_inhibited = PR_TRUE;
  1535.         break;
  1536.     case CL_OFFSCREEN_AUTO:
  1537.         compositor->offscreen_enabled = PR_FALSE;
  1538.         compositor->offscreen_inhibited = PR_FALSE;
  1539.         break;
  1540.     }
  1541. }
  1542.  
  1543. CL_OffscreenMode
  1544. CL_GetCompositorOffscreenDrawing(CL_Compositor *compositor)
  1545. {
  1546.     PRBool enabled;
  1547.     XP_ASSERT(compositor);
  1548.     if (! compositor)
  1549.         return PR_FALSE;
  1550.  
  1551.     if (compositor->offscreen_inhibited)
  1552.         return CL_OFFSCREEN_DISABLED;
  1553.  
  1554.     enabled = compositor->offscreen_enabled;
  1555.     return enabled ? CL_OFFSCREEN_ENABLED : CL_OFFSCREEN_AUTO;
  1556. }
  1557.  
  1558. /* Frame-rate excursion limits */
  1559. #define MAX_FRAME_PERIOD      (1000000.0F / CL_FRAME_RATE_MIN)
  1560. #define MIN_FRAME_PERIOD      (1000000.0F / CL_FRAME_RATE_MAX)
  1561. #define INITIAL_FRAME_PERIOD  (1000000.0F / CL_FRAME_RATE_INITIAL)
  1562.  
  1563. /* Timeout callback for time-based compositing.
  1564.  
  1565.    Adaptively adjust the frame-rate at which compositing is done based
  1566.    on the CPU load.  (CPU load is estimated by measuring the ability
  1567.    of recent composite timeouts to meet their deadlines.)
  1568.  */
  1569. static void
  1570. cl_compositor_callback(void *closure)
  1571. {
  1572. #ifdef CL_ADAPT_FRAME_RATE
  1573.     unsigned int i, index, filter_length, delay_line_index;
  1574.     int64 slack64, frame_period64, delay64, nominal_deadline64, now64;
  1575.     int32 slack, delay, slip, clamped_slack;
  1576.     double earliness, smoothed_slack, frame_period, adjust;
  1577.     
  1578.     CL_Compositor *compositor = (CL_Compositor *)closure;
  1579.     frame_period = compositor->frame_period;
  1580.  
  1581.     XP_ASSERT(compositor->frame_period != 0); /* should never be here in static case */
  1582.     if (compositor->frame_period == 0)
  1583.         return; /* to avoid divide by zero, since fundamentally should never be here */
  1584.  
  1585.     /* First, do the actual drawing work */
  1586.     if (cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS) == PR_FALSE) {
  1587.  
  1588.         compositor->nothing_to_do_count++;
  1589.  
  1590.         if (compositor->nothing_to_do_count > 5) {
  1591.  
  1592.             /*
  1593.              *    Clear the timeout, because we are in the closure
  1594.              *    function, and we don't want another dangling timer.
  1595.              */
  1596.             compositor->composite_timeout = NULL; /* VERY IMPORTANT */
  1597.             compositor->nothing_to_do_count = 0;
  1598.             return;
  1599.         }
  1600.     } else {
  1601.         compositor->nothing_to_do_count = 0;
  1602.     }
  1603.  
  1604.     /* Compute the "slack", which indicates how late (or early) the
  1605.        compositor was meeting its deadline.  Positive slack numbers
  1606.        indicate earliness.  Negative numbers lateness. */
  1607.     now64 = PR_Now();
  1608.     nominal_deadline64 = compositor->nominal_deadline64;
  1609.     LL_SUB(slack64, nominal_deadline64, now64);
  1610.     LL_L2I(slack, slack64);
  1611.  
  1612.     slack -= (int32)((1.0 - CL_CPU_LOAD) * frame_period);
  1613.  
  1614.     /* Clamp slack to maximum permitted amount of frame-period adjustment. */
  1615.     slip = 0;
  1616.     if (frame_period - slack > MAX_FRAME_PERIOD) {
  1617.         clamped_slack = (int32)(frame_period - MAX_FRAME_PERIOD);
  1618.         slip = clamped_slack - slack;
  1619.     }
  1620.  
  1621.     /* Store latest slack value in the delay line, a circular array
  1622.        that keeps track of the most recent slack values. */
  1623.     delay_line_index = compositor->delay_line_index;
  1624.     if (delay_line_index == DELAY_LINE_LENGTH) {
  1625.         /* First time we're running the timeout.  Initialize the delay line */
  1626.         for (i = 0; i < DELAY_LINE_LENGTH; i++)
  1627.             compositor->delay_line[i] = slack;
  1628.     } else {
  1629.         /* Push most recent slack value into circular delay line */
  1630.         compositor->delay_line[delay_line_index] = slack;
  1631.     }
  1632.  
  1633.     /* Compute the number of filter taps corresponding to the
  1634.        requested duration of the filter, assuming that the
  1635.        compositor's frame-rate changes slowly. */
  1636.  
  1637.     /* This should never happen, since we check for this up top. But just in case */    
  1638.     /* something changes in the future in the above code, this is here */    
  1639.     /* just to make sure we find a potential divide by zero quickly, and don't do it.     
  1640.     XP_ASSERT(frame_period != 0); 
  1641.  
  1642.     if(frame_period == 0)
  1643.         filter_length = DELAY_LINE_LENGTH;
  1644.     else
  1645.     */
  1646.     
  1647.     filter_length = (unsigned int) ((SLOW_FILTER_DURATION * 1000) / frame_period);
  1648.  
  1649.     if (filter_length > DELAY_LINE_LENGTH)
  1650.         filter_length = DELAY_LINE_LENGTH;
  1651.     if (filter_length < 4)
  1652.         filter_length = 4;
  1653.  
  1654.     /* Average the last <filter_length> values in the circular delay
  1655.        line to create a smoothed slow-response filtering of the slack
  1656.        values.  Create a "fast-response" filter that uses half as many
  1657.        elements as the "slow" one. */
  1658.     smoothed_slack = 0;
  1659.     earliness = 0;
  1660.     for (i = 0; i < filter_length; i++) {
  1661.         int32 slack_val;
  1662.  
  1663.         index = delay_line_index - i;
  1664.         index &= (DELAY_LINE_LENGTH - 1);
  1665.         slack_val = compositor->delay_line[index];
  1666.         smoothed_slack += slack_val;
  1667.         if (slack_val > 0)
  1668.             earliness += slack_val;
  1669.     }
  1670.     smoothed_slack /= filter_length;
  1671.     earliness /= filter_length;
  1672.  
  1673.     /* Update next index in circular delay-line */
  1674.     delay_line_index++;
  1675.     delay_line_index &= (DELAY_LINE_LENGTH - 1);
  1676.     compositor->delay_line_index = delay_line_index;
  1677.  
  1678.     adjust = earliness + ((smoothed_slack > 0) ? 0 : smoothed_slack * 0.35);
  1679.  
  1680.     /* Adjust the frame rate, but don't allow the frame rate to excur
  1681.        outside its preset limits. */
  1682.     if (adjust < 0) {
  1683.         /* Slack is decreasing, Let's decrease the CPU load by
  1684.            decreasing the frame rate. */
  1685.         frame_period -= 0.10 * adjust;
  1686.         if (frame_period > MAX_FRAME_PERIOD)
  1687.             frame_period = MAX_FRAME_PERIOD;
  1688.     } else {
  1689.         /* Slack is negative and decreasing.  (Really, we're
  1690.            finishing earlier and getting more so) ; Increase
  1691.            frame-rate to make use of available CPU. */
  1692.         frame_period -= 0.20 * adjust;
  1693.         if (frame_period < MIN_FRAME_PERIOD)
  1694.             frame_period = MIN_FRAME_PERIOD;
  1695.     }
  1696.     compositor->frame_period = (float)frame_period;
  1697.  
  1698.     /* Compute delay from now until start of next composite timeout */
  1699.     LL_SUB(delay64, nominal_deadline64, now64);
  1700.     LL_L2I(delay, delay64);
  1701.     delay = (delay + 500) / 1000; /* Convert from microseconds to ms */
  1702.  
  1703.     /* Compute nominal completion time for next composite timeout */
  1704.     LL_I2L(frame_period64, (int32)frame_period + slip);
  1705.     LL_ADD(nominal_deadline64, nominal_deadline64, frame_period64);
  1706.     compositor->nominal_deadline64 = nominal_deadline64;
  1707.  
  1708.     /* Impose minimum delay to prevent timeouts from being scheduled
  1709.        back-to-back */
  1710.     if (delay < CL_MIN_TIMEOUT)
  1711.         delay = CL_MIN_TIMEOUT;
  1712.  
  1713.     /* Schedule the next compositor timeout. */
  1714.     compositor->composite_timeout = 
  1715.         FE_SetTimeout((TimeoutCallbackFunction)cl_compositor_callback,
  1716.                       (void *)compositor,
  1717.                       (uint32)delay);
  1718.  
  1719. #else  /* !CL_ADAPT_FRAME_RATE */
  1720.     CL_Compositor *compositor = (CL_Compositor *)closure;
  1721.     cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS);
  1722.     compositor->composite_timeout = 
  1723.         FE_SetTimeout((TimeoutCallbackFunction)cl_compositor_callback,
  1724.                       (void *)compositor, 0);
  1725. #endif /* CL_ADAPT_FRAME_RATE */
  1726. }
  1727.  
  1728. PRBool 
  1729. CL_GetCompositorEnabled(CL_Compositor *compositor)
  1730. {
  1731.     XP_ASSERT(compositor);
  1732.     
  1733.     if (!compositor)
  1734.         return PR_FALSE;
  1735.     
  1736.     return compositor->enabled;
  1737. }
  1738.  
  1739.  
  1740. void
  1741. cl_start_compositor_timeouts(CL_Compositor *compositor)
  1742. {
  1743.     int64 frame_period64, now64;
  1744.  
  1745.     XP_ASSERT(compositor);
  1746.     if (compositor == NULL)
  1747.         return;
  1748.  
  1749.     if (compositor->frame_period == 0) /* indicates static case, no timeouts... */
  1750.         return;
  1751.  
  1752.     /* No need to start timeouts if already started */
  1753.     if (compositor->composite_timeout)
  1754.         return;
  1755.  
  1756.     if (!compositor->enabled)
  1757.         return;
  1758.  
  1759.     /* Compute nominal time for next composite timeout */
  1760.     now64 = PR_Now();
  1761.     LL_I2L(frame_period64, (int32)compositor->frame_period);
  1762.     LL_ADD(compositor->nominal_deadline64, now64, frame_period64);
  1763.  
  1764.     /* Special value indicates empty delay line */
  1765.     compositor->delay_line_index = DELAY_LINE_LENGTH;
  1766.     compositor->composite_timeout = 
  1767.         FE_SetTimeout((TimeoutCallbackFunction)cl_compositor_callback,
  1768.                       (void *)compositor, 0);
  1769. }
  1770.  
  1771.  
  1772. /* Sets a compositor's enabled state. Disabling a compositor will  */
  1773. /* stop timed composites (but will not prevent explicit composites */
  1774. /* from happening). Enabling a compositor restarts timed draws.    */
  1775. void 
  1776. CL_SetCompositorEnabled(CL_Compositor *compositor, PRBool enabled)
  1777. {
  1778.     XP_ASSERT(compositor);
  1779.  
  1780.     if (!compositor)
  1781.         return;
  1782.     
  1783.     CL_TRACE(0, ("Setting compositor enabled state to %d ", enabled));
  1784.  
  1785.     if (enabled && (compositor->enabled == PR_FALSE) && compositor->frame_period) {
  1786.         cl_composite(compositor, TRIM_UPDATE_REGION_CUTOUTS);
  1787.         
  1788.         CL_TRACE(0, ("Starting compositor timeout"));
  1789.         cl_start_compositor_timeouts(compositor);
  1790.     }
  1791.     else if (!enabled && (compositor->enabled == PR_TRUE)) {
  1792.         if (compositor->composite_timeout)
  1793.             FE_ClearTimeout(compositor->composite_timeout);
  1794.         compositor->composite_timeout = NULL;
  1795.         if (compositor->offscreen_initialized) {
  1796.             cl_RelinquishDrawable(compositor->backing_store);
  1797.             compositor->offscreen_initialized = PR_FALSE;
  1798.         }
  1799.     }
  1800.     
  1801.     compositor->enabled = enabled;
  1802. }
  1803.     
  1804. CL_Drawable *
  1805. CL_GetCompositorDrawable(CL_Compositor *compositor)
  1806. {
  1807.     XP_ASSERT(compositor);
  1808.     
  1809.     if (!compositor)
  1810.         return NULL;
  1811.     
  1812.     return compositor->primary_drawable;
  1813. }
  1814.  
  1815. void 
  1816. CL_SetCompositorDrawable(CL_Compositor *compositor, 
  1817.                          CL_Drawable *drawable)
  1818. {
  1819.     XP_ASSERT(compositor);
  1820.     
  1821.     if (!compositor)
  1822.         return;
  1823.     
  1824.     compositor->primary_drawable = drawable;
  1825.     drawable->compositor = compositor;
  1826. }
  1827.  
  1828. CL_Layer *
  1829. CL_GetCompositorRoot(CL_Compositor *compositor)
  1830. {
  1831.     XP_ASSERT(compositor);
  1832.     
  1833.     if (!compositor)
  1834.         return NULL;
  1835.  
  1836.     return compositor->root;
  1837. }
  1838.  
  1839. /* Set a layer as the root of the layer tree */
  1840. void 
  1841. CL_SetCompositorRoot(CL_Compositor *compositor, CL_Layer *root)
  1842. {
  1843.     XP_ASSERT(compositor);
  1844.  
  1845.     if (!compositor)
  1846.         return;
  1847.  
  1848.     CL_TRACE(0,("Setting root of compositor %x to layer %x", compositor, root));
  1849.  
  1850.     LOCK_COMPOSITOR(compositor);
  1851.     
  1852.     compositor->root = root;
  1853.  
  1854.     if (root) {
  1855.         cl_SetCompositorRecursive(root, compositor);
  1856.         
  1857.         cl_LayerAdded(compositor, root);
  1858.     }
  1859.     
  1860.     UNLOCK_COMPOSITOR(compositor);
  1861. }
  1862.  
  1863. uint32 
  1864. CL_GetCompositorFrameRate(CL_Compositor *compositor)
  1865. {
  1866.     XP_ASSERT(compositor);
  1867.     
  1868.     if (!compositor)
  1869.         return 0;
  1870.  
  1871.     if (compositor->frame_period == 0)
  1872.         return 0;
  1873.     else
  1874.         return (uint32)((1000000.0 / compositor->frame_period) + 0.5);
  1875. }
  1876.  
  1877. void 
  1878. CL_SetCompositorFrameRate(CL_Compositor *compositor, uint32 frame_rate)
  1879. {
  1880.     XP_ASSERT(compositor);
  1881.   
  1882.     if (!compositor)
  1883.         return;
  1884.  
  1885.     LOCK_COMPOSITOR(compositor);
  1886.  
  1887.     if (frame_rate)
  1888.         compositor->frame_period = 1000000.0F / frame_rate;
  1889.     else
  1890.         compositor->frame_period = 0.0F;
  1891.  
  1892.     /* BUGBUG This is probably the wrong behavior. If we had better */
  1893.     /* timing services, we could do better.                         */
  1894.     if (compositor->enabled && compositor->frame_period) {
  1895.         if (compositor->composite_timeout) {
  1896.             FE_ClearTimeout(compositor->composite_timeout);
  1897.             compositor->composite_timeout = NULL;
  1898.         }
  1899.     
  1900.         cl_start_compositor_timeouts(compositor);
  1901.     }
  1902.  
  1903.     UNLOCK_COMPOSITOR(compositor);
  1904. }
  1905.     
  1906. int32 
  1907. CL_GetCompositorXOffset(CL_Compositor *compositor)
  1908. {
  1909.     XP_ASSERT(compositor);
  1910.     
  1911.     if (!compositor)
  1912.         return 0;
  1913.  
  1914.     return compositor->x_offset;
  1915. }
  1916.  
  1917. int32 
  1918. CL_GetCompositorYOffset(CL_Compositor *compositor)
  1919. {
  1920.     XP_ASSERT(compositor);
  1921.     
  1922.     if (!compositor)
  1923.         return 0;
  1924.  
  1925.     return compositor->y_offset;
  1926. }
  1927.  
  1928. void CL_GetCompositorWindowSize(CL_Compositor *compositor,
  1929.                                 XP_Rect *window_size)
  1930. {
  1931.     XP_ASSERT(compositor);
  1932.     XP_ASSERT(window_size);
  1933.     
  1934.     if (!compositor || !window_size)
  1935.         return;
  1936.  
  1937.     LOCK_COMPOSITOR(compositor);
  1938.     *window_size = compositor->window_size;
  1939.     UNLOCK_COMPOSITOR(compositor);
  1940. }
  1941.  
  1942. static PRBool
  1943. cl_build_containment_list(CL_Compositor *compositor, CL_Layer *layer,
  1944.                           int32 which_list)
  1945. {
  1946.     int32 index = 0;
  1947.     CL_EventContainmentList *list = 
  1948.         &compositor->event_containment_lists[which_list];
  1949.  
  1950.     while (layer) {
  1951.         /* 
  1952.          * XXX We're assuming here that we don't have to do anything
  1953.          * special for Win16, since the depth of the layer tree will
  1954.          * hopefully not be > 8k (i.e. 32K segment boundary/4 bytes 
  1955.          * per pointer). Watch me eat my words one day.
  1956.          */
  1957.         if (index >= list->list_size) {
  1958.             list->list_size += CL_CONTAINMENT_LIST_INCREMENT;
  1959.             list->layer_list = XP_REALLOC(list->layer_list, list->list_size);
  1960.             if (list->layer_list == NULL)
  1961.                 return PR_FALSE;
  1962.         }
  1963.  
  1964.         list->layer_list[index++] = layer;
  1965.         layer = CL_GetLayerParent(layer);
  1966.     } 
  1967.  
  1968.     list->list_head = index-1;
  1969.  
  1970.     return PR_TRUE;
  1971. }
  1972.  
  1973. /*
  1974.  * This function checks for a change in either mouse or keyboard focus.
  1975.  * For mouse events, the focus has changed if the last layer to get
  1976.  * mouse events is different from the current one. In that case, we
  1977.  * build a containment list for the two layers. A containment list is
  1978.  * just a glorified name for a list consisting of the path from the
  1979.  * root of the layer tree down to the layer. Consider the following
  1980.  * example where layer C is the old mouse grabber and layer E the new
  1981.  * one.
  1982.  *                           root
  1983.  *                            /\
  1984.  *                           /  ...
  1985.  *                          A
  1986.  *                          |
  1987.  *                          B 
  1988.  *                         / \
  1989.  *                        C   D
  1990.  *                            |
  1991.  *                            E
  1992.  *            
  1993.  * In this case the containment list for layer C is root-A-B-C and the
  1994.  * containment list for layer E is root-A-B-D-E. We trace down both 
  1995.  * lists till we reach a point where there is a divergence. In this 
  1996.  * example, this point is below layer B. For the sub-tree rooted at B
  1997.  * that holds the old mouse grabber (layer C) we send MOUSE_LEAVE events
  1998.  * and for the sub-tree that holds the new mouse grabber (layer E) we
  1999.  * send MOUSE_ENTER events. This ensures that MOUSE_LEAVE and MOUSE_ENTER
  2000.  * events are sent for to all layers for which leaving and entering has
  2001.  * happened.
  2002.  */
  2003. static void
  2004. cl_check_focus_change(CL_Compositor *compositor, CL_Layer *new_grabber, 
  2005.                       CL_Event *mouse_event)
  2006. {    
  2007.     PRBool mouse_enter_occured = PR_FALSE;
  2008.  
  2009.     if (new_grabber != compositor->last_mouse_event_grabber) {
  2010.         CL_Event crossing_event;
  2011.         CL_Layer *last_grabber = compositor->last_mouse_event_grabber;
  2012.         int32 old_list_num = compositor->last_containment_list;
  2013.         int32 new_list_num = CL_NEXT_CONTAINMENT_LIST(old_list_num);
  2014.         int32 old_list_index, new_list_index;
  2015.         CL_EventContainmentList *old_list, *new_list;
  2016.  
  2017.         old_list = &compositor->event_containment_lists[old_list_num];
  2018.         new_list = &compositor->event_containment_lists[new_list_num];
  2019.         
  2020.         /* Build the containment list for the new mouse grabber */
  2021.         if (!cl_build_containment_list(compositor, 
  2022.                                        new_grabber, 
  2023.                                        new_list_num))
  2024.             return;
  2025.         
  2026.         old_list_index = old_list->list_head;
  2027.         new_list_index = new_list->list_head;
  2028.  
  2029.         /* 
  2030.          * Starting from the root, we trace downward in the tree, until
  2031.          * we find a divergence in the path.
  2032.          */
  2033.         while ((old_list_index >= 0) && (new_list_index >= 0) &&
  2034.                (old_list->layer_list[old_list_index] == 
  2035.                 new_list->layer_list[new_list_index])) {
  2036.             old_list_index--;
  2037.             new_list_index--;
  2038.         }
  2039.                
  2040.         crossing_event.x = crossing_event.y = 0;
  2041.         
  2042.         /* 
  2043.          * Send a mouse leave event to all layers that the mouse
  2044.          * has moved out of. 
  2045.          */
  2046.         while (old_list_index >= 0) {
  2047.             CL_Layer *layer = old_list->layer_list[old_list_index];
  2048.             
  2049.             if (layer && (layer->vtable.event_handler_func != NULL)) {
  2050.                 crossing_event.type = CL_EVENT_MOUSE_LEAVE;
  2051.                 crossing_event.which = (uint32)new_grabber;
  2052.                 crossing_event.fe_event = NULL;
  2053.                 crossing_event.x = mouse_event->x;
  2054.                 crossing_event.y = mouse_event->y;
  2055.                 crossing_event.modifiers = 0;
  2056.                 (*layer->vtable.event_handler_func)(layer, &crossing_event);
  2057.             }
  2058.             old_list_index--;
  2059.         }
  2060.         
  2061.         
  2062.         /* 
  2063.          * Send a mouse enter to all the new layers into which the mouse
  2064.          * has moved.
  2065.          */
  2066.         while (new_list_index >= 0) 
  2067.         {
  2068.             CL_Layer *layer = new_list->layer_list[new_list_index];
  2069.             
  2070.             if (layer && (layer->vtable.event_handler_func != NULL)) {
  2071.                 crossing_event.type = CL_EVENT_MOUSE_ENTER;
  2072.                 crossing_event.which = (uint32)last_grabber;
  2073.                 crossing_event.fe_event = NULL;
  2074.                 crossing_event.x = mouse_event->x;
  2075.                 crossing_event.y = mouse_event->y;
  2076.                 crossing_event.modifiers = 0;
  2077.                 (*layer->vtable.event_handler_func)(layer, &crossing_event);
  2078.                 mouse_enter_occured = PR_TRUE;
  2079.             }
  2080.             new_list_index--;
  2081.         }
  2082.  
  2083.         compositor->last_containment_list = new_list_num;
  2084.         compositor->last_mouse_event_grabber = new_grabber;
  2085.     }
  2086.   
  2087.     /* 
  2088.      * Check for a keyboard focus change, depending on the policy
  2089.      */
  2090.     if ((((compositor->focus_policy == CL_FOCUS_POLICY_CLICK) &&
  2091.           (mouse_event->type == CL_EVENT_MOUSE_BUTTON_DOWN) &&
  2092.           (mouse_event->which == 1)) ||
  2093.          ((compositor->focus_policy == CL_FOCUS_POLICY_MOUSE_ENTER) &&
  2094.           mouse_enter_occured))  &&
  2095.         (new_grabber != compositor->key_event_grabber)) {
  2096.         CL_Event keyboard_focus_event;
  2097.         CL_Layer *last_grabber = compositor->key_event_grabber;
  2098.         PRBool accepted = PR_TRUE;
  2099.        
  2100.         keyboard_focus_event.x = keyboard_focus_event.y
  2101.                 = keyboard_focus_event.modifiers = 0;
  2102.         
  2103.         /* Tell the new guy that he's gained focus */
  2104.         if (new_grabber &&
  2105.             (new_grabber->vtable.event_handler_func != NULL)){
  2106.             keyboard_focus_event.type = CL_EVENT_KEY_FOCUS_GAINED;
  2107.             keyboard_focus_event.which = (uint32)last_grabber;
  2108.             keyboard_focus_event.fe_event = NULL;
  2109.             accepted = (*new_grabber->vtable.event_handler_func)(new_grabber,
  2110.                                                       &keyboard_focus_event);
  2111.         }
  2112.  
  2113.         if (accepted) {
  2114.             /* Tell the old event focus holder that it's lost focus */
  2115.             if (last_grabber &&
  2116.                 (last_grabber->vtable.event_handler_func != NULL)){
  2117.                 keyboard_focus_event.type = CL_EVENT_KEY_FOCUS_LOST;
  2118.                 keyboard_focus_event.which = (uint32)new_grabber;
  2119.                 keyboard_focus_event.fe_event = NULL;
  2120.                 (*last_grabber->vtable.event_handler_func)(last_grabber, 
  2121.                                                         &keyboard_focus_event);
  2122.             }
  2123.  
  2124.             compositor->key_event_grabber = new_grabber;
  2125.         }
  2126.     }
  2127. }
  2128.  
  2129.  
  2130. static PRBool 
  2131. cl_front_to_back_event_dispatch(CL_Compositor *compositor, CL_Layer *layer,
  2132.                                 CL_Event *event)
  2133. {
  2134.     CL_Layer *child;
  2135.     PRBool event_grabbed = PR_FALSE;
  2136.     int32 old_gen_id;
  2137.  
  2138.     old_gen_id = compositor->gen_id;
  2139.     
  2140.     if (!layer->hidden) {
  2141.         /* 
  2142.          * First we ask the children if they're interested.
  2143.          * Stop if one of them grabs the event.
  2144.          */
  2145.         for (child = layer->top_child; 
  2146.              child && !event_grabbed; 
  2147.              child = child->sib_below) {
  2148.             event_grabbed = cl_front_to_back_event_dispatch(compositor, 
  2149.                                                             child, event);
  2150.         }
  2151.         
  2152.         /* 
  2153.          * Now check if the event occurred within this layer.
  2154.          * If so, call the event handler if one exists 
  2155.          */
  2156.         if (!event_grabbed &&
  2157.             XP_PointInRect(&layer->clipped_bbox, event->x, event->y) &&
  2158.             (layer->vtable.event_handler_func != NULL)) {
  2159.  
  2160.             event->x -= layer->x_origin;
  2161.             event->y -= layer->y_origin;
  2162.  
  2163.             event_grabbed = (*layer->vtable.event_handler_func)(layer, event);
  2164.  
  2165.             /*
  2166.              * If something in the event handler caused the gen_id to
  2167.              * fail, then we just bail out of here and hope that we
  2168.              * do nothing else that will access the old state of the
  2169.              * compositor.
  2170.              */
  2171.             if (compositor->gen_id != old_gen_id)
  2172.                 return PR_TRUE;
  2173.             
  2174.             /* 
  2175.              * Check for mouse entering/leaving for layers. If
  2176.              * the current event grabber (for mouse events) is not the 
  2177.              * same as the last one, we synthesize the appropriate event.
  2178.              */
  2179.             if (event_grabbed && CL_IS_MOUSE_EVENT(event))
  2180.                 cl_check_focus_change(compositor, layer, event);
  2181.  
  2182.             event->x += layer->x_origin;
  2183.             event->y += layer->y_origin;
  2184.         }
  2185.  
  2186.         return event_grabbed;
  2187.     }
  2188.     
  2189.     return PR_FALSE;
  2190. }
  2191.  
  2192. /* Dispatch an event to the correct layer */
  2193. PRBool
  2194. CL_DispatchEvent(CL_Compositor *compositor, CL_Event *event)
  2195. {
  2196.     CL_Layer *layer;
  2197.     int32 old_gen_id;
  2198.  
  2199.     XP_ASSERT(compositor);
  2200.     XP_ASSERT(event);
  2201.  
  2202.     if (!compositor || !event || !compositor->root)
  2203.         return PR_FALSE;
  2204.  
  2205.     if (event->type == CL_EVENT_MOUSE_MOVE) {
  2206.         compositor->last_mouse_x = event->x;
  2207.         compositor->last_mouse_y = event->y;
  2208.         compositor->last_mouse_button = event->which;
  2209.     }
  2210.     else if (event->type == CL_EVENT_MOUSE_BUTTON_DOWN) 
  2211.         compositor->last_mouse_button = event->which;
  2212.  
  2213.     old_gen_id = compositor->gen_id;
  2214.            
  2215.     if (compositor->mouse_event_grabber && CL_IS_MOUSE_EVENT(event)) {
  2216.         layer = compositor->mouse_event_grabber;
  2217.         if (layer->vtable.event_handler_func) {
  2218.             PRBool ret;
  2219.             
  2220.             event->x -= layer->x_origin;
  2221.             event->y -= layer->y_origin;
  2222.             ret = ((*layer->vtable.event_handler_func)(layer, event));
  2223.  
  2224.             if (compositor->gen_id != old_gen_id)
  2225.                 return ret;
  2226.  
  2227.             /* Check for a focus change */
  2228.             if (ret)
  2229.                 cl_check_focus_change(compositor, layer, event);
  2230.  
  2231.             return ret;
  2232.         }
  2233.     }
  2234.     else if (compositor->key_event_grabber && CL_IS_KEY_EVENT(event)) {
  2235.         layer = compositor->key_event_grabber;
  2236.         if (layer->vtable.event_handler_func) {
  2237.             event->x -= layer->x_origin;
  2238.             event->y -= layer->y_origin;
  2239.             return ((*layer->vtable.event_handler_func)(layer, event));
  2240.         }
  2241.     }
  2242.     else
  2243.         return cl_front_to_back_event_dispatch(compositor,
  2244.                                                compositor->root,
  2245.                                                event);
  2246.  
  2247.     return PR_FALSE;
  2248. }
  2249.  
  2250. /* All mouse events go to this layer. If layer is NULL, stop grabbing */
  2251. PRBool
  2252. CL_GrabMouseEvents(CL_Compositor *compositor, CL_Layer *layer)
  2253. {
  2254.     XP_ASSERT(compositor);
  2255.     
  2256.     if (!compositor)
  2257.         return PR_FALSE;
  2258.  
  2259.     compositor->mouse_event_grabber = layer;
  2260.     return PR_TRUE;
  2261. }
  2262.  
  2263. /* All key events go to this layer. If layer is NULL, stop grabbing */
  2264. PRBool
  2265. CL_GrabKeyEvents(CL_Compositor *compositor, CL_Layer *layer)
  2266. {
  2267.     CL_Event keyboard_focus_event;
  2268.     CL_Layer *last_grabber, *new_grabber;
  2269.     PRBool accepted = PR_TRUE;
  2270.  
  2271.     XP_ASSERT(compositor);
  2272.     
  2273.     if (!compositor)
  2274.         return PR_FALSE;
  2275.  
  2276.     keyboard_focus_event.x = keyboard_focus_event.y = 0;
  2277.     
  2278.     last_grabber = compositor->key_event_grabber;
  2279.     new_grabber = layer;
  2280.  
  2281.     if (new_grabber &&
  2282.         (new_grabber->vtable.event_handler_func != NULL)){
  2283.         keyboard_focus_event.type = CL_EVENT_KEY_FOCUS_GAINED;
  2284.         keyboard_focus_event.which = (uint32)last_grabber;
  2285.         keyboard_focus_event.fe_event = NULL;
  2286.         accepted = (*new_grabber->vtable.event_handler_func)(new_grabber,
  2287.                                                        &keyboard_focus_event);
  2288.     }
  2289.  
  2290.     if (accepted) {
  2291.         if (last_grabber &&
  2292.             (last_grabber->vtable.event_handler_func != NULL)){
  2293.             keyboard_focus_event.type = CL_EVENT_KEY_FOCUS_LOST;
  2294.             keyboard_focus_event.which = (uint32)new_grabber;
  2295.             keyboard_focus_event.fe_event = NULL;
  2296.             (*last_grabber->vtable.event_handler_func)(last_grabber, 
  2297.                                                        &keyboard_focus_event);
  2298.         }
  2299.  
  2300.         compositor->key_event_grabber = layer;
  2301.         return PR_TRUE;
  2302.     }
  2303.     else
  2304.         return PR_FALSE;
  2305. }
  2306.  
  2307. /* Returns PR_TRUE if layer is the mouse event grabber. */
  2308. PRBool
  2309. CL_IsMouseEventGrabber(CL_Compositor *compositor, CL_Layer *layer)
  2310. {
  2311.     XP_ASSERT(compositor);
  2312.     
  2313.     if (!compositor)
  2314.         return PR_FALSE;
  2315.     
  2316.     return (PRBool)(compositor->mouse_event_grabber == layer);
  2317. }
  2318.  
  2319. /* Returns PR_TRUE if layer is the key event grabber. */
  2320. PRBool
  2321. CL_IsKeyEventGrabber(CL_Compositor *compositor, CL_Layer *layer)
  2322. {
  2323.     XP_ASSERT(compositor);
  2324.     
  2325.     if (!compositor)
  2326.         return PR_FALSE;
  2327.     
  2328.     return (PRBool)(compositor->key_event_grabber == layer);
  2329. }
  2330.  
  2331. /* Returns PR_TRUE if layer is the key event grabber. */
  2332. CL_Layer *
  2333. CL_GetKeyEventGrabber(CL_Compositor *compositor)
  2334. {
  2335.     XP_ASSERT(compositor);
  2336.     
  2337.     if (!compositor)
  2338.         return NULL;
  2339.     
  2340.     return (compositor->key_event_grabber);
  2341. }
  2342.  
  2343. void
  2344. CL_SetKeyboardFocusPolicy(CL_Compositor *compositor, 
  2345.                           CL_KeyboardFocusPolicy focus_policy)
  2346. {
  2347.     XP_ASSERT(compositor);
  2348.     
  2349.     if (!compositor)
  2350.         return;
  2351.     
  2352.     compositor->focus_policy = focus_policy;
  2353. }
  2354.  
  2355. void 
  2356. CL_SetCompositorDrawingMethod(CL_Compositor *compositor,
  2357.                               CL_DrawingMethod method)
  2358. {
  2359.     XP_ASSERT(compositor);
  2360.     
  2361.     if (!compositor)
  2362.         return;
  2363.     
  2364.     compositor->back_to_front_only = 
  2365.         (method == CL_DRAWING_METHOD_BACK_TO_FRONT_ONLY);
  2366. }
  2367.  
  2368.  
  2369. /* Called when a layer is added to the layer tree */
  2370. void
  2371. cl_LayerAdded(CL_Compositor *compositor, CL_Layer *layer)
  2372. {
  2373.     XP_ASSERT(compositor);
  2374.     XP_ASSERT(layer);
  2375.  
  2376.     cl_ParentChanged(layer);
  2377.  
  2378.     /* If this child is visible, ask the compositor to update its area */
  2379.     if (layer->visible)
  2380.         cl_UpdateLayer(layer, PR_FALSE);
  2381. }
  2382.  
  2383. void
  2384. cl_LayerDestroyed(CL_Compositor *compositor, CL_Layer *layer)
  2385. {
  2386.     XP_ASSERT(compositor);
  2387.     XP_ASSERT(layer);
  2388.  
  2389.     if (!compositor || !layer)
  2390.         return;
  2391.     
  2392.     if (layer == compositor->mouse_event_grabber)
  2393.         compositor->mouse_event_grabber = NULL;
  2394.     if (layer == compositor->key_event_grabber)
  2395.         compositor->key_event_grabber = NULL;
  2396.     if (layer == compositor->last_mouse_event_grabber) {
  2397.         compositor->event_containment_lists[compositor->last_containment_list].list_head = -1;
  2398.         compositor->last_mouse_event_grabber = NULL;
  2399.     }
  2400.  
  2401.     compositor->gen_id++;
  2402. }
  2403.  
  2404. /* Called when a layer is removed from the layer tree */
  2405. void
  2406. cl_LayerRemoved(CL_Compositor *compositor, CL_Layer *layer)
  2407. {
  2408.     XP_ASSERT(compositor);
  2409.     XP_ASSERT(layer);
  2410.  
  2411.     if (!compositor || !layer)
  2412.         return;
  2413.  
  2414.     /* If this child was visible, ask the compositor
  2415.        to update the area it formerly occupied. */
  2416.     if (layer->visible)
  2417.         cl_UpdateLayer(layer, PR_FALSE);
  2418.  
  2419.     if (layer == compositor->last_mouse_event_grabber) {
  2420.         compositor->event_containment_lists[compositor->last_containment_list].list_head = -1;
  2421.         compositor->last_mouse_event_grabber = NULL;
  2422.     }
  2423. }
  2424.  
  2425. void
  2426. cl_LayerMoved(CL_Compositor *compositor, CL_Layer *layer)
  2427. {
  2428.  
  2429.     /* The auto-generation of mousemoves is playing havoc with the
  2430.      * REAL mouse moves.  Commented out until further notice. */
  2431.     if (0) {
  2432.     /*
  2433.      * If the layer that grabbed mouse events has moved, the
  2434.      * movement is equivalent to a mouse move.
  2435.      */
  2436.     if (compositor && compositor->mouse_event_grabber == layer) {
  2437.         CL_Event event;
  2438.         
  2439.         event.type = CL_EVENT_MOUSE_MOVE;
  2440.         event.fe_event = NULL;
  2441.         event.x = compositor->last_mouse_x - layer->x_offset;
  2442.         event.y = compositor->last_mouse_y - layer->y_offset;
  2443.         event.which = compositor->last_mouse_button;
  2444.  
  2445.         if (layer->vtable.event_handler_func)
  2446.         (*layer->vtable.event_handler_func)(layer, &event);
  2447.     }
  2448.     }
  2449. }
  2450.