~mterry/mir/session-for-surface

 */

 

#include "mir/graphics/display.h"

#include "mir/shell/surface_creation_parameters.h"

#include "mir/shell/placement_strategy.h"

#include "mir/shell/surface_factory.h"

#include "mir_test/fake_event_hub.h"

#include "mir_test/event_factory.h"

#include "mir_test/wait_condition.h"

#include "mir_test_framework/display_server_test_fixture.h"

#include "mir_test_framework/input_testing_server_configuration.h"

 

#include <functional>

#include <map>

 

namespace mi = mir::input;

namespace mia = mi::android;

namespace mis = mi::synthesis;

 

struct InputClient : ClientConfig

{

    {

    }

 

 

        // Set this in the callback, not main thread to avoid missing test events

        mir_surface_set_event_handler(surface, &event_delegate);

    }

 

    static void handle_input(MirSurface* /* surface */, MirEvent const* ev, void* context)

         auto request_params = parameters();

         mir_wait_for(mir_connection_create_surface(connection, &request_params, create_surface_callback, this));

 

 

         mir_surface_release_sync(surface);

 

    std::shared_ptr<MockInputHandler> handler;

    mt::WaitCondition events_received;

 

    std::string const surface_name;

 

    static int const surface_width = 100;

    int const num_events_produced = 3;

    static std::string const test_client_name = "1";

 

    struct ServerConfiguration : mtf::InputTestingServerConfiguration

    {

        void inject_input()

        {

            wait_until_client_appears(test_client_name);

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

                fake_event_hub->synthesize_event(mis::a_key_down_event()

                                                 .of_scancode(KEY_ENTER));

        }

    launch_server_process(server_config);

    

    struct KeyReceivingClient : InputClient

    {

        void expect_input(mt::WaitCondition& events_received) override

        {

            using namespace ::testing;

            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(1)

                .WillOnce(mt::WakeUp(&events_received));

        }

    launch_client_process(client_config);

}

 

{

    using namespace ::testing;

    static std::string const test_client_name = "1";

    struct ServerConfiguration : mtf::InputTestingServerConfiguration

    {

        void inject_input()

        {

            wait_until_client_appears(test_client_name);

 

            fake_event_hub->synthesize_event(mis::a_key_down_event()

                                             .of_scancode(KEY_LEFTSHIFT));

                                             .of_scancode(KEY_4));

 

        }

    launch_server_process(server_config);

    

    struct KeyReceivingClient : InputClient

    {

 

        void expect_input(mt::WaitCondition& events_received) override

        {

            EXPECT_CALL(*handler, handle_input(AllOf(KeyDownEvent(), KeyOfSymbol(XKB_KEY_dollar)))).Times(1)

                .WillOnce(mt::WakeUp(&events_received));

        }

    launch_client_process(client_config);

}

 

{

    using namespace ::testing;

    static std::string const test_client_name = "1";

    struct ServerConfiguration : public mtf::InputTestingServerConfiguration

    {

        void inject_input()

        {

            wait_until_client_appears(test_client_name);

            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,2));

        }

    launch_server_process(server_config);

    

    struct MotionReceivingClient : InputClient

    {

 

        void expect_input(mt::WaitCondition& events_received) override

        {

            // We should see the cursor enter

            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);

            EXPECT_CALL(*handler, handle_input(

                .WillOnce(mt::WakeUp(&events_received));

            // But we should not receive an event for the second movement outside of our surface!

        }

    launch_client_process(client_config);

}

 

    using namespace ::testing;

    

    static std::string const test_client_name = "1";

    struct ServerConfiguration : public mtf::InputTestingServerConfiguration

    {

        void inject_input()

        {

            wait_until_client_appears(test_client_name);

            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));

        }

    launch_server_process(server_config);

    

    struct ButtonReceivingClient : InputClient

    {

 

        void expect_input(mt::WaitCondition& events_received) override

        {

            EXPECT_CALL(*handler, handle_input(ButtonDownEvent(0, 0))).Times(1)

                .WillOnce(mt::WakeUp(&events_received));

        }

    launch_client_process(client_config);

}

 

namespace

{

 

struct StaticPlacementStrategy : public msh::PlacementStrategy

{

    {

    }

 

    msh::SurfaceCreationParameters place(msh::SurfaceCreationParameters const& request_parameters)

    {

        auto placed = request_parameters;

 

        placed.top_left = geometry.top_left;

        placed.size = geometry.size;

        

        return placed;

    }

};

 

}

    static int const client_width = screen_width/2;

    static std::string const test_client_1 = "1";

    static std::string const test_client_2 = "2";

    struct ServerConfiguration : mtf::InputTestingServerConfiguration

    {

        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override

        {

            positions[test_client_1] = geom::Rectangle{geom::Point{0, 0},

                geom::Size{client_width, client_height}};

            positions[test_client_2] = geom::Rectangle{geom::Point{screen_width/2, screen_height/2},

            return std::make_shared<StaticPlacementStrategy>(positions);

        }

        

        void inject_input() override

        {

            wait_until_client_appears(test_client_1);

            wait_until_client_appears(test_client_2);

            // In the bounds of the first surface

            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2-1, screen_height/2-1));

            // In the bounds of the second surface

            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2, screen_height/2));

        }

    

    launch_server_process(server_config);

    

    struct InputClientOne : InputClient

    {

        {

        }

        

            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(1)

                .WillOnce(mt::WakeUp(&events_received));

        }

 

    struct InputClientTwo : InputClient

    {

        {

        }

        

            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(client_width - 1, client_height - 1))).Times(1)

                .WillOnce(mt::WakeUp(&events_received));

        }

 

    launch_client_process(client_1);

    launch_client_process(client_2);

{

    using namespace ::testing;

    static std::string const test_client_name = "1";

    static int const screen_width = 100;

    static int const screen_height = 100;

    

 

    struct ServerConfiguration : mtf::InputTestingServerConfiguration

    {

        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override

        {

            positions[test_client_name] = screen_geometry;

            

            return std::make_shared<StaticPlacementStrategy>(positions);

            return std::make_shared<RegionApplyingSurfaceFactory>(InputTestingServerConfiguration::the_shell_surface_factory(),

                client_input_regions);

        }

        

        void inject_input() override

        {

            wait_until_client_appears(test_client_name);

            

            // First we will move the cursor in to the input region on the left side of the window. We should see a click here

            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 1));

            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));

            fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));

        }

    

    launch_server_process(server_config);

 

    struct ClientConfig : InputClient

    {

        {

        }

 

                    .WillOnce(mt::WakeUp(&events_received));

            }

        }

    launch_client_process(client_config);

}

 

TEST_F(TestClientInput, surfaces_obscure_motion_events_by_stacking)

{

    using namespace ::testing;

    

    static std::string const test_client_name_1 = "1";

    static std::string const test_client_name_2 = "2";

 

    static int const screen_width = 100;

    static int const screen_height = 100;

    static geom::Rectangle const screen_geometry{geom::Point{0, 0},

        geom::Size{screen_width, screen_height}};

 

    {

        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override

        {

            positions[test_client_name_1] = screen_geometry;

            

            auto smaller_geometry = screen_geometry;

            smaller_geometry.size.width = geom::Width{screen_width/2};

            positions[test_client_name_2] = smaller_geometry;

            

            depths[test_client_name_1] = ms::DepthId{0};

            depths[test_client_name_2] = ms::DepthId{1};

            

        }

        

        void inject_input() override

        {

            wait_until_client_appears(test_client_name_1);

            wait_until_client_appears(test_client_name_2);

            // First we will move the cursor in to the region where client 2 obscures client 1

            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 1));

            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));

            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));

            fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));

        }

    

    launch_server_process(server_config);

 

    struct ClientConfigOne : InputClient

    {

        {

        }

 

                    .WillOnce(mt::WakeUp(&events_received));

            }

        }

    launch_client_process(client_config_1);

 

    struct ClientConfigTwo : InputClient

    {

        {

        }

 

                  .WillOnce(mt::WakeUp(&events_received));

            }

        }

    launch_client_process(client_config_2);

}