qxcbdrag.cpp

if(0) QMessageLogger(__FILE__, 478484, __PRETTY_FUNCTION__).debug() << "sending Xdnd position source=" << move.data.data32[0] << "target=" << move.window;

dead code:

QMessageLogger(__FILE__, 484, __PRETTY_FUNCTION__).debug() << "sending Xdnd position source=" << move.data.data32[0] << "target=" << move.window;

410

411

source_time = connection()->time();

412

413

if (w)

414

handle_xdnd_position(w, &move);

415

else

416

xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&move);

}

}

void QXcbDrag::drop(const QPoint &globalPos)

421

{

422

QBasicDrag::drop(globalPos);

if (!current_target)

return;

xcb_client_message_event_t drop;

428

drop.response_type = 33;

429

drop.sequence = 0;

430

drop.window = current_target;

431

drop.format = 32;

432

drop.type = atom(QXcbAtom::XdndDrop);

433

drop.data.data32[0] = connection()->clipboard()->owner();

434

drop.data.data32[1] = 0;

435

drop.data.data32[2] = connection()->time();

436

437

drop.data.data32[3] = 0;

438

drop.data.data32[4] = currentDrag()->supportedActions();

439

440

QXcbWindow *w = connection()->platformWindowFromId(current_proxy_target);

441

442

if (w && (w->window()->type() == Qt::Desktop) )

w = 0;

Transaction t = {

connection()->time(),

447

current_target,

448

current_proxy_target,

currentDrag(),

QTime::currentTime()

};

transactions.append(t);

455

456

457

if (!t.targetWindow && cleanup_timer == -1) {

458

cleanup_timer = startTimer(XdndDropTransactionTimeout);

}

if (w) {

handleDrop(w, &drop);

463

} else {

464

xcb_send_event(xcb_connection(), false, current_proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&drop);

}

current_target = 0;

current_proxy_target = 0;

source_time = 0;

}

Qt::DropAction QXcbDrag::toDropAction(xcb_atom_t a) const

474

{

475

if (a == atom(QXcbAtom::XdndActionCopy) || a == 0)

476

return Qt::CopyAction;

477

if (a == atom(QXcbAtom::XdndActionLink))

478

return Qt::LinkAction;

479

if (a == atom(QXcbAtom::XdndActionMove))

480

return Qt::MoveAction;

481

return Qt::CopyAction;

482

}

483

484

xcb_atom_t QXcbDrag::toXdndAction(Qt::DropAction a) const

{

switch (a) {

case Qt::CopyAction:

return atom(QXcbAtom::XdndActionCopy);

489

case Qt::LinkAction:

490

return atom(QXcbAtom::XdndActionLink);

491

case Qt::MoveAction:

492

case Qt::TargetMoveAction:

493

return atom(QXcbAtom::XdndActionMove);

494

case Qt::IgnoreAction:

495

return 0L;

496

default:

497

return atom(QXcbAtom::XdndActionCopy);

}

}

int QXcbDrag::findTransactionByWindow(xcb_window_t window)

502

{

503

int at = -1;

504

for (int i = 0; i < transactions.count(); ++i) {

505

const Transaction &t = transactions.at(i);

506

if (t.target == window || t.proxy_target == window) {

at = i;

break;

}

}

return at;

}

int QXcbDrag::findTransactionByTime(xcb_timestamp_t timestamp)

515

{

516

int at = -1;

517

for (int i = 0; i < transactions.count(); ++i) {

518

const Transaction &t = transactions.at(i);

519

if (t.timestamp == timestamp) {

at = i;

break;

}

}

return at;

}

void QXcbDrag::handleEnter(QPlatformWindow *window, const xcb_client_message_event_t *event, xcb_window_t proxy)

527

{

528

(void)window;;

529

if(0) QMessageLogger(__FILE__, 680686, __PRETTY_FUNCTION__).debug() << "handleEnter" << window;

dead code: QMessageLogger(__FILE__, 686, __PRETTY_FUNCTION__).debug() << "handleEnter" << window;

xdnd_types.clear();

int version = (int)(event->data.data32[1] >> 24);

534

if (version > xdnd_version)

535

return;

536

537

xdnd_dragsource = event->data.data32[0];

538

if (!proxy)

539

proxy = xdndProxy(connection(), xdnd_dragsource);

540

current_proxy_target = proxy ? proxy : xdnd_dragsource;

541

542

if (event->data.data32[1] & 1) {

543

544

xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, xdnd_dragsource,

545

atom(QXcbAtom::XdndTypelist), XCB_ATOM_ATOM,

546

0, xdnd_max_type);

547

xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);

548

if (reply && reply->type != 0L && reply->format == 32) {

549

int length = xcb_get_property_value_length(reply) / 4;

550

if (length > xdnd_max_type)

551

length = xdnd_max_type;

552

553

xcb_atom_t *atoms = (xcb_atom_t *)xcb_get_property_value(reply);

554

xdnd_types.reserve(length);

555

for (int i = 0; i < length; ++i)

556

xdnd_types.append(atoms[i]);

}

free(reply);

} else {

for(int i = 2; i < 5; i++) {

562

if (event->data.data32[i])

563

xdnd_types.append(event->data.data32[i]);

564

}

565

}

566

for(int i = 0; i < xdnd_types.length(); ++i)

567

if(0) QMessageLogger(__FILE__, 718724, __PRETTY_FUNCTION__).debug() << " " << connection()->atomName(xdnd_types.at(i));

dead code: QMessageLogger(__FILE__, 724, __PRETTY_FUNCTION__).debug() << " " << connection()->atomName(xdnd_types.at(i));

568

}

569

570

void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message_event_t *e)

571

{

572

QPoint p((e->data.data32[2] & 0xffff0000) >> 16, e->data.data32[2] & 0x0000ffff);

573

((!(w)) ? qt_assert("w",__FILE__,724730) : qt_noop());

574

QRect geometry = w->geometry();

575

p -= geometry.topLeft();

576

577

if (!w || !w->window() || (w->window()->type() == Qt::Desktop))

578

return;

579

580

if (e->data.data32[0] != xdnd_dragsource) {

581

if(0) QMessageLogger(__FILE__, 732738, __PRETTY_FUNCTION__).debug("xdnd drag position from unexpected source (%x not %x)", e->data.data32[0], xdnd_dragsource);

dead code:

QMessageLogger(__FILE__, 738, __PRETTY_FUNCTION__).debug("xdnd drag position from unexpected source (%x not %x)", e->data.data32[0], xdnd_dragsource);

return;

}

currentPosition = p;

currentWindow = w->window();

587

588

589

if (e->data.data32[3] != 0L) {

590

target_time = e->data.data32[3];

591

}

592

593

QMimeData *dropData = 0;

594

Qt::DropActions supported_actions = Qt::IgnoreAction;

595

if (currentDrag()) {

596

dropData = currentDrag()->mimeData();

597

supported_actions = currentDrag()->supportedActions();

598

} else {

599

dropData = platformDropData();

600

supported_actions = Qt::DropActions(toDropAction(e->data.data32[4]));

601

}

602

603

QPlatformDragQtResponse qt_response = QWindowSystemInterface::handleDrag(w->window(),dropData,p,supported_actions);

604

QRect answerRect(p + geometry.topLeft(), QSize(1,1));

605

answerRect = qt_response.answerRect().translated(geometry.topLeft()).intersected(geometry);

606

607

xcb_client_message_event_t response;

608

response.response_type = 33;

609

response.sequence = 0;

610

response.window = xdnd_dragsource;

611

response.format = 32;

612

response.type = atom(QXcbAtom::XdndStatus);

613

response.data.data32[0] = xcb_window(w);

614

response.data.data32[1] = qt_response.isAccepted();

615

response.data.data32[2] = 0;

616

response.data.data32[3] = 0;

617

response.data.data32[4] = toXdndAction(qt_response.acceptedAction());

618

619

accepted_drop_action = qt_response.acceptedAction();

620

621

if (answerRect.left() < 0)

622

answerRect.setLeft(0);

623

if (answerRect.right() > 4096)

624

answerRect.setRight(4096);

625

if (answerRect.top() < 0)

626

answerRect.setTop(0);

627

if (answerRect.bottom() > 4096)

628

answerRect.setBottom(4096);

629

if (answerRect.width() < 0)

630

answerRect.setWidth(0);

631

if (answerRect.height() < 0)

632

answerRect.setHeight(0);

target_time = 0L;

if (xdnd_dragsource == connection()->clipboard()->owner())

638

handle_xdnd_status(&response);

639

else

640

xcb_send_event(xcb_connection(), false, current_proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&response)

;

}

namespace

{

class ClientMessageScanner {

647

public:

648

ClientMessageScanner(xcb_atom_t a) : atom(a) {}

649

xcb_atom_t atom;

650

bool checkEvent(xcb_generic_event_t *event) const {

651

if (!event)

652

return false;

653

if ((event->response_type & 0x7f) != 33)

654

return false;

655

return ((xcb_client_message_event_t *)event)->type == atom;

}

};

}

void QXcbDrag::handlePosition(QPlatformWindow * w, const xcb_client_message_event_t *event)

661

{

662

xcb_client_message_event_t *lastEvent = const_cast<xcb_client_message_event_t *>(event);

663

xcb_generic_event_t *nextEvent;

664

ClientMessageScanner scanner(atom(QXcbAtom::XdndPosition));

665

while ((nextEvent = connection()->checkEvent(scanner))) {

666

if (lastEvent != event)

667

free(lastEvent);

668

lastEvent = (xcb_client_message_event_t *)nextEvent;

669

}

670

671

handle_xdnd_position(w, lastEvent);

672

if (lastEvent != event)

free(lastEvent);

}

void QXcbDrag::handle_xdnd_status(const xcb_client_message_event_t *event)

677

{

678

if(0) QMessageLogger(__FILE__, 829835, __PRETTY_FUNCTION__).debug("xdndHandleStatus");

dead code: QMessageLogger(__FILE__, 835, __PRETTY_FUNCTION__).debug("xdndHandleStatus");

679

waiting_for_status = false;

680

681

if (event->data.data32[0] && event->data.data32[0] != current_target)

682

return;

683

684

const bool dropPossible = event->data.data32[1];

685

setCanDrop(dropPossible);

686

687

if (dropPossible) {

688

accepted_drop_action = toDropAction(event->data.data32[4]);

689

updateCursor(accepted_drop_action);

690

} else {

691

updateCursor(Qt::IgnoreAction);

692

}

693

694

if ((event->data.data32[1] & 2) == 0) {

695

QPoint p((event->data.data32[2] & 0xffff0000) >> 16, event->data.data32[2] & 0x0000ffff);

696

QSize s((event->data.data32[3] & 0xffff0000) >> 16, event->data.data32[3] & 0x0000ffff);

697

source_sameanswer = QRect(p, s);

698

} else {

699

source_sameanswer = QRect();

}

}

void QXcbDrag::handleStatus(const xcb_client_message_event_t *event)

704

{

705

if (event->window != connection()->clipboard()->owner() || !drag())

706

return;

707

708

xcb_client_message_event_t *lastEvent = const_cast<xcb_client_message_event_t *>(event);

709

xcb_generic_event_t *nextEvent;

710

ClientMessageScanner scanner(atom(QXcbAtom::XdndStatus));

711

while ((nextEvent = connection()->checkEvent(scanner))) {

712

if (lastEvent != event)

713

free(lastEvent);

714

lastEvent = (xcb_client_message_event_t *)nextEvent;

715

}

716

717

handle_xdnd_status(lastEvent);

718

if (lastEvent != event)

719

free(lastEvent);

720

if(0) QMessageLogger(__FILE__, 871877, __PRETTY_FUNCTION__).debug("xdndHandleStatus end");

dead code: QMessageLogger(__FILE__, 877, __PRETTY_FUNCTION__).debug("xdndHandleStatus end");

721

}

722

723

void QXcbDrag::handleLeave(QPlatformWindow *w, const xcb_client_message_event_t *event)

724

{

725

if(0) QMessageLogger(__FILE__, 876882, __PRETTY_FUNCTION__).debug("xdnd leave");

dead code: QMessageLogger(__FILE__, 882, __PRETTY_FUNCTION__).debug("xdnd leave");

726

if (!currentWindow || w != currentWindow.data()->handle())

727

return;

728

if (event->data.data32[0] != xdnd_dragsource) {

729

730

if(0) QMessageLogger(__FILE__, 889895, __PRETTY_FUNCTION__).debug("xdnd drag leave from unexpected source (%x not %x", event->data.data32[0], xdnd_dragsource);

dead code:

QMessageLogger(__FILE__, 895, __PRETTY_FUNCTION__).debug("xdnd drag leave from unexpected source (%x not %x", event->data.data32[0], xdnd_dragsource);

731

}

732

733

QWindowSystemInterface::handleDrag(w->window(),0,QPoint(),Qt::IgnoreAction);

xdnd_dragsource = 0;

xdnd_types.clear();

currentWindow.clear();

738

}

739

740

void QXcbDrag::send_leave()

{

if (!current_target)

return;

xcb_client_message_event_t leave;

747

leave.response_type = 33;

748

leave.sequence = 0;

749

leave.window = current_target;

750

leave.format = 32;

751

leave.type = atom(QXcbAtom::XdndLeave);

752

leave.data.data32[0] = connection()->clipboard()->owner();

753

leave.data.data32[1] = 0;

754

leave.data.data32[2] = 0;

755

leave.data.data32[3] = 0;

756

leave.data.data32[4] = 0;

757

758

QXcbWindow *w = connection()->platformWindowFromId(current_proxy_target);

759

760

if (w && (w->window()->type() == Qt::Desktop) )

w = 0;

if (w)

handleLeave(w, (const xcb_client_message_event_t *)&leave);

765

else

766

xcb_send_event(xcb_connection(), false,current_proxy_target,

767

XCB_EVENT_MASK_NO_EVENT, (const char *)&leave);

768

769

current_target = 0;

770

current_proxy_target = 0;

771

source_time = 0L;

772

waiting_for_status = false;

773

}

774

775

void QXcbDrag::handleDrop(QPlatformWindow *, const xcb_client_message_event_t *event)

776

{

777

if(0) QMessageLogger(__FILE__, 936942, __PRETTY_FUNCTION__).debug("xdndHandleDrop");

dead code: QMessageLogger(__FILE__, 942, __PRETTY_FUNCTION__).debug("xdndHandleDrop");

778

if (!currentWindow) {

xdnd_dragsource = 0;

return;

}

const uint32_t *l = event->data.data32;

784

785

if(0) QMessageLogger(__FILE__, 944950, __PRETTY_FUNCTION__).debug("xdnd drop");

dead code: QMessageLogger(__FILE__, 950, __PRETTY_FUNCTION__).debug("xdnd drop");

786

787

if (l[0] != xdnd_dragsource) {

788

if(0) QMessageLogger(__FILE__, 947953, __PRETTY_FUNCTION__).debug("xdnd drop from unexpected source (%x not %x", l[0], xdnd_dragsource);

dead code:

QMessageLogger(__FILE__, 953, __PRETTY_FUNCTION__).debug("xdnd drop from unexpected source (%x not %x", l[0], xdnd_dragsource);

return;

}

if (l[2] != 0)

target_time = l[2];

Qt::DropActions supported_drop_actions;

797

QMimeData *dropData = 0;

798

if (currentDrag()) {

799

dropData = currentDrag()->mimeData();

800

supported_drop_actions = Qt::DropActions(l[4]);

801

} else {

802

dropData = platformDropData();

803

supported_drop_actions = accepted_drop_action;

804

805

806

QGuiApplicationPrivate::modifier_buttons = QGuiApplication::queryKeyboardModifiers();

}

if (!dropData)

return;

QPlatformDropQtResponse response = QWindowSystemInterface::handleDrop(currentWindow.data(),dropData,currentPosition,supported_drop_actions);

818

setExecutedDropAction(response.acceptedAction());

819

820

xcb_client_message_event_t finished;

821

finished.response_type = 33;

822

finished.sequence = 0;

823

finished.window = xdnd_dragsource;

824

finished.format = 32;

825

finished.type = atom(QXcbAtom::XdndFinished);

826

finished.data.data32[0] = currentWindow ? xcb_window(currentWindow.data()) : 0L;

827

finished.data.data32[1] = response.isAccepted();

828

finished.data.data32[2] = toXdndAction(response.acceptedAction());

829

xcb_send_event(xcb_connection(), false, current_proxy_target, XCB_EVENT_MASK_NO_EVENT, (char *)&finished)

;

xdnd_dragsource = 0;

currentWindow.clear();

834

waiting_for_status = false;

target_time = 0L;

}

void QXcbDrag::handleFinished(const xcb_client_message_event_t *event)

842

{

843

if(0) QMessageLogger(__FILE__, 10021008, __PRETTY_FUNCTION__).debug("xdndHandleFinished");

dead code: QMessageLogger(__FILE__, 1008, __PRETTY_FUNCTION__).debug("xdndHandleFinished");

844

if (event->window != connection()->clipboard()->owner())

845

return;

846

847

const unsigned long *l = (const unsigned long *)event->data.data32;

848

849

if(0) QMessageLogger(__FILE__, 10081014, __PRETTY_FUNCTION__).debug() << "xdndHandleFinished, l[0]" << l[0]

dead code:

QMessageLogger(__FILE__, 1014, __PRETTY_FUNCTION__).debug() << "xdndHandleFinished, l[0]" << l[0] << "current_target" << current_target << "qt_xdnd_current_proxy_targe" << current_proxy_target;

850

<< "current_target" << current_target

dead code:

QMessageLogger(__FILE__, 1014, __PRETTY_FUNCTION__).debug() << "xdndHandleFinished, l[0]" << l[0] << "current_target" << current_target << "qt_xdnd_current_proxy_targe" << current_proxy_target;

851

<< "qt_xdnd_current_proxy_targe" << current_proxy_target;

dead code:

QMessageLogger(__FILE__, 1014, __PRETTY_FUNCTION__).debug() << "xdndHandleFinished, l[0]" << l[0] << "current_target" << current_target << "qt_xdnd_current_proxy_targe" << current_proxy_target;

852

853

if (l[0]) {

854

int at = findTransactionByWindow(l[0]);

855

if (at != -1) {

856

857

Transaction t = transactions.takeAt(at);

858

if (t.drag)

859

t.drag->deleteLater();

860

} else {

861

QMessageLogger(__FILE__, 10431049, __PRETTY_FUNCTION__).warning("QXcbDrag::handleFinished - drop data has expired");

862

}

863

}

864

waiting_for_status = false;

865

}

866

867

void QXcbDrag::timerEvent(QTimerEvent* e)

868

{

869

if (e->timerId() == cleanup_timer) {

870

bool stopTimer = true;

871

for (int i = 0; i < transactions.count(); ++i) {

872

const Transaction &t = transactions.at(i);

873

if (t.targetWindow) {

continue;

}

QTime currentTime = QTime::currentTime();

879

int delta = t.time.msecsTo(currentTime);

880

if (delta > XdndDropTransactionTimeout) {

if (t.drag)

t.drag->deleteLater();

889

transactions.removeAt(i--);

} else {

stopTimer = false;

}

}

if (stopTimer && cleanup_timer != -1) {

896

killTimer(cleanup_timer);

cleanup_timer = -1;

}

}

}

void QXcbDrag::cancel()

903

{

904

if(0) QMessageLogger(__FILE__, 10861092, __PRETTY_FUNCTION__).debug("QXcbDrag::cancel");

dead code: QMessageLogger(__FILE__, 1092, __PRETTY_FUNCTION__).debug("QXcbDrag::cancel");

905

QBasicDrag::cancel();

if (current_target)

send_leave();

}

static xcb_window_t findXdndAwareParent(QXcbConnection *c, xcb_window_t window)

912

{

913

xcb_window_t target = 0;

914

for(;;) {

915

916

xcb_get_property_cookie_t gpCookie = xcb_get_property(c->xcb_connection(), false, window, c->atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0)

917

918

;

919

xcb_get_property_reply_t *gpReply = xcb_get_property_reply(

920

c->xcb_connection(), gpCookie, 0);

921

bool aware = gpReply && gpReply->type != 0L;

free(gpReply);

if (aware) {

target = window;

break;

}

xcb_query_tree_cookie_t qtCookie = xcb_query_tree_unchecked(c->xcb_connection(), window)

930

;

931

xcb_query_tree_reply_t *qtReply = xcb_query_tree_reply(

932

c->xcb_connection(), qtCookie, __null);

933

if (!qtReply)

934

break;

935

xcb_window_t root = qtReply->root;

936

xcb_window_t parent = qtReply->parent;

free(qtReply);

if (window == root)

break;

window = parent;

}

return target;

}

void QXcbDrag::handleSelectionRequest(const xcb_selection_request_event_t *event)

946

{

947

q_padded_xcb_event<xcb_selection_notify_event_t> store = q_padded_xcb_event<xcb_selection_notify_event_t >(); auto &notify = store.event;;notify;

948

notify.response_type = 31;

949

notify.requestor = event->requestor;

950

notify.selection = event->selection;

951

notify.target = 0L;

952

notify.property = 0L;

953

notify.time = event->time;

int at = -1;

if (currentDrag()

currentDrag()	Description
TRUE	never evaluated
FALSE	never evaluated

&& event->time == source_time

event->time == source_time	Description
TRUE	never evaluated
FALSE	never evaluated

) {

960

961

at = -2;

962

}

never executed: end of block

else {

963

964

965

at = findTransactionByTime(event->time);

966

if (at == -1

at == -1	Description
TRUE	never evaluated
FALSE	never evaluated

) {

967

968

969

at = findTransactionByWindow(event->requestor);

970

}

never executed: end of block

971

972

if (at == -1

at == -1	Description
TRUE	never evaluated
FALSE	never evaluated

) {

973

xcb_window_t target = findXdndAwareParent(connection(), event->requestor);

974

if (target

target	Description
TRUE	never evaluated
FALSE	never evaluated

) {

975

if (event->time == 0L

event->time == 0L	Description
TRUE	never evaluated
FALSE	never evaluated

&& current_target == target

current_target == target	Description
TRUE	never evaluated
FALSE	never evaluated

)

976

at = -2;

never executed: at = -2;

977

else

978

at = findTransactionByWindow(target);

never executed: at = findTransactionByWindow(target);

979

}

980

}

never executed: end of block

981

}

never executed: end of block

982

983

QDrag *transactionDrag = 0;

984

if (at >= 0

at >= 0	Description
TRUE	never evaluated
FALSE	never evaluated

) {

985

transactionDrag = transactions.at(at).drag;

986

}

never executed: end of block

else if (at == -2

at == -2	Description
TRUE	never evaluated
FALSE	never evaluated

) {

987

transactionDrag = currentDrag();

988

}

never executed: end of block

989

990

if (transactionDrag

transactionDrag	Description
TRUE	never evaluated
FALSE	never evaluated

) {

991

xcb_atom_t atomFormat = event->target;

992

int dataFormat = 0;

993

QByteArray data;

994

if (QXcbMime::mimeDataForAtom(connection(), event->target, transactionDrag->mimeData(),

QXcbMime::mime..., &dataFormat)	Description
TRUE	never evaluated
FALSE	never evaluated

995

&data, &atomFormat, &dataFormat)

QXcbMime::mime..., &dataFormat)	Description
TRUE	never evaluated
FALSE	never evaluated

) {

996

int dataSize = data.size() / (dataFormat / 8);

997

xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, event->requestor, event->property,

998

atomFormat, dataFormat, dataSize, (const void *)data.constData());

999

notify.property = event->property;

1000

notify.target = atomFormat;

1001

}

never executed: end of block

1002

}

never executed: end of block

1003

1004

xcb_window_t proxy_target = xdndProxy(connection(), event->requestor);

1005

if (!proxy_target

!proxy_target	Description
TRUE	never evaluated
FALSE	never evaluated

)

1006

proxy_target = event->requestor;

never executed: proxy_target = event->requestor;

1007

1008

xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&notify);

1009

}

never executed: end of block

1010

1011

1012

bool QXcbDrag::dndEnable(QXcbWindow *w, bool on)

1013

{

1014

if(0) QMessageLogger(__FILE__, 11961202, __PRETTY_FUNCTION__).debug() << "xdndEnable" << w << on;

dead code: QMessageLogger(__FILE__, 1202, __PRETTY_FUNCTION__).debug() << "xdndEnable" << w << on;

1015

if (on) {

1016

QXcbWindow *xdnd_widget = 0;

1017

if ((w->window()->type() == Qt::Desktop)) {

if (desktop_proxy)

return false;

QXcbConnectionGrabber grabber(connection());

1022

1023

1024

xcb_window_t proxy_id = xdndProxy(connection(), w->xcb_window());

1025

1026

if (!proxy_id) {

1027

desktop_proxy = new QWindow;

1028

xdnd_widget = static_cast<QXcbWindow *>(desktop_proxy->handle());

1029

proxy_id = xdnd_widget->xcb_window();

1030

xcb_atom_t xdnd_proxy = atom(QXcbAtom::XdndProxy);

1031

xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, w->xcb_window(), xdnd_proxy,

1032

XCB_ATOM_WINDOW, 32, 1, &proxy_id);

1033

xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, proxy_id, xdnd_proxy,

1034

XCB_ATOM_WINDOW, 32, 1, &proxy_id);

}

} else {

xdnd_widget = w;

}

if (xdnd_widget) {

if(0) QMessageLogger(__FILE__, 12231229, __PRETTY_FUNCTION__).debug() << "setting XdndAware for" << xdnd_widget << xdnd_widget->xcb_window();

dead code:

QMessageLogger(__FILE__, 1229, __PRETTY_FUNCTION__).debug() << "setting XdndAware for" << xdnd_widget << xdnd_widget->xcb_window();

1042

xcb_atom_t atm = xdnd_version;

1043

xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, xdnd_widget->xcb_window(),

1044

atom(QXcbAtom::XdndAware), XCB_ATOM_ATOM, 32, 1, &atm);

return true;

} else {

return false;

}

} else {

if ((w->window()->type() == Qt::Desktop)) {

1051

xcb_delete_property(xcb_connection(), w->xcb_window(), atom(QXcbAtom::XdndProxy));

1052

delete desktop_proxy;

1053

desktop_proxy = 0;

1054

} else {

1055

if(0) QMessageLogger(__FILE__, 12371243, __PRETTY_FUNCTION__).debug() << "not deleting XDndAware";

dead code: QMessageLogger(__FILE__, 1243, __PRETTY_FUNCTION__).debug() << "not deleting XDndAware";

}

return true;

}

}

bool QXcbDrag::ownsDragObject() const

{

return true;

}

QXcbDropData::QXcbDropData(QXcbDrag *d)

: QXcbMime(),

drag(d)

{

}

QXcbDropData::~QXcbDropData()

{

}

QVariant QXcbDropData::retrieveData_sys(const QString &mimetype, QVariant::Type requestedType) const

1077

{

1078

QByteArray mime = mimetype.toLatin1();

1079

QVariant data = xdndObtainData(mime, requestedType);

return data;

}

QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QVariant::Type requestedType) const

{

QByteArray result;

QXcbConnection *c = drag->connection();

1088

QXcbWindow *xcb_window = c->platformWindowFromId(drag->xdnd_dragsource);

1089

if (xcb_window && drag->currentDrag() && xcb_window->window()->type() != Qt::Desktop) {

1090

QMimeData *data = drag->currentDrag()->mimeData();

1091

if (data->hasFormat(QLatin1String(format)))

1092

result = data->data(QLatin1String(format));

return result;

}

QVector<xcb_atom_t> atoms = drag->xdnd_types;

1097

QByteArray encoding;

1098

xcb_atom_t a = mimeAtomForFormat(c, QLatin1String(format), requestedType, atoms, &encoding);

if (a == 0L)

return result;

if (c->clipboard()->getSelectionOwner(drag->atom(QXcbAtom::XdndSelection)) == 0L)

1103

return result;

1104

1105

xcb_atom_t xdnd_selection = c->atom(QXcbAtom::XdndSelection);

1106

result = c->clipboard()->getSelection(xdnd_selection, a, xdnd_selection, drag->targetTime());

1107

1108

return mimeConvertToFormat(c, a, result, QLatin1String(format), requestedType, encoding);

}

bool QXcbDropData::hasFormat_sys(const QString &format) const

1113

{

1114

return formats().contains(format);

1115

}

1116

1117

QStringList QXcbDropData::formats_sys() const

1118

{

1119

QStringList formats;

1120

for (int i = 0; i < drag->xdnd_types.size(); ++i) {

1121

QString f = mimeAtomToString(drag->connection(), drag->xdnd_types.at(i));

1122

if (!formats.contains(f))

formats.append(f);

}

return formats;

}

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9