Commit graph

1349 commits

Author SHA1 Message Date
Lucas Kent f083dae328 Windows creates Alt event instead of Menu event. (to match other platforms) (#551)
* Removed VirtualKeyCode::LMenu + VirtualKeyCode::RMenu, Windows now generates VirtualKeyCode::LAlt + VirtualKeyCode::RAlt instead.

* CHANGELOG nits
2018-06-13 13:24:33 -04:00
Victor Berger ced1616e51 wayland: implement set_resizable (#565) 2018-06-13 11:18:44 -04:00
Peter Atashian 233ac4aed2 Update to winapi 0.3.5 (#563) 2018-06-12 11:58:18 -04:00
Danny Fritz be5a2b0e87 Windows & X11: Window::set_resizable (#558)
* Windows: Window::set_resizable

* X11: Window::set_resizable

* Code style regarding resizable

* X11: set_resizable remember max/min window size

* Stub out set_resizable on Android, iOS, and emscripten

* remove comment block from docs

* Windows: set_resizable in fullscreen

* Special case Xfwm

* Added fun provisos to docs
2018-06-11 18:47:50 -04:00
Francesca Frangipane 2b4b64f499
macOS: Only detect clicks+motion within client area (#561)
* macOS: Only detect clicks within client area

* macOS: Only track mouse motion within client area

* Add CHANGELOG entry about #463 fix
2018-06-11 11:16:39 -04:00
Francesca Frangipane 262490d074
X11: Fix super fun race conditions (#554)
* X11: Fix super fun race conditions

* Fix build on rustc<1.26
2018-06-07 14:08:19 -04:00
Francesca Frangipane 8891cfd85e
macOS: Resizable without decorations (#553)
* macOS: Resizable without decorations

* Fix style mask regressions
2018-06-07 13:29:23 -04:00
Danny Fritz 2cc8fa1eac X11: implement with_resizable (#540) (#556) 2018-06-07 12:46:15 -04:00
Francesca Frangipane 79aebf06dc
macOS: Fix alt and win keycodes (#552)
* macOS: Generate LAlt/RAlt VirtualKeyCode

* macOS: Correct RWin/LWin
2018-06-06 11:30:26 -04:00
Francesca Frangipane 19dd961752
X11: Fix flickering when resizing with transparency enabled (#546)
* X11: Fix flickering when resizing with transparency enabled

* X11: Fix with_override_redirect
2018-06-03 13:11:54 -04:00
Christian Duerr bf413ecb83 Fix DPI with 0 width/hight reported by xorg (#544)
* Fix DPI with 0 width/hight reported by xorg

* Add `WINIT_HIDPI_FACTOR` env variable

It is now possible to override the DPI factor using the
`WINIT_HIDPI_FACTOR` environment variable on X11.

The changelog also has been updated to introduce all current changes
made.

* Add documentation for the environment variable

* Fix nitpicks

* Learning the alphabet

* Panic with error message if DPI env var is <= 0
2018-06-03 12:41:47 -04:00
Danny Fritz 58a00bffbb Windows: implement with_resizable (#540) (#541)
* Windows: implement with_resizable (#540)

* Fixed typo
2018-06-02 10:51:24 -04:00
Francesca Frangipane 4372f6fdac
X11: Flatten window model (#536) 2018-05-29 07:48:47 -04:00
Francesca Frangipane 30f798b246
X11: util design improvements (#534) 2018-05-27 08:49:35 -04:00
Francesca Frangipane 282770f11a
Release winit 0.15.0 (#530) 2018-05-22 14:17:41 -04:00
Francesca Frangipane 17373a4e91
X11: Fix primary monitor fallback regression (#532) 2018-05-22 09:07:46 -04:00
Francesca Frangipane a34147b602
macOS: Fix keyboard regressions (#533)
* Emit `ReceivedCharacter` for key repeats
* Enter emits `\r` instead of `\n`
2018-05-22 09:05:33 -04:00
Francesca Frangipane cebd15bfd1
X11: Improve hint support (#529)
Fixes #257
2018-05-20 10:47:22 -04:00
Francesca Frangipane f51f7c0ca8
Add option to make window "always on top" (#528)
* macOS: always_on_top

* Windows: always_on_top

* X11: always_on_top

* Stub set_always_on_top on other platforms
2018-05-20 10:24:05 -04:00
Francesca Frangipane f6d26df64d
Windows: CursorState improvements (#526)
* Windows: CursorState improvements

Fixes #523

Prior to changing the cursor state, we now check the current grab
state, since it can be invalidated by alt-tabbing and other things.

`CursorState::Hide` is also implemented now.

The cursor name is now wrapped in a `Cursor` struct to allow
multithreaded access.

`Window::set_cursor_state` has been reworked to use
`execute_in_thread`. Two unneeded `transmute` calls were also
removed.

The `WM_SETCURSOR` handler is much more readable now.

`MonitorId::get_adapter_name` has been removed, since it's dead
code and appears to be a relic from 4 years ago.

* Windows: CursorState::Grab no longer hides cursor

`MouseCursor::NoneCursor` has been implemented to allow for
equivalent behavior to the older implementation.

Windows and X11 now have consistent cursor grabbing behavior.
macOS still needs to be updated.

* Windows: Grabbing auto-hides again (for now)

This API needs more work, so let's stick to a bug fix and some
refactoring. However, it now hides using a different technique
than it did originally, which applies instantly instead of after
mouse movement.
2018-05-19 12:02:57 -04:00
Francesca Frangipane fddfb2e2d6
Windows: Fix detection of Pause and Scroll keys (#525)
Fixes #524
2018-05-18 18:48:19 -04:00
Francesca Frangipane dec728cfa2
macOS: Implement NSTextInputClient (#518)
Fixes #263
2018-05-17 21:28:30 -04:00
Francesca Frangipane 8440091a4e
macOS: Implement with_resize_increments (#519)
Fixes #135
2018-05-16 10:16:36 -04:00
Francesca Frangipane 2464a135b3
macOS: Fix Window::get_current_monitor (#521)
* macOS: Implement MonitorId::get_position

* macOS: Fix Window::get_current_monitor
2018-05-16 09:41:45 -04:00
Francesca Frangipane 87fa120ebb
macOS: Fix re-enabling decorations after the window is built without them (#520)
Fixes #517
2018-05-16 08:51:56 -04:00
Francesca Frangipane d86f53a02c
X11: Fix get_current_monitor (#515)
* X11: Fix get_current_monitor

Fixes #64

* impl Debug for MonitorId on all platforms
2018-05-14 08:14:57 -04:00
Francesca Frangipane 15a4fec3d9
X11: Fix scroll wheel delta on i3/etc. (#514)
Fixes #447
2018-05-13 08:44:23 -04:00
OJ Kwon 1819be1173 fix(mac_platform): forward keyevent to system (#511)
* fix(mac_platform): forward keyevent to system

* doc(changelog): update changelog
2018-05-12 22:10:57 -04:00
Victor Berger ffa9b51d27 wayland: improve diagnostic of failed init (#512) 2018-05-12 07:58:11 -04:00
tinaun b4a8c08f43 compile with icon_loading feature on docs.rs (#509)
* compile with icon_loading feature on docs.rs

these functions should be more visible now.

* Explicitly document which functions require icon_loading
2018-05-11 10:33:06 -04:00
Francesca Frangipane 741bcc4672
Correct privacy for Icon::to_cardinals (#510) 2018-05-10 18:42:41 -04:00
Jack Magnus 363261077f Windows: Fix panic when calling set_fullscreen(None) (#502)
* Windows: Fix panic for set_fullscreen(None) (#501)

* Add condition to prevent panic

Trying to call set_fullscreen(None) on a window that has never been in
fullscreen mode caused a panic before this change.
The responsible method now simply checks if this precondition is met and
returns (does nothing) otherwise.

* Add entry to CHANGELOG

* Add platform specification to CHANGELOG entry

Forgot to add that the to_fullscreen(None) bugfix is Windows only in
CHANGELOG.
2018-05-08 08:16:49 -04:00
Francesca Frangipane 102dd07456
Window icons (#497) 2018-05-07 17:36:21 -04:00
Victor Berger 1e97103094 wayland: migrate to smithay-client-toolkit (#490)
* wayland: migrate to smithay-client-toolkit

* Update smithay-client-toolkit

* Add changelog entry for wayland rework
2018-05-05 13:36:34 -04:00
Francesca Frangipane cc8907b956
X11: Implement resize increments and base size (#494) 2018-05-03 09:41:11 -04:00
Francesca Frangipane c4b92ebd45
X11: General cleanup (#491)
* X11: General cleanup

This is almost entirely internal changes, and as usual, doesn't actually
fix any problems people have complained about.

- `XSetInputFocus` can't be called before the window is visible. This
was previously handled by looping (with a sleep) and querying for the
window's state until it was visible. Now we use `XIfEvent`, which blocks
until we receive `VisibilityNotify`. Note that this can't be replaced
with an `XSync` (I tried).
- We now call `XSync` at the end of window creation and check for
errors, assuring that broken windows are never returned. When creating
invisible windows, this is the only time the output buffer is flushed
during the entire window creation process (AFAIK). For visible windows,
`XIfEvent` will generally flush, but window creation has overall been
reduced to the minimum number of flushes.
- `check_errors().expect()` has been a common pattern throughout the
backend, but it seems that people (myself included) didn't make a
distinction between using it after synchronous requests and asynchronous
requests. Now we only use it after async requests if we flush first,
though this still isn't correct (since the request likely hasn't been
processed yet). The only real solution (besides forcing a sync *every
time*) is to handle asynchronous errors *asynchronously*. For future
work, I plan on adding logging, though I don't plan on actually
*handling* those errors; that's more of something to hope for in the
hypothetical async/await XCB paradise.
- We now flush whenever it makes sense to. `util::Flusher` was added to
force contributors to be aware of the output buffer.
- `Window::get_position`, `Window::get_inner_position`,
`Window::get_inner_size`, and `Window::get_outer_size` previously all
required *several* round-trips. On my machine, it took an average of
around 80µs. They've now been reduced to one round-trip each, which
reduces my measurement to 16µs. This was accomplished simply by caching
the frame extents, which are expensive to calculate (due to various
queries and heuristics), but change infrequently and predictably. I
still recommend that application developers use these methods sparingly
and generally prefer storing the values from `Resized`/`Moved`, as
that's zero overhead.
- The above change enabled me to change the `Moved` event to supply
window positions, rather than client area positions. Additionally, we no
longer generate `Moved` for real (as in, not synthetic)
`ConfigureNotify` events. Real `ConfigureNotify` events contain
positions relative to the parent window, which are typically constant
and useless. Since that position would be completely different from the
root-relative positions supplied by synthetic `ConfigureNotify` events
(which are the vast majority of them), that meant real `ConfigureNotify`
events would *always* be detected as the position having changed, so the
resultant `Moved` was multiple levels of misleading. In practice, this
meant a garbage `Moved` would be sent every time the window was resized;
now a resize has to actually change the window's position to be
accompanied by `Moved`.
- Every time we processed an `XI_Enter` event, we would leak 4 bytes via
`util::query_pointer` (`XIQueryPointer`). `XIButtonState` contains a
dynamically-allocated mask field which we weren't freeing. As this event
occurs with fairly high frequency, long-running applications could
easily accumulate substantial leaks. `util::PointerState::drop` now
takes care of this.
- The `util` module has been split up into several sub-modules, as it
was getting rather lengthy. This accounts for a significant part of this
diff, unfortunately.
- Atoms are now cached. Xlib caches them too, so `XInternAtom` wouldn't
typically be a round-trip anyway, but the added complexity is
negligible.
- Switched from `std::sync::Mutex` to `parking_lot::Mutex` (within this
backend). There appears to be no downside to this, but if anyone finds
one, this would be easy to revert.
- The WM name and supported hints are now global to the application, and
are updated upon `ReparentNotify`, which should detect when the WM was
replaced (assuming a reparenting WM was involved, that is). Previously,
these values were per-window and would never update, meaning replacing
the WM could potentially lead to (admittedly very minor) problems.
- The result of `Window2::create_empty_cursor` will now only be used if
it actually succeeds.
- `Window2::load_cursor` no longer re-allocates the cursor name.
- `util::lookup_utf8` previously allocated a 16-byte buffer on the heap.
Now it allocates a 1024-byte buffer on the stack, and falls back to
dynamic allocation if the buffer is too small. This base buffer size is
admittedly gratuitous, but less so if you're using IME.
- `with_c_str` was finally removed.
- Added `util::Format` enum to help prevent goofs when dealing with
format arguments.
- `util::get_property`, something I added way back in my first winit PR,
only calculated offsets correctly for `util::Format::Char`. This was
concealed by the accomodating buffer size, as it would be very rare for
the offset to be needed; however, testing with a buffer size of 1,
`util::Format::Long` would read from the same offset multiple times, and
`util::Format::Short` would miss data. This function now works correctly
for all formats, relying on the simple fact that the offset increases by
the buffer size on each iteration. We also account for the extra byte
that `XGetWindowProperty` allocates at the end of the buffer, and copy
data from the buffer instead of moving it and taking ownership of the
pointer.
- Drag and drop now reliably works in release mode. This is presumably
related to the `util::get_property` changes.
- `util::change_property` now exists, which should make it easier to add
features in the future.
- The `EventsLoop` device map is no longer in a mutex.
- `XConnection` now implements `Debug`.
- Valgrind no longer complains about anything related to winit (with
either the system allocator or jemalloc, though "not having valgrind
complain about jemalloc" isn't something to strive for).

* X11: Add better diagnostics when initialization fails

* X11: Handle XIQueryDevice failure

* X11: Use correct types in error handler
2018-05-03 09:15:49 -04:00
Christian Duerr fee874b5b7 Add Copy/Paste keys (#495)
* Add Copy/Paste keys

This is only a tiny update which introduces the `Copy` and `Paste` keys
which are present on X11/Wayland/Windows. I'm not sure if this exists on
MacOS too, but I'm not able to test that and it doesn't have names but
just matches on the hex key values.

The "Copy" element is a reserved keyword in Rust but shouldn't cause any
conflicts in this scenario, this behavior falls in line with
https://docs.rs/winit/0.13.1/winit/enum.MouseCursor.html#variant.Copy,
but it would be possible to rename it. However `Copy` seems like the
most intuitive choice.

* Add Cut key, fix windows and update CHANGELOG

This introduces a bunch of minor fixes:
 * The changes introduced by this branch have been added to the changelog
 * Since related, the `Cut` key has also been added
 * An attempt has been made to fix Windows

* Fix position of fallback comment

The new keys have been inserted at the wrong position, so the fallback
comment has been moved to the `_ => ...` section again.

* Fix windows build

Apparently there are no keys for Cut/Paste on Windows, so for now those
have been removed on Windows and only the `Copy` key has been added on
Windows, the changelog has been updated to reflect that.

Linux still implements Copy/Clone/Paste, but `Copy` is now working
properly on Wayland.

MacOS still does not have any of these keys.

* Remove Windows changes

Because the Windows design wasn't completely clear the VirtualKeyCode
variants are now only used on Linux with X11 and Wayland and ignored on
both MacOS and Windows.

The CHANGELOG has also been updated. Windows has been removed from it
and the Linux section has been clarified a bit.
2018-05-02 19:18:52 -04:00
Joe Moon eba888207e macos platform attributes regression (#488)
* macOS: fix regression in 03c3e794097676888234b3cc82c01228dcbe48c8

fixed !decorations case and refactored logic to be a little easier to
read

* fix default case to inlude closable mask

* add comment to default case of macos platform attrs
2018-04-29 18:51:57 -04:00
Johannes Hofmann ea28791da6 x11: Always receive Awakened event in run_forever (#489)
* x11: Always receive Awakened event in run_forever

Do not reset the pending_wakeup boolean at the start of run_forever so
that each call to EventsLoopProxy::wakeup results in an Awakened event.

Fixes #462

* Update CHANGELOG.md
2018-04-28 19:03:06 -04:00
Francesca Frangipane fe2d37fcdc
Windows: Implement DeviceEvents (#482)
Fixes #467

All variants other than Text have been implemented. While Text can
be implemented using ToUnicode, that doesn't play nice with dead
keys, IME, etc.

Most of the mouse DeviceEvents were already implemented, but due
to the flags that were used when registering for raw input events,
they only worked when the window was in the foreground.

This is also a step forward for #338, as DeviceIds are no longer
useless on Windows. On DeviceEvents, the DeviceId contains that
device's handle. While that handle could ostensibly be used by
developers to query device information, my actual reason for
choosing it is because it's simply a very easy way to handle this.
As a fun bonus, this enabled me to create this method:
  DevideIdExt::get_persistent_identifier() -> Option<String>
Using this gives you a unique identifier for the device that
persists across replugs/reboots/etc., so it's ideal for something
like device-specific configuration.

There's a notable caveat to the new DeviceIds, which is that the
value will always be 0 for a WindowEvent. There doesn't seem to be
any straightforward way around this limitation.

I was concerned that multi-window applications would receive n
copies of every DeviceEvent, but Windows only sends them to one
window per application.

Lastly, there's a chance that these additions will cause
antivirus/etc. software to detect winit applications as keyloggers.
I don't know how likely that is to actually happen to people, but
if it does become an issue, the raw input code is neatly
sequestered and would be easy to make optional during compilation.
2018-04-28 12:42:33 -04:00
Vladimir 3407a8dd78 Macos multi windows leak (#481)
* adding a multiwindow example

* Added NSAutoReleasepool for WindowDelegate::Drop
as setDelegate:nil autoreleases WindowDelegate during work.

Added NSAutoReleasepool for Window2::Create,
as it uses autorelease on objects while doing work.

Added NSAutoreleasepool for Window2::Drop
as nswindow::close uses autorelease on objects.

Added NSAutoreleasepool for IdRef.

Moved Window2 WinitWindow objc class to a static var, as we are creating
multiple windows.

* specifying return type for msg_send!

* removing example/recreate_window_leak.rs

* EventLoop, Shared, no need to retain dead weak ptr

* Change log entry added

* added comment about Shared.find_and_remove_window

* fixed code style errors
2018-04-28 12:10:06 -04:00
Joe Moon 5761fb6b30 macOS: fix subtle regression introduced in 0474dc986 (#487)
* macOS: fix subtle regression introduced in 0474dc986

* update changelog
2018-04-28 00:12:50 -04:00
Francesca Frangipane 7aeb2c083b
macOS: Implement Moved (#478)
* macOS: Implement Moved

Fixes #67

* Also emit Moved after resizes that change position
2018-04-27 20:46:20 -04:00
Francesca Frangipane 8f47fdbe67
Windows: Position fixes (#479)
* Remove executable flag from os/macos.rs

This was causing me some grief while working on Windows, and it
doesn't belong here to begin with.

* Windows: get_position returns screen coordinates instead of workspace coordinates

Previously, get_position used GetWindowPlacement. As per the
documentation of WINDOWSTRUCT, the returned coordinates are in
workspace space, meaning they're relative to the taskbar. It's
also explicitly remarked that these coordinates should only be
used in conjunction with SetWindowPlacement, as mixing them with
functions expecting screen coordinates can cause unpleasantness.
Since our set_position (correctly) uses SetWindowPos, this meant
that passing the return of get_position to set_position would
cause the window to move.

We now use GetWindowRect, which returns screen coordinates. This
gives us both better consistency within the Windows backend and
across platforms.

Note that this only makes a difference if the taskbar is visible.
With the taskbar hidden, the values are exactly the same as before.

* Windows: Moved event position values are consistent with get_position

The old Moved values had two problems:

* They were obtained by casting a WORD (u16) straight to an i32.
This meant wrap-around would never be interpreted as negative,
thus negative positions (which are ubiquitous when using multiple
monitors) would result in positions around u16::MAX.

* WM_MOVE supplies client area positions, not window positions.

Switching to handling WM_WINDOWPOSCHANGED solves both of these
problems.

* Better documentation for Moved and Resized
2018-04-26 20:09:33 -04:00
Francesca Frangipane eadd9a19b2
Replace Closed event with CloseRequested and Destroyed (#476)
* Replace Closed event with CloseRequested and Destroyed

Implements #434

The existing Closed event had ambiguous meaning, both in name and in
cross-platform behavior. Closed is now split into two more precise events:

* CloseRequested - the window has been requested to close, most commonly by
having clicked the window's close button. Whether or not you respond by
closing the window is up to you.

* Destroyed - the window has been destroyed, and can no longer be safely
used.

Most notably, now you can reliably implement classic patterns like
prompting the user to save their work before closing, and have the
opportunity to perform any necessary cleanup.

Migrating to the new API is straightforward. In most cases, you can simply
replace all existing usages of Closed with CloseRequested. For more
information, see the example programs, particularly handling_close and
multiwindow.

iOS applications must replace all usages of Closed with Destroyed, and
require no other changes.
2018-04-24 16:20:40 -04:00
Francesca Frangipane 42f0671531
x11: Windows are Sync again (#474)
* x11: Windows are Sync again

Fixes #472

* Add test ensuring that Window is Sync

Window must be Sync for Vulkano's Arc<FramebufferAbstract> to be usable.
2018-04-21 11:53:57 -04:00
Francesca Frangipane eae7cb247c
Revert #466 'Discard mouse down after Cocoa window resize' (#470)
This reverts commit 19cd53193b.

Testing fullscreen functionality revealed that windowDidResize is invoked in more cases than previously thought, causing the user's events to be eaten and HiDPI problems.
2018-04-17 20:48:57 -04:00
Edwin Cheng 0474dc9861 Implement set_maximized, get_current_monitor, set_fullscreen and set_decorations for MacOS (#465)
* Added helper function for make monitor from display.

* Implement get_current_monitor  for macos

* Implemented with_fullscreen and set_fullscreen for macos

* Implemented set_decorations for macos

* Implement set_maximized and with_maximized for macos

* Changed fullscreen example fullscreen keypress from F11 to F

* Update CHANGELOG.md

* Add and fixed some comments

* Reformat and add more comments

* Better handling window and maximized state

* Reformat and typo fix
2018-04-17 14:07:54 -04:00
Osspial 8fd49a4dbe Add methods to get the position of a window's client area, relative to the desktop (#430)
* Add get_inner_position for windows, prototypes for other platforms

* Fix linux builds

* Implement get_inner_position for osx

* Add get_inner_pos implementations for other platforms

* Fixed get_inner_position on macOS

* Corrected set_position on macOS

* Added CHANGELOG entry
2018-04-16 21:40:30 -04:00
YVT 10688915eb [macOS] Register the Cocoa main thread at an earlier point (#456)
Solves the issues caused by calling `EventsLoopProxy::wakeup()` too
early from a worker thread.
2018-04-16 18:09:02 -04:00
Tristam MacDonald 19cd53193b Discard mouse down after Cocoa window resize (#466)
* Discard mouse down after Cocoa window resize

We are sending the mouse down event after the window resize has
completed, because Cocoa uses a modal event loop to implement window
resize. This leads to a mouse down without a matching mouse up.

* Also handle event discard in poll_events

Add some explanatory comments and a changelog entry.
2018-04-15 10:16:44 -07:00
Evan Weiler 2477d8ce46 [ci skip] Doc fix for struct winit::Window (#452) 2018-04-13 14:51:10 -04:00
Osspial 24333b806a Update windows set_cursor to use more variants of MouseCursor (#407)
* Update windows set_cursor to use more variants of MouseCursor

* Add changelog entry
2018-04-13 13:53:01 -04:00
Lymia Aluysia c327960f3e windows: Adjust min_dimensions and max_dimensions using AdjustWindowRectEx. (#444) 2018-04-13 12:51:29 -04:00
Edwin Cheng bdc01fee1a Implement set_maximized, get_current_monitor, set_fullscreen and set_decorations for windows (#457)
* Implement set_fullscreen for windows

* Implement get_current_monitor for windows

* Implement set_maximized

* Implement set_decorations for windows

* Update CHANGELOG.md

* Fixed minor syntax bug for stable rust version

* Added support for WindowBuilder::with_maximized

* Move all window sized related functions to main thread

* Refactor and formatting force_window_active

* Remove unused code

* Update CHANGELOG.md

* Refactor and change keyboard handling code

* Reformatting and refactoring

* Added back missing link for comment

* Fixed set_maximized and set_fullscreen wrong order bug

* Call ShowWindow(SW_RESTORE) when restore_saved_window

* Sync system maximized status when set_fullscreen

* Fixed wrong function name
2018-04-12 13:12:15 -04:00
Francesca Frangipane 457c0b7208
Windows: Implement Refresh event (#454)
Fixes #180
2018-04-11 09:29:01 -04:00
Francesca Frangipane 09c809003b
x11: Overhaul XIM code (#451)
Fixes #195
Fixes #277
Fixes #455

* Read `XMODIFIERS` explicitly/directly instead of calling `XSetLocaleModifiers` with an
empty string. This is useful for debugging purposes, and more clear to read and handle.
* Fallback to local input method if the one specified in `XMODIFIERS` is later closed on the
server end (i.e. if ibus/fcitx is terminated). Previously, that would cause the event loop
to freeze and usually also segfault.
* If using the fallback input method, respond to the `XMODIFIERS` input method later
becoming available. This means that the input method restarting is handled, and that even if
the program was started while ibus/fcitx/etc. was unavailable, it will start using it as
soon as it becomes available.
* Only one input method is opened for the whole event loop, with each window having its own
input context.
* IME works completely out of the box now, no longer requiring application developers to
call `setlocale` or `XSetLocaleModifiers`.
* Detailed error messages are provided if no input method could be opened. However, no
information is provided to the user if their intended `XMODIFIERS` input method failed to
open but the fallbacks (which will ostensibly always succeed) succeeded; in my opinion, this
is something that is best filled by adding a logging feature to winit.
2018-04-10 22:18:30 -04:00
Joe Moon f08bf44670 [macOS] implement HiDPIFactorChanged event on relevant events: (#443)
* moving window to another screen
* changing resolution of screen
2018-04-10 21:42:22 -04:00
Simon Sapin e36fd1788d Fix some more unconstrained types in msg_send results (#453)
The error I was investigating https://github.com/servo/servo/pull/20474#issuecomment-379802897 turned out to be already be fixed by https://github.com/tomaka/winit/pull/428, but there was a few more cases of the same problem.
2018-04-09 15:58:47 -04:00
Francesca Frangipane 4005bf11e4
x11: More robust geometry calculations (#438)
Tested on the following window managers:
* Xfwm4 4.12.4
* Mutter 3.26.2
* Muffin 3.6.0
* Budgie 10.4
* Marco 1.20.0
* Compiz 0.9.13.1
* KWin 5.12.3
* Enlightenment 0.22.2
* FVWM 2.6.7
* Awesome 4.2
* i3 4.15
* xmonad 0.13
* dwm 6.1
* Openbox 3.6.1
* Fluxbox 1.3.7
* Blackbox 0.70.1
* IceWM 1.3.8
* IceWM 1.4.2
2018-04-07 15:36:10 -04:00
Ed Barnard 591e0d9b8e Fix macOS window sizes to follow convention with changelog entry (#435)
* Fix macOS window sizes to follow convention

* Add changelog entry
2018-04-05 15:51:15 -04:00
cpardotortosa 580321b56f Add Touch events for win32. (#377)
* Add Touch events for win32.

* Add entry to CHANGELOG.md
2018-04-05 15:25:37 -04:00
Francesca Frangipane 1c4973d5b7
x11: Only access XIM from the event loop thread (#439)
XIM isn't thread-safe at all. Any call made to it from another thread will result in the
event loop freezing (this is why the old implementation of Drop for Window had that
problem).

XIM is now confined to one thread, and the existing API is maintained using channels. In
testing this with Alacritty, I initially thought the occasional slight lag on updating the
spot location was due to this change, but it's present without it as well.
2018-04-05 14:58:10 -04:00
hcpl 7cd440135a Try XOpenIM with different locale modifiers (#424)
* Try XOpenIM with different locale modifiers

Implements the solution suggested in
https://github.com/tomaka/winit/issues/277#issuecomment-337751136.

* Use empty XSetLocaleModifiers beforehand

Also, for modifiers, convert from length-based UTF-8 strings to
null-terminated bytestrings.

* Add CHANGELOG entry and comments
2018-04-05 13:21:50 -04:00
Francesca Frangipane f3ab8af813
x11: Don't panic when using dead keys (#432) 2018-04-05 12:58:24 -04:00
Joe Moon be6d2ed3b9 subclass windows in macos so they can be made resizable even with no decorations (#408)
* make windows without decorations resizable and movable in macos

fixes #368

The subclassing logic was copied from servo's fork of glutin:
63026a0f4c/src/api/cocoa/mod.rs (L418)

* remove `isMovableByWindowBackground` and `mouseDownCanMoveWindow`

* revert example changes

* remove resizable mask from decoration: false

* avoid duplicate class declarations

* update changelog

* fix changelog

* changelog whitespace
2018-04-02 19:12:38 -04:00
Gabriel Majeri b40b14f37f Avoid destroying the window twice (#388) 2018-03-25 20:30:16 +02:00
forbjok 7a1946589c x11: Support numpad arrows/Home/End/PageUp/PageDown/Insert/Delete (#396) 2018-03-23 10:36:04 +01:00
Osspial bbcd3019e8 Add ability to change the min/max size of windows at runtime (#405)
* Add min/max size setting for win32 and wayland backends

* Implement dynamic min/max size on macos

* Add min/max size setting for x11

* Add empty functions for remaining platforms

* Improved min/max size setting for x11

* Added CHANGELOG entry for new min/max methods

* Added documentation for new min/max methods

* On win32, bound window size to min/max dimensions on window creation

* On win32, force re-check of window size when changing min/max dimensions

* Fix freeze when setting min and max size
2018-03-23 10:35:35 +01:00
Francesca Frangipane d667a395b6 x11: Destroy dropped windows; handle WM_DELETE_WINDOW (#416)
Fixes #79 #414

This changes the implementation of Drop for Window to send a WM_DELETE_WINDOW ClientMessage,
offloading all the cleanup and window destruction to the event loop. Unsurprisingly, this
entails that the event loop now handles WM_DELETE_WINDOW using the behavior that was
previously contained in Window's Drop implementation, along with destroying the Window.
Not only does this mean that dropped windows are closed, but also that clicking the × button
on the window actually closes it now.

The previous implemention of Drop was also broken, as the event loop would be (seemingly
permenanently) frozen after its invocation. That was caused specifically by the mutex
locking, and is no longer an issue now that the locking is done in the event loop.

While I don't have full confidence that it makes sense for the Drop implementation to behave
this way, this is nonetheless a significant improvement. The previous behavior led to
inconsistent state, panics, and event loop breakage, along with not actually destroying the
window.

This additionally makes the assumption that users don't need Focused or CursorLeft events
for the destroyed window, as Closed is adequate to indicate unfocus, and users may not
expect to receive events for closed/dropped windows. In my testing, those specific events
were sent immediately after the window was destroyed, though this sort of behavior could be
WM-specific. I've opted to explicitly suppress those events in the case of the window no
longer existing.
2018-03-23 10:31:31 +01:00
Joe Moon ce7a426bb5 323 windowbuilder ext macos (#423)
* macOS: Allow hiding the title from the titlebar

* macOS: Allow making the titlebar transparent

* macOS: Give control over content view size

Allows setting `NSFullSizeContentViewWindowMask` with WindowBuilder.

* macOS: add `.with_titlebar_hidden` to WindowBuilderExt

* macOS: adds `titlebar_buttons_hidden` platform specific attribute
2018-03-22 17:57:35 +01:00
YVT 559681b0ed [macOS] Fix crashes due to the stabilization of the ! (never) type (#428)
Due to the recent changes in the Rust compiler, unconstrained type
variables are now deduced to `!` instead of `()`. There are some
occurrences where `msg_send!` is used without constraining its return
type (relying on the assumption that they would be deduced to be `()`).
As a result, the macOS port of winit stopped working.

This PR fixes this issue (#426) by adding explicit return types to
such uses of `msg_send!`.
2018-03-21 20:36:06 +01:00
Paul Rouget e6fefd5e93 Send Awakened event on Android when event loop is woken up (#417) 2018-03-06 18:06:56 +01:00
Nicholas Lordello f3d43016ad Implement MonitorId::get_hidpi_factor for macOS (#410)
* Implement MonitorId::get_hidpi_factor for macOS

* Added changelog entry
2018-03-06 09:35:04 +01:00
Jim Turner 4c62d71950 Derive more traits for events::ModifiersState (#411) 2018-02-22 18:15:56 +01:00
Imanol Fernandez c62296dc2b Add set_suspend_callback method for Android (#406)
Makes it possible for glutin to register a callback when a suspend event happens on Android
2018-02-15 14:09:14 +01:00
HDM 7daf27f389 Add mouse event capturing when click-dragging out of a win32 window (#292)
* Add mouse event capturing when click-dragging out of a win32 window

* Remove git merge conflict comments

* Add changelog entry
2018-02-14 10:31:25 +01:00
Joe Wilm 4cce65274f Fix x11 window size calculations (#402)
The fix for returning accurate window position lead to a regression
computing inner size in pixels. This commit resolves that by getting
inner size from the window ID winit caches and still resolving position
by climbing the window hierarchy.

Resolves #398
2018-02-08 18:10:39 +01:00
Paul Rouget ff17eff00f Implement MonitorId::get_dimensions for Android (#400) 2018-02-08 14:55:17 +01:00
Johannes Hofmann 107a1e7332 x11: Support XRandR versions older than 1.5 (#394)
* x11: Support XRandR versions older than 1.5

Fixes #392

Previously, initializing the member `xrandr` of `XConnection` resulted
in a panic when symbols from XRandR version 1.5 were missing. There was
already code to handle older versions of XRandR but it was never
executed because of the panic.

The member `XConnection.xrandr` now contains only functions that can
safely be used with older versions. Additionally, this commit adds a new
member to `XConnection` of type `Option<ffi::XRandr>` that only contains
a value if version 1.5 functionality is present.

* x11: Document the xrandr* members of XConnection
2018-02-03 11:18:51 +01:00
Joe Wilm 150d2706f9 Fix x11 Window::get_position wrong values (#386)
Some window managers like i3wm will actually nest application windows
(like those opened by winit) within other windows to, for example, add
decorations. Initially when debugging this method on i3, the x and y
positions were always returned as "2".

The solution that other xlib abstractions use is to climb up the window
hierarchy until just below the root window, and that window must be used
to determine the appropriate position.

This patch doesn't take into account borders or the window's offset
within its parent, but it's much more usable than the original
implementation on certain WMs.
2018-01-27 14:26:13 +01:00
Benjamin Cheng 7d38ed2fab X11: Cursor grabbing fixes (#385)
- Only update cursor_state when the grab is successful
- Ungrab before grabbing to prevent passive grabs (ex. clicking) from
causing AlreadyGrabbed
2018-01-26 21:52:18 +01:00
Michael Schumacher 1609808e27 Add support for Caret (^) Key in OSX (de_DE) (#380)
* Add caret key

* Use hex value

* Added caret key support.
2018-01-25 13:32:30 +01:00
Robert Günzler 7e1c70964d [macOS] Move the window if there is no title bar (#382)
* macOS: Move the window if there is no title bar

On macOS by default windows can only be moved by clicking and
dragging on the titlebar, if we spawn a window without one we
need to set the `movableByWindowBackground` property.

Partial fix for #368

* macOS: Make moveByWindowBackground optional

Implements setting the property via WindowBuilderExt:

    WindowBuilder::new()
        .with_decorations(false)
        .with_movable_by_window_background(true)

* Update CHANGELOG
2018-01-22 19:07:51 +01:00
Joe Wilm 0e81251f3a Implement hidpi factor for x11 MonitorId (#387)
This was previously hardcoded to 1.0. The values for physical size in
millimeters and pixel counts on each axis are used to compute the dpi
per monitor.
2018-01-22 18:36:26 +01:00
Victor Berger 0ea4f93f05 Implement set_maximized, set_fullscreen and set_decorations for wayland (#383)
* wayland: implement Window::set_decorations()

* wayland: implement Window::set_maximized()

* wayland: implement Window::set_fullscreen()

* Update changelog.
2018-01-13 06:38:12 +01:00
Francesca Sunshine 124b16fcde x11: Always use correct window ID for XInput2 events (#372)
The `CursorMoved` events that are used to send position updates alongside `Focused` and
`CursorEntered` events were using incorrect values for the window ID. This is a direct
result of the X11 backend being hard to understand, as those values came from variables in
the top-level scope of the function, which one would assume to be valid throughout the
entirety of their scope. In reality, their validity is dependent on the event belonging to
the `XEvent` union, so very surprising things can happen if those variables are read in the
case of XInput2/XKB/etc. events. To prevent future accidents, the aforementioned variables
have been removed, and are now defined per-event instead.

Additionally, the `CursorMoved` event sent alongside `Focused` now uses the correct device
ID; it previously used the ID of a master keyboard, but now uses the ID of the pointer
paired to that keyboard. Note that for those using multi-pointer X, the correctness of this
ID is dependent on the correctness of the window manager's focus model.
2018-01-08 11:06:02 +01:00
Dzmitry Malyshau a8d5a9e1ab [emscripten] request canvas size instead of CSS size (#370) 2017-12-27 18:37:01 +01:00
Tuomas Siipola f89dc9e903 x11: Remember cursor after changing cursor state (#374) 2017-12-27 14:30:59 +01:00
Bryan Gilbert 011720848a Added modifier support to mouse events (#328) 2017-12-26 22:46:28 +01:00
Gabriel Majeri d92666c188 Update winapi to 0.3 (#346)
* Update to `winapi` 0.3

* Update max size comment

* Fix missing import

* Shorten import path

* Update to stable winapi version
2017-12-24 14:46:47 +01:00
Francesca Sunshine 463f316cb8 Add set_decorations method to Window (#365)
This has been stubbed on all platforms other than X11. The X11 implementation has also been
revised to toggle correctly, as it was previously only able to remove decorations.
2017-12-22 13:50:46 +01:00
Francesca Sunshine 23e4293179 unix::WindowExt no longer returns pointers for things that aren't actually pointers (#364)
Fixes #256

`get_xlib_window` and `get_xlib_screen_id` previously returned `Option<*mut c_void>` by
casting integer IDs into pointers, which while producing no functionality issues, is
semantically incorrect and rather surprising. Worse still, the docs for `get_xlib_window`
stated that it was in fact a valid pointer.

Additionally, now all `unix::WindowExt` methods return `std::os::raw` types rather than
`libc` types; note that the two versions of `c_void` are not interchangeable in the eyes of
the compiler, so those wanting the `libc` type will need to explicitly cast.

This is a breaking change, and will require some trivial changes to glutin.
2017-12-17 10:17:26 +01:00
Francesca Sunshine 8f18dab061
x11: Send window maximization hints correctly (#363)
Previously, the maximization hints were being sent as two separate client messages: one for
horizontal, and one for vertical. That resulted in the window only being maximized
horizontally (at least with my WM). The corrected client message sets both of these hints at
once.

In the process of implementing that, the relevant components were refactored to use the util
module, as we gradually move towards a hopeful future of a more readable X11 backend.
2017-12-15 14:37:09 -05:00
Francesca Sunshine 9698d0a8d8
x11: Set window title prior to mapping window (#362)
Fixes #282

Some tiling window managers (i3, dwm, etc.) determine how a window should behave based on
its name. If the name is set after mapping, then window managers will check the name before
we set it, followed by them detecting it as a change when the name is actually set. That
results in the window briefly behaving in an unexpected way, followed by a rapid switch to
the expected behavior.

In accordance to section 4.1.2 of ICCCM, the name, decorations, size hints, and window
deletion redirection have all been moved up to be set before mapping.
2017-12-13 16:41:49 -05:00
Francesca Sunshine d18db208ff x11: Implement file drag and drop (#360)
* x11: Implement file drag and drop

* Fixed typo
2017-12-13 12:22:03 +01:00
thiolliere d2dd82c146 impl touch events for emscripten (#358) 2017-12-01 14:00:09 +01:00
thiolliere 663d615379 Emscripten (#357)
* impl modifiers state for emscripten

* impl mouse events emscripten

* impl mousemotion for emscripten

it is useful when cursor is grabbed

* changelog
2017-12-01 10:53:50 +01:00
stuart nelson 0f14e63b34 Send mouse position after focused/cursorenter events (#349)
* Update mouse pos after cursor enter event

* Update mouse position on windows focus

* Send device_id

* Update other device id

* Fix windows import

* Remove deque for vec

* Just send event

* Use correct push_back method

* Push correct event
2017-11-26 21:43:13 +01:00
Jacob Kiesel fae10c6072 Emit delete character on Windows (#352) 2017-11-21 10:12:51 +01:00
Jacob Kiesel cfd087d9a5 Mouse events (#344)
* Explicit mouse-related DeviceEvents

This makes the API more intuitive for common use-cases and allows us
to better propagate platform knowledge of motion semantics.

* Improve event naming consistency

* Clarify axis event forwards-compatibility

* Rename WindowEvent::MouseMoved/Entered/Left to CursorMoved/...

This emphasizes the difference between motion of the host GUI cursor,
as used for clicking on things, and raw mouse(-like) input data, as
used for first-person controls.

* Add support for windows and OSX, fix merging

* Fix warnings and errors on Linux

* Remove unnecessary breaking changes

* Add MouseWheel events to windows and OSX

* Fix bad push call.

* Fix docs, naming, and x11 events

* Remove mutability warning

* Add changelog entry
2017-11-12 21:56:57 +01:00
Victor Berger c61f9b75f8
Wayland: implement touch events (#342)
* wayland: move pointer to its own file

* wayland: touch events support

* update changelog
2017-11-11 10:03:42 +01:00
Gabriel Majeri bbf13561b5 Fix docs rendering (#340) 2017-11-05 11:21:57 +01:00
Victor Berger 61d25be3e0
wayland: upgrade wayland-window (#339)
* wayland: upgrade wayland-window

This new version of wayland window considerably simplifies the
window handling for winit, meaning much of the previous juggling
is no longer needed, and the windows will appear even if nothing is
drawn.

* wayland: cleanup unused stuff
2017-11-03 17:35:29 +01:00
Andriy Symonovych 37a10e6741 update macos deps (#335) 2017-10-31 11:03:18 +01:00
Victor Berger 62e45fa75d wayland: update dependencies (#334) 2017-10-30 07:27:43 +01:00
Ken Reed 01d1178d7b Made poll events loop over as many events as there may be instead of just one. (#333) 2017-10-29 07:02:57 +01:00
Alex Butler b3c5ee6219 Fix no primary monitor panic in XWayland (#318)
* Fix no primary monitor panic in XWayland

In this case try to use the first existing monitor instead of panicking.
Fixes #317

* Shift no monitor panic to x11::get_primary_monitor

* Update changelog with xll get_primary_monitor fallback
2017-10-28 15:24:37 +02:00
Bruno Ploumhans 36058ab8e6 Improve the documentation of DeviceEvent::Motion (#321) 2017-10-28 12:33:51 +02:00
Chris Tolliday 159364bec3 Impl Clone for EventsLoopProxy (#331) 2017-10-25 20:03:57 +02:00
Victor Berger 58181dbff9 wayland: Fix drop order for display (#326) 2017-10-25 18:28:24 +02:00
kryptan 760e588627 Use EnumDisplayMonitors to enumerate monitors on Windows (#327)
* Use EnumDisplayMonitors to enumerate monitors on Windows

* Add requested changes
2017-10-25 17:12:39 +02:00
Victor Berger d10312c6b1 Rewrite of wayland backend to new wayland-client API (#325)
* wayland: clean state for rewrite to new wayland-client API

* wayland: context init

* wayland: Monitors logic

* wayland: Basic event loop logic

* wayland: Keyboard handling

* wayland: pointer handling

* wayland: refactor to remove WaylandContext

* wayland: window logic

* wayland: event dispatching logic

* wayland: update changelog
2017-10-20 09:46:42 +02:00
kryptan 4e4db1749d Make MonitorId::get_position() return (i32, i32) instead of (u32, u32) because it can be negative on Windows (#324) 2017-10-19 19:08:05 +02:00
Victor Berger 229029f2da Formalize thread-safety guarantees (#322) 2017-10-18 20:40:21 +02:00
kryptan 48902297b7 Implement public API for high-DPI (#319)
* Implement public API for high-DPI #105

* Recover get_inner_size_points and get_inner_size_pixels and change their implementation assuming get_inner_size() returns size in pixels

* Update changelog for high-DPI changes
2017-10-17 13:56:38 +02:00
Chet Gurevitch eff3440482 Mirror x11 ISO_LEFT_TAB detection on wayland and release version 0.8.3 (#314)
* wayland: mirror x11 ISO_LEFT_TAB detection

* Release 0.8.3
2017-10-12 09:39:41 +02:00
Victor Berger 3d8c94bae5 wayland: commit the empty surface at init (#309)
This should trigger the compositor's mechanism for sending a
configure event, which should most of the time be processed
before any winit user actually tries to draw.
2017-10-08 15:51:48 +02:00
Matteo Signer 3f33cd1929 Make ISO_Left_Tab generate VirtualKeyCode::Tab (#308)
* Make ISO_Left_Tab generate VirtualKeyCode::Tab

* Add changes to changelog
2017-10-08 13:59:45 +02:00
Pedro Côrte-Real 1db92063d9 Fix X11 on 32bit architectures (#311)
* Add an i386 target to travis

* Fix X11 on 32bit architectures

One would hope 32bit X11 was dead by now but apparently not :). Fix
the window hint setting code to not assume window IDs are 64bit as
apparently they are not in 32bit arches.
2017-10-07 21:20:37 +02:00
Chris Tolliday 5af88d97e8 On Windows, use SWP_ASYNCWINDOWPOS to prevent thread from blocking when calling (#302)
set_inner_size
2017-10-04 09:42:35 +02:00
Victor Berger 515595153d Wayland: rework the event loop & expose readiness signal (#298)
* wayland: don't create a second event_queue

As each EventsLoop has its own context, this is no longer necessary.

* wayland: buffer events rather than direct dispatch

Changes the behavior of the event loop to first internally
buffer the events generated by the wayland handlers, and then
dispatch them to the client's closure.

- It simplifies the event loop logic
- It makes it possible for the user to call window methods such as
  `set_title()` or `set_inner_size()` without causing a deadlock

* wayland: add is_ready() & fix protocol errors

Adds a `is_ready()` method to the windows to advertize
when it is legal to start drawing, and fix a few wayland
protocol mishandling in the process.
2017-09-27 16:31:46 +02:00
David Harvey-Macaulay df7e349c70 Complete documentation for top-level items (#299) 2017-09-25 15:58:59 +02:00
Victor Berger 9c116a1bae x11: uniformize keyboard scancodes with linux (#297) 2017-09-25 07:25:36 +02:00
tomaka 15fbc0dff4 Publish 0.8.1 with fixes necessary for glutin (#296) 2017-09-23 09:36:30 +02:00
Matteo Signer 52a78d61bf Fix #273 (#274) 2017-09-21 16:09:07 +02:00
tomaka f81a0741f5 Fixes to the documentation of EventsLoop (#288) 2017-09-17 19:59:36 +02:00
Kelvin Ly 192bd798e3 Implement virtual key translation for emscripten (#289)
* Implement virtual key translation

* Remove unused std::mem import from the right file

* Install git on CircleCI instances

* Fix CircleCI config script

* Fix type error in emscripten keyboard events
2017-09-16 15:46:53 +02:00
tomaka 52a7b07c79 Move the Suspended event outside of WindowEvent (#284)
* Move Suspended event outside of WindowEvent

* Adjust the iOS code
2017-09-15 16:24:09 +02:00
tomaka 1d0b5bcfbd Remove the use platform_not_supported hack (#285) 2017-09-15 15:45:45 +02:00
tomaka 769d4fe897 Emscripten rework (#286)
* partial implementation for emscripten

this pull request contain a partial but working implementation of emscripten backend

some implementations may be controversial.

here some implementation detail:

* cursor state:
  * on grab: emscripten request pointer lock deferred and also set a callback when pointer lock change
             the callback request pointer lock deferred.
  * on hide: `emscripten_hide_mouse` exist but not `emscripten_show_mouse`
             a pull request has been open on october 2016 but never been merged
             so I copied the javascript function and put it in emscripten_asm_const function

* fullscreen: if fullscreen is requested then it request fullscreen deferred and set a callback on fullscreen change
              the callback request fullscreen deferred

* run forever: this method use emscripten main loop to run an infinite loop

* keyboard callback doesn't consume the event. I think it is more apopriate as in desktop environment it is the same, is it ?

* emscripten dir is added in example and contains html pages

Some things that are not implemented:

* lots of events

* min and max dimension can be implemented with a callback that listen to size change and resize if dimension out of bound

* title may be implemented using javascript to change document.title

* Use std::os::raw in the emscripten bindings

* Fix emscripten code

* Update code

* Add CI

* Remove the emscripten-specific examples

* Add some information to the README
2017-09-14 16:31:34 +02:00
tomaka ae7802c8c2 Fix warnings for win32 (#283) 2017-09-13 11:15:16 +02:00
pravic c82fcd203f Update docs of windows-specific methods (#281) 2017-09-13 09:19:54 +02:00
Pedro Côrte-Real 59c33d2c6a Move fullscreen modes to not touch physical resolutions (#270)
* Fix X11 screen resolution change using XrandR

The previous XF86 resolution switching was broken and everything
seems to have moved on to xrandr. Use that instead while cleaning
up the code a bit as well.

* Use XRandR for actual multiscreen support in X11

* Use actual monitor names in X11

* Get rid of ptr::read usage in X11

* Use a bog standard Vec instead of VecDeque

* Get rid of the XRandR mode switching stuff

Wayland has made the decision that apps shouldn't change screen
resolutions and just take the screens as they've been setup. In the
modern world where GPU scaling is cheap and LCD panels are scaling
anyway it makes no sense to make "physical" resolution changes when
software should be taking care of it. This massively simplifies the
code and makes it easier to extend to more niche setups like MST and
videowalls.

* Rename fullscreen options to match new semantics

* Implement XRandR 1.5 support

* Get rid of the FullScreen enum

Moving to just having two states None and Some(MonitorId) and then
being able to set full screen in the current monitor with something
like:

window.set_fullscreen(Some(window.current_monitor()));

* Implement Window::get_current_monitor()

Do it by iterating over the available monitors and finding which
has the biggest overlap with the window. For this MonitorId needs
a new get_position() that needs to be implemented for all platforms.

* Add unimplemented get_position() to all MonitorId

* Make get_current_monitor() platform specific

* Add unimplemented get_current_monitor() to all

* Implement proper primary monitor selection in X11

* Shut up some warnings

* Remove libxxf86vm package from travis

Since we're no longer using XF86 there's no need to keep the package
around for CI.

* Don't use new struct syntax

* Fix indentation

* Adjust Android/iOS fullscreen/maximized

On Android and iOS we can assume single screen apps that are already
fullscreen and maximized so there are a few methods that are implemented
by just returning a fixed value or not doing anything.

* Mark OSX/Win fullscreen/maximized unimplemented()!

These would be safe as no-ops but we should make it explicit so
there is more of an incentive to actually implement them.
2017-09-07 10:33:46 +02:00
tomaka 342d5d8587 Remove api_transition macro (#279)
* Remove api_transition macro

* Rename Window2 to Window

* Try fix X11 code
2017-09-06 17:32:24 +02:00
tomaka 2a4b381384 Update iOS for EventsLoop design (#275)
* Inline gen_api_transition! in the ios module

* Event loop proxy work

* Monitors

* Use freestanding functions

* Finish conversion
2017-09-04 12:41:10 +02:00
tomaka fe1deb83ae Update Android code with EventsLoop (#272)
* Update Android code with EventsLoop

* Fix run_forever
2017-09-04 12:41:02 +02:00
Pedro Côrte-Real 5b57b73fe8 Remove dead code causing warnings (#278) 2017-09-04 08:45:56 +02:00
tomaka 3d1c18ded9 Events loop backend (#269)
* Don't use UNIX_BACKEND in Window2::new

* Move get_available_monitors and get_primary_monitor to EventsLoop

* Remove UNIX_BACKEND

* Restore choosing the Linux backend

* Return a XNotSupported for new_x11()

* Fix fullscreen example
2017-09-01 11:04:57 +02:00
tomaka e65cacbc86 Use a sync::Barrier on win32 to sync threads instead of a channel (#271) 2017-08-31 19:45:17 +02:00
Victor Berger 1b22e39fb2 wayland: internal event buffer & wait for xdg configure (#255) 2017-08-31 19:43:24 +02:00
tomaka 7dc6fcdedc Rework MonitorId::get_native_identifier (#267)
* Rework MonitorId::get_native_identifier

* Try fix compilation

* Returns the monitor ID on wayland as well

* Try fix compilation

* Fix iOS compilation
2017-08-30 08:49:18 +02:00
Pedro Côrte-Real 60b575a7c1 Get rid of FullScreenState::get_monitor() 2017-08-29 02:53:13 +01:00
Pedro Côrte-Real 9693f7caa9 Convert new fullscreen API in all platforms 2017-08-29 02:16:16 +01:00
Pedro Côrte-Real 1382adbf11 Unify fullscreen and fullscreen_windowed APIs
Use the enum to make a single fullscreen API that's much more
consistent. Both set_fullscreen() and with_fullscreen() take the
same enum and support all the variations so you can build the window
however you want and switch between the modes at runtime.
2017-08-29 01:36:24 +01:00
Pedro Côrte-Real b35c4a5ee5 maximized/fullscreen as noops for other platforms 2017-08-28 02:23:55 +01:00
Pedro Côrte-Real eff04394c9 Slight maximize/fullscreen X11 cleanup 2017-08-28 02:23:55 +01:00
Pedro Côrte-Real 1d97a2a506 Implement Windowed Fullscreen
There are two kinds of fullscreen. One where you take over the whole
output the other where you just set the window size to the screen
size and get rid of decorations. The first one already existed,
implement the second which is more common for normal desktop apps.
Use an enum to consolidate all the fullscreen states.
2017-08-28 02:23:55 +01:00
Pedro Côrte-Real a4052b8693 Add window maximization API
Implement a simple API to set a window to maximized. Implement it
only for the X11 backend.
2017-08-28 01:28:42 +01:00
Lloyd Cunningham f81d6ddf93 Derive Clone for CreationError 2017-08-23 20:52:06 -05:00
tomaka 200ef9c307 Merge pull request #244 from robsaunders/mac-file-drag-and-drop
Mac file drag and drop
2017-08-18 11:35:19 +02:00
tomaka 63fdc3f903 Merge pull request #241 from rukai/add-windows-virtual-key-codes
Add missing windows virtual key codes
2017-08-07 07:59:51 +02:00
Lloyd Cunningham 24f5b0b591 Derive Clone for MonitorId 2017-08-05 18:15:50 -05:00
Osspial 786666aca8 Revise Mutex+Convar implementation based on PR feedback 2017-08-05 02:51:30 -04:00
Osspial 657860a233 Re-implement resize patch using Mutex + Convar 2017-08-05 02:07:58 -04:00
Osspial d2034b1700 Add null terminator to custom events 2017-08-02 20:50:55 -04:00
Osspial 13bd116891 Fix laggy rendering when resizing win32 window 2017-08-02 20:49:50 -04:00
tomaka a582df443b Merge pull request #229 from swiftcoder/master
Implement raw mouse movement for Mac
2017-08-02 15:30:58 +02:00
tomaka 718e0f8551 Merge pull request #247 from zpgaal/issue_240_simple
Issue 240 alternative fix
2017-07-31 19:32:33 +02:00
zpgaal d868510cc8 Comment to describe message order 2017-07-31 18:00:29 +02:00
Benjamin Saunders c508d68d1d Fix evdev emulated scroll events
When X's evdev input module is configured to emulate scroll events (as
used with e.g. trackpoints), it generates non-emulated scroll button
presses and does not generate motion events. This is contrary to the
behavior of all other hardware I've tested, and contrary to the
behavior of libinput, but nonetheless should be supported.
2017-07-30 11:40:52 -07:00
Tristam MacDonald 15c4641758 Unwrap axis id in raw mouse motion on Mac 2017-07-29 08:11:46 -07:00
Tristam MacDonald 6820e2a826 Implement raw mouse motion for Mac 2017-07-29 08:04:37 -07:00
Tristam MacDonald ed761bef7d Also hide the cursor when grabbed 2017-07-29 08:04:37 -07:00
gzp c57ec33c00 also call default window handle on wm_close 2017-07-28 13:12:16 +02:00
gzp 28cdce99c0 replace wm_destroy by wm_close 2017-07-28 13:09:50 +02:00
Umur Gedik d65d9950f2 Fixes window inner size calc for hidpi windows X11
X11 always return the geometry in pixel units. Since
window.get_inner_size returns the size in points in other window manager
implementations X11 should also return in points instead of pixels.
2017-07-27 14:04:04 +09:00
Rob Saunders 06e01e4cb3 Added event for cancelling a drag and drop. 2017-07-27 10:56:34 +08:00
Rob Saunders 5f00028f6b Mac module emits the winit events DroppedFile and HoveredFile. 2017-07-27 10:51:00 +08:00
Rob Saunders 4ef7c71c66 Initial drag and drop support for Mac OS, printing filenames to stdout. 2017-07-27 00:59:42 +08:00
Lucas Kent 32eea41b1b add missing windows virtual key codes 2017-07-24 20:21:04 +10:00
Victor Berger 8d5b23d56c Update wayland-window to support xdg_shell 2017-07-19 18:28:14 +02:00
tomaka 28eddb64a9 Merge pull request #238 from GuildMasterInfinite/gui-thread
Use `IsGUIThread` to initialize message queue
2017-07-18 20:53:59 +02:00
tomaka 2066909845 Merge pull request #223 from Determinant/xim-send-spot
XIM support for sending spot to IME
2017-07-18 20:09:02 +02:00
Gabriel Majeri 8add21b04f Use IsGUIThread to initialize message queue 2017-07-18 20:57:22 +03:00
Alex Butler 58b800c344 Fix wayland vertical scroll sign 2017-07-18 12:47:01 +01:00
Benjamin Saunders 506e830cb0 Fix X11 scroll direction
This was inconsistent with the documented semantics of MouseScrollDelta.
2017-07-17 23:52:28 -07:00
Benjamin Saunders b09e3b2568 Fix windows build
An inconsistency was introduced by the independent merging of #211
with #213.
2017-07-17 17:57:25 -07:00
tomaka 2e079fe9a2 Merge pull request #211 from Ralith/transparent-ids
Transparent axis/button IDs
2017-07-17 07:37:26 +02:00
Rukai e1e21ded28 Fix x11 ModifiersState 2017-07-15 09:58:32 -07:00
Pierre Krieger 7a1a2667b1 Reimplement platform_window on win32 2017-07-13 21:14:32 +02:00
Determinant 9cd370fa4c Merge branch 'master' of https://github.com/tomaka/winit into xim-send-spot 2017-07-12 13:46:01 -04:00
Determinant d6b9faacc9 rename the field 2017-07-12 13:26:11 -04:00
tomaka 9462a51f32 Merge pull request #203 from Determinant/xim-improvement
XIM: Increase the string lookup buffer size and add IC focus/unfocus.
2017-07-12 19:14:11 +02:00
Determinant 8e13f85fac Merge branch 'xim-improvement' into xim-send-spot 2017-07-12 01:24:30 -04:00
Determinant f2ee78bcf5 Merge branch 'master' of https://github.com/tomaka/winit into xim-send-spot 2017-07-12 00:04:12 -04:00
Determinant aea61a74fb remove the the redundant code, fix a bug 2017-07-12 00:00:51 -04:00
Rukai 117beed0b5 Fix x11 mouse scroll wheel 2017-07-11 17:15:23 +10:00
Imanol Fernandez 5ebeb8ab5f Fix Android compilation error 2017-07-06 23:33:42 +02:00
tomaka 90a81cca29 Merge pull request #214 from tomaka/rm-cgl
Remove dependency on cgl on OSX
2017-07-05 09:38:26 +02:00
Lucien Greathouse 0371b6573f Implement raw mouse motion for Windows 2017-07-05 00:28:08 -07:00
Pierre Krieger ac0d6c890a Remove dependency on cgl on OSX 2017-07-05 09:13:39 +02:00
Determinant 75856e0e39 dynamically reallocate buffer; release mutex before callback 2017-07-01 12:24:35 -04:00
Benjamin Saunders 3d9e8da9ec Transparent axis/button IDs 2017-07-01 02:22:02 -07:00
Brendan Zabarauskas 886eab5c7e Fix build on nightly
Nightly recently fixed some soundness issues related to `Sized`. This had to be fixed in the cocoa crates as well, and also affects our ios bindings.
2017-07-01 17:48:47 +10:00
Pierre Krieger 61ba6dce7f Switch win32 implementation to new design 2017-06-26 21:46:26 +02:00
Victor Berger 05cd9f2114 Merge pull request #199 from alexheretic/xwayland-env-var
Add a `WINIT_UNIX_BACKEND` environment variable to all the user to control the choice of x11/wayland backend.
2017-06-25 10:40:05 +02:00
Determinant 5e5debc48f increase the buffer size; proper IC focus/unfocus 2017-06-23 14:27:48 -04:00
Victor Berger e915454a9d linux: update wayland dependencies 2017-06-23 20:25:06 +02:00
Victor Berger 66a12d5332 linux: stop exposing wayland_client's types 2017-06-23 20:20:49 +02:00
Alex Butler 3a89843767 Add WINIT_UNIX_BACKEND documentation 2017-06-21 20:10:23 +01:00
Alex Butler eaa92a4282 Improve unix backend env var docs 2017-06-21 19:59:56 +01:00
Alex Butler 789598fa84 Rename unix backend env var
Rename inline with stricter behaviour
Add docs explaining behaviour
2017-06-21 19:54:21 +01:00
Alex Butler 7a19ef1907 Make usage of env vars strict
Using `BACKEND_PREFERENCE_ENV_VAR=$backend` will no longer fallback on
any other backend
2017-06-21 19:41:26 +01:00
Alex Butler 9804cad7dd Allow usage of XWayland
Will prefer X11 over wayland when the environment variable
`WINIT_PREFER_UNIX_BACKEND=x11` is set.
2017-06-21 18:34:16 +01:00
mitchmindtree 04ccad1dbc Rename ControlFlow variant from Complete to Break 2017-06-20 21:25:53 +10:00
mitchmindtree df1276d72a Fix x11 EventsLoopProxy::wakeup implementation using a dummy, InputOnly window 2017-06-17 22:59:56 +10:00
mitchmindtree cd71271f0d Fix api_transition ControlFlow update compile errors 2017-06-09 07:33:22 -07:00
mitchmindtree 4b42af910b Make x11 backend take &mut self in poll_events method 2017-06-09 22:55:48 +10:00
mitchmindtree 0af3c04900 Update api transition to use ControlFlow 2017-06-09 22:55:32 +10:00
mitchmindtree 0237526999 Complete macos backend update to addition of ControlFlow 2017-06-09 22:13:30 +10:00
mitchmindtree c5b9bd3612 Update macos backend to addition of ControlFlow (untested) 2017-06-09 19:40:22 +10:00
mitchmindtree db9e80bdb6 Update examples and tests to addition of ControlFlow 2017-06-08 00:12:41 +10:00
mitchmindtree f2dd2f0752 WIP - Make poll_events and run_forever take &mut self
This removes the need for the EventsLoop::interrupt method by inroducing
a ControlFlow type. This new type is to be returned by the user's
callback and indicates whether the `EventsLoop` should continue waiting
for events or break from the loop.

Only the wayland, x11 and api_transition backends have been updated so
far, and only the wayland backend has actually been tested.
2017-06-02 21:19:45 +10:00
mitchmindtree 38856b1c60 X11 - Move event insertion from interrupt to proxy wakeup. 2017-05-31 18:07:51 +10:00
mitchmindtree 2b55b2e0ef Temporarily remove windows window-specific awakened event. Needs to be updated to non-window-specific Event. 2017-05-31 16:11:06 +10:00
mitchmindtree 8f0ef514b1 Fix incorred Awakened import in windows backend 2017-05-31 15:52:15 +10:00
mitchmindtree 647a1727d0 Attempt to update api_transition to addition of EventsLoopProxy 2017-05-31 15:35:08 +10:00
mitchmindtree 339318f295 Update macOS backend to removal of Send+Sync and addition of EventsLoopProxy 2017-05-31 15:00:49 +10:00
mitchmindtree 9ca2f83784 Call flush so that the wayland eventsloop correctly breaks from dispatch when wakeup is called 2017-05-27 22:51:59 +10:00
mitchmindtree f6587aed39 [WIP] Have EventsLoopProxy::wakeup return a Result. Begin linux impl.
X11 and Wayland implementations are now half implemented, however both
still do not correctly break from the inner blocking event dispatch
functions when `wakeup` is called, which they should do.
2017-05-25 23:19:13 +10:00
mitchmindtree 06a5ec35b3 [WIP] Remove Sync and Clone from EventsLoop. Add EventsLoopProxy.
This commit only updates the top-level API to get some early feedback.
None of the platform-specific code has been updated yet. I'm hoping to
get around to this over the next couple days however if someone more
familiar with the windows backend would like to do a PR against this
fork that would be a great help.

Closes #187.
2017-05-25 20:13:54 +10:00
mitchmindtree fdb1c56366 Move interrupt flag reset to beginning of run_forever in wayland backend 2017-05-25 02:54:32 +10:00
mitchmindtree 1523548d3e wayland: Reset the intterupted flag before breaking from run_forever
This is important for any code that re-enters `run_forever` after some
previous interrupt.
2017-05-25 00:19:30 +10:00
Victor Berger 148c751f32 wayland: Initially paint the window white so that they always exist 2017-05-23 21:53:17 +02:00
Victor Berger c2c27c1b37 wayland: Fix deadlock in poll_events 2017-05-14 15:28:27 +02:00
tomaka c33bedce5e Merge pull request #178 from jwilm/fix-x11-poll-events
Fix poll_events on x11 not draining completely
2017-05-12 09:10:25 +02:00
Joe Wilm 55b5054d50 Derive Clone on winit::EventsLoop wrapper
Resolves #177.
2017-05-11 23:04:28 -07:00
Joe Wilm 4ec5078bdb Fix poll_events on x11 not draining completely
If the interrupted flag were set going into poll_events, it would only
ever handle the first event in the queue. Now, the flag is reset at the
start so events are processed until the caller requests otherwise.
2017-05-11 23:00:22 -07:00
vanderlokken f034017ab2 FIxed obsolete strings 2017-05-11 03:14:38 +03:00
vanderlokken 5645941a14 Fixed obsolete comments 2017-05-11 03:10:07 +03:00
Joe Wilm 46057d7122 Remove unnecessary locking
For X11 interrupt, we can just use the root window which doesn't require
taking a lock to find.
2017-05-09 21:30:31 -07:00
Joe Wilm f3db0ba641 Fix x11 interrupt to actually wake event loop
This is the same behavior as with WindowProxy::wakeup_event_loop in
previous versions.

Unfortunately, `EventsLoop::interrupt` is also the recommend way to exit
a `run_forever` loop from within the event handler callback. Pushing an
extra event on the queue in that case is simply wasteful. Changing this
would require a refactor taking one of two possible forms:

1. Add a method *in addition* to interrupt intended for waking up the
   event loop
2. Add a return type to the event callback like

    enum Continue { True, False }

   which would be used in lieu of the atomic interrupt flag.
2017-05-09 09:51:00 -07:00
Joe Wilm 8288d419fd Remove unnecessary mut 2017-05-09 09:50:16 -07:00
Joe Wilm c92ac695af Fix x11 poll_events to drain queue
It was only processing a single event per call. The docs say

> Fetches all the events that are pending, calls the callback function
> for each of them, and returns.

which suggests that was incorrect.
2017-05-09 09:20:35 -07:00
Joe Wilm 0b75a6b60c Make keyboard input event order consistent
All platforms should now receive events in the following order:

1. KeyboardInput(ElementState::Pressed, ..)
2. ReceivedCharacter
3. KeyboardInput(ElementState::Released, ..)

cc https://github.com/tomaka/glutin/issues/878
2017-05-07 21:16:48 -07:00
tomaka 15aafc2908 Merge pull request #164 from Ralith/rich-input
Richer input events
2017-05-07 08:35:03 +02:00
Jon Gjengset 4087627b12
Set WM_CLASS and WM_NAME before mapping window
ICCCM 4.1.2.5 (https://tronche.com/gui/x/icccm/sec-4.html#WM_CLASS)
states that:

> This property must be present when the window leaves the Withdrawn
> state and may be changed only while the window is in the Withdrawn
> state.

Previously, we would first map the window, and then set these
properties, causing sadness for window managers (#167,
tomaka/glutin#879). This patch changes that by setting the class and
name attributes immediately after the window is created, and before it
is mapped.

Fixes #167.
2017-05-04 17:37:24 -04:00
torkleyy c4cdb9aa5c Set repr of VirtualKeyCode to u32
This allows to have an array of bools for the key states.
2017-04-26 07:53:20 +02:00
Benjamin Saunders 22bc119cd7 Richer input events
This expands input events to represent sub-pixel mouse positions, devices responsible for generating events, and raw
device-oriented events. The X11 back end is refactored to make full use of the new expressiveness. Other backends have
had new functionality minimally stubbed out, save for the macos backend which already supports sub-pixel mouse
positions.
2017-04-23 01:08:15 -07:00
mitchmindtree cccc48b84d [macos] Emit a resize event when Window changes screens 2017-03-19 20:30:54 +11:00
mitchmindtree 4656540417 Close NSWindow when Window is dropped if not already closed.
Previously, if a `Window` was `Drop`ped while open, the window would
remain open until the user pressed the x button. This fixes the
behaviour so that the window is closed when dropped if it has not
already been closed.
2017-03-19 19:32:24 +11:00
mitchmindtree 27bd796c2a [macos] Remove Window from EventsLoop's Window list on close and drop
Previously, a Window was only removed from the list when dropped.
2017-03-19 19:20:38 +11:00
mitchmindtree 41e7572147 [macos] Avoid panic when callback is None.
This can happen when window is destroyed/created during a call to user
callback as this causes WindowDelegate method to be called.

Instead if the user callback is `None` store the event in
`pending_events`.
2017-03-19 19:09:20 +11:00
mitchmindtree 4b39f81621 Avoid leaking Windows by storing Weak pointers in EventsLoop 2017-03-19 18:19:24 +11:00
Victor Berger 08254e68fb Readd pub import erroneously removed 2017-03-15 10:11:43 +01:00
Victor Berger 50f38e2f76 wayland: Update to wayland 0.8.6 2017-03-13 19:18:49 +01:00
tomaka 2e82cac69a Merge pull request #154 from vberger/wayland_new_api
Port wayland to the new API
2017-03-11 09:04:09 +01:00
Victor Berger d3356763dc wayland: add some comments 2017-03-10 23:56:31 +01:00
Victor Berger 3ff9eb08e8 wayland: cleanup signal to prune dead windows 2017-03-10 23:40:31 +01:00