diff --git a/src/lib/deskflow/IPrimaryScreen.h b/src/lib/deskflow/IPrimaryScreen.h index 3f10ac521..d1754daa3 100644 --- a/src/lib/deskflow/IPrimaryScreen.h +++ b/src/lib/deskflow/IPrimaryScreen.h @@ -79,7 +79,7 @@ public: //! Update configuration /*! This is called when the configuration has changed. \c activeSides - is a bitmask of EDirectionMask indicating which sides of the + is a bitmask of DirectionMask indicating which sides of the primary screen are linked to clients. Override to handle the possible change in jump zones. */ diff --git a/src/lib/deskflow/ProtocolTypes.h b/src/lib/deskflow/ProtocolTypes.h index e631b2b65..1d3369eb1 100644 --- a/src/lib/deskflow/ProtocolTypes.h +++ b/src/lib/deskflow/ProtocolTypes.h @@ -158,16 +158,16 @@ static constexpr uint32_t PROTOCOL_MAX_STRING_LENGTH = 1024 * 1024; * * @since Protocol version 1.0 */ -enum EDirection +enum class Direction : uint8_t { - kNoDirection, ///< No specific direction - kLeft, ///< Left edge of screen - kRight, ///< Right edge of screen - kTop, ///< Top edge of screen - kBottom, ///< Bottom edge of screen - kFirstDirection = kLeft, ///< First valid direction value - kLastDirection = kBottom, ///< Last valid direction value - kNumDirections = kLastDirection - kFirstDirection + 1 ///< Total number of directions + NoDirection, ///< No specific direction + Left, ///< Left edge of screen + Right, ///< Right edge of screen + Top, ///< Top edge of screen + Bottom, ///< Bottom edge of screen + FirstDirection = Direction::Left, ///< First valid direction value + LastDirection = Direction::Bottom, ///< Last valid direction value + NumDirections = Direction::LastDirection - Direction::FirstDirection + 1 ///< Total number of directions }; /** @@ -180,11 +180,11 @@ enum EDirection */ enum class DirectionMask { - NoDirMask = 0, ///< No direction mask - LeftMask = 1 << kLeft, ///< Left edge mask - RightMask = 1 << kRight, ///< Right edge mask - TopMask = 1 << kTop, ///< Top edge mask - BottomMask = 1 << kBottom ///< Bottom edge mask + NoDirMask = 0, ///< No direction mask + LeftMask = 1 << static_cast(Direction::Left), ///< Left edge mask + RightMask = 1 << static_cast(Direction::Right), ///< Right edge mask + TopMask = 1 << static_cast(Direction::Top), ///< Top edge mask + BottomMask = 1 << static_cast(Direction::Bottom) ///< Bottom edge mask }; /** diff --git a/src/lib/deskflow/Screen.h b/src/lib/deskflow/Screen.h index 79c586089..8859e851c 100644 --- a/src/lib/deskflow/Screen.h +++ b/src/lib/deskflow/Screen.h @@ -71,7 +71,7 @@ public: //! Update configuration /*! This is called when the configuration has changed. \c activeSides - is a bitmask of EDirectionMask indicating which sides of the + is a bitmask of DirectionMask indicating which sides of the primary screen are linked to clients. */ void reconfigure(uint32_t activeSides); diff --git a/src/lib/server/Config.cpp b/src/lib/server/Config.cpp index 31676f45e..400ee2ad2 100644 --- a/src/lib/server/Config.cpp +++ b/src/lib/server/Config.cpp @@ -197,11 +197,11 @@ void Config::removeAllAliases() } bool Config::connect( - const std::string &srcName, EDirection srcSide, float srcStart, float srcEnd, const std::string &dstName, + const std::string &srcName, Direction srcSide, float srcStart, float srcEnd, const std::string &dstName, float dstStart, float dstEnd ) { - assert(srcSide >= kFirstDirection && srcSide <= kLastDirection); + assert(srcSide >= Direction::FirstDirection && srcSide <= Direction::LastDirection); // find source cell CellMap::iterator index = m_map.find(getCanonicalName(srcName)); @@ -215,9 +215,9 @@ bool Config::connect( return index->second.add(srcEdge, dstEdge); } -bool Config::disconnect(const std::string &srcName, EDirection srcSide) +bool Config::disconnect(const std::string &srcName, Direction srcSide) { - assert(srcSide >= kFirstDirection && srcSide <= kLastDirection); + assert(srcSide >= Direction::FirstDirection && srcSide <= Direction::LastDirection); // find source cell CellMap::iterator index = m_map.find(srcName); @@ -231,9 +231,9 @@ bool Config::disconnect(const std::string &srcName, EDirection srcSide) return true; } -bool Config::disconnect(const std::string &srcName, EDirection srcSide, float position) +bool Config::disconnect(const std::string &srcName, Direction srcSide, float position) { - assert(srcSide >= kFirstDirection && srcSide <= kLastDirection); + assert(srcSide >= Direction::FirstDirection && srcSide <= Direction::LastDirection); // find source cell CellMap::iterator index = m_map.find(srcName); @@ -405,10 +405,9 @@ std::string Config::getCanonicalName(const std::string &name) const } } -std::string -Config::getNeighbor(const std::string &srcName, EDirection srcSide, float position, float *positionOut) const +std::string Config::getNeighbor(const std::string &srcName, Direction srcSide, float position, float *positionOut) const { - assert(srcSide >= kFirstDirection && srcSide <= kLastDirection); + assert(srcSide >= Direction::FirstDirection && srcSide <= Direction::LastDirection); // find source cell CellMap::const_iterator index = m_map.find(getCanonicalName(srcName)); @@ -433,14 +432,14 @@ Config::getNeighbor(const std::string &srcName, EDirection srcSide, float positi } } -bool Config::hasNeighbor(const std::string &srcName, EDirection srcSide) const +bool Config::hasNeighbor(const std::string &srcName, Direction srcSide) const { return hasNeighbor(srcName, srcSide, 0.0f, 1.0f); } -bool Config::hasNeighbor(const std::string &srcName, EDirection srcSide, float start, float end) const +bool Config::hasNeighbor(const std::string &srcName, Direction srcSide, float start, float end) const { - assert(srcSide >= kFirstDirection && srcSide <= kLastDirection); + assert(srcSide >= Direction::FirstDirection && srcSide <= Direction::LastDirection); // find source cell CellMap::const_iterator index = m_map.find(getCanonicalName(srcName)); @@ -556,13 +555,13 @@ void Config::read(ConfigReadContext &context) *this = tmp; } -const char *Config::dirName(EDirection dir) +const char *Config::dirName(Direction dir) { static const char *s_name[] = {"left", "right", "up", "down"}; - assert(dir >= kFirstDirection && dir <= kLastDirection); + assert(dir >= Direction::FirstDirection && dir <= Direction::LastDirection); - return s_name[dir - kFirstDirection]; + return s_name[static_cast(dir) - static_cast(Direction::FirstDirection)]; } InputFilter *Config::getInputFilter() @@ -855,15 +854,16 @@ void Config::readSectionLinks(ConfigReadContext &s) Interval dstInterval(s.parseInterval(dstArgs)); // handle argument - EDirection dir; + using enum Direction; + Direction dir; if (side == "left") { - dir = kLeft; + dir = Left; } else if (side == "right") { - dir = kRight; + dir = Right; } else if (side == "up") { - dir = kTop; + dir = Top; } else if (side == "down") { - dir = kBottom; + dir = Bottom; } else { // unknown argument throw XConfigRead(s, "unknown side \"%{1}\" in link", side); @@ -1048,15 +1048,16 @@ void Config::parseAction( throw XConfigRead(s, "syntax for action: switchInDirection()"); } - EDirection direction; + Direction direction; + using enum Direction; if (args[0] == "left") { - direction = kLeft; + direction = Left; } else if (args[0] == "right") { - direction = kRight; + direction = Right; } else if (args[0] == "up") { - direction = kTop; + direction = Top; } else if (args[0] == "down") { - direction = kBottom; + direction = Bottom; } else { throw XConfigRead(s, "unknown direction \"%{1}\" in switchToScreen", args[0]); } @@ -1343,12 +1344,12 @@ bool Config::Name::operator==(const std::string &name) const // Config::CellEdge // -Config::CellEdge::CellEdge(EDirection side, float position) +Config::CellEdge::CellEdge(Direction side, float position) { init("", side, Interval(position, position)); } -Config::CellEdge::CellEdge(EDirection side, const Interval &interval) +Config::CellEdge::CellEdge(Direction side, const Interval &interval) { assert(interval.first >= 0.0f); assert(interval.second <= 1.0f); @@ -1357,7 +1358,7 @@ Config::CellEdge::CellEdge(EDirection side, const Interval &interval) init("", side, interval); } -Config::CellEdge::CellEdge(const std::string &name, EDirection side, const Interval &interval) +Config::CellEdge::CellEdge(const std::string &name, Direction side, const Interval &interval) { assert(interval.first >= 0.0f); assert(interval.second <= 1.0f); @@ -1366,9 +1367,9 @@ Config::CellEdge::CellEdge(const std::string &name, EDirection side, const Inter init(name, side, interval); } -void Config::CellEdge::init(const std::string_view &name, EDirection side, const Interval &interval) +void Config::CellEdge::init(const std::string_view &name, Direction side, const Interval &interval) { - assert(side != kNoDirection); + assert(side != Direction::NoDirection); m_name = name; m_side = side; @@ -1390,7 +1391,7 @@ std::string Config::CellEdge::getName() const return m_name; } -EDirection Config::CellEdge::getSide() const +Direction Config::CellEdge::getSide() const { return m_side; } @@ -1459,7 +1460,7 @@ bool Config::Cell::add(const CellEdge &src, const CellEdge &dst) return true; } -void Config::Cell::remove(EDirection side) +void Config::Cell::remove(Direction side) { for (auto j = m_neighbors.begin(); j != m_neighbors.end();) { if (j->first.getSide() == side) { @@ -1470,7 +1471,7 @@ void Config::Cell::remove(EDirection side) } } -void Config::Cell::remove(EDirection side, float position) +void Config::Cell::remove(Direction side, float position) { for (auto j = m_neighbors.begin(); j != m_neighbors.end(); ++j) { if (j->first.getSide() == side && j->first.isInside(position)) { @@ -1517,7 +1518,7 @@ bool Config::Cell::overlaps(const CellEdge &edge) const return false; } -bool Config::Cell::getLink(EDirection side, float position, const CellEdge *&src, const CellEdge *&dst) const +bool Config::Cell::getLink(Direction side, float position, const CellEdge *&src, const CellEdge *&dst) const { CellEdge edge(side, position); EdgeLinks::const_iterator i = m_neighbors.upper_bound(edge); diff --git a/src/lib/server/Config.h b/src/lib/server/Config.h index 8bd0abc83..2587d40ef 100644 --- a/src/lib/server/Config.h +++ b/src/lib/server/Config.h @@ -58,15 +58,15 @@ public: class CellEdge { public: - CellEdge(EDirection side, float position); - CellEdge(EDirection side, const Interval &); - CellEdge(const std::string &name, EDirection side, const Interval &); + CellEdge(Direction side, float position); + CellEdge(Direction side, const Interval &); + CellEdge(const std::string &name, Direction side, const Interval &); ~CellEdge() = default; Interval getInterval() const; void setName(const std::string_view &newName); std::string getName() const; - EDirection getSide() const; + Direction getSide() const; bool overlaps(const CellEdge &) const; bool isInside(float x) const; @@ -84,11 +84,11 @@ public: bool operator!=(const CellEdge &) const; private: - void init(const std::string_view &name, EDirection side, const Interval &); + void init(const std::string_view &name, Direction side, const Interval &); private: std::string m_name; - EDirection m_side; + Direction m_side; Interval m_interval; }; @@ -114,15 +114,15 @@ private: using const_iterator = EdgeLinks::const_iterator; bool add(const CellEdge &src, const CellEdge &dst); - void remove(EDirection side); - void remove(EDirection side, float position); + void remove(Direction side); + void remove(Direction side, float position); void remove(const Name &destinationName); void rename(const Name &oldName, const std::string &newName); bool hasEdge(const CellEdge &) const; bool overlaps(const CellEdge &) const; - bool getLink(EDirection side, float position, const CellEdge *&src, const CellEdge *&dst) const; + bool getLink(Direction side, float position, const CellEdge *&src, const CellEdge *&dst) const; bool operator==(const Cell &) const; bool operator!=(const Cell &) const; @@ -278,7 +278,7 @@ public: be inside the range [0,1]. */ bool connect( - const std::string &srcName, EDirection srcSide, float srcStart, float srcEnd, const std::string &dstName, + const std::string &srcName, Direction srcSide, float srcStart, float srcEnd, const std::string &dstName, float dstStart, float dstEnd ); @@ -287,7 +287,7 @@ public: Removes all connections created by connect() on side \c srcSide. Returns false if \c srcName is unknown. */ - bool disconnect(const std::string &srcName, EDirection srcSide); + bool disconnect(const std::string &srcName, Direction srcSide); //! Disconnect screens /*! @@ -295,7 +295,7 @@ public: covering position \c position. Returns false if \c srcName is unknown. */ - bool disconnect(const std::string &srcName, EDirection srcSide, float position); + bool disconnect(const std::string &srcName, Direction srcSide, float position); //! Set server address /*! @@ -381,21 +381,21 @@ public: saves the position on the neighbor in \c positionOut if it's not \c nullptr. */ - std::string getNeighbor(const std::string &, EDirection, float position, float *positionOut) const; + std::string getNeighbor(const std::string &, Direction, float position, float *positionOut) const; //! Check for neighbor /*! Returns \c true if the screen has a neighbor anywhere along the edge given by the direction. */ - bool hasNeighbor(const std::string &, EDirection) const; + bool hasNeighbor(const std::string &, Direction) const; //! Check for neighbor /*! Returns \c true if the screen has a neighbor in the given range along the edge given by the direction. */ - bool hasNeighbor(const std::string &, EDirection, float start, float end) const; + bool hasNeighbor(const std::string &, Direction, float start, float end) const; //! Get beginning neighbor iterator link_const_iterator beginNeighbor(const std::string &) const; @@ -448,7 +448,7 @@ public: /*! Returns the name of a direction (for debugging). */ - static const char *dirName(EDirection); + static const char *dirName(Direction); //! Get interval as string /*! diff --git a/src/lib/server/InputFilter.cpp b/src/lib/server/InputFilter.cpp index a9773d330..85ba7745a 100644 --- a/src/lib/server/InputFilter.cpp +++ b/src/lib/server/InputFilter.cpp @@ -297,14 +297,14 @@ void InputFilter::SwitchToScreenAction::perform(const Event &event) m_events->addEvent(Event(EventTypes::ServerSwitchToScreen, event.getTarget(), info, Event::kDeliverImmediately)); } -InputFilter::SwitchInDirectionAction::SwitchInDirectionAction(IEventQueue *events, EDirection direction) +InputFilter::SwitchInDirectionAction::SwitchInDirectionAction(IEventQueue *events, Direction direction) : m_direction(direction), m_events(events) { // do nothing } -EDirection InputFilter::SwitchInDirectionAction::getDirection() const +Direction InputFilter::SwitchInDirectionAction::getDirection() const { return m_direction; } @@ -318,7 +318,7 @@ std::string InputFilter::SwitchInDirectionAction::format() const { static const char *s_names[] = {"", "left", "right", "up", "down"}; - return deskflow::string::sprintf("switchInDirection(%s)", s_names[m_direction]); + return deskflow::string::sprintf("switchInDirection(%s)", s_names[static_cast(m_direction)]); } void InputFilter::SwitchInDirectionAction::perform(const Event &event) diff --git a/src/lib/server/InputFilter.h b/src/lib/server/InputFilter.h index 3ad18deef..04db947b2 100644 --- a/src/lib/server/InputFilter.h +++ b/src/lib/server/InputFilter.h @@ -197,9 +197,9 @@ public: class SwitchInDirectionAction : public Action { public: - SwitchInDirectionAction(IEventQueue *events, EDirection); + SwitchInDirectionAction(IEventQueue *events, Direction); - EDirection getDirection() const; + Direction getDirection() const; // Action overrides Action *clone() const override; @@ -207,7 +207,7 @@ public: void perform(const Event &) override; private: - EDirection m_direction; + Direction m_direction; IEventQueue *m_events; }; diff --git a/src/lib/server/Server.cpp b/src/lib/server/Server.cpp index 676214f92..16310546f 100644 --- a/src/lib/server/Server.cpp +++ b/src/lib/server/Server.cpp @@ -306,18 +306,19 @@ std::string Server::getName(const BaseClientProxy *client) const uint32_t Server::getActivePrimarySides() const { using enum DirectionMask; + using enum Direction; uint32_t sides = 0; if (!isLockedToScreenServer()) { - if (hasAnyNeighbor(m_primaryClient, kLeft)) { + if (hasAnyNeighbor(m_primaryClient, Left)) { sides |= static_cast(LeftMask); } - if (hasAnyNeighbor(m_primaryClient, kRight)) { + if (hasAnyNeighbor(m_primaryClient, Right)) { sides |= static_cast(RightMask); } - if (hasAnyNeighbor(m_primaryClient, kTop)) { + if (hasAnyNeighbor(m_primaryClient, Top)) { sides |= static_cast(TopMask); } - if (hasAnyNeighbor(m_primaryClient, kBottom)) { + if (hasAnyNeighbor(m_primaryClient, Bottom)) { sides |= static_cast(BottomMask); } } @@ -490,7 +491,7 @@ void Server::jumpToScreen(BaseClientProxy *newScreen) switchScreen(newScreen, x, y, false); } -float Server::mapToFraction(const BaseClientProxy *client, EDirection dir, int32_t x, int32_t y) const +float Server::mapToFraction(const BaseClientProxy *client, Direction dir, int32_t x, int32_t y) const { int32_t sx; int32_t sy; @@ -498,22 +499,23 @@ float Server::mapToFraction(const BaseClientProxy *client, EDirection dir, int32 int32_t sh; client->getShape(sx, sy, sw, sh); switch (dir) { - case kLeft: - case kRight: + using enum Direction; + case Left: + case Right: return static_cast(y - sy + 0.5f) / static_cast(sh); - case kTop: - case kBottom: + case Top: + case Bottom: return static_cast(x - sx + 0.5f) / static_cast(sw); - case kNoDirection: + case NoDirection: assert(0 && "bad direction"); break; } return 0.0f; } -void Server::mapToPixel(const BaseClientProxy *client, EDirection dir, float f, int32_t &x, int32_t &y) const +void Server::mapToPixel(const BaseClientProxy *client, Direction dir, float f, int32_t &x, int32_t &y) const { int32_t sx; int32_t sy; @@ -521,30 +523,31 @@ void Server::mapToPixel(const BaseClientProxy *client, EDirection dir, float f, int32_t sh; client->getShape(sx, sy, sw, sh); switch (dir) { - case kLeft: - case kRight: + using enum Direction; + case Left: + case Right: y = static_cast(f * sh) + sy; break; - case kTop: - case kBottom: + case Top: + case Bottom: x = static_cast(f * sw) + sx; break; - case kNoDirection: + case NoDirection: assert(0 && "bad direction"); break; } } -bool Server::hasAnyNeighbor(const BaseClientProxy *client, EDirection dir) const +bool Server::hasAnyNeighbor(const BaseClientProxy *client, Direction dir) const { assert(client != nullptr); return m_config->hasNeighbor(getName(client), dir); } -BaseClientProxy *Server::getNeighbor(const BaseClientProxy *src, EDirection dir, int32_t &x, int32_t &y) const +BaseClientProxy *Server::getNeighbor(const BaseClientProxy *src, Direction dir, int32_t &x, int32_t &y) const { // note -- must be locked on entry @@ -589,7 +592,7 @@ BaseClientProxy *Server::getNeighbor(const BaseClientProxy *src, EDirection dir, } } -BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, int32_t &x, int32_t &y) const +BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, Direction srcSide, int32_t &x, int32_t &y) const { // note -- must be locked on entry @@ -615,7 +618,8 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, // actual to canonical position on entry to and from canonical to // actual on exit from the search. switch (srcSide) { - case kLeft: + using enum Direction; + case Left: x -= dx; while (dst != nullptr) { lastGoodScreen = dst; @@ -631,7 +635,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, x += dx; break; - case kRight: + case Right: x -= dx; while (dst != nullptr) { x -= dw; @@ -647,7 +651,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, x += dx; break; - case kTop: + case Top: y -= dy; while (dst != nullptr) { lastGoodScreen = dst; @@ -663,7 +667,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, y += dy; break; - case kBottom: + case Bottom: y -= dy; while (dst != nullptr) { y -= dh; @@ -679,7 +683,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, y += dy; break; - case kNoDirection: + case NoDirection: assert(0 && "bad direction"); return nullptr; } @@ -697,7 +701,7 @@ BaseClientProxy *Server::mapToNeighbor(BaseClientProxy *src, EDirection srcSide, return dst; } -void Server::avoidJumpZone(const BaseClientProxy *dst, EDirection dir, int32_t &x, int32_t &y) const +void Server::avoidJumpZone(const BaseClientProxy *dst, Direction dir, int32_t &x, int32_t &y) const { // we only need to avoid jump zones on the primary screen if (dst != m_primaryClient) { @@ -717,33 +721,34 @@ void Server::avoidJumpZone(const BaseClientProxy *dst, EDirection dir, int32_t & // that doesn't have a neighbor (i.e. an asymmetrical side) then we // don't need to move inwards because that side can't provoke a jump. switch (dir) { - case kLeft: - if (!m_config->getNeighbor(dstName, kRight, t, nullptr).empty() && x > dx + dw - 1 - z) + using enum Direction; + case Left: + if (!m_config->getNeighbor(dstName, Right, t, nullptr).empty() && x > dx + dw - 1 - z) x = dx + dw - 1 - z; break; - case kRight: - if (!m_config->getNeighbor(dstName, kLeft, t, nullptr).empty() && x < dx + z) + case Right: + if (!m_config->getNeighbor(dstName, Left, t, nullptr).empty() && x < dx + z) x = dx + z; break; - case kTop: - if (!m_config->getNeighbor(dstName, kBottom, t, nullptr).empty() && y > dy + dh - 1 - z) + case Top: + if (!m_config->getNeighbor(dstName, Bottom, t, nullptr).empty() && y > dy + dh - 1 - z) y = dy + dh - 1 - z; break; - case kBottom: - if (!m_config->getNeighbor(dstName, kTop, t, nullptr).empty() && y < dy + z) + case Bottom: + if (!m_config->getNeighbor(dstName, Top, t, nullptr).empty() && y < dy + z) y = dy + z; break; - case kNoDirection: + case NoDirection: assert(0 && "bad direction"); } } bool Server::isSwitchOkay( - BaseClientProxy *newScreen, EDirection dir, int32_t x, int32_t y, int32_t xActive, int32_t yActive + BaseClientProxy *newScreen, Direction dir, int32_t x, int32_t y, int32_t xActive, int32_t yActive ) { LOG((CLOG_DEBUG1 "try to leave \"%s\" on %s", getName(m_active).c_str(), Config::dirName(dir))); @@ -845,7 +850,7 @@ void Server::stopSwitch() { if (m_switchScreen != nullptr) { m_switchScreen = nullptr; - m_switchDir = kNoDirection; + m_switchDir = Direction::NoDirection; stopSwitchTwoTap(); stopSwitchWait(); } @@ -882,19 +887,20 @@ void Server::armSwitchTwoTap(int32_t x, int32_t y) // move in the opposite direction that the mouse actually // moved. try to ignore that crap here. switch (m_switchDir) { - case kLeft: + using enum Direction; + case Left: m_switchTwoTapArmed = (m_xDelta > 0 && m_xDelta2 > 0); break; - case kRight: + case Right: m_switchTwoTapArmed = (m_xDelta < 0 && m_xDelta2 < 0); break; - case kTop: + case Top: m_switchTwoTapArmed = (m_yDelta > 0 && m_yDelta2 > 0); break; - case kBottom: + case Bottom: m_switchTwoTapArmed = (m_yDelta < 0 && m_yDelta2 < 0); break; @@ -1609,36 +1615,38 @@ bool Server::onMouseMovePrimary(int32_t x, int32_t y) // see if we should change screens // when the cursor is in a corner, there may be a screen either // horizontally or vertically. check both directions. - EDirection dirh = kNoDirection, dirv = kNoDirection; + using enum Direction; + auto dirh = NoDirection; + auto dirv = NoDirection; int32_t xh = x; int32_t yv = y; if (x < ax + zoneSize) { xh -= zoneSize; - dirh = kLeft; + dirh = Left; } else if (x >= ax + aw - zoneSize) { xh += zoneSize; - dirh = kRight; + dirh = Right; } if (y < ay + zoneSize) { yv -= zoneSize; - dirv = kTop; + dirv = Top; } else if (y >= ay + ah - zoneSize) { yv += zoneSize; - dirv = kBottom; + dirv = Bottom; } - if (dirh == kNoDirection && dirv == kNoDirection) { + if (dirh == NoDirection && dirv == NoDirection) { // still on local screen noSwitch(x, y); return false; } // check both horizontally and vertically - EDirection dirs[] = {dirh, dirv}; + Direction dirs[] = {dirh, dirv}; int32_t xs[] = {xh, x}; int32_t ys[] = {y, yv}; for (int i = 0; i < 2; ++i) { - EDirection dir = dirs[i]; - if (dir == kNoDirection) { + Direction dir = dirs[i]; + if (dir == NoDirection) { continue; } x = xs[i], y = ys[i]; @@ -1736,15 +1744,16 @@ void Server::onMouseMoveSecondary(int32_t dx, int32_t dy) yc = ay + ah - 1; } - EDirection dir; + Direction dir; + using enum Direction; if (m_x < ax) { - dir = kLeft; + dir = Left; } else if (m_x > ax + aw - 1) { - dir = kRight; + dir = Right; } else if (m_y < ay) { - dir = kTop; + dir = Top; } else if (m_y > ay + ah - 1) { - dir = kBottom; + dir = Bottom; } else { // we haven't left the screen newScreen = m_active; @@ -1757,19 +1766,19 @@ void Server::onMouseMoveSecondary(int32_t dx, int32_t dy) bool clearWait; int32_t zoneSize = m_primaryClient->getJumpZoneSize(); switch (m_switchDir) { - case kLeft: + case Left: clearWait = (m_x >= ax + zoneSize); break; - case kRight: + case Right: clearWait = (m_x <= ax + aw - 1 - zoneSize); break; - case kTop: + case Top: clearWait = (m_y >= ay + zoneSize); break; - case kBottom: + case Bottom: clearWait = (m_y <= ay + ah - 1 + zoneSize); break; @@ -2042,7 +2051,7 @@ Server::SwitchToScreenInfo *Server::SwitchToScreenInfo::alloc(const std::string // Server::SwitchInDirectionInfo // -Server::SwitchInDirectionInfo *Server::SwitchInDirectionInfo::alloc(EDirection direction) +Server::SwitchInDirectionInfo *Server::SwitchInDirectionInfo::alloc(Direction direction) { auto *info = (SwitchInDirectionInfo *)malloc(sizeof(SwitchInDirectionInfo)); info->m_direction = direction; diff --git a/src/lib/server/Server.h b/src/lib/server/Server.h index 0345de34d..045e8e5e0 100644 --- a/src/lib/server/Server.h +++ b/src/lib/server/Server.h @@ -77,10 +77,10 @@ public: class SwitchInDirectionInfo { public: - static SwitchInDirectionInfo *alloc(EDirection direction); + static SwitchInDirectionInfo *alloc(Direction direction); public: - EDirection m_direction; + Direction m_direction; }; //! Screen connected data @@ -215,35 +215,35 @@ private: // convert pixel position to fraction, using x or y depending on the // direction. - float mapToFraction(const BaseClientProxy *, EDirection, int32_t x, int32_t y) const; + float mapToFraction(const BaseClientProxy *, Direction, int32_t x, int32_t y) const; // convert fraction to pixel position, writing only x or y depending // on the direction. - void mapToPixel(const BaseClientProxy *, EDirection, float f, int32_t &x, int32_t &y) const; + void mapToPixel(const BaseClientProxy *, Direction, float f, int32_t &x, int32_t &y) const; // returns true if the client has a neighbor anywhere along the edge // indicated by the direction. - bool hasAnyNeighbor(const BaseClientProxy *, EDirection) const; + bool hasAnyNeighbor(const BaseClientProxy *, Direction) const; // lookup neighboring screen, mapping the coordinate independent of // the direction to the neighbor's coordinate space. - BaseClientProxy *getNeighbor(const BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const; + BaseClientProxy *getNeighbor(const BaseClientProxy *, Direction, int32_t &x, int32_t &y) const; // lookup neighboring screen. given a position relative to the // source screen, find the screen we should move onto and where. // if the position is sufficiently far from the source then we // cross multiple screens. if there is no suitable screen then // return nullptr and x,y are not modified. - BaseClientProxy *mapToNeighbor(BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const; + BaseClientProxy *mapToNeighbor(BaseClientProxy *, Direction, int32_t &x, int32_t &y) const; // adjusts x and y or neither to avoid ending up in a jump zone // after entering the client in the given direction. - void avoidJumpZone(const BaseClientProxy *, EDirection, int32_t &x, int32_t &y) const; + void avoidJumpZone(const BaseClientProxy *, Direction, int32_t &x, int32_t &y) const; // test if a switch is permitted. this includes testing user // options like switch delay and tracking any state required to // implement them. returns true iff a switch is permitted. - bool isSwitchOkay(BaseClientProxy *dst, EDirection, int32_t x, int32_t y, int32_t xActive, int32_t yActive); + bool isSwitchOkay(BaseClientProxy *dst, Direction, int32_t x, int32_t y, int32_t xActive, int32_t yActive); // update switch state due to a mouse move at \p x, \p y that // doesn't switch screens. @@ -409,7 +409,7 @@ private: // common state for screen switch tests. all tests are always // trying to reach the same screen in the same direction. - EDirection m_switchDir = EDirection::kNoDirection; + Direction m_switchDir = Direction::NoDirection; BaseClientProxy *m_switchScreen = nullptr; // state for delayed screen switching diff --git a/src/unittests/server/ServerConfigTests.cpp b/src/unittests/server/ServerConfigTests.cpp index 110090fc8..b9e06890c 100644 --- a/src/unittests/server/ServerConfigTests.cpp +++ b/src/unittests/server/ServerConfigTests.cpp @@ -41,12 +41,12 @@ void ServerConfigTests::equalityCheck() QVERIFY(a.addScreen("screenB")); QVERIFY(a.addScreen("screenC")); - QVERIFY(a.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); - QVERIFY(a.connect("screenB", EDirection::kLeft, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(a.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(a.connect("screenB", Direction::Left, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); QVERIFY(b.addScreen("screenA")); QVERIFY(b.addScreen("screenC")); - QVERIFY(b.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); - QVERIFY(b.connect("screenB", EDirection::kLeft, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(b.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(b.connect("screenB", Direction::Left, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); QVERIFY(a.addOption("screenA", kOptionClipboardSharing, 1)); QVERIFY(b.addOption("screenA", kOptionClipboardSharing, 1)); QVERIFY(a.addOption(std::string(), kOptionClipboardSharing, 1)); @@ -125,7 +125,7 @@ void ServerConfigTests::equalityCheck_diff_neighbours1() Config b(nullptr); QVERIFY(a.addScreen("screenA")); QVERIFY(a.addScreen("screenB")); - QVERIFY(a.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(a.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); QVERIFY(b.addScreen("screenA")); QVERIFY(b.addScreen("screenB")); QVERIFY(a != b); @@ -138,10 +138,10 @@ void ServerConfigTests::equalityCheck_diff_neighbours2() Config b(nullptr); QVERIFY(a.addScreen("screenA")); QVERIFY(a.addScreen("screenB")); - QVERIFY(a.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(a.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); QVERIFY(b.addScreen("screenA")); QVERIFY(b.addScreen("screenB")); - QVERIFY(b.connect("screenA", EDirection::kBottom, 0.0f, 0.25f, "screenB", 0.25f, 1.0f)); + QVERIFY(b.connect("screenA", Direction::Bottom, 0.0f, 0.25f, "screenB", 0.25f, 1.0f)); QVERIFY(a != b); } @@ -152,11 +152,11 @@ void ServerConfigTests::equalityCheck_diff_neighbours3() QVERIFY(a.addScreen("screenA")); QVERIFY(a.addScreen("screenB")); QVERIFY(a.addScreen("screenC")); - QVERIFY(a.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); + QVERIFY(a.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenB", 0.5f, 1.0f)); QVERIFY(b.addScreen("screenA")); QVERIFY(b.addScreen("screenB")); QVERIFY(b.addScreen("screenC")); - QVERIFY(b.connect("screenA", EDirection::kBottom, 0.0f, 0.5f, "screenC", 0.5f, 1.0f)); + QVERIFY(b.connect("screenA", Direction::Bottom, 0.0f, 0.5f, "screenC", 0.5f, 1.0f)); QVERIFY(a != b); }