ActionBase::ResultE ShaderShadowMapEngine::runOnEnter(
Light *light, LightTypeE eType, RenderAction *ract)
{
BitVector bvMask = ract->getPassMask ( );
SSMEngineData *data = ract->getData<SSMEngineData *>(_iDataSlotId);
if(data == NULL)
{
SSMEngineDataUnrecPtr newData = SSMEngineData::createLocal();
this->setData(newData, _iDataSlotId, ract);
data = newData;
}
if(0x0000 != bvMask)
{
// already generating a shadow map for another light source
if(0x0000 != (bvMask & bvLightPassMask))
{
this->recurseFrom(ract, light);
handleEnter(light, eType, ract, data);
}
}
else
{
// first light source to generate a shadow map
ract->addPassMask(bvLightPassMask);
handleEnter(light, eType, ract, data);
ract->subPassMask(bvLightPassMask);
}
// continue rendering normally
return Action::Continue;
}
ActionBase::ResultE TrapezoidalShadowMapEngine::runOnEnter(
Light *light, LightTypeE eType, RenderAction *ract)
{
BitVector passMask = ract->getPassMask ( );
TSMEngineData *data = ract->getData<TSMEngineData *>(_iDataSlotId);
if(data == NULL)
{
TSMEngineDataUnrecPtr newData = TSMEngineData::createLocal();
this->setData(newData, _iDataSlotId, ract);
data = newData;
}
if(passMask != 0x0000)
{
// already generating a shadow map for another light source?
if((passMask & bvLightPassMask) != 0x0000)
{
this->recurseFrom(ract, light);
handleEnter(light, eType, ract, data);
}
}
else
{
ract->addPassMask(bvLightPassMask);
handleEnter(light, eType, ract, data);
ract->subPassMask(bvLightPassMask);
}
return Action::Continue;
}
void Console::keyPressEvent(QKeyEvent *e) {
// locked State: a command has been submitted but no result
// has been received yet.
if (locked) return;
switch (e->key()) {
case Qt::Key_Return:
handleEnter();
break;
case Qt::Key_Backspace:
handleLeft(e);
break;
case Qt::Key_Up:
handleHistoryUp();
break;
case Qt::Key_Down:
handleHistoryDown();
break;
case Qt::Key_Left:
handleLeft(e);
break;
case Qt::Key_Home:
handleHome();
break;
default:
QPlainTextEdit::keyPressEvent(e);
break;
}
}
bool FormGadget::handleEvent(EventType& event)
{
bool handled=false;
switch (event.eType)
{
case frmGadgetEnterEvent:
handled=handleEnter(event);
break;
case frmGadgetMiscEvent:
handled=handleMiscEvent(event);
break;
}
return handled;
}
void QXcbDrag::move(const QMouseEvent *me)
{
// The mouse event is in the coordinate system of the window that started the drag.
// We do not know which window that was at this point, so we just use the device pixel ratio
// of the QGuiApplication. This will break once we support screens with different DPR. Fixing
// this properly requires some redesign of the drag and drop architecture.
static const int dpr = int(qApp->devicePixelRatio());
QBasicDrag::move(me);
QPoint globalPos = me->globalPos();
if (source_sameanswer.contains(globalPos) && source_sameanswer.isValid())
return;
const QList<QXcbScreen *> &screens = connection()->screens();
QXcbScreen *screen = connection()->primaryScreen();
for (int i = 0; i < screens.size(); ++i) {
if (screens.at(i)->geometry().contains(globalPos)) {
screen = screens.at(i);
break;
}
}
if (screen != current_screen) {
// ### need to recreate the shaped pixmap window?
// int screen = QCursor::x11Screen();
// if ((qt_xdnd_current_screen == -1 && screen != X11->defaultScreen) || (screen != qt_xdnd_current_screen)) {
// // recreate the pixmap on the new screen...
// delete xdnd_data.deco;
// QWidget* parent = object->source()->window()->x11Info().screen() == screen
// ? object->source()->window() : QApplication::desktop()->screen(screen);
// xdnd_data.deco = new QShapedPixmapWidget(parent);
// if (!QWidget::mouseGrabber()) {
// updatePixmap();
// xdnd_data.deco->grabMouse();
// }
// }
// xdnd_data.deco->move(QCursor::pos() - xdnd_data.deco->pm_hot);
current_screen = screen;
}
// qt_xdnd_current_screen = screen;
xcb_window_t rootwin = current_screen->root();
xcb_translate_coordinates_reply_t *translate =
::translateCoordinates(connection(), rootwin, rootwin, globalPos.x() * dpr, globalPos.y() * dpr);
if (!translate)
return;
xcb_window_t target = translate->child;
int lx = translate->dst_x;
int ly = translate->dst_y;
free (translate);
if (target && target != rootwin) {
xcb_window_t src = rootwin;
while (target != 0) {
DNDDEBUG << "checking target for XdndAware" << target << lx << ly;
// translate coordinates
translate = ::translateCoordinates(connection(), src, target, lx, ly);
if (!translate) {
target = 0;
break;
}
lx = translate->dst_x;
ly = translate->dst_y;
src = target;
xcb_window_t child = translate->child;
free(translate);
// check if it has XdndAware
xcb_get_property_cookie_t cookie = Q_XCB_CALL(xcb_get_property(xcb_connection(), false, target,
atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 0));
xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
bool aware = reply && reply->type != XCB_NONE;
free(reply);
if (aware) {
DNDDEBUG << "Found XdndAware on " << target;
break;
}
target = child;
}
if (!target || target == shapedPixmapWindow()->handle()->winId()) {
DNDDEBUG << "need to find real window";
target = findRealWindow(globalPos, rootwin, 6, true);
if (target == 0)
target = findRealWindow(globalPos, rootwin, 6, false);
DNDDEBUG << "real window found" << target;
}
}
QXcbWindow *w = 0;
if (target) {
w = connection()->platformWindowFromId(target);
if (w && (w->window()->type() == Qt::Desktop) /*&& !w->acceptDrops()*/)
w = 0;
} else {
w = 0;
target = rootwin;
}
xcb_window_t proxy_target = xdndProxy(connection(), target);
if (!proxy_target)
proxy_target = target;
int target_version = 1;
if (proxy_target) {
xcb_get_property_cookie_t cookie = xcb_get_property(xcb_connection(), false, proxy_target,
atom(QXcbAtom::XdndAware), XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
xcb_get_property_reply_t *reply = xcb_get_property_reply(xcb_connection(), cookie, 0);
if (!reply || reply->type == XCB_NONE)
target = 0;
target_version = *(uint32_t *)xcb_get_property_value(reply);
target_version = qMin(xdnd_version, target_version ? target_version : 1);
free(reply);
}
if (target != current_target) {
if (current_target)
send_leave();
current_target = target;
current_proxy_target = proxy_target;
if (target) {
int flags = target_version << 24;
if (drag_types.size() > 3)
flags |= 0x0001;
xcb_client_message_event_t enter;
enter.response_type = XCB_CLIENT_MESSAGE;
enter.window = target;
enter.format = 32;
enter.type = atom(QXcbAtom::XdndEnter);
enter.data.data32[0] = connection()->clipboard()->owner();
enter.data.data32[1] = flags;
enter.data.data32[2] = drag_types.size()>0 ? drag_types.at(0) : 0;
enter.data.data32[3] = drag_types.size()>1 ? drag_types.at(1) : 0;
enter.data.data32[4] = drag_types.size()>2 ? drag_types.at(2) : 0;
// provisionally set the rectangle to 5x5 pixels...
source_sameanswer = QRect(globalPos.x() - 2, globalPos.y() -2 , 5, 5);
DEBUG() << "sending Xdnd enter source=" << enter.data.data32[0];
if (w)
handleEnter(w->window(), &enter);
else if (target)
xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&enter);
waiting_for_status = false;
}
}
if (waiting_for_status)
return;
if (target) {
waiting_for_status = true;
xcb_client_message_event_t move;
move.response_type = XCB_CLIENT_MESSAGE;
move.window = target;
move.format = 32;
move.type = atom(QXcbAtom::XdndPosition);
move.data.data32[0] = connection()->clipboard()->owner();
move.data.data32[1] = 0; // flags
move.data.data32[2] = (globalPos.x() * dpr << 16) + globalPos.y() * dpr;
move.data.data32[3] = connection()->time();
move.data.data32[4] = toXdndAction(defaultAction(currentDrag()->supportedActions(), QGuiApplication::keyboardModifiers()));
DEBUG() << "sending Xdnd position source=" << move.data.data32[0] << "target=" << move.window;
source_time = connection()->time();
if (w)
handle_xdnd_position(w->window(), &move);
else
xcb_send_event(xcb_connection(), false, proxy_target, XCB_EVENT_MASK_NO_EVENT, (const char *)&move);
}
}
void XWaylandManager::wmEvents()
{
// Uncomment if you want to be flooded by messages
//qCDebug(XWAYLAND_TRACE) << "WM event";
xcb_generic_event_t *event;
while ((event = xcb_poll_for_event(Xcb::connection()))) {
//handle selection event
//handle dnd event
int type = event->response_type & ~0x80;
switch (type) {
case XCB_BUTTON_PRESS:
case XCB_BUTTON_RELEASE:
handleButton((xcb_button_press_event_t *)event);
break;
case XCB_ENTER_NOTIFY:
handleEnter((xcb_enter_notify_event_t *)event);
break;
case XCB_LEAVE_NOTIFY:
handleLeave((xcb_leave_notify_event_t *)event);
break;
case XCB_MOTION_NOTIFY:
handleMotion((xcb_motion_notify_event_t *)event);
break;
case XCB_CREATE_NOTIFY:
handleCreateNotify((xcb_create_notify_event_t *)event);
break;
case XCB_MAP_REQUEST:
handleMapRequest((xcb_map_request_event_t *)event);
break;
case XCB_MAP_NOTIFY:
handleMapNotify((xcb_map_notify_event_t *)event);
break;
case XCB_UNMAP_NOTIFY:
handleUnmapNotify((xcb_unmap_notify_event_t *)event);
break;
case XCB_REPARENT_NOTIFY:
handleReparentNotify((xcb_reparent_notify_event_t *)event);
break;
case XCB_CONFIGURE_REQUEST:
handleConfigureRequest((xcb_configure_request_event_t *)event);
break;
case XCB_CONFIGURE_NOTIFY:
handleConfigureNotify((xcb_configure_notify_event_t *)event);
break;
case XCB_DESTROY_NOTIFY:
handleDestroyNotify((xcb_destroy_notify_event_t *)event);
break;
case XCB_MAPPING_NOTIFY:
break;
case XCB_PROPERTY_NOTIFY:
handlePropertyNotify((xcb_property_notify_event_t *)event);
break;
case XCB_CLIENT_MESSAGE:
handleClientMessage((xcb_client_message_event_t *)event);
break;
default:
break;
}
free(event);
}
xcb_flush(Xcb::connection());
}
