|  | 
              
                display
              
                A display.
              
                mode
              
                One of: :async-pointer, :sync-pointer, 
                :reply-pointer, :async-keyboard, :sync-keyboard
                , :replay-keyboard, :async-both, 
                :sync-both.
              
                time
              
                A timestamp
                .
             
              Releases some queued events if the client has caused a device 
              to freeze. The request has no effect if the time is 
              earlier than the last-grab time of the most recent active grab 
              for the client, or if the time is later than the current 
              server time. If time is nil, the current server 
              time is used. The effect of this function depends on the 
              specified mode.
             
              
                :async-pointer -- If the pointer is frozen by the 
                client, pointer event processing continues normally. If the 
                pointer is frozen twice by the client on behalf of two 
                separate grabs, :async-pointer releases events for 
                both grabs. :async-pointer has no effect if the 
                pointer is not frozen by the client, but the pointer need not 
                be grabbed by the client.
              
                :sync-pointer -- If the pointer is frozen and actively 
                grabbed by the client, pointer event processing continues 
                normally until the next :button-press or :button-release event is reported to the client, 
                at which time the pointer again appears to freeze. However, 
                if the reported event causes the pointer grab to be released, 
                the pointer does not freeze. :sync-pointer has no 
                effect if the pointer is not frozen by the client, or if the 
                pointer is not grabbed by the client.
              
                :replay-pointer -- If the pointer is actively grabbed 
                by the client and is frozen as the result of an event having 
                been sent to the client (either from the activation of a grab-button
                , or from a previous 
                allow-events with mode :sync-pointer, but not 
                from a 
                grab-pointer), the pointer grab is released and 
                that event is completely reprocessed, but this time ignoring 
                any passive grabs at or above (towards the root) the 
                grab-window of the grab just released. The request has no 
                effect if the pointer is not grabbed by the client, or if the 
                pointer is not frozen as the result of an event.
              
                :async-keyboard -- If the keyboard is frozen by the 
                client, keyboard event processing continues normally. If the 
                keyboard is frozen twice by the client on behalf of two 
                separate grabs, :async-keyboard releases events for 
                both grabs. :async-keyboard has no effect if the 
                keyboard is not frozen by the client, but the keyboard need 
                not be grabbed by the client.
              
                :sync-keyboard -- If the keyboard is frozen and 
                actively grabbed by the client, keyboard event processing 
                continues normally until the next :key-press or 
                :key-release event is reported to the client, at 
                which time the keyboard again appears to freeze. However if 
                the reported event causes the keyboard grab to be released, 
                the keyboard does not freeze. :sync-keyboard has no 
                effect if the keyboard is not frozen by the client, or if the 
                keyboard is not grabbed by the client.
              
                :replay-keyboard -- If the keyboard is actively 
                grabbed by the client and is frozen as the result of an event 
                having been sent to the client (either from the activation of 
                a grab-key, or from a previous 
                allow-events with mode :sync-keyboard, but not 
                from a 
                grab-keyboard), the keyboard grab is released and 
                that event is completely reprocessed, but this time ignoring 
                any passive grabs at or above (towards the root) the 
                grab-window of the grab just released. The request has no 
                effect if the keyboard is not grabbed by the client, or if 
                the keyboard is not frozen as the result of an event.
              
                :sync-both -- If both pointer and keyboard are frozen 
                by the client, event processing (for both devices) continues 
                normally until the next :button-press, :button-release, :key-press, or 
                :key-release event is reported to the client for a 
                grabbed device (button event for the pointer, key event for 
                the keyboard). At this time, the devices again appear to 
                freeze. If the reported event causes the grab to be released, 
                the devices do not freeze. However, if the other device is 
                still grabbed, then a subsequent event for it will still 
                cause both devices to freeze. :sync-both has no effect 
                unless both pointer and keyboard are frozen by the client. If 
                the pointer of keyboard is frozen twice by the client on 
                behalf of two separate grabs, :sync-both thaws 
                for both, but a subsequent freeze for :sync-both will 
                only freeze each device once.
              
                :async-both -- If the pointer and the keyboard are 
                frozen by the client, event processing for both devices 
                continues normally. If a device is frozen twice by the client 
                on behalf of two separate grabs, :async-both thaws
                 for both. :async-both has no effect unless both 
                pointer and keyboard are frozen by the client.
             
              :async-pointer, :sync-pointer, and 
              :replay-pointer have no effect on processing of keyboard 
              events. :async-keyboard, :sync-keyboard, and 
              :replay-keyboard have no effect on processing of pointer 
              events.
             
              It is possible for both a pointer grab and a keyboard grab to 
              be active simultaneously by the same or different clients. When 
              a device is frozen on behalf of either grab, no event 
              processing is performed for the device. It is possible for a 
              single device to be frozen due to both grabs. In this case, the 
              freeze must be released on behalf of both grabs before events 
              can again be processed.
       |