SFML/src/SFML/Window/Android/WindowImplAndroid.hpp at master · criptych/SFML · GitHub

History

260 lines (228 loc) · 9.75 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

////////////////////////////////////////////////////////////

// SFML - Simple and Fast Multimedia Library

// This software is provided 'as-is', without any express or implied warranty.

// In no event will the authors be held liable for any damages arising from the use of this software.

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it freely,

// subject to the following restrictions:

// 1. The origin of this software must not be misrepresented;

// you must not claim that you wrote the original software.

// If you use this software in a product, an acknowledgment

// in the product documentation would be appreciated but is not required.

// 2. Altered source versions must be plainly marked as such,

// and must not be misrepresented as being the original software.

// 3. This notice may not be removed or altered from any source distribution.

////////////////////////////////////////////////////////////

#pragma once

////////////////////////////////////////////////////////////

// Headers

////////////////////////////////////////////////////////////

#include <SFML/Window/EglContext.hpp>

#include <SFML/Window/Event.hpp>

#include <SFML/Window/WindowImpl.hpp>

#include <SFML/System/Android/Activity.hpp>

#include <android/input.h>

namespace sf::priv

{

////////////////////////////////////////////////////////////

/// \brief Android implementation of WindowImpl

///

////////////////////////////////////////////////////////////

class WindowImplAndroid : public WindowImpl

{

public:

////////////////////////////////////////////////////////////

/// \brief Construct the window implementation from an existing control

///

/// \param handle Platform-specific handle of the control

///

////////////////////////////////////////////////////////////

WindowImplAndroid(WindowHandle handle);

////////////////////////////////////////////////////////////

/// \brief Create the window implementation

///

/// \param mode Video mode to use

/// \param title Title of the window

/// \param style Window style

/// \param state Window state

/// \param settings Additional settings for the underlying OpenGL context

///

////////////////////////////////////////////////////////////

WindowImplAndroid(VideoMode mode, const String& title, std::uint32_t style, State state, const ContextSettings& settings);

////////////////////////////////////////////////////////////

/// \brief Destructor

///

////////////////////////////////////////////////////////////

~WindowImplAndroid() override;

////////////////////////////////////////////////////////////

/// \brief Get the OS-specific handle of the window

///

/// \return Handle of the window

///

////////////////////////////////////////////////////////////

[[nodiscard]] WindowHandle getNativeHandle() const override;

////////////////////////////////////////////////////////////

/// \brief Get the position of the window

///

/// \return Position of the window, in pixels

///

////////////////////////////////////////////////////////////

[[nodiscard]] Vector2i getPosition() const override;

////////////////////////////////////////////////////////////

/// \brief Change the position of the window on screen

///

/// \param position New position of the window, in pixels

///

////////////////////////////////////////////////////////////

void setPosition(Vector2i position) override;

////////////////////////////////////////////////////////////

/// \brief Get the client size of the window

///

/// \return Size of the window, in pixels

///

////////////////////////////////////////////////////////////

[[nodiscard]] Vector2u getSize() const override;

////////////////////////////////////////////////////////////

/// \brief Change the size of the rendering region of the window

///

/// \param size New size, in pixels

///

////////////////////////////////////////////////////////////

void setSize(Vector2u size) override;

////////////////////////////////////////////////////////////

/// \brief Set the minimum window rendering region size

///

/// Pass `std::nullopt` to unset the minimum size

///

/// \param minimumSize New minimum size, in pixels

///

////////////////////////////////////////////////////////////

void setMinimumSize(const std::optional<Vector2u>& minimumSize) override;

////////////////////////////////////////////////////////////

/// \brief Set the maximum window rendering region size

///

/// Pass `std::nullopt` to unset the maximum size

///

/// \param maximumSize New maximum size, in pixels

///

////////////////////////////////////////////////////////////

void setMaximumSize(const std::optional<Vector2u>& maximumSize) override;

////////////////////////////////////////////////////////////

/// \brief Change the title of the window

///

/// \param title New title

///

////////////////////////////////////////////////////////////

void setTitle(const String& title) override;

////////////////////////////////////////////////////////////

/// \brief Change the window's icon

///

/// \param size Icon's width and height, in pixels

/// \param pixels Pointer to the pixels in memory, format must be RGBA 32 bits

///

////////////////////////////////////////////////////////////

void setIcon(Vector2u size, const std::uint8_t* pixels) override;

////////////////////////////////////////////////////////////

/// \brief Show or hide the window

///

/// \param visible `true` to show, `false` to hide

///

////////////////////////////////////////////////////////////

void setVisible(bool visible) override;

////////////////////////////////////////////////////////////

/// \brief Show or hide the mouse cursor

///

/// \param visible `true` to show, `false` to hide

///

////////////////////////////////////////////////////////////

void setMouseCursorVisible(bool visible) override;

////////////////////////////////////////////////////////////

/// \brief Clips or releases the mouse cursor

///

/// \param grabbed `true` to enable, `false` to disable

///

////////////////////////////////////////////////////////////

void setMouseCursorGrabbed(bool grabbed) override;

////////////////////////////////////////////////////////////

/// \brief Set the displayed cursor to a native system cursor

///

/// \param cursor Native system cursor type to display

///

////////////////////////////////////////////////////////////

void setMouseCursor(const CursorImpl& cursor) override;

////////////////////////////////////////////////////////////

/// \brief Enable or disable automatic key-repeat

///

/// \param enabled `true` to enable, `false` to disable

///

////////////////////////////////////////////////////////////

void setKeyRepeatEnabled(bool enabled) override;

////////////////////////////////////////////////////////////

/// \brief Request the current window to be made the active

/// foreground window

///

////////////////////////////////////////////////////////////

void requestFocus() override;

////////////////////////////////////////////////////////////

/// \brief Check whether the window has the input focus

///

/// \return `true` if window has focus, `false` otherwise

///

////////////////////////////////////////////////////////////

[[nodiscard]] bool hasFocus() const override;

static void forwardEvent(const Event& event);

static WindowImplAndroid* singleInstance;

protected:

////////////////////////////////////////////////////////////

/// \brief Process incoming events from the operating system

///

////////////////////////////////////////////////////////////

void processEvents() override;

private:

////////////////////////////////////////////////////////////

/// \brief Process messages from the looper associated with the main thread

///

/// \param fd File descriptor

/// \param events Bitmask of the poll events that were triggered

/// \param data Data pointer supplied

///

/// \return Whether it should continue (1) or unregister the callback (0)

///

////////////////////////////////////////////////////////////

static int processEvent(int fd, int events, void* data);

static int processScrollEvent(AInputEvent* inputEvent, ActivityStates& states);

static int processKeyEvent(AInputEvent* inputEvent, ActivityStates& states);

static int processMotionEvent(AInputEvent* inputEvent, ActivityStates& states);

static int processPointerEvent(bool isDown, AInputEvent* event, ActivityStates& states);

////////////////////////////////////////////////////////////

/// \brief Convert a Android key to SFML key code

///

/// \param symbol Android key to convert

///

/// \return Corresponding SFML key code

///

////////////////////////////////////////////////////////////

static Keyboard::Key androidKeyToSF(std::int32_t key);

////////////////////////////////////////////////////////////

/// \brief Get Unicode decoded from the input event

///

/// \param Event Input event

///

/// \return The Unicode value

///

////////////////////////////////////////////////////////////

static char32_t getUnicode(AInputEvent* event);

Vector2u m_size;

bool m_windowBeingCreated{};

bool m_windowBeingDestroyed{};

bool m_hasFocus{};

};

} // namespace sf::priv

SFML/src/SFML/Window/Android/WindowImplAndroid.hpp at master · criptych/SFML · GitHub

Expand file tree

Breadcrumbs

WindowImplAndroid.hpp

Latest commit

History

Breadcrumbs

WindowImplAndroid.hpp

File metadata and controls