ObjFW  Check-in [16aab59c3c]

	     OF_WARN_UNUSED_RESULT=				\
	     OF_WEAK_UNAVAILABLE=				\
	     SIGHUP						\
	     SIGUSR1						\
	     SIGUSR2
MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES
IGNORE_PREFIX = OF OF_ OT OT_
IGNORE_PREFIX = HID OF OF_ OT OT_
EXTRACT_STATIC = yes

 * version 3.0 along with this program. If not, see
 * <https://www.gnu.org/licenses/>.
 */

#import "HIDGameController.h"

OF_ASSUME_NONNULL_BEGIN

@class HIDGameControllerMapping;

@interface HIDEvdevGameController: HIDGameController
{
	OFString *_path;
	int _fd;
	bool _discardUntilReport;
	unsigned long *_evBits, *_keyBits, *_absBits;
	uint16_t _vendorID, _productID;
	OFString *_name;
	OFDictionary OF_GENERIC(OFString *, HIDGameControllerButton *)
	HIDGameControllerMapping *_mapping;
	    *_buttons;
	OFDictionary OF_GENERIC(OFString *, HIDGameControllerAxis *) *_axes;
}

- (instancetype)of_initWithPath: (OFString *)path OF_METHOD_FAMILY(init);
- (void)of_pollState;
@end

OF_ASSUME_NONNULL_END

#include "config.h"

#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

#import "HIDEvdevGameController.h"

#import "OFArray.h"
#import "OFDictionary.h"
#import "OFFileManager.h"
#import "OFLocale.h"
#import "OFNumber.h"

#import "HIDGameControllerAxis.h"
#import "HIDGameControllerButton.h"
#import "HIDGameControllerMapping.h"

#include <sys/ioctl.h>
#include <linux/input.h>

#import "OFInitializationFailedException.h"
#import "OFInvalidArgumentException.h"
#import "OFOpenItemFailedException.h"
#import "OFOutOfRangeException.h"
#import "OFReadFailedException.h"

@interface HIDEvdevGameControllerAxis: HIDGameControllerAxis
{
@public
	int32_t _minValue, _maxValue;
}
@end

@implementation HIDEvdevGameControllerAxis
@interface HIDEvdevGameControllerMapping: HIDGameControllerMapping
- (instancetype)of_initWithButtons: (OFDictionary *)buttons
			      axes: (OFDictionary *)axes OF_METHOD_FAMILY(init);
@end

static const uint16_t buttonIDs[] = {
	BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_TL2,
	BTN_TR2, BTN_SELECT, BTN_START, BTN_MODE, BTN_THUMBL, BTN_THUMBR,
	BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT,
	BTN_TRIGGER_HAPPY1, BTN_TRIGGER_HAPPY2, BTN_TRIGGER_HAPPY3,

	if (value > max)
		value = max;

	return ((value - min) / (max - min) * 2) - 1;
}

@implementation HIDEvdevGameController
@synthesize name = _name, buttons = _buttons, axes = _axes;
@synthesize name = _name, unmappedMapping = _mapping;

+ (OFArray OF_GENERIC(HIDGameController *) *)controllers
{
	OFMutableArray *controllers = [OFMutableArray array];
	void *pool = objc_autoreleasePoolPush();

	for (OFString *device in [[OFFileManager defaultManager]

}

- (instancetype)of_initWithPath: (OFString *)path
{
	self = [super init];

	@try {
		void *pool = objc_autoreleasePoolPush();
		OFStringEncoding encoding = [OFLocale encoding];
		struct input_id inputID;
		char name[128];
		OFMutableDictionary *buttons, *axes;

		_path = [path copy];

		if (ioctl(_fd, EVIOCGNAME(sizeof(name)), name) == -1)
			@throw [OFInitializationFailedException exception];

		_name = [[OFString alloc] initWithCString: name
						 encoding: encoding];

		buttons = [[OFMutableDictionary alloc] init];
		buttons = [OFMutableDictionary dictionary];
		_buttons = buttons;
		for (size_t i = 0; i < sizeof(buttonIDs) / sizeof(*buttonIDs);
		    i++) {
			if (OFBitSetIsSet(_keyBits, buttonIDs[i])) {
				OFString *buttonName;
				HIDGameControllerButton *button;

				buttonName = buttonToName(buttonIDs[i]);
				if (buttonName == nil)
					continue;

				button = [[[HIDGameControllerButton alloc]
				    initWithName: buttonName] autorelease];

				[buttons setObject: button forKey: buttonName];
			}
		}
		[buttons makeImmutable];

		axes = [[OFMutableDictionary alloc] init];
		axes = [OFMutableDictionary dictionary];
		_axes = axes;
		if (OFBitSetIsSet(_evBits, EV_ABS)) {
			_absBits = OFAllocZeroedMemory(OFRoundUpToPowerOf2(
			    OF_ULONG_BIT, ABS_MAX) / OF_ULONG_BIT,
			    sizeof(unsigned long));

			if (ioctl(_fd, EVIOCGBIT(EV_ABS, OFRoundUpToPowerOf2(
			    OF_ULONG_BIT, ABS_MAX) / OF_ULONG_BIT *

					    autorelease];

					[axes setObject: axis forKey: axisName];
				}
			}
		}
		[axes makeImmutable];

		_mapping = [[HIDEvdevGameControllerMapping alloc]
		    of_initWithButtons: buttons
				  axes: axes];

		[self of_pollState];

		objc_autoreleasePoolPop(pool);
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}

- (void)dealloc
{
	[_path release];

	if (_fd != -1)
		close(_fd);

	OFFreeMemory(_evBits);
	OFFreeMemory(_keyBits);
	OFFreeMemory(_absBits);

	[_name release];
	[_buttons release];
	[_axes release];
	[_mapping release];

	[super dealloc];
}

- (OFNumber *)vendorID
{
	return [OFNumber numberWithUnsignedShort: _vendorID];

		if (!OFBitSetIsSet(_keyBits, buttonIDs[i]))
			continue;

		name = buttonToName(buttonIDs[i]);
		if (name == nil)
			continue;

		button = [_buttons objectForKey: name];
		button = [_mapping.buttons objectForKey: name];
		if (button == nil)
			continue;

		button.value = (OFBitSetIsSet(keyState, buttonIDs[i]) ? 1 : 0);
	}

	if (OFBitSetIsSet(_evBits, EV_ABS)) {

				continue;

			name = axisToName(axisIDs[i]);
			if (name == nil)
				continue;

			axis = (HIDEvdevGameControllerAxis *)
			    [_axes objectForKey: name];
			    [_mapping.axes objectForKey: name];
			if (axis == nil)
				continue;

			if (ioctl(_fd, EVIOCGABS(axisIDs[i]), &info) == -1)
				@throw [OFReadFailedException
				    exceptionWithObject: self
					requestedLength: sizeof(info)
						  errNo: errno];

			axis->_minValue = info.minimum;
			axis->_maxValue = info.maximum;
			axis.value = scale(info.value,
			    info.minimum, info.maximum);
		}
	}
}

- (void)retrieveState
{
	void *pool = objc_autoreleasePoolPush();
	struct input_event event;

	for (;;) {
		OFString *name;
		HIDGameControllerButton *button;
		HIDEvdevGameControllerAxis *axis;

			}
			break;
		case EV_KEY:
			name = buttonToName(event.code);
			if (name == nil)
				continue;

			button = [_buttons objectForKey: name];
			button = [_mapping.buttons objectForKey: name];
			if (button == nil)
				continue;

			button.value = (event.value ? 1 : 0);

			break;
		case EV_ABS:
			name = axisToName(event.code);
			if (name == nil)
				continue;

			axis = (HIDEvdevGameControllerAxis *)
			    [_axes objectForKey: name];
			    [_mapping.axes objectForKey: name];
			if (axis == nil)
				continue;

			axis.value = scale(event.value,
			   axis->_minValue, axis->_maxValue);

			break;
		}
	}

	objc_autoreleasePoolPop(pool);
}

- (OFComparisonResult)compare: (HIDEvdevGameController *)otherController
{
	unsigned long long selfIndex, otherIndex;

	if (![otherController isKindOfClass: [HIDEvdevGameController class]])

		return OFOrderedDescending;
	if (selfIndex < otherIndex)
		return OFOrderedAscending;

	return OFOrderedSame;
}
@end

@implementation HIDEvdevGameControllerAxis
@end

@implementation HIDEvdevGameControllerMapping
- (instancetype)of_initWithButtons: (OFDictionary *)buttons
			      axes: (OFDictionary *)axes
{
	self = [super init];

	@try {
		_buttons = [buttons retain];
		_axes = [axes retain];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}
@end

#  import <ObjFW/OFObject.h>
#  import <ObjFW/OFString.h>
# endif
#endif

OF_ASSUME_NONNULL_BEGIN

@class HIDGameControllerAxis;
@class HIDGameControllerMapping;
@class HIDGameControllerButton;
@class OFArray OF_GENERIC(ObjectType);
@class OFDictionary OF_GENERIC(KeyType, ObjectType);
@class OFNumber;

/**
 * @class HIDGameController HIDGameController.h ObjFWHID/HIDGameController.h
 *
 * @brief A class for reading state from a game controller.
 */
@interface HIDGameController: OFObject
#ifdef OF_HAVE_CLASS_PROPERTIES
@property (class, readonly, nonatomic)
    OFArray <HIDGameController *> *controllers;
#endif

/**
 * @brief The product ID of the controller or `nil` if unavailable.
 */
@property OF_NULLABLE_PROPERTY (readonly, nonatomic) OFNumber *productID;

/**
 * @brief A map of all button names to their @ref HIDGameControllerButton.
 * @brief An unmapped mapping for the game controller, meaning no remapping is
 */
@property (readonly, nonatomic)
    OFDictionary OF_GENERIC(OFString *, HIDGameControllerButton *) *buttons;

 *	  being performed.
/**
 * @brief A map of all axis names to their @ref HIDGameControllerAxis.
 */
@property (readonly, nonatomic)
@property (readonly, nonatomic) HIDGameControllerMapping *unmappedMapping;
    OFDictionary OF_GENERIC(OFString *, HIDGameControllerAxis *) *axes;

/**
 * @brief Returns the available controllers.
 *
 * @return The available controllers
 */
+ (OFArray OF_GENERIC(HIDGameController *) *)controllers;

#import "OFSet.h"

#if defined(OF_LINUX) && defined(OF_HAVE_FILES)
# include "HIDEvdevGameController.h"
#endif

@implementation HIDGameController
@dynamic name, buttons, axes;
@dynamic name, unmappedMapping;

+ (OFArray OF_GENERIC(HIDGameController *) *)controllers
{
#if defined(OF_LINUX) && defined(OF_HAVE_FILES)
	return [HIDEvdevGameController controllers];
#else
	return [OFArray array];

 */

#import "HIDGameControllerElement.h"

OF_ASSUME_NONNULL_BEGIN

/**
 * @class HIDGameControllerAxis \
 *	  HIDGameControllerAxis.h ObjFWHID/HIDGameControllerAxis.h
 *
 * @brief An button of a game controller.
 * @brief An axis of a game controller.
 */
@interface HIDGameControllerAxis: HIDGameControllerElement
{
	float _value;
	OF_RESERVE_IVARS(HIDGameControllerButton, 4)
}

 */

#import "HIDGameControllerElement.h"

OF_ASSUME_NONNULL_BEGIN

/**
 * @class HIDGameControllerButton \
 *	  HIDGameControllerButton.h ObjFWHID/HIDGameControllerButton.h
 *
 * @brief An button of a game controller.
 * @brief A button of a game controller.
 */
@interface HIDGameControllerButton: HIDGameControllerElement
{
	float _value;
	OF_RESERVE_IVARS(HIDGameControllerButton, 4)
}

#import "HIDGameControllerElement.h"
#import "HIDGameControllerAxis.h"
#import "HIDGameControllerButton.h"

OF_ASSUME_NONNULL_BEGIN

/**
 * @class HIDGameControllerDirectionalPad \
 *	  HIDGameControllerDirectionalPad.h \
 *	  ObjFWHID/HIDGameControllerDirectionalPad.h
 *
 * @brief An directional pad or thumb stick of a game controller.
 */
OF_SUBCLASSING_RESTRICTED
@interface HIDGameControllerDirectionalPad: HIDGameControllerElement
{
	HIDGameControllerAxis *_xAxis, *_yAxis;
	HIDGameControllerButton *_upButton, *_downButton;

#  import <ObjFW/OFString.h>
# endif
#endif

OF_ASSUME_NONNULL_BEGIN

/**
 * @class HIDGameControllerElement \
 *	  HIDGameControllerElement.h ObjFWHID/HIDGameControllerElement.h
 *
 * @brief An element of a game controller, e.g. a button, an axis or a
 *	  directional pad.
 */
@interface HIDGameControllerElement: OFObject
{
	OFString *_name;
	bool _analog;

/*
 * Copyright (c) 2008-2024 Jonathan Schleifer <js@nil.im>
 *
 * All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License version 3.0 only,
 * as published by the Free Software Foundation.
 *
 * This program 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
 * version 3.0 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3.0 along with this program. If not, see
 * <https://www.gnu.org/licenses/>.
 */

#ifdef OBJFWHID_LOCAL_INCLUDES
# import "OFObject.h"
# import "OFString.h"
#else
# if defined(__has_feature) && __has_feature(modules)
@import ObjFW;
# else
#  import <ObjFW/OFObject.h>
#  import <ObjFW/OFString.h>
# endif
#endif

OF_ASSUME_NONNULL_BEGIN

@class HIDGameControllerAxis;
@class HIDGameControllerButton;
@class HIDGameControllerDirectionalPad;
@class OFDictionary OF_GENERIC(KeyType, ObjectType);

/**
 * @class HIDGameControllerMapping \
 *	  HIDGameControllerMapping.h ObjFWHID/HIDGameControllerMapping.h
 *
 * @brief A mapping for a @ref HIDGameController.
 */
@interface HIDGameControllerMapping: OFObject
{
	OFDictionary OF_GENERIC(OFString *, HIDGameControllerButton *)
	    *_buttons;
	OFDictionary OF_GENERIC(OFString *, HIDGameControllerAxis *) *_axes;
	OFDictionary OF_GENERIC(OFString *, HIDGameControllerDirectionalPad *)
	    *_directionalPads;
	OF_RESERVE_IVARS(HIDGameControllerMapping, 4)
}

/**
 * @brief A map of all button names to their @ref HIDGameControllerButton.
 */
@property (readonly, nonatomic)
    OFDictionary OF_GENERIC(OFString *, HIDGameControllerButton *) *buttons;

/**
 * @brief A map of all axis names to their @ref HIDGameControllerAxis.
 */
@property (readonly, nonatomic)
    OFDictionary OF_GENERIC(OFString *, HIDGameControllerAxis *) *axes;

/**
 * @brief A map of all directional pads to their
 *	  @ref HIDGameControllerDirectionalPad.
 */
@property (readonly, nonatomic) OFDictionary OF_GENERIC(OFString *,
    HIDGameControllerDirectionalPad *) *directionalPads;
@end

OF_ASSUME_NONNULL_END

/*
 * Copyright (c) 2008-2024 Jonathan Schleifer <js@nil.im>
 *
 * All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License version 3.0 only,
 * as published by the Free Software Foundation.
 *
 * This program 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
 * version 3.0 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3.0 along with this program. If not, see
 * <https://www.gnu.org/licenses/>.
 */

#include "config.h"

#import "HIDGameControllerMapping.h"

@implementation HIDGameControllerMapping: OFObject
@synthesize buttons = _buttons, axes = _axes;
@synthesize directionalPads = _directionalPads;

- (void)dealloc
{
	[_buttons release];
	[_axes release];
	[_directionalPads release];

	[super dealloc];
}
@end

include ../../extra.mk

DISTCLEAN = Info.plist

SHARED_LIB = ${OBJFWHID_SHARED_LIB}
STATIC_LIB = ${OBJFWHID_STATIC_LIB}
FRAMEWORK = ${OBJFWHID_FRAMEWORK}
LIB_MAJOR = ${OBJFWHID_LIB_MAJOR}
LIB_MINOR = ${OBJFWHID_LIB_MINOR}
LIB_PATCH = ${OBJFWHID_LIB_PATCH}

SRCS = HIDGameController.m			\
       HIDGameControllerAxis.m			\
       HIDGameControllerButton.m			\
       HIDGameControllerDirectionalPad.m		\
       HIDGameControllerElement.m
       HIDGameControllerButton.m		\
       HIDGameControllerDirectionalPad.m	\
       HIDGameControllerElement.m		\
       HIDGameControllerMapping.m

INCLUDES := ${SRCS:.m=.h}	\
	    ObjFWHID.h

SRCS += HIDGameControllerEmulatedAxis.m		\
	HIDGameControllerEmulatedButton.m

#import "OFThread.h"
#import "OFValue.h"

#import "OTTestCase.h"

#import "HIDGameController.h"
#import "HIDGameControllerButton.h"
#import "HIDGameControllerMapping.h"

#import "OTAssertionFailedException.h"
#import "OTTestSkippedException.h"

#ifdef OF_IOS
# include <CoreFoundation/CoreFoundation.h>
#endif

		[OFStdOut writeLine: @"Press A to continue"];

		for (;;) {
			void *pool = objc_autoreleasePoolPush();
			HIDGameController *controller =
			    [[HIDGameController controllers] objectAtIndex: 0];
			HIDGameControllerButton *button =
			    [controller.unmappedMapping.buttons
			    [controller.buttons objectForKey: @"A"];
			    objectForKey: @"A"];

			[controller retrieveState];

			if (button.pressed)
				break;

			[OFThread waitForVerticalBlank];

	for (;;) {
		void *pool = objc_autoreleasePoolPush();
		HIDGameController *controller =
		    [[HIDGameController controllers] objectAtIndex: 0];
		HIDGameControllerButton *button =
# ifdef OF_WII
		    [controller.buttons objectForKey: @"Home"];
		    [controller.unmappedMapping.buttons objectForKey: @"Home"];
# else
		    [controller.buttons objectForKey: @"Start"];
		    [controller.unmappedMapping.buttons objectForKey: @"Start"];
# endif

		[controller retrieveState];

		if (button.pressed)
			break;

#import "OFNumber.h"
#import "OFStdIOStream.h"
#import "OFThread.h"

#import "HIDGameController.h"
#import "HIDGameControllerAxis.h"
#import "HIDGameControllerButton.h"
#import "HIDGameControllerMapping.h"

#import "OFReadFailedException.h"

#if defined(OF_NINTENDO_DS)
static size_t buttonsPerLine = 2;
#elif defined(OF_NINTENDO_3DS)
static size_t buttonsPerLine = 3;

			[OFStdOut clear];
		}

		[OFStdOut setCursorPosition: OFMakePoint(0, 0)];

		for (HIDGameController *controller in _controllers) {
			HIDGameControllerMapping *mapping =
			    controller.unmappedMapping;
			OFArray OF_GENERIC(OFString *) *buttons =
			    controller.buttons.allKeys.sortedArray;
			    mapping.buttons.allKeys.sortedArray;
			OFArray OF_GENERIC(OFString *) *axes =
			    controller.axes.allKeys.sortedArray;
			size_t i = 0;
			    mapping.axes.allKeys.sortedArray;
			size_t i;

			[OFStdOut setForegroundColor: [OFColor green]];
			[OFStdOut writeString: controller.description];

			@try {
				[controller retrieveState];
			} @catch (OFReadFailedException *e) {
				[OFStdOut setForegroundColor: [OFColor red]];
				[OFStdOut writeFormat: @"\n%@", e.description];
				continue;
			}

			i = 0;
			for (OFString *name in buttons) {
				HIDGameControllerButton *button =
				    [controller.buttons objectForKey: name];
				    [mapping.buttons objectForKey: name];

				if (i == 0)
					[OFStdOut writeString: @"\n"];

				if (button.value == 1)
					[OFStdOut setForegroundColor:
					    [OFColor red]];

					i = 0;
				} else
					[OFStdOut writeString: @" "];
			}
			[OFStdOut setForegroundColor: [OFColor gray]];
			[OFStdOut writeString: @"\n"];

			i = 0;
			for (OFString *name in axes) {
				HIDGameControllerAxis *axis =
				    [controller.axes objectForKey: name];
				    [mapping.axes objectForKey: name];

				if (i == 0)
					[OFStdOut writeString: @"\n"];

				[OFStdOut writeFormat: @"%@: %5.2f ",
						       name, axis.value];

				if (++i == buttonsPerLine) {
					i = 0;
				} else
					[OFStdOut writeString: @" "];
			}

			[OFStdOut writeString: @"\n"];
		}

#if defined(OF_WII) || defined(OF_NINTENDO_DS) || defined(OF_NINTENDO_3DS)
		[OFThread waitForVerticalBlank];