package xgbsel import "io" import "errors" import "github.com/jezek/xgb" import "github.com/jezek/xgbutil" import "github.com/jezek/xgb/xproto" import "github.com/jezek/xgbutil/xprop" import "github.com/jezek/xgbutil/xevent" import "github.com/jezek/xgbutil/xwindow" const format8bit byte = 8 const format16bit byte = 16 const format32bit byte = 32 const propertyNewValue byte = 0 const propertyDelete byte = 1 type claimRequest struct { reader io.ReadSeekCloser ty xproto.Atom event xevent.SelectionRequestEvent } type claimRequestKey struct { property xproto.Atom requestor xproto.Window } // Claim represents a claim that a window has on a particular selection. type Claim struct { open bool incr bool window *xwindow.Window data Data selection xproto.Atom timestamp xproto.Timestamp requests map[claimRequestKey] *claimRequest } // NewClaim claims ownership of a specified selection, and allows using data // passed to it to fulfill requests for the selection's contents. The timestamp // should be set to that of the event that triggered the claim, such as a Ctrl+C // event, or a mouse motion that led to text being selected. If the claim was // not triggered by an event, specify xproto.TimeCurrentTime. func NewClaim (window *xwindow.Window, selection xproto.Atom, data Data, timestamp xproto.Timestamp) (*Claim, error) { // Follow: // https://tronche.com/gui/x/icccm/sec-2.html#s-2.1 // A client wishing to acquire ownership of a particular selection // should call SetSelectionOwner. The client should set the specified // selection to the atom that represents the selection, set the // specified owner to some window that the client created, and set the // specified time to some time between the current last-change time of // the selection concerned and the current server time. This time value // usually will be obtained from the timestamp of the event that // triggers the acquisition of the selection. Clients should not set the // time value to CurrentTime, because if they do so, they have no way of // finding when they gained ownership of the selection. Clients must use // a window they created so that requestors can route events to the // owner of the selection. err := xproto.SetSelectionOwnerChecked ( window.X.Conn(), window.Id, selection, timestamp).Check() if err != nil { return nil, err } ownerReply, err := xproto.GetSelectionOwner ( window.X.Conn(), selection).Reply() if err != nil { return nil, err } if ownerReply.Owner != window.Id { return nil, errors.New("someone else took the selection") } return &Claim { open: true, incr: false, // TODO change to enable INCR window: window, data: data, selection: selection, timestamp: timestamp, requests: make(map[claimRequestKey] *claimRequest), }, nil } func (claim *Claim) refuseSelectionRequest (request xevent.SelectionRequestEvent) { // ... refuse the SelectionRequest by sending the requestor window a // SelectionNotify event with the property set to None (by means of a // SendEvent request with an empty event mask). event := xproto.SelectionNotifyEvent { Requestor: request.Requestor, Selection: request.Selection, Target: request.Target, Property: 0, }.Bytes() xproto.SendEvent ( claim.window.X.Conn(), false, request.Requestor, 0, string(event)) } func (claim *Claim) fulfillSelectionRequest ( data []byte, format byte, ty xproto.Atom, request xevent.SelectionRequestEvent, ) { die := func () { claim.refuseSelectionRequest(request) } // If the specified property is not None, the owner should place the // data resulting from converting the selection into the specified // property on the requestor window and should set the property's type // to some appropriate value, which need not be the same as the // specified target. err := claim.changePropertyChecked ( xproto.PropModeReplace, request.Requestor, request.Property, ty, format, data) if err != nil { die() } // If the property is successfully stored, the owner should acknowledge // the successful conversion by sending the requestor window a // SelectionNotify event (by means of a SendEvent request with an empty // mask). event := xproto.SelectionNotifyEvent { Requestor: request.Requestor, Selection: request.Selection, Target: request.Target, Property: request.Property, }.Bytes() xproto.SendEvent ( claim.window.X.Conn(), false, request.Requestor, 0, string(event)) } func (claim *Claim) changePropertyChecked ( mode byte, window xproto.Window, property xproto.Atom, ty xproto.Atom, format byte, data []byte, ) error { return xproto.ChangePropertyChecked ( claim.window.X.Conn(), mode, window, property, ty, format, uint32(len(data) / (int(format) / 8)), data).Check() } // While the selection claim is active, HandleSelectionRequest should be called // when the owner window recieves a SelectionRequest event. This must be // registered as an event handler manually. func (claim *Claim) HandleSelectionRequest ( connection *xgbutil.XUtil, event xevent.SelectionRequestEvent, ) { // do not fulfill *new* selection requests after the claim has been // relinquished if !claim.open { return } // Follow: // https://tronche.com/gui/x/icccm/sec-2.html#s-2.2 die := func () { claim.refuseSelectionRequest(event) } // When a requestor wants the value of a selection, the owner receives a // SelectionRequest event. The specified owner and selection will be the // values that were specified in the SetSelectionOwner request. The // owner should compare the timestamp with the period it has owned the // selection and, if the time is outside, refuse the SelectionRequest. if event.Selection != claim.selection { die(); return } // If the specified property is None, the requestor is an obsolete // client. Owners are encouraged to support these clients by using the // specified target atom as the property name to be used for the reply. if event.Property == 0 { event.Property = event.Target } // Otherwise, the owner should use the target to decide the form into // which the selection should be converted. Some targets may be defined // such that requestors can pass parameters along with the request. The // owner will find these parameters in the property named in the // selection request. The type, format, and contents of this property // are dependent upon the definition of the target. If the target is not // defined to have parameters, the owner should ignore the property if // it is present. If the selection cannot be converted into a form based // on the target (and parameters, if any), the owner should refuse the // SelectionRequest as previously described. targetName, err := xprop.AtomName(claim.window.X, event.Target) if err != nil { die(); return } switch targetName { case "TARGETS": // generate a list of supported targets targetNames := []Target { "TARGETS" } targetNames = append(targetNames, claim.data.Supported()...) data := make([]byte, len(targetNames) * 4) for index, name := range targetNames { atom, err := xprop.Atm(claim.window.X, string(name)) if err != nil { die(); return } xgb.Put32(data[(index) * 4:], uint32(atom)) } // send that list to the requestor atomAtom, err := xprop.Atm(claim.window.X, "ATOM") if err != nil { die(); return } claim.fulfillSelectionRequest(data, format32bit, atomAtom, event) default: incr, err := xprop.Atm(claim.window.X, "INCR") if err != nil { die(); return } // respond with data reader, ok := claim.data.Convert(Target(targetName)) if !ok { die(); return } if claim.incr { // TODO: we need to subscribe to PropertyNotify events // on the destination window. apparently event masks as // set by ChangeWindowAttributes are client-specific. // we also need to clean up afterwards. // https://tronche.com/gui/x/xlib/window/XChangeWindowAttributes.html request := &claimRequest { reader: reader, ty: event.Target, event: event, } // Requestors may receive a property of type INCR in // response to any target that results in selection // data. This indicates that the owner will send the // actual data incrementally. The contents of the INCR // property will be an integer, which represents a lower // bound on the number of bytes of data in the // selection. data := [4]byte { } xgb.Put32(data[:], 1) err := claim.changePropertyChecked ( xproto.PropModeReplace, event.Requestor, event.Property, incr, format32bit, data[:]) if err != nil { die() } claim.requests[claimRequestKey { property: event.Property, requestor: event.Requestor, }] = request } else { reader.Seek(0, io.SeekStart) data, err := io.ReadAll(reader) reader.Close() if err != nil { die() } claim.fulfillSelectionRequest(data, format8bit, event.Target, event) } } } // While the selection claim is active, HandlePropertyNotify should be called // when the requesting window recieves a PropertyNotify event. This must be // registered as an event handler manually. func (claim *Claim) HandlePropertyNotify ( connection *xgbutil.XUtil, event xevent.PropertyNotifyEvent, ) { // The selection requestor starts the transfer process by deleting the // (type==INCR) property forming the reply to the selection. // // The selection owner then: // ... Waits between each append for a PropertyNotify (state==Deleted) // event that shows that the requestor has read the data. The reason for // doing this is to limit the consumption of space in the server. if event.State != propertyDelete { return } // if the request does not exist, the property was either modified in // error or the request has already finished. either way, we simply // exit. key := claimRequestKey { property: event.Atom, requestor: event.Window, } request, ok := claim.requests[key] if !ok { return } done := func () { request.reader.Close() delete(claim.requests, key) } die := func () { done() claim.refuseSelectionRequest(request.event) } // FIXME change the length of this if maximum-request-size is smaller buffer := [1024]byte { } size, err := request.reader.Read(buffer[:]) if err != nil { die(); return } dataRead := buffer[:size] if len(dataRead) > 0 { // there is more data to send // ... Appends the data in suitable-size chunks to the same property on // the same window as the selection reply with a type corresponding to // the actual type of the converted selection. The size should be less // than the maximum-request-size in the connection handshake. err := claim.changePropertyChecked ( xproto.PropModeReplace, request.event.Requestor, request.event.Property, request.ty, format8bit, dataRead) if err != nil { die(); return } } else { // all data has been sent // ... Waits (after the entire data has been transferred to the // server) until a PropertyNotify (state==Deleted) event that // shows that the data has been read by the requestor and then // writes zero-length data to the property. err := claim.changePropertyChecked ( xproto.PropModeReplace, request.event.Requestor, request.event.Property, request.ty, format8bit, nil) if err != nil { die(); return } done() } } // While the selection claim is active, HandleSelectionClear should be called // when the requesting window recieves a SelectionClear event. This must be // registered as an event handler manually. func (claim *Claim) HandleSelectionClear ( connection *xgbutil.XUtil, event xevent.SelectionClearEvent, ) { // When some other client acquires a selection, the previous owner // receives a SelectionClear event. The timestamp argument is the time // at which the ownership changed hands, and the owner argument is the // window the previous owner specified in its SetSelectionOwner request. // If an owner loses ownership while it has a transfer in progress (that // is, before it receives notification that the requestor has received // all the data), it must continue to service the ongoing transfer until // it is complete. claim.open = false } // Open returns false if the claim has been relinquished, either from recieving // a SelectionClear event or with the Close method. func (claim *Claim) Open () bool { return claim.open } // Active returns true if requests are currently being fulfilled. While this is // true, the claim should still be forwarded events regardless if it is closed // or not. It is safe to forward the same event to multiple claims. func (claim *Claim) Active () bool { return len(claim.requests) > 0 } // Close voluntarily relinquishes the selection claim. This will inform the X // server that the selection is being voluntarily given up, and cause the claim // to stop fulfilling new requests. func (claim *Claim) Close () error { if !claim.open { return nil } claim.open = false // To relinquish ownership of a selection voluntarily, a client should // execute a SetSelectionOwner request for that selection atom, with // owner specified as None and the time specified as the timestamp that // was used to acquire the selection. err := xproto.SetSelectionOwnerChecked ( claim.window.X.Conn(), 0, claim.selection, claim.timestamp).Check() if err != nil { return err } return nil }