static void testFileRecording() {
InputRecorder * inputRecorder;
InputController * inputController;
const char * tempFilePath;
int tempFD;
unsigned char * fileContents;
size_t fileLength;
inputController = InputController_create(NULL, NULL);
tempFilePath = temporaryFilePath("tmpXXXXXX", &tempFD);
close(tempFD);
inputRecorder = InputRecorder_createWithFileOutput(inputController, NULL, 0, tempFilePath);
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 8, "Expected 8 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents, "\x00\x00\x00\x00\x00\x00\x00\x00", 8), "Expected 0000 00000000 0000 but got %02X%02X %02X%02X%02X%02X %02X%02X", fileContents[0], fileContents[1], fileContents[2], fileContents[3], fileContents[4], fileContents[5], fileContents[6], fileContents[7]);
free(fileContents);
InputRecorder_dispose(inputRecorder);
inputRecorder = InputRecorder_createWithFileOutput(inputController, "abcd", 4, tempFilePath);
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 12, "Expected 12 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents, "\x00\x00\x04\x00\x00\x00""abcd\x00\x00", 12), "Expected 0000 04000000 61626364 0000 but got %02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X", fileContents[0], fileContents[1], fileContents[2], fileContents[3], fileContents[4], fileContents[5], fileContents[6], fileContents[7], fileContents[8], fileContents[9], fileContents[10], fileContents[11]);
free(fileContents);
InputRecorder_dispose(inputRecorder);
InputController_dispose(inputController);
inputController = InputController_create(NULL, "a", "bc", NULL);
inputRecorder = InputRecorder_createWithFileOutput(inputController, NULL, 0, tempFilePath);
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 13, "Expected 13 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents, "\x00\x00\x00\x00\x00\x00\x02\x00""a\x00""bc\x00", 13), "Expected 0000 00000000 0200 6100 626300 but got %02X%02X %02X%02X%02X%02X %02X%02X %02X%02X %02X%02X%02X", fileContents[0], fileContents[1], fileContents[2], fileContents[3], fileContents[4], fileContents[5], fileContents[6], fileContents[7], fileContents[8], fileContents[9], fileContents[10], fileContents[11], fileContents[12]);
free(fileContents);
inputController->triggerAction(inputController, ATOM("a"));
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 19, "Expected 19 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents + 13, "\x00\x00\x00\x00\x00\x00", 6), "Expected 00000000 0000 but got %02X%02X%02X%02X %02X%02X", fileContents[13], fileContents[14], fileContents[15], fileContents[16], fileContents[17], fileContents[18]);
free(fileContents);
InputRecorder_nextFrame(inputRecorder);
inputController->triggerAction(inputController, ATOM("bc"));
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 25, "Expected 25 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents + 19, "\x01\x00\x00\x00\x01\x00", 6), "Expected 01000000 0100 but got %02X%02X%02X%02X %02X%02X", fileContents[19], fileContents[20], fileContents[21], fileContents[22], fileContents[23], fileContents[24]);
free(fileContents);
InputRecorder_nextFrame(inputRecorder);
InputRecorder_nextFrame(inputRecorder);
InputRecorder_nextFrame(inputRecorder);
inputController->releaseAction(inputController, ATOM("bc"));
fileContents = readFileSimple(tempFilePath, &fileLength);
TestCase_assert(fileContents != NULL, "Expected non-NULL but got NULL");
TestCase_assert(fileLength == 31, "Expected 31 but got " SIZE_T_FORMAT, fileLength);
TestCase_assert(!memcmp(fileContents + 25, "\x03\x00\x00\x00\x01\x00", 6), "Expected 03000000 0100 but got %02X%02X%02X%02X %02X%02X", fileContents[25], fileContents[26], fileContents[27], fileContents[28], fileContents[29], fileContents[30]);
free(fileContents);
InputRecorder_dispose(inputRecorder);
InputController_dispose(inputController);
unlink(tempFilePath);
}
static Bool DndParseClientMessage(XClientMessageEvent *cm, DndData * dnd_data,
char * receiver)
{
DndMessage * dnd_message = (DndMessage*)&cm->data.b[0] ;
if (cm->message_type != ATOM(_MOTIF_DRAG_AND_DROP_MESSAGE)) {
return False ;
}
if (dnd_message->byte_order != DndByteOrder()) {
SWAP2BYTES(dnd_message->flags);
SWAP4BYTES(dnd_message->time);
} /* do the rest in the switch */
dnd_data->reason = dnd_message->reason ;
if (DND_GET_EVENT_TYPE(dnd_data->reason))
*receiver = 1 ;
else
*receiver = 0 ;
dnd_data->reason &= DND_CLEAR_EVENT_TYPE ;
dnd_data->time = dnd_message->time ;
/* we're reading in more stuff that necessary. but who cares */
dnd_data->status = DND_GET_STATUS(dnd_message->flags) ;
dnd_data->operation = DND_GET_OPERATION(dnd_message->flags) ;
dnd_data->operations = DND_GET_OPERATIONS(dnd_message->flags) ;
dnd_data->completion = DND_GET_COMPLETION(dnd_message->flags) ;
switch(dnd_data->reason) {
case DND_TOP_LEVEL_ENTER:
case DND_TOP_LEVEL_LEAVE:
if (dnd_message->byte_order != DndByteOrder()) {
SWAP4BYTES(dnd_message->data.top.src_window);
SWAP4BYTES(dnd_message->data.top.property);
}
dnd_data->src_window = dnd_message->data.top.src_window ;
dnd_data->property = dnd_message->data.top.property ;
break ; /* cannot fall through, see above comment in write msg */
case DND_DRAG_MOTION:
case DND_OPERATION_CHANGED:
case DND_DROP_SITE_ENTER:
case DND_DROP_START:
if (dnd_message->byte_order != DndByteOrder()) {
SWAP2BYTES(dnd_message->data.pot.x);
SWAP2BYTES(dnd_message->data.pot.y);
SWAP4BYTES(dnd_message->data.pot.property);
SWAP4BYTES(dnd_message->data.pot.src_window);
}
dnd_data->x = dnd_message->data.pot.x ;
dnd_data->y = dnd_message->data.pot.y ;
dnd_data->property = dnd_message->data.pot.property ;
dnd_data->src_window = dnd_message->data.pot.src_window ;
break ;
case DND_DROP_SITE_LEAVE:
break;
default:
break ;
}
return True ;
}
static void Target_mouseMoved(float x, float y) {
struct mouseEvent event;
event.position = VECTOR2f(x, y);
EventDispatcher_dispatchEvent(screenManager->eventDispatcher, ATOM(EVENT_MOUSE_MOVED), &event);
}
void
ewmh_init(void)
{
int b = 1;
W->net_atom = xcalloc(net_last, sizeof(Atom));
/* EWMH hints */
W->net_atom[wm_state] = ATOM("WM_STATE");
W->net_atom[wm_class] = ATOM("WM_CLASS");
W->net_atom[wm_name] = ATOM("WM_NAME");
W->net_atom[net_supported] = ATOM("_NET_SUPPORTED");
W->net_atom[net_client_list] = ATOM("_NET_CLIENT_LIST");
W->net_atom[net_frame_extents] = ATOM("_NET_FRAME_EXTENTS");
W->net_atom[net_number_of_desktops] = ATOM("_NET_NUMBER_OF_DESKTOPS");
W->net_atom[net_current_desktop] = ATOM("_NET_CURRENT_DESKTOP");
W->net_atom[net_desktop_names] = ATOM("_NET_DESKTOP_NAMES");
W->net_atom[net_desktop_geometry] = ATOM("_NET_DESKTOP_GEOMETRY");
W->net_atom[net_active_window] = ATOM("_NET_ACTIVE_WINDOW");
W->net_atom[net_close_window] = ATOM("_NET_CLOSE_WINDOW");
W->net_atom[net_wm_name] = ATOM("_NET_WM_NAME");
W->net_atom[net_wm_pid] = ATOM("_NET_WM_PID");
W->net_atom[net_wm_desktop] = ATOM("_NET_WM_DESKTOP");
W->net_atom[net_showing_desktop] = ATOM("_NET_SHOWING_DESKTOP");
W->net_atom[net_wm_icon_name] = ATOM("_NET_WM_ICON_NAME");
W->net_atom[net_wm_window_type] = ATOM("_NET_WM_WINDOW_TYPE");
W->net_atom[net_supporting_wm_check] = ATOM("_NET_SUPPORTING_WM_CHECK");
W->net_atom[net_wm_window_opacity] = ATOM("_NET_WM_WINDOW_OPACITY");
W->net_atom[net_wm_window_type_normal] = ATOM("_NET_WM_WINDOW_TYPE_NORMAL");
W->net_atom[net_wm_window_type_desktop] = ATOM("_NET_WM_WINDOW_TYPE_DESKTOP");
W->net_atom[net_wm_window_type_dock] = ATOM("_NET_WM_WINDOW_TYPE_DOCK");
W->net_atom[net_wm_window_type_splash] = ATOM("_NET_WM_WINDOW_TYPE_SPLASH");
W->net_atom[net_wm_window_type_dialog] = ATOM("_NET_WM_WINDOW_TYPE_DIALOG");
W->net_atom[net_wm_icon] = ATOM("_NET_WM_ICON");
W->net_atom[net_wm_state] = ATOM("_NET_WM_STATE");
W->net_atom[net_wm_state_fullscreen] = ATOM("_NET_WM_STATE_FULLSCREEN");
W->net_atom[net_wm_state_sticky] = ATOM("_NET_WM_STATE_STICKY");
W->net_atom[net_wm_state_demands_attention] = ATOM("_NET_WM_STATE_DEMANDS_ATTENTION");
W->net_atom[net_wm_state_hidden] = ATOM("_NET_WM_STATE_HIDDEN");
W->net_atom[net_system_tray_s] = ATOM("_NET_SYSTEM_TRAY_S0");
W->net_atom[net_system_tray_opcode] = ATOM("_NET_SYSTEM_TRAY_OPCODE");
W->net_atom[net_system_tray_message_data] = ATOM("_NET_SYSTEM_TRAY_MESSAGE_DATA");
W->net_atom[net_system_tray_visual] = ATOM("_NET_SYSTEM_TRAY_VISUAL");
W->net_atom[net_system_tray_orientation] = ATOM("_NET_SYSTEM_TRAY_ORIENTATION");
W->net_atom[xembed] = ATOM("_XEMBED");
W->net_atom[xembedinfo] = ATOM("_XEMBED_INFO");
W->net_atom[manager] = ATOM("MANAGER");
W->net_atom[utf8_string] = ATOM("UTF8_STRING");
/* WMFS hints */
W->net_atom[wmfs_running] = ATOM("_WMFS_RUNNING");
W->net_atom[wmfs_focus] = ATOM("_WMFS_FOCUS");
W->net_atom[wmfs_update_hints] = ATOM("_WMFS_UPDATE_HINTS");
W->net_atom[wmfs_set_screen] = ATOM("_WMFS_SET_SCREEN");
W->net_atom[wmfs_screen_count] = ATOM("_WMFS_SCREEN_COUNT");
W->net_atom[wmfs_current_tag] = ATOM("_WMFS_CURRENT_TAG");
W->net_atom[wmfs_tag_list] = ATOM("_WMFS_TAG_LIST");
W->net_atom[wmfs_current_screen] = ATOM("_WMFS_CURRENT_SCREEN");
W->net_atom[wmfs_current_layout] = ATOM("_WMFS_CURRENT_LAYOUT");
W->net_atom[wmfs_function] = ATOM("_WMFS_FUNCTION");
W->net_atom[wmfs_cmd] = ATOM("_WMFS_CMD");
XChangeProperty(W->dpy, W->root, W->net_atom[net_supported], XA_ATOM, 32,
PropModeReplace, (unsigned char*)W->net_atom, net_last);
XChangeProperty(W->dpy, W->root, W->net_atom[wmfs_running], XA_CARDINAL, 32,
PropModeReplace, (unsigned char*)&b, 1);
/* Set _NET_SUPPORTING_WM_CHECK */
XChangeProperty(W->dpy, W->root, W->net_atom[net_supporting_wm_check], XA_WINDOW, 32,
PropModeReplace, (unsigned char*)&W->root, 1);
XChangeProperty(W->dpy, W->root, ATOM("WM_CLASS"), XA_STRING, 8,
PropModeReplace, (unsigned char*)&"wmfs", 4);
XChangeProperty(W->dpy, W->root, W->net_atom[net_wm_name], W->net_atom[utf8_string], 8,
PropModeReplace, (unsigned char*)&"wmfs2", 5);
/*
* Set _NET_WM_PID
XChangeProperty(W->dpy, W->root, W->net_atom[net_wm_pid], XA_CARDINAL, 32,
PropModeReplace, (unsigned char*)&pid, 1);
* Set _NET_SHOWING_DESKTOP
XChangeProperty(W->dpy, W->root, W->net_atom[net_showing_desktop], XA_CARDINAL, 32,
PropModeReplace, (unsigned char*)&showing_desk, 1);
*/
}
void ClassAssertion(std::string className, std::string individualName) {
predCache.ClassAssertion(ATOM(className), ATOM(individualName));
}
bool QX11Data::clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout, bool checkManager)
{
QElapsedTimer started;
started.start();
QElapsedTimer now = started;
if (QAbstractEventDispatcher::instance()->inherits("QtMotif")
|| QApplication::clipboard()->property("useEventLoopWhenWaiting").toBool()) {
if (waiting_for_data) {
Q_ASSERT(!"QClipboard: internal error, qt_xclb_wait_for_event recursed");
return false;
}
waiting_for_data = true;
has_captured_event = false;
capture_event_win = win;
capture_event_type = type;
QApplication::EventFilter old_event_filter =
qApp->setEventFilter(qt_x11_clipboard_event_filter);
do {
if (XCheckTypedWindowEvent(display, win, type, event)) {
waiting_for_data = false;
qApp->setEventFilter(old_event_filter);
return true;
}
if (checkManager && XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone)
return false;
XSync(X11->display, false);
usleep(50000);
now.start();
QEventLoop::ProcessEventsFlags flags(QEventLoop::ExcludeUserInputEvents
| QEventLoop::ExcludeSocketNotifiers
| QEventLoop::WaitForMoreEvents
| QEventLoop::X11ExcludeTimers);
QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
eventDispatcher->processEvents(flags);
if (has_captured_event) {
waiting_for_data = false;
*event = captured_event;
qApp->setEventFilter(old_event_filter);
return true;
}
} while (started.msecsTo(now) < timeout);
waiting_for_data = false;
qApp->setEventFilter(old_event_filter);
} else {
do {
if (XCheckTypedWindowEvent(X11->display,win,type,event))
return true;
if (checkManager && XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone)
return false;
// process other clipboard events, since someone is probably requesting data from us
XEvent e;
// Pass the event through the event dispatcher filter so that applications
// which install an event filter on the dispatcher get to handle it first.
if (XCheckIfEvent(X11->display, &e, checkForClipboardEvents, 0) &&
!QAbstractEventDispatcher::instance()->filterEvent(&e))
qApp->x11ProcessEvent(&e);
now.start();
XFlush(X11->display);
// sleep 50 ms, so we don't use up CPU cycles all the time.
struct timeval usleep_tv;
usleep_tv.tv_sec = 0;
usleep_tv.tv_usec = 50000;
select(0, 0, 0, 0, &usleep_tv);
} while (started.msecsTo(now) < timeout);
}
return false;
}
bool QClipboard::event(QEvent *e)
{
if (e->type() == QEvent::Timer) {
QTimerEvent *te = (QTimerEvent *) e;
if (waiting_for_data) // should never happen
return false;
if (te->timerId() == timer_id) {
killTimer(timer_id);
timer_id = 0;
timer_event_clear = true;
if (selection_watcher) // clear selection
selectionData()->clear();
if (clipboard_watcher) // clear clipboard
clipboardData()->clear();
timer_event_clear = false;
return true;
} else if (te->timerId() == pending_timer_id) {
// I hate klipper
killTimer(pending_timer_id);
pending_timer_id = 0;
if (pending_clipboard_changed) {
pending_clipboard_changed = false;
clipboardData()->clear();
emitChanged(QClipboard::Clipboard);
}
if (pending_selection_changed) {
pending_selection_changed = false;
selectionData()->clear();
emitChanged(QClipboard::Selection);
}
return true;
} else if (te->timerId() == incr_timer_id) {
killTimer(incr_timer_id);
incr_timer_id = 0;
qt_xclb_incr_timeout();
return true;
} else {
return QObject::event(e);
}
} else if (e->type() != QEvent::Clipboard) {
return QObject::event(e);
}
XEvent *xevent = (XEvent *)(((QClipboardEvent *)e)->data());
Display *dpy = X11->display;
if (!xevent) {
// That means application exits and we need to give clipboard
// content to the clipboard manager.
// First we check if there is a clipboard manager.
if (XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone
|| !owner)
return true;
Window ownerId = owner->internalWinId();
Q_ASSERT(ownerId);
// we delete the property so the manager saves all TARGETS.
XDeleteProperty(X11->display, ownerId, ATOM(_QT_SELECTION));
XConvertSelection(X11->display, ATOM(CLIPBOARD_MANAGER), ATOM(SAVE_TARGETS),
ATOM(_QT_SELECTION), ownerId, X11->time);
XSync(dpy, false);
XEvent event;
// waiting until the clipboard manager fetches the content.
if (!X11->clipboardWaitForEvent(ownerId, SelectionNotify, &event, 10000, true)) {
qWarning("QClipboard: Unable to receive an event from the "
"clipboard manager in a reasonable time");
}
return true;
}
switch (xevent->type) {
case SelectionClear:
// new selection owner
if (xevent->xselectionclear.selection == XA_PRIMARY) {
QClipboardData *d = selectionData();
// ignore the event if it was generated before we gained selection ownership
if (d->timestamp != CurrentTime && xevent->xselectionclear.time <= d->timestamp)
break;
DEBUG("QClipboard: new selection owner 0x%lx at time %lx (ours %lx)",
XGetSelectionOwner(dpy, XA_PRIMARY),
xevent->xselectionclear.time, d->timestamp);
if (! waiting_for_data) {
d->clear();
emitChanged(QClipboard::Selection);
} else {
pending_selection_changed = true;
if (! pending_timer_id)
pending_timer_id = QApplication::clipboard()->startTimer(0);
}
} else if (xevent->xselectionclear.selection == ATOM(CLIPBOARD)) {
QClipboardData *d = clipboardData();
// ignore the event if it was generated before we gained selection ownership
if (d->timestamp != CurrentTime && xevent->xselectionclear.time <= d->timestamp)
break;
DEBUG("QClipboard: new clipboard owner 0x%lx at time %lx (%lx)",
XGetSelectionOwner(dpy, ATOM(CLIPBOARD)),
xevent->xselectionclear.time, d->timestamp);
if (! waiting_for_data) {
d->clear();
emitChanged(QClipboard::Clipboard);
} else {
pending_clipboard_changed = true;
if (! pending_timer_id)
pending_timer_id = QApplication::clipboard()->startTimer(0);
}
} else {
qWarning("QClipboard: Unknown SelectionClear event received");
return false;
}
break;
case SelectionNotify:
/*
Something has delivered data to us, but this was not caught
by QClipboardWatcher::getDataInFormat()
Just skip the event to prevent Bad Things (tm) from
happening later on...
*/
break;
case SelectionRequest:
{
// someone wants our data
XSelectionRequestEvent *req = &xevent->xselectionrequest;
if (requestor && req->requestor == requestor->internalWinId())
break;
XEvent event;
event.xselection.type = SelectionNotify;
event.xselection.display = req->display;
event.xselection.requestor = req->requestor;
event.xselection.selection = req->selection;
event.xselection.target = req->target;
event.xselection.property = XNone;
event.xselection.time = req->time;
DEBUG("QClipboard: SelectionRequest from %lx\n"
" selection 0x%lx (%s) target 0x%lx (%s)",
req->requestor,
req->selection,
X11->xdndAtomToString(req->selection).data(),
req->target,
X11->xdndAtomToString(req->target).data());
QClipboardData *d;
if (req->selection == XA_PRIMARY) {
d = selectionData();
} else if (req->selection == ATOM(CLIPBOARD)) {
d = clipboardData();
} else {
qWarning("QClipboard: Unknown selection '%lx'", req->selection);
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
if (! d->source()) {
qWarning("QClipboard: Cannot transfer data, no data available");
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
DEBUG("QClipboard: SelectionRequest at time %lx (ours %lx)",
req->time, d->timestamp);
if (d->timestamp == CurrentTime // we don't own the selection anymore
|| (req->time != CurrentTime && req->time < d->timestamp)) {
DEBUG("QClipboard: SelectionRequest too old");
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
Atom xa_targets = ATOM(TARGETS);
Atom xa_multiple = ATOM(MULTIPLE);
Atom xa_timestamp = ATOM(TIMESTAMP);
struct AtomPair { Atom target; Atom property; } *multi = 0;
Atom multi_type = XNone;
int multi_format = 0;
int nmulti = 0;
int imulti = -1;
bool multi_writeback = false;
if (req->target == xa_multiple) {
QByteArray multi_data;
if (req->property == XNone
|| !X11->clipboardReadProperty(req->requestor, req->property, false, &multi_data,
0, &multi_type, &multi_format)
|| multi_format != 32) {
// MULTIPLE property not formatted correctly
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
break;
}
nmulti = multi_data.size()/sizeof(*multi);
multi = new AtomPair[nmulti];
memcpy(multi,multi_data.data(),multi_data.size());
imulti = 0;
}
for (; imulti < nmulti; ++imulti) {
Atom target;
Atom property;
if (multi) {
target = multi[imulti].target;
property = multi[imulti].property;
} else {
target = req->target;
property = req->property;
if (property == XNone) // obsolete client
property = target;
}
Atom ret = XNone;
if (target == XNone || property == XNone) {
;
} else if (target == xa_timestamp) {
if (d->timestamp != CurrentTime) {
XChangeProperty(dpy, req->requestor, property, XA_INTEGER, 32,
PropModeReplace, (uchar *) &d->timestamp, 1);
ret = property;
} else {
qWarning("QClipboard: Invalid data timestamp");
}
} else if (target == xa_targets) {
ret = send_targets_selection(d, req->requestor, property);
} else {
ret = send_selection(d, target, req->requestor, property);
}
if (nmulti > 0) {
if (ret == XNone) {
multi[imulti].property = XNone;
multi_writeback = true;
}
} else {
event.xselection.property = ret;
break;
}
}
if (nmulti > 0) {
if (multi_writeback) {
// according to ICCCM 2.6.2 says to put None back
// into the original property on the requestor window
XChangeProperty(dpy, req->requestor, req->property, multi_type, 32,
PropModeReplace, (uchar *) multi, nmulti * 2);
}
delete [] multi;
event.xselection.property = req->property;
}
// send selection notify to requestor
XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
DEBUG("QClipboard: SelectionNotify to 0x%lx\n"
" property 0x%lx (%s)",
req->requestor, event.xselection.property,
X11->xdndAtomToString(event.xselection.property).data());
}
break;
}
return true;
}
void MCompositeScene::drawItems(QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget)
{
QRegion visible(sceneRect().toRect());
QVector<int> to_paint(10);
int size = 0;
bool desktop_painted = false;
// visibility is determined from top to bottom
for (int i = numItems - 1; i >= 0; --i) {
MCompositeWindow *cw = (MCompositeWindow *) items[i];
#ifdef GLES2_VERSION
static int item_type = MCompositeWindowGroup::Type;
#else
static int item_type = QGraphicsItem::Type + 2;
#endif
if (cw->type() != item_type) {
if (!cw->propertyCache()) // this window is dead
continue;
if (cw->hasTransitioningWindow() && cw->propertyCache()->isDecorator())
// if we have a transition animation, don't draw the decorator
// lest we can have it drawn with the transition (especially
// when desktop window is not yet shown, NB#192454)
continue;
if (cw->group())
// items that belong to a group are drawn by the group
continue;
if (cw->isDirectRendered() || !cw->isVisible()
|| !(cw->propertyCache()->isMapped() || cw->isWindowTransitioning())
|| cw->propertyCache()->isInputOnly())
continue;
if (visible.isEmpty())
// nothing below is visible anymore
break;
}
// Ensure that intersects() still work, otherwise, painting a window
// is skipped when another window above it is scaled or moved to an
// area that exposed the lower window and causes an ugly flicker.
// r reflects the applied transformation and position of the window
QRegion r = cw->sceneTransform().map(cw->propertyCache()->shapeRegion());
// transitioning window can be smaller than shapeRegion(), so paint
// all transitioning windows
if (cw->isWindowTransitioning() || visible.intersects(r)
|| cw->type() == MCompositeWindowGroup::Type) {
if (size >= 9)
to_paint.resize(to_paint.size()+1);
to_paint[size++] = i;
if (cw->propertyCache()->windowTypeAtom()
== ATOM(_NET_WM_WINDOW_TYPE_DESKTOP))
desktop_painted = true;
}
// subtract opaque regions
if (!cw->isWindowTransitioning()
&& !cw->propertyCache()->hasAlpha()
&& cw->opacity() == 1.0
&& !cw->group()) // window is not renderered off-screen)
visible -= r;
}
if (size > 0) {
// paint from bottom to top so that blending works
for (int i = size - 1; i >= 0; --i) {
int item_i = to_paint[i];
MCompositeWindow *cw = (MCompositeWindow*)items[item_i];
painter->save();
if (!desktop_painted) {
if (cw->hasTransitioningWindow()) {
// clear rubbish from the root window during startup when
// desktop window does not exist and we show zoom animations
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
}
desktop_painted = true;
if (cw->propertyCache()->isDecorator()) {
// don't paint decorator on top of plain black background
// (see NB#182860, NB#192454)
painter->restore();
continue;
}
}
// TODO: paint only the intersected region (glScissor?)
painter->setMatrix(cw->sceneMatrix(), true);
cw->paint(painter, &options[item_i], widget);
painter->restore();
}
}
}
int ucrypto_ec_on_load(ErlNifEnv *env, void **priv_data, ERL_NIF_TERM load_info)
{
ec_key_resource = enif_open_resource_type(env, NULL, "ucrypto_ec_resource", &ec_key_handle_cleanup, (ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER), NULL);
ATOM(ATOM_OK, "ok");
ATOM(ATOM_ERROR, "error");
ATOM(ATOM_TRUE, "true");
ATOM(ATOM_FALSE, "false");
ATOM(ATOM_UNINITIALIZED_KEY, "uninitialized_key");
ATOM(ATOM_UNKNOWN_CURVE, "unknown_curve");
ATOM(ATOM_secp112r1, "secp112r1");
ATOM(ATOM_secp112r2, "secp112r2");
ATOM(ATOM_secp128r1, "secp128r1");
ATOM(ATOM_secp128r2, "secp128r2");
ATOM(ATOM_secp160k1, "secp160k1");
ATOM(ATOM_secp160r1, "secp160r1");
ATOM(ATOM_secp160r2, "secp160r2");
ATOM(ATOM_secp192k1, "secp192k1");
ATOM(ATOM_secp224k1, "secp224k1");
ATOM(ATOM_secp224r1, "secp224r1");
ATOM(ATOM_secp256k1, "secp256k1");
ATOM(ATOM_secp384r1, "secp384r1");
ATOM(ATOM_secp521r1, "secp521r1");
return 0;
}
/** Init ewmh atoms
*/
void
ewmh_init_hints(void)
{
int i = 1, s, j, showing_desk = 0;
char root_name[] = KWM_VERSION;
char class[] = "wmfs", st[64];
long pid = (long)getpid();
char systray_atom[48];
s = screen_count();
net_atom = xcalloc(net_last + s, sizeof(Atom));
/* EWMH hints */
net_atom[net_supported] = ATOM("_NET_SUPPORTED");
net_atom[net_client_list] = ATOM("_NET_CLIENT_LIST");
net_atom[net_frame_extents] = ATOM("_NET_FRAME_EXTENTS");
net_atom[net_number_of_desktops] = ATOM("_NET_NUMBER_OF_DESKTOPS");
net_atom[net_current_desktop] = ATOM("_NET_CURRENT_DESKTOP");
net_atom[net_desktop_names] = ATOM("_NET_DESKTOP_NAMES");
net_atom[net_desktop_geometry] = ATOM("_NET_DESKTOP_GEOMETRY");
net_atom[net_active_window] = ATOM("_NET_ACTIVE_WINDOW");
net_atom[net_close_window] = ATOM("_NET_CLOSE_WINDOW");
net_atom[net_wm_name] = ATOM("_NET_WM_NAME");
net_atom[net_wm_pid] = ATOM("_NET_WM_PID");
net_atom[net_wm_desktop] = ATOM("_NET_WM_DESKTOP");
net_atom[net_showing_desktop] = ATOM("_NET_SHOWING_DESKTOP");
net_atom[net_wm_icon_name] = ATOM("_NET_WM_ICON_NAME");
net_atom[net_wm_window_type] = ATOM("_NET_WM_WINDOW_TYPE");
net_atom[net_supporting_wm_check] = ATOM("_NET_SUPPORTING_WM_CHECK");
net_atom[net_wm_window_opacity] = ATOM("_NET_WM_WINDOW_OPACITY");
net_atom[net_wm_window_type_normal] = ATOM("_NET_WM_WINDOW_TYPE_NORMAL");
net_atom[net_wm_window_type_dock] = ATOM("_NET_WM_WINDOW_TYPE_DOCK");
net_atom[net_wm_window_type_splash] = ATOM("_NET_WM_WINDOW_TYPE_SPLASH");
net_atom[net_wm_window_type_dialog] = ATOM("_NET_WM_WINDOW_TYPE_DIALOG");
net_atom[net_wm_icon] = ATOM("_NET_WM_ICON");
net_atom[net_wm_state] = ATOM("_NET_WM_STATE");
net_atom[net_wm_state_fullscreen] = ATOM("_NET_WM_STATE_FULLSCREEN");
net_atom[net_wm_state_sticky] = ATOM("_NET_WM_STATE_STICKY");
net_atom[net_wm_state_demands_attention] = ATOM("_NET_WM_STATE_DEMANDS_ATTENTION");
net_atom[net_wm_system_tray_opcode] = ATOM("_NET_SYSTEM_TRAY_OPCODE");
net_atom[net_system_tray_message_data] = ATOM("_NET_SYSTEM_TRAY_MESSAGE_DATA");
net_atom[net_system_tray_visual] = ATOM("_NET_SYSTEM_TRAY_VISUAL");
snprintf(systray_atom, sizeof(systray_atom), "_NET_SYSTEM_TRAY_S%d", 0/*SCREEN*/);
net_atom[net_system_tray_s] = ATOM(systray_atom);
net_atom[net_system_tray_orientation] = ATOM("_NET_SYSTEM_TRAY_ORIENTATION");
net_atom[xembed] = ATOM("_XEMBED");
net_atom[xembedinfo] = ATOM("_XEMBED_INFO");
net_atom[manager] = ATOM("MANAGER");
net_atom[utf8_string] = ATOM("UTF8_STRING");
/* WMFS hints */
net_atom[wmfs_running] = ATOM("_WMFS_RUNNING");
net_atom[wmfs_update_hints] = ATOM("_WMFS_UPDATE_HINTS");
net_atom[wmfs_update_status] = ATOM("_WMFS_UPDATE_STATUS");
net_atom[wmfs_set_screen] = ATOM("_WMFS_SET_SCREEN");
net_atom[wmfs_screen_count] = ATOM("_WMFS_SCREEN_COUNT");
net_atom[wmfs_current_tag] = ATOM("_WMFS_CURRENT_TAG");
net_atom[wmfs_tag_list] = ATOM("_WMFS_TAG_LIST");
net_atom[wmfs_current_screen] = ATOM("_WMFS_CURRENT_SCREEN");
net_atom[wmfs_current_layout] = ATOM("_WMFS_CURRENT_LAYOUT");
net_atom[wmfs_mwfact] = ATOM("_WMFS_MWFACT");
net_atom[wmfs_nmaster] = ATOM("_WMFS_NMASTER");
net_atom[wmfs_function] = ATOM("_WMFS_FUNCTION");
net_atom[wmfs_cmd] = ATOM("_WMFS_CMD");
net_atom[wmfs_font] = ATOM("_WMFS_FONT");
/* Multi atom _WMFS_STATUSTEXT_<screennum> */
for(j = 0; j < s; ++j)
{
sprintf(st, "_WMFS_STATUSTEXT_%d", j);
net_atom[wmfs_statustext + j] = ATOM(st);
}
XChangeProperty(dpy, ROOT, net_atom[net_supported], XA_ATOM, 32,
PropModeReplace, (uchar*)net_atom, net_last + s);
XChangeProperty(dpy, ROOT, net_atom[wmfs_running], XA_CARDINAL, 32,
PropModeReplace, (uchar*)&i, 1);
/* Set _NET_SUPPORTING_WM_CHECK */
XChangeProperty(dpy, ROOT, net_atom[net_supporting_wm_check], XA_WINDOW, 32,
PropModeReplace, (uchar*)&ROOT, 1);
XChangeProperty(dpy, ROOT, net_atom[net_wm_name], net_atom[utf8_string], 8,
PropModeReplace, (uchar*)&root_name, strlen(root_name));
XChangeProperty(dpy, ROOT, ATOM("WM_CLASS"), XA_STRING, 8,
PropModeReplace, (uchar*)&class, strlen(class));
/* Set _NET_WM_PID */
XChangeProperty(dpy, ROOT, net_atom[net_wm_pid], XA_CARDINAL, 32,
PropModeReplace, (uchar*)&pid, 1);
/* Set _NET_SHOWING_DESKTOP */
XChangeProperty(dpy, ROOT, net_atom[net_showing_desktop], XA_CARDINAL, 32,
PropModeReplace, (uchar*)&showing_desk, 1);
return;
}
bool QEventDispatcherX11::processEvents(QEventLoop::ProcessEventsFlags flags)
{
Q_D(QEventDispatcherX11);
d->interrupt = false;
QApplication::sendPostedEvents();
ulong marker = XNextRequest(X11->display);
int nevents = 0;
do {
while (!d->interrupt) {
XEvent event;
if (!(flags & QEventLoop::ExcludeUserInputEvents)
&& !d->queuedUserInputEvents.isEmpty()) {
// process a pending user input event
event = d->queuedUserInputEvents.takeFirst();
} else if (XEventsQueued(X11->display, QueuedAlready)) {
// process events from the X server
XNextEvent(X11->display, &event);
if (flags & QEventLoop::ExcludeUserInputEvents) {
// queue user input events
switch (event.type) {
case ButtonPress:
case ButtonRelease:
case MotionNotify:
case XKeyPress:
case XKeyRelease:
case EnterNotify:
case LeaveNotify:
d->queuedUserInputEvents.append(event);
continue;
case ClientMessage:
// only keep the wm_take_focus and
// _qt_scrolldone protocols, queue all other
// client messages
if (event.xclient.format == 32) {
if (event.xclient.message_type == ATOM(WM_PROTOCOLS) &&
(Atom) event.xclient.data.l[0] == ATOM(WM_TAKE_FOCUS)) {
break;
} else if (event.xclient.message_type == ATOM(_QT_SCROLL_DONE)) {
break;
}
}
d->queuedUserInputEvents.append(event);
continue;
default:
break;
}
}
} else {
// no event to process
break;
}
// send through event filter
if (filterEvent(&event))
continue;
nevents++;
if (qApp->x11ProcessEvent(&event) == 1)
return true;
if (event.xany.serial >= marker) {
if (XEventsQueued(X11->display, QueuedAfterFlush))
flags &= ~QEventLoop::WaitForMoreEvents;
goto out;
}
}
} while (!d->interrupt && XEventsQueued(X11->display, QueuedAfterFlush));
out:
if (!d->interrupt) {
const uint exclude_all =
QEventLoop::ExcludeSocketNotifiers | QEventLoop::X11ExcludeTimers | QEventLoop::WaitForMoreEvents;
if (nevents > 0 && ((uint)flags & exclude_all) == exclude_all) {
QApplication::sendPostedEvents();
return nevents > 0;
}
// return true if we handled events, false otherwise
return QEventDispatcherUNIX::processEvents(flags) || (nevents > 0);
}
return nevents > 0;
}
void hook_destroy() {
// remove property from root window
XDeleteProperty(g_display, g_root, ATOM(HERBST_HOOK_WIN_ID_ATOM));
XDestroyWindow(g_display, g_event_window);
}
static bool Target_draw() {
return EventDispatcher_dispatchEvent(screenManager->eventDispatcher, ATOM(EVENT_DRAW), NULL);
}
static void Target_foregrounded() {
if (screenManager != NULL) {
EventDispatcher_dispatchEvent(screenManager->eventDispatcher, ATOM(EVENT_FOREGROUNDED), NULL);
}
}
return; \
} \
} \
break; \
#define ATOM_END_MK \
ATOM(Zero) \
ATOM(CRC32) \
ATOM(Void) \
ATOM_END
//Parsing
DATA_BEGIN
LIST(Ebml)
ATOM_BEGIN
ATOM(Ebml_Version)
ATOM(Ebml_ReadVersion)
ATOM(Ebml_MaxIDLength)
ATOM(Ebml_MaxSizeLength)
ATOM(Ebml_DocType)
ATOM(Ebml_DocTypeVersion)
ATOM(Ebml_DocTypeReadVersion)
ATOM_END_MK
LIST(Stream)
ATOM_BEGIN
ATOM(Stream_Header)
ATOM(Stream_ByteOffset)
ATOM(Stream_FrameNumber)
ATOM(Stream_Dts)
ATOM_END_MK
ATOM(CompressedIndex)
/*!
\fn void CSizeGrip::mousePressEvent(QMouseEvent * event)
Receives the mouse press events for the widget, and primes the
resize operation. The mouse press event is passed in the \a event
parameter.
*/
void CSizeGrip::mousePressEvent(QMouseEvent * e)
{
ungrabGesture(Qt::TapAndHoldGesture);
if (e->button() != Qt::LeftButton) {
QWidget::mousePressEvent(e);
return;
}
QWidget *tlw = qt_sizegrip_topLevelWidget();
p = e->globalPos();
gotMousePress = true;
r = tlw->geometry();
#ifdef Q_WS_X11
#if QT_VERSION >= 0x050000
// Use a native X11 sizegrip for "real" top-level windows if supported.
if (tlw->isWindow() && X11->isSupportedByWM(ATOM(_NET_WM_MOVERESIZE))
&& !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
&& !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = ATOM(_NET_WM_MOVERESIZE);
xev.xclient.display = X11->display;
xev.xclient.window = tlw->winId();
xev.xclient.format = 32;
xev.xclient.data.l[0] = e->globalPos().x();
xev.xclient.data.l[1] = e->globalPos().y();
if (atBottom())
xev.xclient.data.l[2] = atLeft() ? 6 : 4; // bottomleft/bottomright
else
xev.xclient.data.l[2] = atLeft() ? 0 : 2; // topleft/topright
xev.xclient.data.l[3] = Button1;
xev.xclient.data.l[4] = 0;
XUngrabPointer(X11->display, X11->time);
XSendEvent(X11->display, QX11Info::appRootWindow(x11Info().screen()), False,
SubstructureRedirectMask | SubstructureNotifyMask, &xev);
return;
}
#endif
#endif // Q_WS_X11
#ifdef Q_WS_WIN
#if QT_VERSION >= 0x050000
if (tlw->isWindow() && !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
uint orientation = 0;
if (atBottom())
orientation = atLeft() ? SZ_SIZEBOTTOMLEFT : SZ_SIZEBOTTOMRIGHT;
else
orientation = atLeft() ? SZ_SIZETOPLEFT : SZ_SIZETOPRIGHT;
ReleaseCapture();
PostMessage(tlw->winId(), WM_SYSCOMMAND, orientation, 0);
return;
}
#endif
#endif // Q_WS_WIN
// Find available desktop/workspace geometry.
QRect availableGeometry;
bool hasVerticalSizeConstraint = true;
bool hasHorizontalSizeConstraint = true;
if (tlw->isWindow())
availableGeometry = QApplication::desktop()->availableGeometry(tlw);
else {
const QWidget *tlwParent = tlw->parentWidget();
// Check if tlw is inside QAbstractScrollArea/QScrollArea.
// If that's the case tlw->parentWidget() will return the viewport
// and tlw->parentWidget()->parentWidget() will return the scroll area.
#ifndef QT_NO_SCROLLAREA
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(tlwParent->parentWidget());
if (scrollArea) {
hasHorizontalSizeConstraint = scrollArea->horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
hasVerticalSizeConstraint = scrollArea->verticalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
}
#endif // QT_NO_SCROLLAREA
availableGeometry = tlwParent->contentsRect();
}
// Find frame geometries, title bar height, and decoration sizes.
const QRect frameGeometry = tlw->frameGeometry();
const int titleBarHeight = qMax(tlw->geometry().y() - frameGeometry.y(), 0);
const int bottomDecoration = qMax(frameGeometry.height() - tlw->height() - titleBarHeight, 0);
const int leftRightDecoration = qMax((frameGeometry.width() - tlw->width()) / 2, 0);
// Determine dyMax depending on whether the sizegrip is at the bottom
// of the widget or not.
if (atBottom()) {
if (hasVerticalSizeConstraint)
dyMax = availableGeometry.bottom() - r.bottom() - bottomDecoration;
else
dyMax = INT_MAX;
} else {
if (hasVerticalSizeConstraint)
dyMax = availableGeometry.y() - r.y() + titleBarHeight;
else
dyMax = -INT_MAX;
}
// In RTL mode, the size grip is to the left; find dxMax from the desktop/workspace
// geometry, the size grip geometry and the width of the decoration.
if (atLeft()) {
if (hasHorizontalSizeConstraint)
dxMax = availableGeometry.x() - r.x() + leftRightDecoration;
else
dxMax = -INT_MAX;
} else {
if (hasHorizontalSizeConstraint)
dxMax = availableGeometry.right() - r.right() - leftRightDecoration;
else
dxMax = INT_MAX;
}
}
void QClipboard::setMimeData(QMimeData* src, Mode mode)
{
Atom atom, sentinel_atom;
QClipboardData *d;
switch (mode) {
case Selection:
atom = XA_PRIMARY;
sentinel_atom = ATOM(_QT_SELECTION_SENTINEL);
d = selectionData();
break;
case Clipboard:
atom = ATOM(CLIPBOARD);
sentinel_atom = ATOM(_QT_CLIPBOARD_SENTINEL);
d = clipboardData();
break;
default:
qWarning("QClipboard::setMimeData: unsupported mode '%d'", mode);
return;
}
Display *dpy = X11->display;
Window newOwner;
if (! src) { // no data, clear clipboard contents
newOwner = XNone;
d->clear();
} else {
setupOwner();
newOwner = owner->internalWinId();
d->setSource(src);
d->timestamp = X11->time;
}
Window prevOwner = XGetSelectionOwner(dpy, atom);
// use X11->time, since d->timestamp == CurrentTime when clearing
XSetSelectionOwner(dpy, atom, newOwner, X11->time);
if (mode == Selection)
emitChanged(QClipboard::Selection);
else
emitChanged(QClipboard::Clipboard);
if (XGetSelectionOwner(dpy, atom) != newOwner) {
qWarning("QClipboard::setData: Cannot set X11 selection owner for %s",
X11->xdndAtomToString(atom).data());
d->clear();
return;
}
// Signal to other Qt processes that the selection has changed
Window owners[2];
owners[0] = newOwner;
owners[1] = prevOwner;
XChangeProperty(dpy, QApplication::desktop()->screen(0)->internalWinId(),
sentinel_atom, XA_WINDOW, 32, PropModeReplace,
(unsigned char*)&owners, 2);
}
/*!
\fn void CSizeGrip::mouseMoveEvent(QMouseEvent * event)
Resizes the top-level widget containing this widget. The mouse
move event is passed in the \a event parameter.
*/
void CSizeGrip::mouseMoveEvent(QMouseEvent * e)
{
if (e->buttons() != Qt::LeftButton) {
QWidget::mouseMoveEvent(e);
return;
}
QWidget* tlw = qt_sizegrip_topLevelWidget();
if (!gotMousePress || tlw->testAttribute(Qt::WA_WState_ConfigPending))
return;
#ifdef Q_WS_X11
#if QT_VERSION >= 0x050000
if (tlw->isWindow() && X11->isSupportedByWM(ATOM(_NET_WM_MOVERESIZE))
&& tlw->isTopLevel() && !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
&& !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth())
return;
#endif
#endif
#ifdef Q_WS_WIN
#if QT_VERSION >= 0x050000
if (tlw->isWindow() && GetSystemMenu(tlw->winId(), FALSE) != 0 && internalWinId()
&& !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
MSG msg;
while(PeekMessage(&msg, winId(), WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE));
return;
}
#endif
#endif
QPoint np(e->globalPos());
// Don't extend beyond the available geometry; bound to dyMax and dxMax.
QSize ns;
if (atBottom())
ns.rheight() = r.height() + qMin(np.y() - p.y(), dyMax);
else
ns.rheight() = r.height() - qMax(np.y() - p.y(), dyMax);
if (atLeft())
ns.rwidth() = r.width() - qMax(np.x() - p.x(), dxMax);
else
ns.rwidth() = r.width() + qMin(np.x() - p.x(), dxMax);
ns = QLayout::closestAcceptableSize(tlw, ns);
QPoint p;
QRect nr(p, ns);
if (atBottom()) {
if (atLeft())
nr.moveTopRight(r.topRight());
else
nr.moveTopLeft(r.topLeft());
} else {
if (atLeft())
nr.moveBottomRight(r.bottomRight());
else
nr.moveBottomLeft(r.bottomLeft());
}
((CPObject*)tlw)->changeGeometrySize(nr.x(),nr.y(),nr.width(),nr.height());
}
bool QX11Data::clipboardReadProperty(Window win, Atom property, bool deleteProperty,
QByteArray *buffer, int *size, Atom *type, int *format)
{
int maxsize = maxSelectionIncr(display);
ulong bytes_left; // bytes_after
ulong length; // nitems
uchar *data;
Atom dummy_type;
int dummy_format;
int r;
if (!type) // allow null args
type = &dummy_type;
if (!format)
format = &dummy_format;
// Don't read anything, just get the size of the property data
r = XGetWindowProperty(display, win, property, 0, 0, False,
AnyPropertyType, type, format,
&length, &bytes_left, &data);
if (r != Success || (type && *type == XNone)) {
buffer->resize(0);
return false;
}
XFree((char*)data);
int offset = 0, buffer_offset = 0, format_inc = 1, proplen = bytes_left;
VDEBUG("QClipboard: read_property(): initial property length: %d", proplen);
switch (*format) {
case 8:
default:
format_inc = sizeof(char) / 1;
break;
case 16:
format_inc = sizeof(short) / 2;
proplen *= sizeof(short) / 2;
break;
case 32:
format_inc = sizeof(long) / 4;
proplen *= sizeof(long) / 4;
break;
}
int newSize = proplen;
buffer->resize(newSize);
bool ok = (buffer->size() == newSize);
VDEBUG("QClipboard: read_property(): buffer resized to %d", buffer->size());
if (ok && newSize) {
// could allocate buffer
while (bytes_left) {
// more to read...
r = XGetWindowProperty(display, win, property, offset, maxsize/4,
False, AnyPropertyType, type, format,
&length, &bytes_left, &data);
if (r != Success || (type && *type == XNone))
break;
offset += length / (32 / *format);
length *= format_inc * (*format) / 8;
// Here we check if we get a buffer overflow and tries to
// recover -- this shouldn't normally happen, but it doesn't
// hurt to be defensive
if ((int)(buffer_offset + length) > buffer->size()) {
length = buffer->size() - buffer_offset;
// escape loop
bytes_left = 0;
}
memcpy(buffer->data() + buffer_offset, data, length);
buffer_offset += length;
XFree((char*)data);
}
if (*format == 8 && *type == ATOM(COMPOUND_TEXT)) {
// convert COMPOUND_TEXT to a multibyte string
XTextProperty textprop;
textprop.encoding = *type;
textprop.format = *format;
textprop.nitems = buffer_offset;
textprop.value = (unsigned char *) buffer->data();
char **list_ret = 0;
int count;
if (XmbTextPropertyToTextList(display, &textprop, &list_ret,
&count) == Success && count && list_ret) {
offset = buffer_offset = strlen(list_ret[0]);
buffer->resize(offset);
memcpy(buffer->data(), list_ret[0], offset);
}
if (list_ret) XFreeStringList(list_ret);
}
}
// correct size, not 0-term.
if (size)
*size = buffer_offset;
VDEBUG("QClipboard: read_property(): buffer size %d, buffer offset %d, offset %d",
buffer->size(), buffer_offset, offset);
if (deleteProperty)
XDeleteProperty(display, win, property);
XFlush(display);
return ok;
}
static int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
ErlNifResourceFlags flags = (ErlNifResourceFlags)
(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER);
histogram_RESOURCE = enif_open_resource_type(env,
NULL,
"histogram_resource",
&histogram_resource_cleanup,
flags,
NULL);
meter_RESOURCE = enif_open_resource_type(env,
NULL,
"meter_resource",
&meter_resource_cleanup,
flags,
NULL);
// Initialize common atoms
ATOM(ATOM_OK, "ok");
ATOM(ATOM_ERROR, "error");
ATOM(ATOM_TRUE, "true");
ATOM(ATOM_FALSE, "false");
ATOM(ATOM_MIN, "min");
ATOM(ATOM_MAX, "max");
ATOM(ATOM_MEAN, "mean");
ATOM(ATOM_MEDIAN, "median");
ATOM(ATOM_COUNT, "count");
ATOM(ATOM_P50, "p50");
ATOM(ATOM_P95, "p95");
ATOM(ATOM_P99, "p99");
ATOM(ATOM_P999, "p999");
ATOM(ATOM_ONE, "one");
ATOM(ATOM_FIVE, "five");
ATOM(ATOM_FIFTEEN, "fifteen");
ATOM(ATOM_SIZE, "size");
ATOM(ATOM_WINDOW_WIDTH, "window_width");
ATOM(ATOM_STDDEV, "stddev");
ATOM(ATOM_TICK_INTERVAL, "tick_interval");
return 0;
}
static int qt_x_errhandler(Display *dpy, XErrorEvent *err)
{
qDebug() << "qt_x_errhandler" << err->error_code;
switch (err->error_code) {
case BadAtom:
#if 0
if (err->request_code == 20 /* X_GetProperty */
&& (err->resourceid == XA_RESOURCE_MANAGER
|| err->resourceid == XA_RGB_DEFAULT_MAP
|| err->resourceid == ATOM(_NET_SUPPORTED)
|| err->resourceid == ATOM(_NET_SUPPORTING_WM_CHECK)
|| err->resourceid == ATOM(KDE_FULL_SESSION)
|| err->resourceid == ATOM(KWIN_RUNNING)
|| err->resourceid == ATOM(XdndProxy)
|| err->resourceid == ATOM(XdndAware))
) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
#endif
qDebug() << "BadAtom";
break;
case BadWindow:
if (err->request_code == 2 /* X_ChangeWindowAttributes */
|| err->request_code == 38 /* X_QueryPointer */) {
for (int i = 0; i < ScreenCount(dpy); ++i) {
if (err->resourceid == RootWindow(dpy, i)) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
}
}
seen_badwindow = true;
if (err->request_code == 25 /* X_SendEvent */) {
for (int i = 0; i < ScreenCount(dpy); ++i) {
if (err->resourceid == RootWindow(dpy, i)) {
// Perhaps we're running under SECURITY reduction? :/
return 0;
}
}
#if 0
if (X11->xdndHandleBadwindow()) {
qDebug("xdndHandleBadwindow returned true");
return 0;
}
#endif
}
#if 0
if (X11->ignore_badwindow)
return 0;
#endif
break;
case BadMatch:
if (err->request_code == 42 /* X_SetInputFocus */)
return 0;
break;
default:
#if 0 //!defined(QT_NO_XINPUT)
if (err->request_code == X11->xinput_major
&& err->error_code == (X11->xinput_errorbase + XI_BadDevice)
&& err->minor_code == 3 /* X_OpenDevice */) {
return 0;
}
#endif
break;
}
char errstr[256];
XGetErrorText( dpy, err->error_code, errstr, 256 );
char buffer[256];
char request_str[256];
qsnprintf(buffer, 256, "%d", err->request_code);
XGetErrorDatabaseText(dpy, "XRequest", buffer, "", request_str, 256);
if (err->request_code < 128) {
// X error for a normal protocol request
qWarning( "X Error: %s %d\n"
" Major opcode: %d (%s)\n"
" Resource id: 0x%lx",
errstr, err->error_code,
err->request_code,
request_str,
err->resourceid );
} else {
// X error for an extension request
const char *extensionName = 0;
#if 0
if (err->request_code == X11->xrender_major)
extensionName = "RENDER";
else if (err->request_code == X11->xrandr_major)
extensionName = "RANDR";
else if (err->request_code == X11->xinput_major)
extensionName = "XInputExtension";
else if (err->request_code == X11->mitshm_major)
extensionName = "MIT-SHM";
#endif
char minor_str[256];
if (extensionName) {
qsnprintf(buffer, 256, "%s.%d", extensionName, err->minor_code);
XGetErrorDatabaseText(dpy, "XRequest", buffer, "", minor_str, 256);
} else {
extensionName = "Uknown extension";
qsnprintf(minor_str, 256, "Unknown request");
}
qWarning( "X Error: %s %d\n"
" Extension: %d (%s)\n"
" Minor opcode: %d (%s)\n"
" Resource id: 0x%lx",
errstr, err->error_code,
err->request_code,
extensionName,
err->minor_code,
minor_str,
err->resourceid );
}
// ### we really should distinguish between severe, non-severe and
// ### application specific errors
return 0;
}
QVariant QX11Data::motifdndObtainData(const char *mimeType)
{
QByteArray result;
if (Dnd_selection == 0 || !dropWidget)
return result;
// try to convert the selection to the requested property
// qDebug("trying to convert to '%s'", mimeType);
int n=0;
QByteArray f;
do {
f = motifdndFormat(n);
if (f.isEmpty())
return result;
n++;
} while(qstricmp(mimeType, f.data()));
Atom conversion_type = XNone;
if (f == "text/plain;charset=ISO-8859-1") {
conversion_type = XA_STRING;
} else if (f == "text/plain;charset=UTF-8") {
conversion_type = ATOM(UTF8_STRING);
} else if (f == (QByteArray("text/plain;charset=") + QTextCodec::codecForLocale()->name())) {
conversion_type = ATOM(COMPOUND_TEXT);
} else if (f == "text/plain") {
conversion_type = ATOM(TEXT);
} else if (f.startsWith("x-motif-dnd/")) {
// strip off the "x-motif-dnd/" prefix
conversion_type = X11->xdndStringToAtom(f.remove(0, 12));
}
if (XGetSelectionOwner(X11->display, Dnd_selection) == XNone) {
return result; // should never happen?
}
QWidget* tw = dropWidget;
if ((dropWidget->windowType() == Qt::Desktop)) {
tw = new QWidget;
}
// convert selection to the appropriate type
XConvertSelection (X11->display, Dnd_selection, conversion_type,
Dnd_selection, tw->internalWinId(), Dnd_selection_time);
XFlush(X11->display);
XEvent xevent;
bool got=X11->clipboardWaitForEvent(tw->internalWinId(), SelectionNotify, &xevent, 5000);
if (got) {
Atom type;
if (X11->clipboardReadProperty(tw->internalWinId(), Dnd_selection, true, &result, 0, &type, 0)) {
}
}
// we have to convert selection in order to indicate success to the initiator
XConvertSelection (X11->display, Dnd_selection, ATOM(XmTRANSFER_SUCCESS),
Dnd_selection, tw->internalWinId(), Dnd_selection_time);
// wait again for SelectionNotify event
X11->clipboardWaitForEvent(tw->internalWinId(), SelectionNotify, &xevent, 5000);
if ((dropWidget->windowType() == Qt::Desktop)) {
delete tw;
}
return result;
}
LispObj *
Lisp_PQgetvalue(LispBuiltin *builtin)
/*
pq-getvalue result tuple field &optional type-specifier
*/
{
char *string;
double real = 0.0;
PGresult *res;
int tuple, field, isint = 0, isreal = 0, integer;
LispObj *result, *otupple, *field_number, *type;
type = ARGUMENT(3);
field_number = ARGUMENT(2);
otupple = ARGUMENT(1);
result = ARGUMENT(0);
if (!CHECKO(result, PGresult_t))
LispDestroy("%s: cannot convert %s to PGresult*",
STRFUN(builtin), STROBJ(result));
res = (PGresult*)(result->data.opaque.data);
CHECK_INDEX(otupple);
tuple = FIXNUM_VALUE(otupple);
CHECK_INDEX(field_number);
field = FIXNUM_VALUE(field_number);
string = PQgetvalue(res, tuple, field);
if (type != UNSPEC) {
char *typestring;
CHECK_SYMBOL(type);
typestring = ATOMID(type);
if (strcmp(typestring, "INT16") == 0) {
integer = *(short*)string;
isint = 1;
goto simple_type;
}
else if (strcmp(typestring, "INT32") == 0) {
integer = *(int*)string;
isint = 1;
goto simple_type;
}
else if (strcmp(typestring, "FLOAT") == 0) {
real = *(float*)string;
isreal = 1;
goto simple_type;
}
else if (strcmp(typestring, "REAL") == 0) {
real = *(double*)string;
isreal = 1;
goto simple_type;
}
else if (strcmp(typestring, "PG-POLYGON") == 0)
goto polygon_type;
else if (strcmp(typestring, "STRING") != 0)
LispDestroy("%s: unknown type %s",
STRFUN(builtin), typestring);
}
simple_type:
return (isint ? INTEGER(integer) : isreal ? DFLOAT(real) :
(string ? STRING(string) : NIL));
polygon_type:
{
LispObj *poly, *box, *p = NIL, *cdr, *obj;
POLYGON *polygon;
int i, size;
size = PQgetlength(res, tuple, field);
polygon = (POLYGON*)(string - sizeof(int));
GCDisable();
/* get polygon->boundbox */
cdr = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->boundbox.high.x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->boundbox.high.y), NIL))))));
obj = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->boundbox.low.x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->boundbox.low.y), NIL))))));
box = EVAL(CONS(ATOM("MAKE-PG-BOX"),
CONS(KEYWORD("HIGH"),
CONS(cdr,
CONS(KEYWORD("LOW"),
CONS(obj, NIL))))));
/* get polygon->p values */
for (i = 0; i < polygon->npts; i++) {
obj = EVAL(CONS(ATOM("MAKE-PG-POINT"),
CONS(KEYWORD("X"),
CONS(REAL(polygon->p[i].x),
CONS(KEYWORD("Y"),
CONS(REAL(polygon->p[i].y), NIL))))));
if (i == 0)
p = cdr = CONS(obj, NIL);
else {
RPLACD(cdr, CONS(obj, NIL));
cdr = CDR(cdr);
}
}
/* make result */
poly = EVAL(CONS(ATOM("MAKE-PG-POLYGON"),
CONS(KEYWORD("SIZE"),
CONS(REAL(size),
CONS(KEYWORD("NUM-POINTS"),
CONS(REAL(polygon->npts),
CONS(KEYWORD("BOUNDBOX"),
CONS(box,
CONS(KEYWORD("POINTS"),
CONS(QUOTE(p), NIL))))))))));
GCEnable();
return (poly);
}
}
void QX11Data::motifdndHandle(QWidget *widget, const XEvent * xe, bool /* passive */)
{
XEvent event = *xe;
XClientMessageEvent cm ;
DndData dnd_data ;
char receiver ;
if (!(DndParseClientMessage ((XClientMessageEvent*)&event,
&dnd_data, &receiver))) {
return;
}
switch (dnd_data.reason) {
case DND_DRAG_MOTION:
{
QPoint p = widget->mapFromGlobal(QPoint(dnd_data.x, dnd_data.y));
QWidget *c = widget->childAt(p);
if (!c || !c->acceptDrops()) {
// not over a drop site
if (dropWidget) {
QDragLeaveEvent dragLeaveEvent;
QApplication::sendEvent(dropWidget, &dragLeaveEvent);
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
dnd_data.reason = DND_DROP_SITE_LEAVE;
dnd_data.time = X11->time;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
} else {
dnd_data.reason = DND_DRAG_MOTION;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.time = X11->time;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
}
} else {
Q_ASSERT(c != 0);
p = c->mapFrom(widget, p);
if (dropWidget != c) {
if (dropWidget) {
QDragLeaveEvent le;
QApplication::sendEvent(dropWidget, &le);
}
dropWidget = c;
lastAcceptedAction = Qt::IgnoreAction;
const Qt::DropActions possibleActions =
DndOperationsToQtDropActions(dnd_data.operations);
QDragEnterEvent de(p, possibleActions, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
QApplication::sendEvent(dropWidget, &de);
dnd_data.reason = DND_DROP_SITE_ENTER;
dnd_data.time = X11->time;
if (de.isAccepted()) {
lastAcceptedAction = de.dropAction();
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
} else {
dnd_data.status = DND_INVALID_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
} else {
const Qt::DropActions possibleActions =
DndOperationsToQtDropActions(dnd_data.operations);
QDragMoveEvent me(p, possibleActions, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
if (lastAcceptedAction != Qt::IgnoreAction) {
me.setDropAction(lastAcceptedAction);
me.accept();
}
QApplication::sendEvent(dropWidget, &me);
dnd_data.reason = DND_DRAG_MOTION;
dnd_data.time = X11->time;
if (me.isAccepted()) {
lastAcceptedAction = me.dropAction();
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
} else {
dnd_data.status = DND_INVALID_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
}
}
break;
}
case DND_TOP_LEVEL_ENTER:
{
/* get the size of our drop site for later use */
motifdnd_active = true;
sourceWindow = dnd_data.src_window;
/* no answer needed, just read source property */
DndReadSourceProperty (event.xclient.display,
sourceWindow,
dnd_data.property,
&src_targets, &num_src_targets);
break;
}
case DND_TOP_LEVEL_LEAVE:
{
XEvent nextEvent;
if (XCheckTypedWindowEvent(X11->display, widget->winId(), ClientMessage, &nextEvent)) {
// we just want to check, not eat (should use XPeekIfEvent)
XPutBackEvent(X11->display, &nextEvent);
if (DndParseClientMessage (&nextEvent.xclient, &dnd_data, &receiver)
&& dnd_data.reason == DND_DROP_START) {
// expecting drop next, keeping DnD alive
break;
}
}
// not expecting drop, need to send drag leave events and such here
if (dropWidget) {
QDragLeaveEvent le;
QApplication::sendEvent(dropWidget, &le);
}
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
motifdnd_active = false;
break;
}
case DND_OPERATION_CHANGED:
// ### need to echo
break;
case DND_DROP_START:
{
Q_ASSERT(motifdnd_active);
Q_ASSERT(sourceWindow == dnd_data.src_window);
if (!dropWidget || lastAcceptedAction == Qt::IgnoreAction) {
// echo DROP_START
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
// we have to convert selection in order to indicate failure to the initiator
XConvertSelection (X11->display, dnd_data.property, ATOM(XmTRANSFER_FAILURE),
dnd_data.property, dnd_data.src_window, dnd_data.time);
if (dropWidget) {
QDragLeaveEvent e;
QApplication::sendEvent(dropWidget, &e);
}
motifdnd_active = false;
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
return;
}
// store selection and its time
Dnd_selection = dnd_data.property;
Dnd_selection_time = dnd_data.time;
QPoint p(dnd_data.x, dnd_data.y);
QDropEvent de(dropWidget->mapFromGlobal(p), Qt::CopyAction, QDragManager::self()->dropData,
QApplication::mouseButtons(), QApplication::keyboardModifiers());
if (lastAcceptedAction != Qt::IgnoreAction) {
de.setDropAction(lastAcceptedAction);
de.accept();
}
QApplication::sendEvent(dropWidget, &de);
// reset
Dnd_selection = XNone;
Dnd_selection_time = 0;
// echo DROP_START depending on the result of the dropEvent
if (de.isAccepted()) {
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_VALID_DROP_SITE;
dnd_data.operation = QtDropActionToDndOperation(de.dropAction());
} else {
dnd_data.reason = DND_DROP_START;
dnd_data.status = DND_NO_DROP_SITE;
dnd_data.operation = DND_NOOP;
dnd_data.operations = DND_NOOP;
}
DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
sourceWindow = XNone;
dropWidget = 0;
lastAcceptedAction = Qt::IgnoreAction;
motifdnd_active = false;
break;
}
default:
break;
} // end of switch (dnd_data.reason)
}
void ObjectPropertyAssertion(std::string relation, std::string subject,
std::string object) {
predCache.ObjectPropertyAssertion(ATOM(relation), ATOM(subject),
ATOM(object));
}
UNLOCK();
return discarded == 0 ? TRUE : FALSE;
}
/*******************************
* BUILT-IN ATOM TABLE *
*******************************/
#define ATOM(s) s
typedef const char * ccharp;
static const ccharp atoms[] = {
#include "pl-atom.ic"
ATOM((char *)NULL)
};
#undef ATOM
#ifdef O_PLMT
#define acquire_atom_table(t, b) \
{ LD->thread.info->atom_table = atomTable; \
t = LD->thread.info->atom_table->table; \
b = LD->thread.info->atom_table->buckets; \
}
#define release_atom_table() \
{ LD->thread.info->atom_table = NULL; \
LD->thread.info->atom_bucket = NULL; \
}
static DndTargetsTable TargetsTable(Display *display)
{
Atom type;
int format;
unsigned long size;
unsigned long bytes_after;
Window motif_window = MotifWindow(display) ;
unsigned char *retval;
DndTargetsTable targets_table ;
int i,j ;
char * target_data ;
/* this version does no caching, so it's slow: round trip each time */
/* ideally, register for property notify on this target_list
atom and update when necessary only */
if ((XGetWindowProperty (display, motif_window,
ATOM(_MOTIF_DRAG_TARGETS), 0L, 100000L,
False, ATOM(_MOTIF_DRAG_TARGETS),
&type, &format, &size, &bytes_after,
&retval) != Success) ||
type == XNone) {
qWarning("QMotifDND: Cannot get property on Motif window");
return 0;
}
DndTargets * target_prop = (DndTargets *)retval;
if (target_prop->protocol_version != DND_PROTOCOL_VERSION) {
qWarning("QMotifDND: Protocol mismatch");
}
if (target_prop->byte_order != DndByteOrder()) {
/* need to swap num_target_lists and size */
SWAP2BYTES(target_prop->num_target_lists);
SWAP4BYTES(target_prop->data_size);
}
/* now parse DndTarget prop data in a TargetsTable */
targets_table = (DndTargetsTable)malloc(sizeof(DndTargetsTableRec));
targets_table->num_entries = target_prop->num_target_lists ;
targets_table->entries = (DndTargetsTableEntry)
malloc(sizeof(DndTargetsTableEntryRec) * target_prop->num_target_lists);
target_data = (char*)target_prop + sizeof(*target_prop) ;
for (i = 0 ; i < targets_table->num_entries; i++) {
CARD16 num_targets ;
CARD32 atom ;
memcpy(&num_targets, target_data, 2);
target_data += 2;
/* potential swap needed here */
if (target_prop->byte_order != DndByteOrder())
SWAP2BYTES(num_targets);
targets_table->entries[i].num_targets = num_targets ;
targets_table->entries[i].targets = (Atom *)
malloc(sizeof(Atom) * targets_table->entries[i].num_targets);
for (j = 0; j < num_targets; j++) {
memcpy(&atom, target_data, 4);
target_data += 4;
/* another potential swap needed here */
if (target_prop->byte_order != DndByteOrder())
SWAP4BYTES(atom);
targets_table->entries[i].targets[j] = (Atom) atom ;
}
}
if (target_prop) {
XFree((char *)target_prop);
}
return targets_table ;
}
/** Scan if there are windows on X
* for manage it
*/
static void
scan(void)
{
uint n;
XWindowAttributes wa;
Window usl, usl2, *w = NULL;
Atom rt;
int s, rf, tag = -1, screen = -1, free = -1, i;
ulong ir, il;
uchar *ret;
Client *c;
s = screen_count();
if(XQueryTree(dpy, ROOT, &usl, &usl2, &w, &n))
for(i = n - 1; i != -1; --i)
{
XGetWindowAttributes(dpy, w[i], &wa);
if(!wa.override_redirect && wa.map_state == IsViewable)
{
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_TAG"), 0, 32,
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
{
tag = *ret;
XFree(ret);
}
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_SCREEN"), 0, 32,
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
{
screen = *ret;
XFree(ret);
}
if(XGetWindowProperty(dpy, w[i], ATOM("_WMFS_ISFREE"), 0, 32,
False, XA_CARDINAL, &rt, &rf, &ir, &il, &ret) == Success && ret)
{
free = *ret;
XFree(ret);
}
c = client_manage(w[i], &wa, False);
if(tag != -1 && tag != MAXTAG + 1)
c->tag = tag;
if(screen != -1 && screen <= s - 1)
c->screen = screen;
if(free != -1)
c->flags |= (free) ? FreeFlag : 0;
client_update_attributes(c);
}
}
/* Set update layout request */
for(c = clients; c; c = c->next)
{
if(c->tag > (uint)conf.ntag[c->screen])
c->tag = conf.ntag[c->screen];
tags[c->screen][c->tag].request_update = True;
}
for(i = 0; i < s; ++i)
arrange(i, True);
XFree(w);
return;
}