libs-back/Source/wayland/WaylandServer+Cursor.m

/* 
   WaylandServer - Cursor Handling

   Copyright (C) 2020 Free Software Foundation, Inc.

   Author: Riccardo Canalicchio <riccardo.canalicchio(at)gmail.com>
   Date: November 2021

   This file is part of the GNU Objective C Backend Library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; see the file COPYING.LIB.
   If not, see <http://www.gnu.org/licenses/> or write to the
   Free Software Foundation, 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include "wayland/WaylandServer.h"
#include <AppKit/NSEvent.h>
#include <AppKit/NSView.h>
#include <AppKit/NSWindow.h>
#include <AppKit/GSWindowDecorationView.h>
#include <AppKit/GSTheme.h>
#include <AppKit/NSApplication.h>
#include <linux/input.h>

static void
pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial,
		     struct wl_surface *surface, wl_fixed_t sx_w,
		     wl_fixed_t sy_w)
{
  if (!surface)
    {
      NSDebugLog(@"no surface");
      return;
    }

  WaylandConfig *wlconfig = data;
  struct window *window = wl_surface_get_user_data(surface);
  float		 sx = wl_fixed_to_double(sx_w);
  float		 sy = wl_fixed_to_double(sy_w);
  [GSCurrentServer() initializeMouseIfRequired];

  wlconfig->pointer.x = sx;
  wlconfig->pointer.y = sy;
  wlconfig->pointer.focus = window;

  // FIXME: Send NSMouseEntered event.
}

static void
pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial,
		     struct wl_surface *surface)
{
  if (!surface)
    {
      NSDebugLog(@"no surface");
      return;
    }

  WaylandConfig *wlconfig = data;
  struct window *window = wl_surface_get_user_data(surface);
  [GSCurrentServer() initializeMouseIfRequired];

  if (wlconfig->pointer.focus->window_id == window->window_id)
    {
      wlconfig->pointer.focus = NULL;
      wlconfig->pointer.serial = 0;
    }

  // FIXME: Send NSMouseExited event.
}

// triggered when the cursor is over a surface
static void
pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time,
		      wl_fixed_t sx_w, wl_fixed_t sy_w)
{
  WaylandConfig *wlconfig = data;
  struct window *window;
  if (window->moving || window->resizing)
    {
      return;
    }
  float sx = wl_fixed_to_double(sx_w);
  float sy = wl_fixed_to_double(sy_w);

  [GSCurrentServer() initializeMouseIfRequired];

  if (wlconfig->pointer.focus && wlconfig->pointer.serial)
    {
      window = wlconfig->pointer.focus;
      NSEvent	      *event;
      NSEventType	 eventType;
      NSPoint		 eventLocation;
      NSGraphicsContext *gcontext;
      unsigned int	 eventFlags;
      float		 deltaX = sx - window->wlconfig->pointer.x;
      float		 deltaY = sy - window->wlconfig->pointer.y;

      //	NSDebugLog(@"obtaining locations: wayland=%fx%f pointer=%fx%f",
      //		   sx, sy, window->wlconfig->pointer.x,
      //window->wlconfig->pointer.y);

      gcontext = GSCurrentContext();
      eventLocation = NSMakePoint(sx, window->height - sy);

      eventFlags = 0;
      eventType = NSLeftMouseDragged;

      //	NSDebugLog(@"sending pointer delta: %fx%f, window=%d", deltaX,
      //deltaY, window->window_id);

      event = [NSEvent mouseEventWithType:eventType
				 location:eventLocation
			    modifierFlags:eventFlags
				timestamp:(NSTimeInterval) time / 1000.0
			     windowNumber:(int) window->window_id
				  context:gcontext
			      eventNumber:time
			       clickCount:1
				 pressure:1.0
			     buttonNumber:0 /* FIXME */
				   deltaX:deltaX
				   deltaY:deltaY
				   deltaZ:0.];

      [GSCurrentServer() postEvent:event atStart:NO];
    }

  wlconfig->pointer.x = sx;
  wlconfig->pointer.y = sy;
}

static void
pointer_handle_button(void *data, struct wl_pointer *pointer, uint32_t serial,
		      uint32_t time, uint32_t button, uint32_t state_w)
{
  WaylandConfig		*wlconfig = data;
  NSEvent			  *event;
  NSEventType		       eventType;
  NSPoint		       eventLocation;
  NSGraphicsContext	    *gcontext;
  unsigned int		       eventFlags;
  float			       deltaX = 0.0;
  float			       deltaY = 0.0;
  int			       clickCount = 1;
  int			       tick;
  int			       buttonNumber;
  enum wl_pointer_button_state state = state_w;
  struct window		*window = wlconfig->pointer.focus;

  [GSCurrentServer() initializeMouseIfRequired];

  gcontext = GSCurrentContext();
  eventLocation
    = NSMakePoint(wlconfig->pointer.x, window->height - wlconfig->pointer.y);
  eventFlags = 0;

  if (window->toplevel)
    {
      // if the window is a toplevel we check if the event is for resizing or
      // moving the window these actions are delegated to the compositor and
      // therefore we skip forwarding the events to the NSWindow / NSView

      NSWindow *nswindow = GSWindowWithNumber(window->window_id);
      if (nswindow != nil)
	{
	  GSWindowDecorationView *wd = [GSWindowDecorationView windowDecorator];
	  //            NSPoint p = [[nswindow contentView] convertPoint:
	  //            eventLocation fromView: nil];
	  GSTheme *theme = [GSTheme theme];
	  CGFloat  titleHeight = [theme titlebarHeight];
	  CGFloat  resizebarHeight = [theme resizebarHeight];
	  NSRect   windowframe = [nswindow frame];
	  NSDebugLog(@"[%d] titleHeight: %f", window->window_id, titleHeight);
	  NSDebugLog(@"[%d] resizebarHeight: %f", window->window_id,
		     resizebarHeight);
	  NSDebugLog(@"[%d] windowframe: %f,%f %fx%f", windowframe.origin.x,
		     windowframe.origin.y, windowframe.size.width,
		     windowframe.size.height);
	  NSDebugLog(@"[%d] eventLocation: %f,%f", window->window_id,
		     eventLocation.x, eventLocation.y);

	  NSRect     titleBarRect = NSZeroRect;
	  NSRect     resizeBarRect = NSZeroRect;
	  NSRect     closeButtonRect = NSZeroRect;
	  NSRect     miniaturizeButtonRect = NSZeroRect;
	  NSUInteger styleMask = [nswindow styleMask];
	  bool	     hasTitleBar = NO;
	  bool	     hasResizeBar = NO;
	  bool	     hasCloseButton = NO;
	  bool	     hasMiniaturizeButton = NO;

	  // wayland controls the window move / resize

	  if (styleMask
	      & (NSTitledWindowMask | NSClosableWindowMask
		 | NSMiniaturizableWindowMask))
	    {
	      hasTitleBar = YES;
	      titleBarRect
		= NSMakeRect(0.0, windowframe.size.height - titleHeight,
			     windowframe.size.width, titleHeight);

	      NSDebugLog(@"[%d] titleBarRect: %f,%f %fx%f",
			 titleBarRect.origin.x, titleBarRect.origin.y,
			 titleBarRect.size.width, titleBarRect.size.height);
	    }

	  if (styleMask & NSResizableWindowMask)
	    {
	      hasResizeBar = YES;
	      float padding = 10.0;
	      resizeBarRect = NSMakeRect(-padding, -padding,
					 windowframe.size.width + padding * 2,
					 resizebarHeight + padding * 2);

	      NSDebugLog(@"[%d] resizeBarRect: %f,%f %fx%f",
			 resizeBarRect.origin.x, resizeBarRect.origin.y,
			 resizeBarRect.size.width, resizeBarRect.size.height);
	    }

	  if (styleMask & NSClosableWindowMask)
	    {
	      hasCloseButton = YES;

	      closeButtonRect
		= NSMakeRect(windowframe.size.width - [theme titlebarButtonSize]
			       - [theme titlebarPaddingRight],
			     windowframe.size.height -
			       [theme titlebarButtonSize] -
			       [theme titlebarPaddingTop],
			     [theme titlebarButtonSize],
			     [theme titlebarButtonSize]);
	    }

	  if (styleMask & NSMiniaturizableWindowMask)
	    {
	      hasMiniaturizeButton = YES;
	      miniaturizeButtonRect = NSMakeRect([theme titlebarPaddingLeft],
						 windowframe.size.height -
						   [theme titlebarButtonSize] -
						   [theme titlebarPaddingTop],
						 [theme titlebarButtonSize],
						 [theme titlebarButtonSize]);
	    }

	  if (hasTitleBar && !NSPointInRect(eventLocation, closeButtonRect)
	      && !NSPointInRect(eventLocation, miniaturizeButtonRect)
	      && NSPointInRect(eventLocation, titleBarRect))
	    {
	      NSDebugLog(@"[%d] point in titleBarRect [%f,%f] [%f,%f %fx%f]",
			 window->window_id, eventLocation.x, eventLocation.y,
			 titleBarRect.origin.x, titleBarRect.origin.y,
			 titleBarRect.size.width, titleBarRect.size.height);

	      if (state == WL_POINTER_BUTTON_STATE_PRESSED)
		{
		  xdg_toplevel_move(window->toplevel, wlconfig->seat, serial);
		  window->moving = YES;
		  return;
		}
	      else
		{
		  window->moving = NO;
		}
	    }
	  if (hasResizeBar && NSPointInRect(eventLocation, resizeBarRect))
	    {
	      uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
	      NSDebugLog(@"[%d] point in resizeBarRect [%f,%f] [%f,%f %fx%f]",
			 window->window_id, eventLocation.x, eventLocation.y,
			 resizeBarRect.origin.x, resizeBarRect.origin.y,
			 resizeBarRect.size.width, resizeBarRect.size.height);

	      if (resizeBarRect.size.width < 30 * 2
		  && eventLocation.x < resizeBarRect.size.width / 2)
		{
		  edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
		}
	      else if (eventLocation.x > resizeBarRect.size.width - 30)
		{
		  edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
		}
	      else if (eventLocation.x < 29)
		{
		  edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
		}
	      else
		{
		  edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
		}

	      if (state == WL_POINTER_BUTTON_STATE_PRESSED)
		{
		  xdg_toplevel_resize(window->toplevel, wlconfig->seat, serial,
				      edges);
		  window->resizing = YES;
		  return;
		}
	      else
		{
		  window->resizing = NO;
		}
	    }
	}
    } // endif window->toplevel

  if (state == WL_POINTER_BUTTON_STATE_PRESSED)
    {
      if (button == wlconfig->pointer.last_click_button
	  && time - wlconfig->pointer.last_click_time < 300
	  && abs(wlconfig->pointer.x - wlconfig->pointer.last_click_x) < 3
	  && abs(wlconfig->pointer.y - wlconfig->pointer.last_click_y) < 3)
	{
	  wlconfig->pointer.last_click_time = 0;
	  clickCount++;
	}
      else
	{
	  NSDebugLog(@"handle_button MISS: b=%d t=%d x=%f y=%f", button, time,
		     wlconfig->pointer.x, wlconfig->pointer.y);
	  wlconfig->pointer.last_click_button = button;
	  wlconfig->pointer.last_click_time = time;
	  wlconfig->pointer.last_click_x = wlconfig->pointer.x;
	  wlconfig->pointer.last_click_y = wlconfig->pointer.y;
	}

      switch (button)
	{
	case BTN_LEFT:
	  eventType = NSLeftMouseDown;
	  break;
	case BTN_RIGHT:
	  eventType = NSRightMouseDown;
	  break;
	case BTN_MIDDLE:
	  eventType = NSOtherMouseDown;
	  break;
	  // TODO: handle BTN_SIDE, BTN_EXTRA, BTN_FORWARD, BTN_BACK and other
	  // constants in libinput.
	  // We may just want to send NSOtherMouseDown and populate buttonNumber
	  // with the libinput constant?
	}
      wlconfig->pointer.serial = serial;
    }
  else if (state == WL_POINTER_BUTTON_STATE_RELEASED)
    {
      switch (button)
	{
	case BTN_LEFT:
	  eventType = NSLeftMouseUp;
	  break;
	case BTN_RIGHT:
	  eventType = NSRightMouseUp;
	  break;
	case BTN_MIDDLE:
	  eventType = NSOtherMouseUp;
	  break;
	}
      wlconfig->pointer.serial = 0;
    }
  else
    {
      return;
    }

  /* FIXME: unlike in _motion and _axis handlers, the argument used in _button
     is the "serial" of the event, not passed and unavailable in _motion and
     _axis handlers. Is it allowed to pass "serial" as the eventNumber: in
     _button handler, but "time" as the eventNumber: in the _motion and _axis
     handlers? */
  tick = serial;

  NSDebugLog(@"sending pointer event at: %fx%f, window=%d", wlconfig->pointer.x,
	     wlconfig->pointer.y, window->window_id);

  /* FIXME: X11 backend uses the XGetPointerMapping()-returned values from
     its map_return argument as constants for buttonNumber. As the variant
     with buttonNumber: seems to be a GNUstep extension, and the value
     internal, it might be ok to just provide libinput constant as we're doing
     here. If this is truly correct, please update this comment to document
     the correctness of doing so. */
  buttonNumber = button;

  event = [NSEvent mouseEventWithType:eventType
			     location:eventLocation
			modifierFlags:eventFlags
			    timestamp:(NSTimeInterval) time / 1000.0
			 windowNumber:(int) window->window_id
			      context:gcontext
			  eventNumber:tick
			   clickCount:clickCount
			     pressure:1.0
			 buttonNumber:buttonNumber
			       deltaX:deltaX /* FIXME unused */
			       deltaY:deltaY /* FIXME unused */
			       deltaZ:0.];

  [GSCurrentServer() postEvent:event atStart:NO];
}

static void
pointer_handle_axis(void *data, struct wl_pointer *pointer, uint32_t time,
		    uint32_t axis, wl_fixed_t value)
{
  NSDebugLog(@"pointer_handle_axis: axis=%d value=%g", axis,
	     wl_fixed_to_double(value));
  WaylandConfig	*wlconfig = data;
  NSEvent		  *event;
  NSEventType	     eventType;
  NSPoint	     eventLocation;
  NSGraphicsContext *gcontext;
  unsigned int	     eventFlags;
  float		     deltaX = 0.0;
  float		     deltaY = 0.0;
  int		     clickCount = 1;
  int		     buttonNumber;

  struct window *window = wlconfig->pointer.focus;

  [GSCurrentServer() initializeMouseIfRequired];

  gcontext = GSCurrentContext();
  eventLocation
    = NSMakePoint(wlconfig->pointer.x, window->height - wlconfig->pointer.y);
  eventFlags = 0;

  /* FIXME: we should get axis_source out of wl_pointer; however, the wl_pointer
     is not defined in wayland-client.h. How does one get the axis_source out of
     it to confirm the source is the physical mouse wheel? */
#if 0
  if (pointer->axis_source != WL_POINTER_AXIS_SOURCE_WHEEL)
    return;
#endif

  float mouse_scroll_multiplier = wlconfig->mouse_scroll_multiplier;
  /* For smooth-scroll events, we're not doing any cross-event or delta
     calculations, as is done in button event handling. */
  switch (axis)
    {
    case WL_POINTER_AXIS_VERTICAL_SCROLL:
      eventType = NSScrollWheel;
      deltaY = wl_fixed_to_double(value) * wlconfig->mouse_scroll_multiplier;
    case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
      eventType = NSScrollWheel;
      deltaX = wl_fixed_to_double(value) * wlconfig->mouse_scroll_multiplier;
    }

  NSDebugLog(@"sending pointer scroll at: %fx%f, value %fx%f, window=%d",
	     wlconfig->pointer.x, wlconfig->pointer.y, deltaX, deltaY,
	     window->window_id);

  /* FIXME: X11 backend uses the XGetPointerMapping()-returned values from
     its map_return argument as constants for buttonNumber. As the variant
     with buttonNumber: seems to be a GNUstep extension, and the value
     internal, it might be ok to just not provide any value here.
     If this is truly correct, please update this comment to document
     the correctness of doing so. */
  buttonNumber = 0;

  event = [NSEvent mouseEventWithType:eventType
			     location:eventLocation
			modifierFlags:eventFlags
			    timestamp:(NSTimeInterval) time / 1000.0
			 windowNumber:(int) window->window_id
			      context:gcontext
			  eventNumber:time
			   clickCount:clickCount
			     pressure:1.0
			 buttonNumber:buttonNumber
			       deltaX:deltaX
			       deltaY:deltaY
			       deltaZ:0.];

  [GSCurrentServer() postEvent:event atStart:NO];
}

const struct wl_pointer_listener pointer_listener = {
  pointer_handle_enter,	 pointer_handle_leave, pointer_handle_motion,
  pointer_handle_button, pointer_handle_axis,
};

@implementation
WaylandServer (Cursor)
- (NSPoint)mouselocation
{
  int		 aScreen = -1;
  struct output *output;

  NSDebugLog(@"mouselocation");

  // FIXME: find a cleaner way to get the first element of a wl_list
  wl_list_for_each(output, &wlconfig->output_list, link)
  {
    aScreen = output->server_output_id;
    break;
  }
  if (aScreen < 0)
    // No outputs in the wl_list.
    return NSZeroPoint;

  return [self mouseLocationOnScreen:aScreen window:NULL];
}

- (NSPoint)mouseLocationOnScreen:(int)aScreen window:(int *)win
{
  //    NSDebugLog(@"mouseLocationOnScreen: %d %fx%f", win,
  //	       wlconfig->pointer.x, wlconfig->pointer.y);
  struct window *window = wlconfig->pointer.focus;
  struct output *output;
  float		 x;
  float		 y;

  /*if (wlconfig->pointer.serial) {
      NSDebugLog(@"captured");
      x = wlconfig->pointer.captured_x;
      y = wlconfig->pointer.captured_y;
      } else*/
  {
    // NSDebugLog(@"NOT captured");
    x = wlconfig->pointer.x;
    y = wlconfig->pointer.y;

    if (window)
      {
	x += window->pos_x;
	y += window->pos_y;
	if (win)
	  {
	    *win = &window->window_id;
	  }
      }
  }

  wl_list_for_each(output, &wlconfig->output_list, link)
  {
    if (output->server_output_id == aScreen)
      {
	y = output->height - y;
	break;
      }
  }

  //    NSDebugLog(@"mouseLocationOnScreen: returning %fx%f", x, y);

  return NSMakePoint(x, y);
}

- (BOOL)capturemouse:(int)win
{
  NSDebugLog(@"capturemouse: %d", win);
  return NO;
}

- (void)releasemouse
{
  NSDebugLog(@"releasemouse");
}

- (void)setMouseLocation:(NSPoint)mouseLocation onScreen:(int)aScreen
{
  NSDebugLog(@"setMouseLocation");
}

- (void)hidecursor
{
  NSDebugLog(@"hidecursor");
}

- (void)showcursor
{
  NSDebugLog(@"showcursor");
}

- (void)standardcursor:(int)style:(void **)cid
{
  NSDebugLog(@"standardcursor");
}

- (void)imagecursor:(NSPoint)hotp:(NSImage *)image:(void **)cid
{
  NSDebugLog(@"imagecursor");
}

- (void)setcursorcolor:(NSColor *)fg:(NSColor *)bg:(void *)cid
{
  NSLog(@"Call to obsolete method -setcursorcolor:::");
  [self recolorcursor:fg:bg:cid];
  [self setcursor:cid];
}

- (void)recolorcursor:(NSColor *)fg:(NSColor *)bg:(void *)cid
{
  NSDebugLog(@"recolorcursor");
}

- (void)setcursor:(void *)cid
{
  NSDebugLog(@"setcursor");
}

- (void)freecursor:(void *)cid
{
  NSDebugLog(@"freecursor");
}
- (void)setIgnoreMouse:(BOOL)ignoreMouse:(int)win
{
  NSDebugLog(@"setIgnoreMouse");
}

- (void)initializeMouseIfRequired
{
  if (!_mouseInitialized)
    [self initializeMouse];
}

- (void)initializeMouse
{
  _mouseInitialized = YES;

  [self mouseOptionsChanged:nil];
  [[NSDistributedNotificationCenter defaultCenter]
    addObserver:self
       selector:@selector(mouseOptionsChanged:)
	   name:NSUserDefaultsDidChangeNotification
	 object:nil];
}

- (void)mouseOptionsChanged:(NSNotification *)aNotif
{
  NSUserDefaults *defs = [NSUserDefaults standardUserDefaults];

  wlconfig->mouse_scroll_multiplier =
    [defs integerForKey:@"GSMouseScrollMultiplier"];
  if (wlconfig->mouse_scroll_multiplier < 0.0001f)
    wlconfig->mouse_scroll_multiplier = 1.0f;
}
@end