28 |
29 | _masir_ is a focus follows mouse daemon for Microsoft Windows 11 and above.
30 |
31 | _masir_ allows you to focus an application window by moving your mouse over it, without requiring mouse clicks or
32 | touchpad taps.
33 |
34 | _masir_ does not have a dependency on any specific external software or tiling window manager.
35 |
36 | _masir_ has an additional integration with [komorebi](https://github.com/LGUG2Z/komorebi) to ensure that only windows
37 | managed by the tiling window manager are eligible to be focused. Integrations with other tiling window managers are
38 | welcome (["Integrations"](#integrations).)
39 |
40 | _masir_ is a free and educational source project, and one that encourages you to make charitable donations if you find
41 | the software to be useful and have the financial means.
42 |
43 | I encourage you to make a charitable donation to
44 | the [Palestine Children's Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) or contributing to
45 | a [Gaza Funds campaign](https://gazafunds.com) before you consider sponsoring me on GitHub.
46 |
47 | [GitHub Sponsors is enabled for this project](https://github.com/sponsors/LGUG2Z). Unfortunately I don't have anything
48 | specific to offer besides my gratitude and shout outs at the end of _komorebi_ live development videos and tutorials.
49 |
50 | If you would like to tip or sponsor the project but are unable to use GitHub Sponsors, you may also sponsor
51 | through [Ko-fi](https://ko-fi.com/lgug2z).
52 |
53 | # Installation
54 |
55 | ```powershell
56 | winget install LGUG2Z.masir
57 | ```
58 |
59 | `masir` can be run as a standalone process, or launched alongside `komorebi`
60 | using the `komorebic start` command with the `--masir` flag.
61 |
62 | # Contribution Guidelines
63 |
64 | If you would like to contribute to `masir` please take the time to carefully read the guidelines below.
65 |
66 | ## Commit hygiene
67 |
68 | - Flatten all `use` statements
69 | - Run `cargo +stable clippy` and ensure that all lints and suggestions have been addressed before committing
70 | - Run `cargo +nightly fmt --all` to ensure consistent formatting before committing
71 | - Use `git cz` with
72 | the [Commitizen CLI](https://github.com/commitizen/cz-cli#conventional-commit-messages-as-a-global-utility) to prepare
73 | commit messages
74 | - Provide **at least** one short sentence or paragraph in your commit message body to describe your thought process for the
75 | changes being committed
76 |
77 | ## License
78 |
79 | `masir` is licensed under the [Komorebi 2.0.0 license](./LICENSE.md), which
80 | is a fork of the [PolyForm Strict 1.0.0
81 | license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
82 | this means that you are free to do whatever you want with `masir` for
83 | personal use other than redistribution, or distribution of new works (i.e.
84 | hard-forks) based on the software.
85 |
86 | Anyone is free to make their own fork of `masir` with changes intended
87 | either for personal use or for integration back upstream via pull requests.
88 |
89 | The [Komorebi 2.0.0 License](./LICENSE.md) does not permit any kind of
90 | commercial use.
91 |
92 | ### Contribution licensing
93 |
94 | Contributions are accepted with the following understanding:
95 |
96 | - Contributed content is licensed under the terms of the 0-BSD license
97 | - Contributors accept the terms of the project license at the time of contribution
98 |
99 | By making a contribution, you accept both the current project license terms, and that all contributions that you have
100 | made are provided under the terms of the 0-BSD license.
101 |
102 | #### Zero-Clause BSD
103 |
104 | ```
105 | Permission to use, copy, modify, and/or distribute this software for
106 | any purpose with or without fee is hereby granted.
107 |
108 | THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
109 | WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
110 | OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
111 | FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
112 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
113 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
114 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
115 | ```
116 |
117 | # Integrations
118 |
119 | If you would like to create an integration between _masir_ and a tiling window manager, there is only one requirement:
120 |
121 | - An updated list of window HWNDs known to and managed by the tiling window manager written to a file in a known
122 | location.
123 |
124 | The path to this file of HWNDs can be passed with the `--hwnds` flag for testing purposes.
125 |
126 | _masir_ will check for the presence of the HWND under the mouse cursor in this file when deciding if the window is
127 | eligible to be focused.
128 |
129 | Once testing is complete, native support for checking this file without requiring the `--hwnds` argument can be added
130 | directly to `masir` (see `TODO: We can add checks for other window managers here`
131 | in [`main.rs`](https://github.com/LGUG2Z/masir/blob/a35754a4a29538323bf248b4491f726e366f68bd/src/main.rs#L53)).
132 |
--------------------------------------------------------------------------------
/justfile:
--------------------------------------------------------------------------------
1 | set windows-shell := ["pwsh.exe", "-NoLogo", "-Command"]
2 | export RUST_BACKTRACE := "full"
3 |
4 | clean:
5 | cargo clean
6 |
7 | fmt:
8 | cargo +nightly fmt
9 | cargo +stable clippy
10 | prettier -w .github/
11 | prettier -w README.md
12 |
13 | install:
14 | cargo +stable install --path . --locked
15 |
16 | run:
17 | cargo run --locked
18 |
19 | info $RUST_LOG="info":
20 | just run
21 |
22 | warn $RUST_LOG="warn":
23 | just run
24 |
25 | debug $RUST_LOG="debug":
26 | just run
27 |
28 | trace $RUST_LOG="trace":
29 | just run
30 |
--------------------------------------------------------------------------------
/rust-toolchain.toml:
--------------------------------------------------------------------------------
1 | [toolchain]
2 | channel = "stable"
--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | imports_granularity = "Item"
--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
1 | use clap::Parser;
2 | use color_eyre::Result;
3 | use std::collections::HashMap;
4 | use std::path::PathBuf;
5 | use std::time::Duration;
6 | use std::time::Instant;
7 | use windows::core::Result as WindowsCrateResult;
8 | use windows::Win32::Foundation::HWND;
9 | use windows::Win32::Foundation::POINT;
10 | use windows::Win32::UI::Input::KeyboardAndMouse::SendInput;
11 | use windows::Win32::UI::Input::KeyboardAndMouse::INPUT;
12 | use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_MOUSE;
13 | use windows::Win32::UI::WindowsAndMessaging::GetAncestor;
14 | use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
15 | use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
16 | use windows::Win32::UI::WindowsAndMessaging::GetWindowLongW;
17 | use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
18 | use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
19 | use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
20 | use windows::Win32::UI::WindowsAndMessaging::GA_ROOT;
21 | use windows::Win32::UI::WindowsAndMessaging::GET_ANCESTOR_FLAGS;
22 | use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
23 | use windows::Win32::UI::WindowsAndMessaging::WINDOW_EX_STYLE;
24 | use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
25 | use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
26 | use winput::message_loop;
27 | use winput::message_loop::Event;
28 | use winput::Action;
29 |
30 | const CLASS_IGNORELIST: [(&str, MatchingStrategy); 9] = [
31 | ("SHELLDLL_DefView", MatchingStrategy::Equals), // desktop window
32 | ("Shell_TrayWnd", MatchingStrategy::Equals), // tray
33 | ("TrayNotifyWnd", MatchingStrategy::Equals), // tray
34 | ("MSTaskSwWClass", MatchingStrategy::Equals), // start bar icons
35 | ("Windows.UI.Core.CoreWindow", MatchingStrategy::Equals), // start menu
36 | ("XamlExplorerHostIslandWindow", MatchingStrategy::Equals), // task switcher
37 | ("ForegroundStaging", MatchingStrategy::Equals), // also task switcher
38 | ("Flow.Launcher", MatchingStrategy::Contains),
39 | ("PowerToys.PowerLauncher", MatchingStrategy::Contains),
40 | ];
41 |
42 | #[derive(Debug, PartialEq, Eq)]
43 | enum MatchingStrategy {
44 | Contains,
45 | Equals,
46 | }
47 |
48 | #[derive(Parser)]
49 | #[clap(author, about, version)]
50 | struct Opts {
51 | /// Disable automatic integrations with tiling window managers (e.g. komorebi)
52 | #[clap(long)]
53 | disable_integrations: bool,
54 | /// Path to a file with known focus-able HWNDs (e.g. komorebi.hwnd.json)
55 | #[clap(long)]
56 | hwnds: Option,
57 | }
58 |
59 | fn main() -> Result<()> {
60 | let opts: Opts = Opts::parse();
61 |
62 | let hwnds = match opts.hwnds {
63 | None if opts.disable_integrations => None,
64 | None => {
65 | let hwnds: PathBuf = dirs::data_local_dir()
66 | .expect("there is no local data directory")
67 | .join("komorebi")
68 | .join("komorebi.hwnd.json");
69 |
70 | // TODO: We can add checks for other window managers here
71 |
72 | if hwnds.is_file() {
73 | Some(hwnds)
74 | } else {
75 | None
76 | }
77 | }
78 | Some(hwnds) => {
79 | if hwnds.is_file() {
80 | Some(hwnds)
81 | } else {
82 | None
83 | }
84 | }
85 | };
86 |
87 | if std::env::var("RUST_LIB_BACKTRACE").is_err() {
88 | std::env::set_var("RUST_LIB_BACKTRACE", "1");
89 | }
90 |
91 | color_eyre::install()?;
92 |
93 | if std::env::var("RUST_LOG").is_err() {
94 | std::env::set_var("RUST_LOG", "info");
95 | }
96 |
97 | tracing::subscriber::set_global_default(
98 | tracing_subscriber::fmt::Subscriber::builder()
99 | .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
100 | .finish(),
101 | )?;
102 |
103 | listen_for_movements(hwnds.clone());
104 |
105 | match hwnds {
106 | None => tracing::info!("masir is now running"),
107 | Some(hwnds) => tracing::info!(
108 | "masir is now running, and additionally checking hwnds against {}",
109 | hwnds.display()
110 | ),
111 | }
112 |
113 | let (ctrlc_sender, ctrlc_receiver) = std::sync::mpsc::channel();
114 | ctrlc::set_handler(move || {
115 | ctrlc_sender
116 | .send(())
117 | .expect("could not send signal on ctrl-c channel");
118 | })?;
119 |
120 | ctrlc_receiver
121 | .recv()
122 | .expect("could not receive signal on ctrl-c channel");
123 |
124 | tracing::info!("received ctrl-c, exiting");
125 |
126 | Ok(())
127 | }
128 |
129 | fn listen_for_movements(hwnds: Option) {
130 | std::thread::spawn(move || {
131 | let receiver = message_loop::start().expect("could not start winput message loop");
132 |
133 | let mut eligibility_cache = HashMap::new();
134 | let mut class_cache: HashMap = HashMap::new();
135 | let mut hwnd_pair_cache: HashMap = HashMap::new();
136 | let mut root_hwnd_cache: HashMap = HashMap::new();
137 |
138 | let mut cache_instantiation_time = Instant::now();
139 | let max_cache_age = Duration::from_secs(60) * 10; // 10 minutes
140 |
141 | let mut is_mouse_down = false;
142 |
143 | loop {
144 | // clear our caches every 10 minutes
145 | if cache_instantiation_time.elapsed() > max_cache_age {
146 | tracing::info!("clearing caches, cache age is >10 minutes");
147 |
148 | eligibility_cache = HashMap::new();
149 | class_cache = HashMap::new();
150 | hwnd_pair_cache = HashMap::new();
151 | root_hwnd_cache = HashMap::new();
152 |
153 | cache_instantiation_time = Instant::now();
154 | }
155 |
156 | match receiver.next_event() {
157 | Event::MouseMoveRelative { .. } => {
158 | // resizing windows / dragging and dropping files fix
159 | if is_mouse_down {
160 | continue;
161 | }
162 |
163 | if let (Ok(cursor_pos_hwnd), Ok(foreground_hwnd)) =
164 | (window_at_cursor_pos(), foreground_window())
165 | {
166 | if cursor_pos_hwnd == foreground_hwnd {
167 | continue;
168 | }
169 |
170 | let mut cursor_root_hwnd = root_hwnd_cache.get(&cursor_pos_hwnd).cloned();
171 |
172 | // make syscalls if necessary and populate the root hwnd cache
173 | match &cursor_root_hwnd {
174 | None => {
175 | if let Ok(root_hwnd) = get_ancestor(cursor_pos_hwnd, GA_ROOT) {
176 | root_hwnd_cache.insert(cursor_pos_hwnd, root_hwnd);
177 | cursor_root_hwnd = Some(root_hwnd);
178 | }
179 | }
180 | Some(root_hwnd) => {
181 | tracing::debug!(
182 | "hwnd {cursor_pos_hwnd} root hwnd was found in the cache: {root_hwnd}"
183 | );
184 | }
185 | }
186 |
187 | if let Some(cursor_root_hwnd) = cursor_root_hwnd {
188 | if cursor_root_hwnd == foreground_hwnd {
189 | continue;
190 | }
191 |
192 | if let Some(paired_hwnd) = hwnd_pair_cache.get(&cursor_root_hwnd) {
193 | if *paired_hwnd == foreground_hwnd {
194 | tracing::trace!("hwnds {cursor_root_hwnd} and {foreground_hwnd} are known to refer to the same application, skipping");
195 | continue;
196 | }
197 | }
198 |
199 | let mut should_raise = false;
200 |
201 | // check our class cache to avoid syscalls
202 | let mut cursor_root_class = class_cache.get(&cursor_root_hwnd).cloned();
203 | let mut foreground_class = class_cache.get(&foreground_hwnd).cloned();
204 |
205 | // make syscalls if necessary and populate the class cache
206 | match &cursor_root_class {
207 | None => {
208 | if let Ok(class) = real_window_class_w(cursor_root_hwnd) {
209 | class_cache.insert(cursor_root_hwnd, class.clone());
210 | cursor_root_class = Some(class);
211 | }
212 | }
213 | Some(class) => {
214 | tracing::debug!(
215 | "hwnd {cursor_root_hwnd} class was found in the cache: {class}"
216 | );
217 | }
218 | }
219 |
220 | // make syscalls if necessary and populate the class cache
221 | match &foreground_class {
222 | None => {
223 | if let Ok(class) = real_window_class_w(foreground_hwnd) {
224 | class_cache.insert(foreground_hwnd, class.clone());
225 | foreground_class = Some(class);
226 | }
227 | }
228 | Some(class) => {
229 | tracing::debug!(
230 | "hwnd {foreground_hwnd} class was found in the cache: {class}"
231 | );
232 | }
233 | }
234 |
235 | if let (Some(cursor_root_class), Some(foreground_class)) =
236 | (&cursor_root_class, &foreground_class)
237 | {
238 | // steam fixes - populate the hwnd pair cache if necessary
239 | if cursor_root_class == "Chrome_RenderWidgetHostHWND"
240 | && foreground_class == "SDL_app"
241 | {
242 | hwnd_pair_cache.insert(cursor_root_hwnd, foreground_hwnd);
243 | continue;
244 | }
245 | }
246 |
247 | // check our eligibility caches
248 | if let (Some(cursor_root_is_eligible), Some(foreground_is_eligible)) = (
249 | eligibility_cache.get(&cursor_root_hwnd),
250 | eligibility_cache.get(&foreground_hwnd),
251 | ) {
252 | if *cursor_root_is_eligible && *foreground_is_eligible {
253 | should_raise = true;
254 | tracing::debug!(
255 | "hwnds {cursor_root_hwnd} and {foreground_hwnd} were found as eligible in the cache"
256 | );
257 | }
258 | } else if let Some(hwnds) = &hwnds {
259 | // use the hwnds file if twm integration is enabled
260 | if let Ok(raw_hwnds) = std::fs::read_to_string(hwnds) {
261 | let mut cursor_root_is_eligible = true;
262 | let mut foreground_is_eligible = true;
263 |
264 | // step one: test against the hwnds in the twm hwnds file
265 | cursor_root_is_eligible &=
266 | raw_hwnds.contains(&cursor_root_hwnd.to_string());
267 | foreground_is_eligible &=
268 | raw_hwnds.contains(&foreground_hwnd.to_string());
269 |
270 | // step two: test against known classes
271 | if let (Some(cursor_root_class), Some(foreground_class)) =
272 | (&cursor_root_class, &foreground_class)
273 | {
274 | for (class, strategy) in CLASS_IGNORELIST.iter() {
275 | let cursor_root_has_match =
276 | has_match(cursor_root_class, class, strategy);
277 | let foreground_has_match =
278 | has_match(foreground_class, class, strategy);
279 |
280 | cursor_root_is_eligible &= !cursor_root_has_match;
281 | foreground_is_eligible &= !foreground_has_match;
282 | }
283 | }
284 |
285 | // TODO: right now we just ignore the non-eligible case due to
286 | // potential delays with the twm writing to the hwnds file
287 | if cursor_root_is_eligible {
288 | eligibility_cache.insert(cursor_root_hwnd, true);
289 | }
290 | if foreground_is_eligible {
291 | eligibility_cache.insert(foreground_hwnd, true);
292 | }
293 |
294 | should_raise =
295 | cursor_root_is_eligible && foreground_is_eligible;
296 | }
297 | } else {
298 | let mut cursor_root_is_eligible = true;
299 | let mut foreground_is_eligible = true;
300 |
301 | // step one: test against known window styles
302 | cursor_root_is_eligible &= !has_filtered_style(cursor_root_hwnd);
303 | foreground_is_eligible &= !has_filtered_style(foreground_hwnd);
304 |
305 | // step two: test against known classes
306 | if let (Some(cursor_root_class), Some(foreground_class)) =
307 | (&cursor_root_class, &foreground_class)
308 | {
309 | for (class, strategy) in CLASS_IGNORELIST.iter() {
310 | let cursor_root_has_match =
311 | has_match(cursor_root_class, class, strategy);
312 | let foreground_has_match =
313 | has_match(foreground_class, class, strategy);
314 |
315 | cursor_root_is_eligible &= !cursor_root_has_match;
316 | foreground_is_eligible &= !foreground_has_match;
317 | }
318 | }
319 |
320 | eligibility_cache.insert(cursor_root_hwnd, cursor_root_is_eligible);
321 | eligibility_cache.insert(foreground_hwnd, foreground_is_eligible);
322 |
323 | should_raise = cursor_root_is_eligible && foreground_is_eligible;
324 | }
325 |
326 | if should_raise {
327 | match raise_and_focus_window(cursor_root_hwnd) {
328 | Ok(_) => {
329 | tracing::info!("raised hwnd: {cursor_root_hwnd}");
330 | }
331 | Err(error) => {
332 | tracing::error!(
333 | "failed to raise hwnd {cursor_root_hwnd}: {error}"
334 | );
335 | }
336 | }
337 | }
338 | }
339 | }
340 | }
341 | Event::MouseButton { action, .. } => match action {
342 | Action::Press => is_mouse_down = true,
343 | Action::Release => is_mouse_down = false,
344 | },
345 | _ => {}
346 | }
347 | }
348 | });
349 | }
350 |
351 | macro_rules! as_ptr {
352 | ($value:expr) => {
353 | $value as *mut core::ffi::c_void
354 | };
355 | }
356 |
357 | enum WindowsResult {
358 | Err(E),
359 | Ok(T),
360 | }
361 |
362 | macro_rules! impl_from_integer_for_windows_result {
363 | ( $( $integer_type:ty ),+ ) => {
364 | $(
365 | impl From<$integer_type> for WindowsResult<$integer_type, color_eyre::eyre::Error> {
366 | fn from(return_value: $integer_type) -> Self {
367 | match return_value {
368 | 0 => Self::Err(std::io::Error::last_os_error().into()),
369 | _ => Self::Ok(return_value),
370 | }
371 | }
372 | }
373 | )+
374 | };
375 | }
376 |
377 | impl_from_integer_for_windows_result!(usize, isize, u16, u32, i32);
378 |
379 | impl From> for Result {
380 | fn from(result: WindowsResult) -> Self {
381 | match result {
382 | WindowsResult::Err(error) => Err(error),
383 | WindowsResult::Ok(ok) => Ok(ok),
384 | }
385 | }
386 | }
387 |
388 | trait ProcessWindowsCrateResult {
389 | fn process(self) -> Result;
390 | }
391 |
392 | macro_rules! impl_process_windows_crate_integer_wrapper_result {
393 | ( $($input:ty => $deref:ty),+ $(,)? ) => (
394 | paste::paste! {
395 | $(
396 | impl ProcessWindowsCrateResult<$deref> for $input {
397 | fn process(self) -> Result<$deref> {
398 | if self == $input(std::ptr::null_mut()) {
399 | Err(std::io::Error::last_os_error().into())
400 | } else {
401 | Ok(self.0 as $deref)
402 | }
403 | }
404 | }
405 | )+
406 | }
407 | );
408 | }
409 |
410 | impl_process_windows_crate_integer_wrapper_result!(
411 | HWND => isize,
412 | );
413 |
414 | impl ProcessWindowsCrateResult for WindowsCrateResult {
415 | fn process(self) -> Result {
416 | match self {
417 | Ok(value) => Ok(value),
418 | Err(error) => Err(error.into()),
419 | }
420 | }
421 | }
422 |
423 | fn has_match(str1: &str, str2: &str, matching_strategy: &MatchingStrategy) -> bool {
424 | match matching_strategy {
425 | MatchingStrategy::Equals => str1 == str2,
426 | MatchingStrategy::Contains => str1.contains(str2),
427 | }
428 | }
429 |
430 | fn get_window_ex_style(hwnd: isize) -> WINDOW_EX_STYLE {
431 | unsafe { WINDOW_EX_STYLE(GetWindowLongW(HWND(as_ptr!(hwnd)), GWL_EXSTYLE) as u32) }
432 | }
433 |
434 | fn has_filtered_style(hwnd: isize) -> bool {
435 | let ex_style = get_window_ex_style(hwnd);
436 |
437 | ex_style.contains(WS_EX_TOOLWINDOW) || ex_style.contains(WS_EX_NOACTIVATE)
438 | }
439 |
440 | fn get_ancestor(hwnd: isize, gaflags: GET_ANCESTOR_FLAGS) -> Result {
441 | unsafe { GetAncestor(HWND(as_ptr!(hwnd)), gaflags) }.process()
442 | }
443 |
444 | fn window_from_point(point: POINT) -> Result {
445 | unsafe { WindowFromPoint(point) }.process()
446 | }
447 |
448 | fn window_at_cursor_pos() -> Result {
449 | window_from_point(cursor_pos()?)
450 | }
451 |
452 | fn foreground_window() -> Result {
453 | unsafe { GetForegroundWindow() }.process()
454 | }
455 |
456 | fn cursor_pos() -> Result {
457 | let mut cursor_pos = POINT::default();
458 | unsafe { GetCursorPos(&mut cursor_pos) }.process()?;
459 |
460 | Ok(cursor_pos)
461 | }
462 |
463 | fn raise_and_focus_window(hwnd: isize) -> Result<()> {
464 | let event = [INPUT {
465 | r#type: INPUT_MOUSE,
466 | ..Default::default()
467 | }];
468 |
469 | unsafe {
470 | // Send an input event to our own process first so that we pass the
471 | // foreground lock check
472 | SendInput(&event, size_of::() as i32);
473 | // Error ignored, as the operation is not always necessary.
474 |
475 | SetForegroundWindow(HWND(as_ptr!(hwnd)))
476 | }
477 | .ok()
478 | .process()
479 | }
480 |
481 | fn real_window_class_w(hwnd: isize) -> Result {
482 | const BUF_SIZE: usize = 512;
483 | let mut class: [u16; BUF_SIZE] = [0; BUF_SIZE];
484 |
485 | let len = Result::from(WindowsResult::from(unsafe {
486 | RealGetWindowClassW(HWND(as_ptr!(hwnd)), &mut class)
487 | }))?;
488 |
489 | Ok(String::from_utf16(&class[0..len as usize])?)
490 | }
491 |
--------------------------------------------------------------------------------
/wix/License.rtf:
--------------------------------------------------------------------------------
1 | {\rtf1\ansi\ansicpg1252\deff0\nouicompat\deflang1033\deflangfe1033{\fonttbl{\f0\fswiss\fprq2\fcharset0 Arial;}}
2 | {\*\generator Riched20 10.0.22621}{\*\mmathPr\mdispDef1\mwrapIndent1440 }\viewkind4\uc1
3 | \pard\sa200\sl276\slmult1\f0\fs24\lang9 # Komorebi License\par
4 | \par
5 | Version 2.0.0\par
6 | \par
7 | ## Acceptance\par
8 | \par
9 | In order to get any license under these terms, you must agree\par
10 | to them as both strict obligations and conditions to all\par
11 | your licenses.\par
12 | \par
13 | ## Copyright License\par
14 | \par
15 | The licensor grants you a copyright license for the software\par
16 | to do everything you might do with the software that would\par
17 | otherwise infringe the licensor's copyright in it for any\par
18 | permitted purpose. However, you may only distribute the source\par
19 | code of the software according to the [Distribution License](\par
20 | #distribution-license), you may only make changes according\par
21 | to the [Changes License](#changes-license), and you may not\par
22 | otherwise distribute the software or new works based on the\par
23 | software.\par
24 | \par
25 | ## Distribution License\par
26 | \par
27 | The licensor grants you an additional copyright license to\par
28 | distribute copies of the source code of the software. Your\par
29 | license to distribute covers distributing the source code of\par
30 | the software with changes permitted by the [Changes License](\par
31 | #changes-license).\par
32 | \par
33 | ## Changes License\par
34 | \par
35 | The licensor grants you an additional copyright license to\par
36 | make changes for any permitted purpose.\par
37 | \par
38 | ## Patent License\par
39 | \par
40 | The licensor grants you a patent license for the software that\par
41 | covers patent claims the licensor can license, or becomes able\par
42 | to license, that you would infringe by using the software.\par
43 | \par
44 | ## Personal Uses\par
45 | \par
46 | Personal use for research, experiment, and testing for\par
47 | the benefit of public knowledge, personal study, private\par
48 | entertainment, hobby projects, amateur pursuits, or religious\par
49 | observance, without any anticipated commercial application,\par
50 | is use for a permitted purpose.\par
51 | \par
52 | ## Fair Use\par
53 | \par
54 | You may have "fair use" rights for the software under the\par
55 | law. These terms do not limit them.\par
56 | \par
57 | ## No Other Rights\par
58 | \par
59 | These terms do not allow you to sublicense or transfer any of\par
60 | your licenses to anyone else, or prevent the licensor from\par
61 | granting licenses to anyone else. These terms do not imply\par
62 | any other licenses.\par
63 | \par
64 | ## Patent Defense\par
65 | \par
66 | If you make any written claim that the software infringes or\par
67 | contributes to infringement of any patent, your patent license\par
68 | for the software granted under these terms ends immediately. If\par
69 | your company makes such a claim, your patent license ends\par
70 | immediately for work on behalf of your company.\par
71 | \par
72 | ## Violations\par
73 | \par
74 | The first time you are notified in writing that you have\par
75 | violated any of these terms, or done anything with the software\par
76 | not covered by your licenses, your licenses can nonetheless\par
77 | continue if you come into full compliance with these terms,\par
78 | and take practical steps to correct past violations, within\par
79 | 32 days of receiving notice. Otherwise, all your licenses\par
80 | end immediately.\par
81 | \par
82 | ## No Liability\par
83 | \par
84 | ***As far as the law allows, the software comes as is, without\par
85 | any warranty or condition, and the licensor will not be liable\par
86 | to you for any damages arising out of these terms or the use\par
87 | or nature of the software, under any kind of legal claim.***\par
88 | \par
89 | ## Definitions\par
90 | \par
91 | The **licensor** is the individual or entity offering these\par
92 | terms, and the **software** is the software the licensor makes\par
93 | available under these terms.\par
94 | \par
95 | **You** refers to the individual or entity agreeing to these\par
96 | terms.\par
97 | \par
98 | **Your company** is any legal entity, sole proprietorship,\par
99 | or other kind of organization that you work for, plus all\par
100 | organizations that have control over, are under the control of,\par
101 | or are under common control with that organization. **Control**\par
102 | means ownership of substantially all the assets of an entity,\par
103 | or the power to direct its management and policies by vote,\par
104 | contract, or otherwise. Control can be direct or indirect.\par
105 | \par
106 | **Your licenses** are all the licenses granted to you for the\par
107 | software under these terms.\par
108 | \par
109 | **Use** means anything you do with the software requiring one\par
110 | of your licenses.\par
111 | }
112 |
--------------------------------------------------------------------------------
/wix/main.wxs:
--------------------------------------------------------------------------------
1 |
2 |
17 |
18 |
46 |
47 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
69 |
70 |
80 |
81 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
98 |
99 |
103 |
104 |
105 |
106 |
107 |
115 |
116 |
117 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
138 |
142 |
143 |
144 |
145 |
146 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
179 |
180 |
181 |
182 |
183 |
184 |
188 |
189 |
190 |
191 |
199 |
200 |
201 |
202 |
210 |
211 |
212 |
213 |
214 |
215 |
--------------------------------------------------------------------------------
10 | 
11 | 
12 |
13 | 
14 |
15 |
16 | 
17 |
18 |
19 | 
20 |
21 |
22 | 
23 |
24 |
25 | 
26 |
27 |