LCOV - code coverage report
Current view: top level - src/libvalent/input - valent-input-adapter.c (source / functions) Coverage Total Hit
Test: Code Coverage Lines: 100.0 % 34 34
Test Date: 2024-12-06 20:21:07 Functions: 100.0 % 8 8
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 42.1 % 38 16

             Branch data     Line data    Source code
       1                 :             : // SPDX-License-Identifier: GPL-3.0-or-later
       2                 :             : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
       3                 :             : 
       4                 :             : #define G_LOG_DOMAIN "valent-input-adapter"
       5                 :             : 
       6                 :             : #include "config.h"
       7                 :             : 
       8                 :             : #include <gio/gio.h>
       9                 :             : #include <libvalent-core.h>
      10                 :             : 
      11                 :             : #include "valent-input-adapter.h"
      12                 :             : 
      13                 :             : 
      14                 :             : /**
      15                 :             :  * ValentInputAdapter:
      16                 :             :  *
      17                 :             :  * An abstract base class for virtual input devices.
      18                 :             :  *
      19                 :             :  * `ValentInputAdapter` is a base class for plugins that provide an interface to
      20                 :             :  * the pointer and keyboard. This usually means simulating pointer and keyboard
      21                 :             :  * events on the host system.
      22                 :             :  *
      23                 :             :  * ## `.plugin` File
      24                 :             :  *
      25                 :             :  * Implementations may define the following extra fields in the `.plugin` file:
      26                 :             :  *
      27                 :             :  * - `X-InputAdapterPriority`
      28                 :             :  *
      29                 :             :  *     An integer indicating the adapter priority. The implementation with the
      30                 :             :  *     lowest value will be used as the primary adapter.
      31                 :             :  *
      32                 :             :  * Since: 1.0
      33                 :             :  */
      34                 :             : 
      35                 :             : typedef struct
      36                 :             : {
      37                 :             :   uint8_t  active : 1;
      38                 :             : } ValentInputAdapterPrivate;
      39                 :             : 
      40   [ +  +  +  - ]:         449 : G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ValentInputAdapter, valent_input_adapter, VALENT_TYPE_EXTENSION)
      41                 :             : 
      42                 :             : /* LCOV_EXCL_START */
      43                 :             : static void
      44                 :             : valent_input_adapter_real_keyboard_keysym (ValentInputAdapter *adapter,
      45                 :             :                                            uint32_t            keysym,
      46                 :             :                                            gboolean            state)
      47                 :             : {
      48                 :             : }
      49                 :             : 
      50                 :             : static void
      51                 :             : valent_input_adapter_real_pointer_axis (ValentInputAdapter *adapter,
      52                 :             :                                         double              dx,
      53                 :             :                                         double              dy)
      54                 :             : {
      55                 :             : }
      56                 :             : 
      57                 :             : static void
      58                 :             : valent_input_adapter_real_pointer_button (ValentInputAdapter  *adapter,
      59                 :             :                                           unsigned int         button,
      60                 :             :                                           gboolean             state)
      61                 :             : {
      62                 :             : }
      63                 :             : 
      64                 :             : static void
      65                 :             : valent_input_adapter_real_pointer_motion (ValentInputAdapter *adapter,
      66                 :             :                                           double              dx,
      67                 :             :                                           double              dy)
      68                 :             : {
      69                 :             : }
      70                 :             : /* LCOV_EXCL_STOP */
      71                 :             : 
      72                 :             : /*
      73                 :             :  * GObject
      74                 :             :  */
      75                 :             : static void
      76                 :          58 : valent_input_adapter_class_init (ValentInputAdapterClass *klass)
      77                 :             : {
      78                 :          58 :   klass->keyboard_keysym = valent_input_adapter_real_keyboard_keysym;
      79                 :          58 :   klass->pointer_axis = valent_input_adapter_real_pointer_axis;
      80                 :          58 :   klass->pointer_button = valent_input_adapter_real_pointer_button;
      81                 :          58 :   klass->pointer_motion = valent_input_adapter_real_pointer_motion;
      82                 :             : }
      83                 :             : 
      84                 :             : static void
      85                 :           7 : valent_input_adapter_init (ValentInputAdapter *adapter)
      86                 :             : {
      87                 :           7 : }
      88                 :             : 
      89                 :             : /**
      90                 :             :  * valent_input_adapter_keyboard_keysym:
      91                 :             :  * @adapter: a `ValentInputAdapter`
      92                 :             :  * @keysym: a keysym
      93                 :             :  * @state: %TRUE to press, or %FALSE to release
      94                 :             :  *
      95                 :             :  * Press or release @keysym.
      96                 :             :  *
      97                 :             :  * Since: 1.0
      98                 :             :  */
      99                 :             : void
     100                 :          26 : valent_input_adapter_keyboard_keysym (ValentInputAdapter *adapter,
     101                 :             :                                       uint32_t            keysym,
     102                 :             :                                       gboolean            state)
     103                 :             : {
     104                 :          26 :   VALENT_ENTRY;
     105                 :             : 
     106         [ +  - ]:          26 :   g_return_if_fail (VALENT_IS_INPUT_ADAPTER (adapter));
     107                 :             : 
     108                 :             :   /* Silently ignore empty symbols */
     109         [ +  - ]:          26 :   if G_UNLIKELY (keysym == 0)
     110                 :          26 :     VALENT_EXIT;
     111                 :             : 
     112                 :          26 :   VALENT_INPUT_ADAPTER_GET_CLASS (adapter)->keyboard_keysym (adapter,
     113                 :             :                                                              keysym,
     114                 :             :                                                              state);
     115                 :             : 
     116                 :          26 :   VALENT_EXIT;
     117                 :             : }
     118                 :             : 
     119                 :             : /**
     120                 :             :  * valent_input_adapter_pointer_axis:
     121                 :             :  * @adapter: a `ValentInputAdapter`
     122                 :             :  * @dx: movement on x-axis
     123                 :             :  * @dy: movement on y-axis
     124                 :             :  *
     125                 :             :  * Scroll the surface under the pointer (@dx, @dy), relative to its current
     126                 :             :  * position.
     127                 :             :  *
     128                 :             :  * Implementations should handle any necessary scaling.
     129                 :             :  *
     130                 :             :  * Since: 1.0
     131                 :             :  */
     132                 :             : void
     133                 :           3 : valent_input_adapter_pointer_axis (ValentInputAdapter *adapter,
     134                 :             :                                    double              dx,
     135                 :             :                                    double              dy)
     136                 :             : {
     137                 :           3 :   VALENT_ENTRY;
     138                 :             : 
     139         [ +  - ]:           3 :   g_return_if_fail (VALENT_IS_INPUT_ADAPTER (adapter));
     140                 :             : 
     141                 :             :   /* Silently ignore 0-delta motion */
     142   [ -  +  -  -  :           3 :   if G_UNLIKELY (G_APPROX_VALUE (dx, 0.0, 0.01) && G_APPROX_VALUE (dy, 0.0, 0.01))
          +  -  +  -  +  
                -  -  - ]
     143                 :           3 :     VALENT_EXIT;
     144                 :             : 
     145                 :           3 :   VALENT_INPUT_ADAPTER_GET_CLASS (adapter)->pointer_axis (adapter, dx, dy);
     146                 :             : 
     147                 :           3 :   VALENT_EXIT;
     148                 :             : }
     149                 :             : 
     150                 :             : /**
     151                 :             :  * valent_input_adapter_pointer_button:
     152                 :             :  * @adapter: a `ValentInputAdapter`
     153                 :             :  * @button: a button number
     154                 :             :  * @state: %TRUE to press, or %FALSE to release
     155                 :             :  *
     156                 :             :  * Press or release @button.
     157                 :             :  *
     158                 :             :  * Since: 1.0
     159                 :             :  */
     160                 :             : void
     161                 :          16 : valent_input_adapter_pointer_button (ValentInputAdapter *adapter,
     162                 :             :                                      unsigned int        button,
     163                 :             :                                      gboolean            state)
     164                 :             : {
     165                 :          16 :   VALENT_ENTRY;
     166                 :             : 
     167         [ +  - ]:          16 :   g_return_if_fail (VALENT_IS_INPUT_ADAPTER (adapter));
     168                 :             : 
     169                 :          16 :   VALENT_INPUT_ADAPTER_GET_CLASS (adapter)->pointer_button (adapter,
     170                 :             :                                                             button,
     171                 :             :                                                             state);
     172                 :             : 
     173                 :          16 :   VALENT_EXIT;
     174                 :             : }
     175                 :             : 
     176                 :             : /**
     177                 :             :  * valent_input_adapter_pointer_motion:
     178                 :             :  * @adapter: a `ValentInputAdapter`
     179                 :             :  * @dx: movement on x-axis
     180                 :             :  * @dy: movement on y-axis
     181                 :             :  *
     182                 :             :  * Move the pointer (@dx, @dy), relative to its current position.
     183                 :             :  *
     184                 :             :  * Implementation should handle any necessary scaling
     185                 :             :  *
     186                 :             :  * Since: 1.0
     187                 :             :  */
     188                 :             : void
     189                 :           5 : valent_input_adapter_pointer_motion (ValentInputAdapter *adapter,
     190                 :             :                                      double              dx,
     191                 :             :                                      double              dy)
     192                 :             : {
     193                 :           5 :   VALENT_ENTRY;
     194                 :             : 
     195         [ +  - ]:           5 :   g_return_if_fail (VALENT_IS_INPUT_ADAPTER (adapter));
     196                 :             : 
     197                 :             :   /* Silently ignore 0-delta motion */
     198   [ +  +  -  +  :           5 :   if G_UNLIKELY (G_APPROX_VALUE (dx, 0.0, 0.01) && G_APPROX_VALUE (dy, 0.0, 0.01))
          -  +  -  -  -  
                -  -  - ]
     199                 :           5 :     VALENT_EXIT;
     200                 :             : 
     201                 :           5 :   VALENT_INPUT_ADAPTER_GET_CLASS (adapter)->pointer_motion (adapter, dx, dy);
     202                 :             : 
     203                 :           5 :   VALENT_EXIT;
     204                 :             : }
     205                 :             : 
        

Generated by: LCOV version 2.0-1