Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-24 02:42:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

kdeui: format and indent kmanagerselection source file

Browse source 
Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
This commit is contained in:
Ivailo Monev 2022-10-29 07:05:59 +03:00
parent cb621f540d
commit 697834865a
1 changed files with 178 additions and 196 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

270
kdeui/util/kmanagerselection.cpp
View file

@ -28,12 +28,9 @@ DEALINGS IN THE SOFTWARE.
#include <sys/types.h> #include <sys/types.h>
#include <sys/time.h> #include <sys/time.h>
#include <unistd.h> #include <unistd.h>
#include <QtCore/QObject> #include <QtCore/QObject>
#ifdef Q_WS_X11 // FIXME(E)
#include <qx11info_x11.h> #include <qx11info_x11.h>
#include <qwidget.h> #include <qwidget.h>
#include <kdebug.h> #include <kdebug.h>
@ -97,18 +94,18 @@ KSelectionOwner::~KSelectionOwner()
} }
bool KSelectionOwner::claim( bool force_P, bool force_kill_P ) bool KSelectionOwner::claim( bool force_P, bool force_kill_P )
{ {
if( Private::manager_atom == None ) if ( Private::manager_atom == None ) {
getAtoms(); getAtoms();
if( d->timestamp != CurrentTime ) }
if ( d->timestamp != CurrentTime ) {
release(); release();
}
Display* const dpy = QX11Info::display(); Display* const dpy = QX11Info::display();
Window prev_owner = XGetSelectionOwner( dpy, d->selection ); Window prev_owner = XGetSelectionOwner( dpy, d->selection );
if( prev_owner != None ) if ( prev_owner != None ) {
{ if ( !force_P ) {
if( !force_P ) // kDebug() << "Selection already owned, failing";
{
// kDebug() << "Selection already owned, failing";
return false; return false;
} }
XSelectInput( dpy, prev_owner, StructureNotifyMask ); XSelectInput( dpy, prev_owner, StructureNotifyMask );
@ -117,7 +114,7 @@ bool KSelectionOwner::claim( bool force_P, bool force_kill_P )
attrs.override_redirect = True; attrs.override_redirect = True;
d->window = XCreateWindow( dpy, RootWindow( dpy, d->screen ), 0, 0, 1, 1, d->window = XCreateWindow( dpy, RootWindow( dpy, d->screen ), 0, 0, 1, 1,
0, CopyFromParent, InputOnly, CopyFromParent, CWOverrideRedirect, &attrs ); 0, CopyFromParent, InputOnly, CopyFromParent, CWOverrideRedirect, &attrs );
// kDebug() << "Using owner window " << window; // kDebug() << "Using owner window " << window;
Atom tmp = XA_ATOM; Atom tmp = XA_ATOM;
XSelectInput( dpy, d->window, PropertyChangeMask ); XSelectInput( dpy, d->window, PropertyChangeMask );
XChangeProperty( dpy, d->window, XA_ATOM, XA_ATOM, 32, PropModeReplace, XChangeProperty( dpy, d->window, XA_ATOM, XA_ATOM, 32, PropModeReplace,
@ -129,30 +126,24 @@ bool KSelectionOwner::claim( bool force_P, bool force_kill_P )
XSelectInput( dpy, d->window, StructureNotifyMask ); // for DestroyNotify XSelectInput( dpy, d->window, StructureNotifyMask ); // for DestroyNotify
XSetSelectionOwner( dpy, d->selection, d->window, d->timestamp ); XSetSelectionOwner( dpy, d->selection, d->window, d->timestamp );
Window new_owner = XGetSelectionOwner( dpy, d->selection ); Window new_owner = XGetSelectionOwner( dpy, d->selection );
if( new_owner != d->window ) if ( new_owner != d->window ) {
{ // kDebug() << "Failed to claim selection : " << new_owner;
// kDebug() << "Failed to claim selection : " << new_owner;
XDestroyWindow( dpy, d->window ); XDestroyWindow( dpy, d->window );
d->timestamp = CurrentTime; d->timestamp = CurrentTime;
return false; return false;
} }
if( prev_owner != None ) if ( prev_owner != None ) {
{ // kDebug() << "Waiting for previous owner to disown";
// kDebug() << "Waiting for previous owner to disown"; for ( int cnt = 0; ; ++cnt ) {
for( int cnt = 0; if ( XCheckTypedWindowEvent( dpy, prev_owner, DestroyNotify, &ev ) == True ) {
;
++cnt )
{
if( XCheckTypedWindowEvent( dpy, prev_owner, DestroyNotify, &ev ) == True )
break; break;
}
struct timeval tm = { 0, 50000 }; // 50 ms struct timeval tm = { 0, 50000 }; // 50 ms
select( 0, NULL, NULL, NULL, &tm ); select( 0, NULL, NULL, NULL, &tm );
if( cnt == 19 ) if ( cnt == 19 ) {
{ if ( force_kill_P ) {
if( force_kill_P )
{
KXErrorHandler err; KXErrorHandler err;
// kDebug() << "Killing previous owner"; // kDebug() << "Killing previous owner";
XKillClient( dpy, prev_owner ); XKillClient( dpy, prev_owner );
err.error( true ); // ignore errors when killing err.error( true ); // ignore errors when killing
} }
@ -171,133 +162,130 @@ bool KSelectionOwner::claim( bool force_P, bool force_kill_P )
ev.xclient.data.l[ 3 ] = d->extra1; ev.xclient.data.l[ 3 ] = d->extra1;
ev.xclient.data.l[ 4 ] = d->extra2; ev.xclient.data.l[ 4 ] = d->extra2;
XSendEvent( dpy, RootWindow( dpy, d->screen ), False, StructureNotifyMask, &ev ); XSendEvent( dpy, RootWindow( dpy, d->screen ), False, StructureNotifyMask, &ev );
// kDebug() << "Claimed selection"; // kDebug() << "Claimed selection";
return true; return true;
} }
// destroy resource first // destroy resource first
void KSelectionOwner::release() void KSelectionOwner::release()
{ {
if( d->timestamp == CurrentTime ) if ( d->timestamp == CurrentTime ) {
return; return;
XDestroyWindow( QX11Info::display(), d->window ); // also makes the selection not owned
// kDebug() << "Releasing selection";
d->timestamp = CurrentTime;
} }
XDestroyWindow( QX11Info::display(), d->window ); // also makes the selection not owned
// kDebug() << "Releasing selection";
d->timestamp = CurrentTime;
}
Window KSelectionOwner::ownerWindow() const Window KSelectionOwner::ownerWindow() const
{ {
if( d->timestamp == CurrentTime ) if ( d->timestamp == CurrentTime ) {
return None; return None;
return d->window;
} }
return d->window;
}
void KSelectionOwner::setData( long extra1_P, long extra2_P ) void KSelectionOwner::setData( long extra1_P, long extra2_P )
{ {
d->extra1 = extra1_P; d->extra1 = extra1_P;
d->extra2 = extra2_P; d->extra2 = extra2_P;
} }
bool KSelectionOwner::filterEvent( XEvent* ev_P ) bool KSelectionOwner::filterEvent( XEvent* ev_P )
{ {
if( d->timestamp != CurrentTime && ev_P->xany.window == d->window ) if ( d->timestamp != CurrentTime && ev_P->xany.window == d->window ) {
{ if ( handleMessage( ev_P )) {
if( handleMessage( ev_P ))
return true; return true;
} }
switch( ev_P->type ) }
{ switch( ev_P->type ) {
case SelectionClear: case SelectionClear: {
{ if ( d->timestamp == CurrentTime || ev_P->xselectionclear.selection != d->selection ) {
if( d->timestamp == CurrentTime || ev_P->xselectionclear.selection != d->selection )
return false; return false;
}
d->timestamp = CurrentTime; d->timestamp = CurrentTime;
// kDebug() << "Lost selection"; // kDebug() << "Lost selection";
Window window = d->window; Window window = d->window;
emit lostOwnership(); emit lostOwnership();
XSelectInput( QX11Info::display(), window, 0 ); XSelectInput( QX11Info::display(), window, 0 );
XDestroyWindow( QX11Info::display(), window ); XDestroyWindow( QX11Info::display(), window );
return true; return true;
} }
case DestroyNotify: case DestroyNotify: {
{ if ( d->timestamp == CurrentTime || ev_P->xdestroywindow.window != d->window ) {
if( d->timestamp == CurrentTime || ev_P->xdestroywindow.window != d->window )
return false; return false;
}
d->timestamp = CurrentTime; d->timestamp = CurrentTime;
// kDebug() << "Lost selection (destroyed)"; // kDebug() << "Lost selection (destroyed)";
emit lostOwnership(); emit lostOwnership();
return true; return true;
} }
case SelectionNotify: case SelectionNotify: {
{ if ( d->timestamp == CurrentTime || ev_P->xselection.selection != d->selection ) {
if( d->timestamp == CurrentTime || ev_P->xselection.selection != d->selection )
return false; return false;
}
// ignore? // ignore?
return false; return false;
} }
case SelectionRequest: case SelectionRequest: {
filter_selection_request( ev_P->xselectionrequest ); filter_selection_request( ev_P->xselectionrequest );
return false; return false;
} }
return false;
} }
return false;
}
bool KSelectionOwner::handleMessage( XEvent* ) bool KSelectionOwner::handleMessage( XEvent* )
{ {
return false; return false;
} }
void KSelectionOwner::filter_selection_request( XSelectionRequestEvent& ev_P ) void KSelectionOwner::filter_selection_request( XSelectionRequestEvent& ev_P )
{ {
if( d->timestamp == CurrentTime || ev_P.selection != d->selection ) if ( d->timestamp == CurrentTime || ev_P.selection != d->selection ) {
return; return;
if( ev_P.time != CurrentTime }
&& ev_P.time - d->timestamp > 1U << 31 ) if ( ev_P.time != CurrentTime
&& ev_P.time - d->timestamp > 1U << 31 ) {
return; // too old or too new request return; // too old or too new request
// kDebug() << "Got selection request"; }
// kDebug() << "Got selection request";
bool handled = false; bool handled = false;
if( ev_P.target == Private::xa_multiple ) if ( ev_P.target == Private::xa_multiple ) {
{ if ( ev_P.property != None ) {
if( ev_P.property != None )
{
const int MAX_ATOMS = 100; // no need to handle more? const int MAX_ATOMS = 100; // no need to handle more?
int format; int format;
Atom type; Atom type;
unsigned long items; unsigned long items;
unsigned long after; unsigned long after;
unsigned char* data; unsigned char* data;
if( XGetWindowProperty( QX11Info::display(), ev_P.requestor, ev_P.property, 0, if ( XGetWindowProperty( QX11Info::display(), ev_P.requestor, ev_P.property, 0,
MAX_ATOMS, False, AnyPropertyType, &type, &format, &items, &after, MAX_ATOMS, False, AnyPropertyType, &type, &format, &items, &after,
&data ) == Success && format == 32 && items % 2 == 0 ) &data ) == Success && format == 32 && items % 2 == 0 ) {
{
bool handled_array[ MAX_ATOMS ]; bool handled_array[ MAX_ATOMS ];
Atom* atoms = reinterpret_cast< Atom* >( data ); Atom* atoms = reinterpret_cast< Atom* >( data );
for( unsigned int i = 0; for ( unsigned int i = 0; i < items / 2; ++i ) {
i < items / 2; handled_array[ i ] = handle_selection( atoms[ i * 2 ], atoms[ i * 2 + 1 ], ev_P.requestor );
++i ) }
handled_array[ i ] = handle_selection(
atoms[ i * 2 ], atoms[ i * 2 + 1 ], ev_P.requestor );
bool all_handled = true; bool all_handled = true;
for( unsigned int i = 0; for ( unsigned int i = 0; i < items / 2; ++i ) {
i < items / 2; if ( !handled_array[ i ] ) {
++i )
if( !handled_array[ i ] )
{
all_handled = false; all_handled = false;
atoms[ i * 2 + 1 ] = None; atoms[ i * 2 + 1 ] = None;
} }
if( !all_handled ) }
if ( !all_handled ) {
XChangeProperty( QX11Info::display(), ev_P.requestor, ev_P.property, XA_ATOM, XChangeProperty( QX11Info::display(), ev_P.requestor, ev_P.property, XA_ATOM,
32, PropModeReplace, reinterpret_cast< unsigned char* >( atoms ), items ); 32, PropModeReplace, reinterpret_cast< unsigned char* >( atoms ), items );
}
handled = true; handled = true;
XFree( data ); XFree( data );
} }
} }
} } else {
else if ( ev_P.property == None ) { // obsolete client
{
if( ev_P.property == None ) // obsolete client
ev_P.property = ev_P.target; ev_P.property = ev_P.target;
}
handled = handle_selection( ev_P.target, ev_P.property, ev_P.requestor ); handled = handle_selection( ev_P.target, ev_P.property, ev_P.requestor );
} }
XEvent ev; XEvent ev;
@ -308,52 +296,49 @@ void KSelectionOwner::filter_selection_request( XSelectionRequestEvent& ev_P )
ev.xselection.target = ev_P.target; ev.xselection.target = ev_P.target;
ev.xselection.property = handled ? ev_P.property : None; ev.xselection.property = handled ? ev_P.property : None;
XSendEvent( QX11Info::display(), ev_P.requestor, False, 0, &ev ); XSendEvent( QX11Info::display(), ev_P.requestor, False, 0, &ev );
} }
bool KSelectionOwner::handle_selection( Atom target_P, Atom property_P, Window requestor_P ) bool KSelectionOwner::handle_selection( Atom target_P, Atom property_P, Window requestor_P )
{ {
if( target_P == Private::xa_timestamp ) if ( target_P == Private::xa_timestamp ) {
{ // kDebug() << "Handling timestamp request";
// kDebug() << "Handling timestamp request";
XChangeProperty( QX11Info::display(), requestor_P, property_P, XA_INTEGER, 32, XChangeProperty( QX11Info::display(), requestor_P, property_P, XA_INTEGER, 32,
PropModeReplace, reinterpret_cast< unsigned char* >( &d->timestamp ), 1 ); PropModeReplace, reinterpret_cast< unsigned char* >( &d->timestamp ), 1 );
} } else if ( target_P == Private::xa_targets ) {
else if( target_P == Private::xa_targets )
replyTargets( property_P, requestor_P ); replyTargets( property_P, requestor_P );
else if( genericReply( target_P, property_P, requestor_P )) } else if ( genericReply( target_P, property_P, requestor_P )) {
; // handled ; // handled
else } else {
return false; // unknown return false; // unknown
return true;
} }
return true;
}
void KSelectionOwner::replyTargets( Atom property_P, Window requestor_P ) void KSelectionOwner::replyTargets( Atom property_P, Window requestor_P )
{ {
Atom atoms[ 3 ] = { Private::xa_multiple, Private::xa_timestamp, Private::xa_targets }; Atom atoms[ 3 ] = { Private::xa_multiple, Private::xa_timestamp, Private::xa_targets };
// kDebug() << "Handling targets request"; // kDebug() << "Handling targets request";
XChangeProperty( QX11Info::display(), requestor_P, property_P, XA_ATOM, 32, PropModeReplace, XChangeProperty( QX11Info::display(), requestor_P, property_P, XA_ATOM, 32, PropModeReplace,
reinterpret_cast< unsigned char* >( atoms ), 3 ); reinterpret_cast< unsigned char* >( atoms ), 3 );
} }
bool KSelectionOwner::genericReply( Atom, Atom, Window ) bool KSelectionOwner::genericReply( Atom, Atom, Window )
{ {
return false; return false;
} }
void KSelectionOwner::getAtoms() void KSelectionOwner::getAtoms()
{ {
if( Private::manager_atom == None ) if ( Private::manager_atom == None ) {
{
Atom atoms[ 4 ]; Atom atoms[ 4 ];
const char* const names[] = const char* const names[] = { "MANAGER", "MULTIPLE", "TARGETS", "TIMESTAMP" };
{ "MANAGER", "MULTIPLE", "TARGETS", "TIMESTAMP" };
XInternAtoms( QX11Info::display(), const_cast< char** >( names ), 4, False, atoms ); XInternAtoms( QX11Info::display(), const_cast< char** >( names ), 4, False, atoms );
Private::manager_atom = atoms[ 0 ]; Private::manager_atom = atoms[ 0 ];
Private::xa_multiple = atoms[ 1]; Private::xa_multiple = atoms[ 1 ];
Private::xa_targets = atoms[ 2 ]; Private::xa_targets = atoms[ 2 ];
Private::xa_timestamp = atoms[ 3 ]; Private::xa_timestamp = atoms[ 3 ];
} }
} }
Atom KSelectionOwner::Private::manager_atom = None; Atom KSelectionOwner::Private::manager_atom = None;
Atom KSelectionOwner::Private::xa_multiple = None; Atom KSelectionOwner::Private::xa_multiple = None;
@ -396,26 +381,25 @@ private:
KSelectionWatcher::KSelectionWatcher( Atom selection_P, int screen_P, QObject* parent_P ) KSelectionWatcher::KSelectionWatcher( Atom selection_P, int screen_P, QObject* parent_P )
: QObject( parent_P ), : QObject( parent_P ),
d( new Private( this, selection_P, screen_P )) d( new Private( this, selection_P, screen_P ))
{ {
init(); init();
} }
KSelectionWatcher::KSelectionWatcher( const char* selection_P, int screen_P, QObject* parent_P ) KSelectionWatcher::KSelectionWatcher( const char* selection_P, int screen_P, QObject* parent_P )
: QObject( parent_P ), : QObject( parent_P ),
d( new Private( this, XInternAtom( QX11Info::display(), selection_P, False ), screen_P )) d( new Private( this, XInternAtom( QX11Info::display(), selection_P, False ), screen_P ))
{ {
init(); init();
} }
KSelectionWatcher::~KSelectionWatcher() KSelectionWatcher::~KSelectionWatcher()
{ {
delete d; delete d;
} }
void KSelectionWatcher::init() void KSelectionWatcher::init()
{ {
if( Private::manager_atom == None ) if ( Private::manager_atom == None ) {
{
Display* const dpy = QX11Info::display(); Display* const dpy = QX11Info::display();
Private::manager_atom = XInternAtom( dpy, "MANAGER", False ); Private::manager_atom = XInternAtom( dpy, "MANAGER", False );
XWindowAttributes attrs; XWindowAttributes attrs;
@ -425,58 +409,56 @@ void KSelectionWatcher::init()
XSelectInput( dpy, RootWindow( dpy, d->screen ), event_mask | StructureNotifyMask ); XSelectInput( dpy, RootWindow( dpy, d->screen ), event_mask | StructureNotifyMask );
} }
owner(); // trigger reading of current selection status owner(); // trigger reading of current selection status
} }
Window KSelectionWatcher::owner() Window KSelectionWatcher::owner()
{ {
Display* const dpy = QX11Info::display(); Display* const dpy = QX11Info::display();
KXErrorHandler handler; KXErrorHandler handler;
Window current_owner = XGetSelectionOwner( dpy, d->selection ); Window current_owner = XGetSelectionOwner( dpy, d->selection );
if( current_owner == None ) if ( current_owner == None )
return None; return None;
if( current_owner == d->selection_owner ) if ( current_owner == d->selection_owner ) {
return d->selection_owner; return d->selection_owner;
}
XSelectInput( dpy, current_owner, StructureNotifyMask ); XSelectInput( dpy, current_owner, StructureNotifyMask );
if( !handler.error( true ) && current_owner == XGetSelectionOwner( dpy, d->selection )) if ( !handler.error( true ) && current_owner == XGetSelectionOwner( dpy, d->selection )) {
{ // kDebug() << "isOwner: " << current_owner;
// kDebug() << "isOwner: " << current_owner;
d->selection_owner = current_owner; d->selection_owner = current_owner;
emit newOwner( d->selection_owner ); emit newOwner( d->selection_owner );
} } else {
else
d->selection_owner = None; d->selection_owner = None;
return d->selection_owner;
} }
return d->selection_owner;
}
// void return value in order to allow more watchers in one process // void return value in order to allow more watchers in one process
void KSelectionWatcher::filterEvent( XEvent* ev_P ) void KSelectionWatcher::filterEvent( XEvent* ev_P )
{ {
if( ev_P->type == ClientMessage ) if ( ev_P->type == ClientMessage ) {
{ // kDebug() << "got ClientMessage";
// kDebug() << "got ClientMessage"; if ( ev_P->xclient.message_type != Private::manager_atom
if( ev_P->xclient.message_type != Private::manager_atom || ev_P->xclient.data.l[ 1 ] != static_cast< long >( d->selection )) {
|| ev_P->xclient.data.l[ 1 ] != static_cast< long >( d->selection ))
return; return;
// kDebug() << "handling message"; }
if( static_cast< long >( owner()) == ev_P->xclient.data.l[ 2 ] ) // kDebug() << "handling message";
{ if ( static_cast< long >( owner()) == ev_P->xclient.data.l[ 2 ] ) {
// owner() emits newOwner() if needed, no need to do it twice // owner() emits newOwner() if needed, no need to do it twice
} }
return; return;
} }
if( ev_P->type == DestroyNotify ) if ( ev_P->type == DestroyNotify ) {
{ if ( d->selection_owner == None || ev_P->xdestroywindow.window != d->selection_owner ) {
if( d->selection_owner == None || ev_P->xdestroywindow.window != d->selection_owner )
return; return;
}
d->selection_owner = None; // in case the exactly same ID gets reused as the owner d->selection_owner = None; // in case the exactly same ID gets reused as the owner
if( owner() == None ) if ( owner() == None ) {
emit lostOwner(); // it must be safe to delete 'this' in a slot emit lostOwner(); // it must be safe to delete 'this' in a slot
return;
} }
return; return;
} }
}
Atom KSelectionWatcher::Private::manager_atom = None; Atom KSelectionWatcher::Private::manager_atom = None;
#include "moc_kmanagerselection.cpp" #include "moc_kmanagerselection.cpp"
#endif