2020-01-18 11:38:21 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
* list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2018-10-11 17:52:40 +03:00
|
|
|
#pragma once
|
|
|
|
|
2019-05-28 12:53:16 +03:00
|
|
|
#include <AK/HashMap.h>
|
2018-10-11 17:52:40 +03:00
|
|
|
#include <AK/HashTable.h>
|
2019-01-09 05:16:58 +03:00
|
|
|
#include <AK/InlineLinkedList.h>
|
2018-10-13 18:00:45 +03:00
|
|
|
#include <AK/WeakPtr.h>
|
2020-02-06 17:04:03 +03:00
|
|
|
#include <LibCore/ConfigFile.h>
|
|
|
|
#include <LibCore/ElapsedTimer.h>
|
2020-02-06 14:04:00 +03:00
|
|
|
#include <LibGfx/Color.h>
|
|
|
|
#include <LibGfx/DisjointRectSet.h>
|
|
|
|
#include <LibGfx/Painter.h>
|
|
|
|
#include <LibGfx/Palette.h>
|
|
|
|
#include <LibGfx/Rect.h>
|
2020-02-06 22:03:37 +03:00
|
|
|
#include <WindowServer/Cursor.h>
|
|
|
|
#include <WindowServer/Event.h>
|
|
|
|
#include <WindowServer/MenuBar.h>
|
|
|
|
#include <WindowServer/MenuManager.h>
|
|
|
|
#include <WindowServer/Window.h>
|
|
|
|
#include <WindowServer/WindowSwitcher.h>
|
|
|
|
#include <WindowServer/WindowType.h>
|
|
|
|
|
|
|
|
namespace WindowServer {
|
|
|
|
|
|
|
|
class Screen;
|
|
|
|
class MouseEvent;
|
|
|
|
class Window;
|
|
|
|
class ClientConnection;
|
|
|
|
class WindowSwitcher;
|
|
|
|
class Button;
|
2018-10-12 02:10:16 +03:00
|
|
|
|
2019-06-07 18:13:23 +03:00
|
|
|
enum class ResizeDirection {
|
2019-05-28 12:53:16 +03:00
|
|
|
None,
|
|
|
|
Left,
|
|
|
|
UpLeft,
|
|
|
|
Up,
|
|
|
|
UpRight,
|
|
|
|
Right,
|
|
|
|
DownRight,
|
|
|
|
Down,
|
|
|
|
DownLeft
|
|
|
|
};
|
2019-02-13 03:04:11 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
class WindowManager : public Core::Object {
|
|
|
|
C_OBJECT(WindowManager)
|
2019-07-25 20:49:28 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
friend class Compositor;
|
|
|
|
friend class WindowFrame;
|
|
|
|
friend class WindowSwitcher;
|
2019-05-28 12:53:16 +03:00
|
|
|
|
2018-10-11 17:52:40 +03:00
|
|
|
public:
|
2020-02-06 22:03:37 +03:00
|
|
|
static WindowManager& the();
|
2019-02-17 02:13:47 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
explicit WindowManager(const Gfx::PaletteImpl&);
|
|
|
|
virtual ~WindowManager() override;
|
2019-02-17 02:13:47 +03:00
|
|
|
|
2019-12-29 02:47:49 +03:00
|
|
|
Palette palette() const { return Palette(*m_palette); }
|
2019-12-24 22:57:54 +03:00
|
|
|
|
2020-05-18 13:16:17 +03:00
|
|
|
RefPtr<Core::ConfigFile> config() const { return m_config; }
|
2019-05-26 02:43:15 +03:00
|
|
|
void reload_config(bool);
|
2019-05-25 07:10:23 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
void add_window(Window&);
|
|
|
|
void remove_window(Window&);
|
2018-10-11 17:52:40 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
void notify_title_changed(Window&);
|
2020-07-16 02:40:52 +03:00
|
|
|
void notify_modal_unparented(Window&);
|
2020-06-10 11:57:59 +03:00
|
|
|
void notify_rect_changed(Window&, const Gfx::IntRect& oldRect, const Gfx::IntRect& newRect);
|
2020-02-06 22:03:37 +03:00
|
|
|
void notify_minimization_state_changed(Window&);
|
|
|
|
void notify_opacity_changed(Window&);
|
|
|
|
void notify_occlusion_state_changed(Window&);
|
2020-05-30 23:08:26 +03:00
|
|
|
void notify_progress_changed(Window&);
|
2020-02-06 22:03:37 +03:00
|
|
|
void notify_client_changed_app_menubar(ClientConnection&);
|
2018-10-11 17:52:40 +03:00
|
|
|
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntRect maximized_window_rect(const Window&) const;
|
2019-05-12 22:32:02 +03:00
|
|
|
|
2020-05-18 13:09:54 +03:00
|
|
|
const ClientConnection* dnd_client() const { return m_dnd_client.ptr(); }
|
2019-12-08 18:50:23 +03:00
|
|
|
const String& dnd_text() const { return m_dnd_text; }
|
2020-11-07 22:44:21 +03:00
|
|
|
const Core::MimeData& dnd_mime_data() const { return *m_dnd_mime_data; }
|
2020-02-06 13:56:38 +03:00
|
|
|
const Gfx::Bitmap* dnd_bitmap() const { return m_dnd_bitmap; }
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntRect dnd_rect() const;
|
2019-12-08 18:50:23 +03:00
|
|
|
|
2020-11-07 22:44:21 +03:00
|
|
|
void start_dnd_drag(ClientConnection&, const String& text, Gfx::Bitmap*, const Core::MimeData&);
|
2019-12-08 18:50:23 +03:00
|
|
|
void end_dnd_drag();
|
|
|
|
|
2020-07-15 19:13:13 +03:00
|
|
|
Window* active_window() { return m_active_window.ptr(); }
|
2020-05-18 13:09:54 +03:00
|
|
|
const Window* active_window() const { return m_active_window.ptr(); }
|
2020-07-15 19:13:13 +03:00
|
|
|
Window* active_input_window() { return m_active_input_window.ptr(); }
|
|
|
|
const Window* active_input_window() const { return m_active_input_window.ptr(); }
|
2020-02-06 22:03:37 +03:00
|
|
|
const ClientConnection* active_client() const;
|
2018-10-13 18:42:24 +03:00
|
|
|
|
2020-05-18 13:09:54 +03:00
|
|
|
const Window* highlight_window() const { return m_highlight_window.ptr(); }
|
2020-02-06 22:03:37 +03:00
|
|
|
void set_highlight_window(Window*);
|
2019-03-03 17:17:05 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
void move_to_front_and_make_active(Window&);
|
2018-10-14 02:23:01 +03:00
|
|
|
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntRect menubar_rect() const;
|
|
|
|
Gfx::IntRect desktop_rect() const;
|
2019-01-11 05:52:09 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
const Cursor& active_cursor() const;
|
2020-11-02 09:28:14 +03:00
|
|
|
const Cursor& hidden_cursor() const { return *m_hidden_cursor; }
|
2020-02-06 22:03:37 +03:00
|
|
|
const Cursor& arrow_cursor() const { return *m_arrow_cursor; }
|
2020-10-30 20:06:32 +03:00
|
|
|
const Cursor& crosshair_cursor() const { return *m_crosshair_cursor; }
|
2020-02-06 22:03:37 +03:00
|
|
|
const Cursor& hand_cursor() const { return *m_hand_cursor; }
|
2020-07-07 22:01:29 +03:00
|
|
|
const Cursor& help_cursor() const { return *m_help_cursor; }
|
2020-02-06 22:03:37 +03:00
|
|
|
const Cursor& resize_horizontally_cursor() const { return *m_resize_horizontally_cursor; }
|
|
|
|
const Cursor& resize_vertically_cursor() const { return *m_resize_vertically_cursor; }
|
|
|
|
const Cursor& resize_diagonally_tlbr_cursor() const { return *m_resize_diagonally_tlbr_cursor; }
|
|
|
|
const Cursor& resize_diagonally_bltr_cursor() const { return *m_resize_diagonally_bltr_cursor; }
|
2020-07-07 21:19:56 +03:00
|
|
|
const Cursor& resize_column_cursor() const { return *m_resize_column_cursor; }
|
|
|
|
const Cursor& resize_row_cursor() const { return *m_resize_row_cursor; }
|
2020-02-06 22:03:37 +03:00
|
|
|
const Cursor& i_beam_cursor() const { return *m_i_beam_cursor; }
|
|
|
|
const Cursor& disallowed_cursor() const { return *m_disallowed_cursor; }
|
|
|
|
const Cursor& move_cursor() const { return *m_move_cursor; }
|
|
|
|
const Cursor& drag_cursor() const { return *m_drag_cursor; }
|
2020-07-07 22:23:40 +03:00
|
|
|
const Cursor& wait_cursor() const { return *m_wait_cursor; }
|
2020-02-06 22:03:37 +03:00
|
|
|
|
2020-02-06 13:56:38 +03:00
|
|
|
const Gfx::Font& font() const;
|
|
|
|
const Gfx::Font& window_title_font() const;
|
2019-02-11 15:59:26 +03:00
|
|
|
|
2020-02-27 18:09:41 +03:00
|
|
|
bool set_resolution(int width, int height);
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntSize resolution() const;
|
2019-02-17 15:12:59 +03:00
|
|
|
|
2020-12-30 00:32:54 +03:00
|
|
|
void set_acceleration_factor(double);
|
|
|
|
void set_scroll_step_size(unsigned);
|
|
|
|
|
2020-07-15 19:13:13 +03:00
|
|
|
Window* set_active_input_window(Window*);
|
|
|
|
void restore_active_input_window(Window*);
|
2020-07-15 04:17:00 +03:00
|
|
|
void set_active_window(Window*, bool make_input = true);
|
2020-02-06 22:03:37 +03:00
|
|
|
void set_hovered_button(Button*);
|
2019-04-04 15:38:53 +03:00
|
|
|
|
2020-05-18 13:09:54 +03:00
|
|
|
const Button* cursor_tracking_button() const { return m_cursor_tracking_button.ptr(); }
|
2020-02-06 22:03:37 +03:00
|
|
|
void set_cursor_tracking_button(Button*);
|
2019-04-23 02:17:20 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
void set_resize_candidate(Window&, ResizeDirection);
|
2019-04-07 00:20:06 +03:00
|
|
|
void clear_resize_candidate();
|
2020-02-06 22:03:37 +03:00
|
|
|
ResizeDirection resize_direction_of_window(const Window&);
|
2019-04-07 00:20:06 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
void tell_wm_listeners_window_state_changed(Window&);
|
|
|
|
void tell_wm_listeners_window_icon_changed(Window&);
|
|
|
|
void tell_wm_listeners_window_rect_changed(Window&);
|
2019-04-13 17:59:55 +03:00
|
|
|
|
2020-07-15 04:17:00 +03:00
|
|
|
bool is_active_window_or_accessory(Window&) const;
|
|
|
|
|
2020-06-10 11:57:59 +03:00
|
|
|
void start_window_resize(Window&, const Gfx::IntPoint&, MouseButton);
|
2020-02-06 22:03:37 +03:00
|
|
|
void start_window_resize(Window&, const MouseEvent&);
|
2019-05-03 02:38:24 +03:00
|
|
|
|
2021-01-11 02:29:28 +03:00
|
|
|
const Window* active_fullscreen_window() const
|
|
|
|
{
|
|
|
|
if (m_active_window && m_active_window->is_fullscreen()) {
|
|
|
|
return m_active_window;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
};
|
|
|
|
|
|
|
|
Window* active_fullscreen_window()
|
|
|
|
{
|
|
|
|
if (m_active_window && m_active_window->is_fullscreen()) {
|
|
|
|
return m_active_window;
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
2019-05-17 22:33:44 +03:00
|
|
|
|
2020-02-17 22:05:14 +03:00
|
|
|
bool update_theme(String theme_path, String theme_name);
|
2019-12-23 22:24:26 +03:00
|
|
|
|
2020-02-12 09:22:52 +03:00
|
|
|
void set_hovered_window(Window*);
|
|
|
|
void deliver_mouse_event(Window& window, MouseEvent& event);
|
|
|
|
|
2020-05-09 17:40:13 +03:00
|
|
|
void did_popup_a_menu(Badge<Menu>);
|
|
|
|
|
2020-07-07 21:09:18 +03:00
|
|
|
void start_menu_doubleclick(Window& window, const MouseEvent& event);
|
|
|
|
bool is_menu_doubleclick(Window& window, const MouseEvent& event) const;
|
|
|
|
|
2020-07-16 02:40:52 +03:00
|
|
|
void minimize_windows(Window&, bool);
|
|
|
|
void maximize_windows(Window&, bool);
|
|
|
|
|
|
|
|
template<typename Function>
|
2020-08-18 22:33:43 +03:00
|
|
|
IterationDecision for_each_window_in_modal_stack(Window& window, Function f)
|
2020-07-16 02:40:52 +03:00
|
|
|
{
|
2021-01-07 22:12:17 +03:00
|
|
|
auto* blocking_modal_window = window.blocking_modal_window();
|
2020-07-16 02:40:52 +03:00
|
|
|
if (blocking_modal_window || window.is_modal()) {
|
|
|
|
Vector<Window*> modal_stack;
|
|
|
|
auto* modal_stack_top = blocking_modal_window ? blocking_modal_window : &window;
|
|
|
|
for (auto* parent = modal_stack_top->parent_window(); parent; parent = parent->parent_window()) {
|
2021-01-07 22:12:17 +03:00
|
|
|
auto* blocked_by = parent->blocking_modal_window();
|
2020-07-16 18:39:52 +03:00
|
|
|
if (!blocked_by || (blocked_by != modal_stack_top && !modal_stack_top->is_descendant_of(*blocked_by)))
|
2020-07-16 02:40:52 +03:00
|
|
|
break;
|
|
|
|
modal_stack.append(parent);
|
|
|
|
if (!parent->is_modal())
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!modal_stack.is_empty()) {
|
|
|
|
for (size_t i = modal_stack.size(); i > 0; i--) {
|
2020-08-18 22:33:43 +03:00
|
|
|
IterationDecision decision = f(*modal_stack[i - 1], false);
|
|
|
|
if (decision != IterationDecision::Continue)
|
|
|
|
return decision;
|
2020-07-16 02:40:52 +03:00
|
|
|
}
|
|
|
|
}
|
2020-08-18 22:33:43 +03:00
|
|
|
return f(*modal_stack_top, true);
|
2020-07-16 02:40:52 +03:00
|
|
|
} else {
|
|
|
|
// Not a modal window stack, just "iterate" over this window
|
2020-08-18 22:33:43 +03:00
|
|
|
return f(window, true);
|
2020-07-16 02:40:52 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-31 04:52:45 +03:00
|
|
|
Gfx::IntPoint get_recommended_window_position(const Gfx::IntPoint& desired);
|
|
|
|
|
2018-10-11 17:52:40 +03:00
|
|
|
private:
|
2020-02-06 22:03:37 +03:00
|
|
|
NonnullRefPtr<Cursor> get_cursor(const String& name);
|
|
|
|
|
|
|
|
void process_mouse_event(MouseEvent&, Window*& hovered_window);
|
|
|
|
void process_event_for_doubleclick(Window& window, MouseEvent& event);
|
|
|
|
bool process_ongoing_window_resize(const MouseEvent&, Window*& hovered_window);
|
|
|
|
bool process_ongoing_window_move(MouseEvent&, Window*& hovered_window);
|
|
|
|
bool process_ongoing_drag(MouseEvent&, Window*& hovered_window);
|
|
|
|
void start_window_move(Window&, const MouseEvent&);
|
2019-05-28 12:53:16 +03:00
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision for_each_visible_window_of_type_from_back_to_front(WindowType, Callback, bool ignore_highlight = false);
|
2019-05-28 12:53:16 +03:00
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision for_each_visible_window_of_type_from_front_to_back(WindowType, Callback, bool ignore_highlight = false);
|
2019-05-28 12:53:16 +03:00
|
|
|
template<typename Callback>
|
|
|
|
IterationDecision for_each_visible_window_from_front_to_back(Callback);
|
|
|
|
template<typename Callback>
|
|
|
|
IterationDecision for_each_visible_window_from_back_to_front(Callback);
|
|
|
|
template<typename Callback>
|
|
|
|
void for_each_window_listening_to_wm_events(Callback);
|
|
|
|
template<typename Callback>
|
|
|
|
void for_each_window(Callback);
|
2019-12-29 05:06:04 +03:00
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision for_each_window_of_type_from_front_to_back(WindowType, Callback, bool ignore_highlight = false);
|
2019-05-24 20:32:46 +03:00
|
|
|
|
2020-02-02 14:34:39 +03:00
|
|
|
virtual void event(Core::Event&) override;
|
2020-02-06 22:03:37 +03:00
|
|
|
void paint_window_frame(const Window&);
|
|
|
|
void tell_wm_listener_about_window(Window& listener, Window&);
|
|
|
|
void tell_wm_listener_about_window_icon(Window& listener, Window&);
|
|
|
|
void tell_wm_listener_about_window_rect(Window& listener, Window&);
|
2020-07-15 19:13:13 +03:00
|
|
|
bool pick_new_active_window(Window*);
|
2020-07-15 04:17:00 +03:00
|
|
|
|
|
|
|
void do_move_to_front(Window&, bool, bool);
|
2019-01-12 18:51:14 +03:00
|
|
|
|
2020-11-02 09:28:14 +03:00
|
|
|
RefPtr<Cursor> m_hidden_cursor;
|
2020-02-06 22:03:37 +03:00
|
|
|
RefPtr<Cursor> m_arrow_cursor;
|
|
|
|
RefPtr<Cursor> m_hand_cursor;
|
2020-07-07 22:01:29 +03:00
|
|
|
RefPtr<Cursor> m_help_cursor;
|
2020-02-06 22:03:37 +03:00
|
|
|
RefPtr<Cursor> m_resize_horizontally_cursor;
|
|
|
|
RefPtr<Cursor> m_resize_vertically_cursor;
|
|
|
|
RefPtr<Cursor> m_resize_diagonally_tlbr_cursor;
|
|
|
|
RefPtr<Cursor> m_resize_diagonally_bltr_cursor;
|
2020-07-07 21:19:56 +03:00
|
|
|
RefPtr<Cursor> m_resize_column_cursor;
|
|
|
|
RefPtr<Cursor> m_resize_row_cursor;
|
2020-02-06 22:03:37 +03:00
|
|
|
RefPtr<Cursor> m_i_beam_cursor;
|
|
|
|
RefPtr<Cursor> m_disallowed_cursor;
|
|
|
|
RefPtr<Cursor> m_move_cursor;
|
|
|
|
RefPtr<Cursor> m_drag_cursor;
|
2020-07-07 22:23:40 +03:00
|
|
|
RefPtr<Cursor> m_wait_cursor;
|
2020-10-30 20:06:32 +03:00
|
|
|
RefPtr<Cursor> m_crosshair_cursor;
|
2019-01-12 18:51:14 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
InlineLinkedList<Window> m_windows_in_order;
|
2018-10-12 03:24:05 +03:00
|
|
|
|
2019-05-28 12:53:16 +03:00
|
|
|
struct DoubleClickInfo {
|
2019-09-08 11:15:08 +03:00
|
|
|
struct ClickMetadata {
|
2020-02-02 14:34:39 +03:00
|
|
|
Core::ElapsedTimer clock;
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntPoint last_position;
|
2019-09-08 11:15:08 +03:00
|
|
|
};
|
|
|
|
|
2020-07-07 21:09:18 +03:00
|
|
|
const ClickMetadata& metadata_for_button(MouseButton) const;
|
2019-09-08 11:15:08 +03:00
|
|
|
ClickMetadata& metadata_for_button(MouseButton);
|
|
|
|
|
2019-05-28 12:53:16 +03:00
|
|
|
void reset()
|
|
|
|
{
|
2019-09-08 11:15:08 +03:00
|
|
|
m_left = {};
|
|
|
|
m_right = {};
|
|
|
|
m_middle = {};
|
2020-05-03 01:29:57 +03:00
|
|
|
m_back = {};
|
|
|
|
m_forward = {};
|
2019-05-15 23:17:09 +03:00
|
|
|
}
|
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<Window> m_clicked_window;
|
2019-09-08 11:15:08 +03:00
|
|
|
|
|
|
|
private:
|
|
|
|
ClickMetadata m_left;
|
|
|
|
ClickMetadata m_right;
|
|
|
|
ClickMetadata m_middle;
|
2020-05-02 23:07:43 +03:00
|
|
|
ClickMetadata m_back;
|
|
|
|
ClickMetadata m_forward;
|
2019-05-15 23:17:09 +03:00
|
|
|
};
|
2020-07-07 21:09:18 +03:00
|
|
|
|
|
|
|
bool is_considered_doubleclick(const MouseEvent& event, const DoubleClickInfo::ClickMetadata& metadata) const;
|
|
|
|
|
2019-05-15 23:17:09 +03:00
|
|
|
DoubleClickInfo m_double_click_info;
|
2019-06-22 15:48:52 +03:00
|
|
|
int m_double_click_speed { 0 };
|
2019-09-09 09:46:07 +03:00
|
|
|
int m_max_distance_for_double_click { 4 };
|
2019-05-15 23:17:09 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<Window> m_active_window;
|
|
|
|
WeakPtr<Window> m_hovered_window;
|
|
|
|
WeakPtr<Window> m_highlight_window;
|
|
|
|
WeakPtr<Window> m_active_input_window;
|
2020-07-15 04:17:00 +03:00
|
|
|
WeakPtr<Window> m_active_input_tracking_window;
|
2018-10-13 18:00:45 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<Window> m_move_window;
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntPoint m_move_origin;
|
|
|
|
Gfx::IntPoint m_move_window_origin;
|
2019-01-09 06:18:28 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<Window> m_resize_window;
|
|
|
|
WeakPtr<Window> m_resize_candidate;
|
2019-04-07 00:20:06 +03:00
|
|
|
MouseButton m_resizing_mouse_button { MouseButton::None };
|
2020-06-10 11:57:59 +03:00
|
|
|
Gfx::IntRect m_resize_window_original_rect;
|
|
|
|
Gfx::IntPoint m_resize_origin;
|
2019-02-20 17:34:55 +03:00
|
|
|
ResizeDirection m_resize_direction { ResizeDirection::None };
|
|
|
|
|
2019-07-03 22:17:35 +03:00
|
|
|
u8 m_keyboard_modifiers { 0 };
|
2019-03-03 14:56:48 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WindowSwitcher m_switcher;
|
2019-03-03 17:17:05 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<Button> m_cursor_tracking_button;
|
|
|
|
WeakPtr<Button> m_hovered_button;
|
2019-04-14 05:33:43 +03:00
|
|
|
|
2020-02-06 13:56:38 +03:00
|
|
|
NonnullRefPtr<Gfx::PaletteImpl> m_palette;
|
2019-12-24 22:57:54 +03:00
|
|
|
|
2020-05-18 13:16:17 +03:00
|
|
|
RefPtr<Core::ConfigFile> m_config;
|
2019-11-11 12:43:03 +03:00
|
|
|
|
2020-02-06 22:03:37 +03:00
|
|
|
WeakPtr<ClientConnection> m_dnd_client;
|
2019-12-08 18:50:23 +03:00
|
|
|
String m_dnd_text;
|
2020-11-07 22:44:21 +03:00
|
|
|
RefPtr<Core::MimeData> m_dnd_mime_data;
|
2020-02-06 13:56:38 +03:00
|
|
|
RefPtr<Gfx::Bitmap> m_dnd_bitmap;
|
2018-10-11 17:52:40 +03:00
|
|
|
};
|
2019-03-03 17:17:05 +03:00
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision WindowManager::for_each_visible_window_of_type_from_back_to_front(WindowType type, Callback callback, bool ignore_highlight)
|
2019-03-03 17:17:05 +03:00
|
|
|
{
|
2019-03-10 04:33:43 +03:00
|
|
|
bool do_highlight_window_at_end = false;
|
2019-08-08 14:40:47 +03:00
|
|
|
for (auto& window : m_windows_in_order) {
|
|
|
|
if (!window.is_visible())
|
2019-03-03 17:17:05 +03:00
|
|
|
continue;
|
2019-08-08 14:40:47 +03:00
|
|
|
if (window.is_minimized())
|
2019-04-05 23:32:00 +03:00
|
|
|
continue;
|
2019-08-08 14:40:47 +03:00
|
|
|
if (window.type() != type)
|
2019-03-03 17:17:05 +03:00
|
|
|
continue;
|
2019-08-08 14:40:47 +03:00
|
|
|
if (!ignore_highlight && m_highlight_window == &window) {
|
2019-03-10 04:33:43 +03:00
|
|
|
do_highlight_window_at_end = true;
|
|
|
|
continue;
|
|
|
|
}
|
2019-08-08 14:40:47 +03:00
|
|
|
if (callback(window) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2019-03-03 17:17:05 +03:00
|
|
|
}
|
2019-03-10 04:33:43 +03:00
|
|
|
if (do_highlight_window_at_end) {
|
2019-06-07 18:13:23 +03:00
|
|
|
if (callback(*m_highlight_window) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2019-03-10 04:33:43 +03:00
|
|
|
}
|
2019-03-03 17:17:05 +03:00
|
|
|
return IterationDecision::Continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision WindowManager::for_each_visible_window_from_back_to_front(Callback callback)
|
2019-03-03 17:17:05 +03:00
|
|
|
{
|
2020-04-18 22:10:16 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Desktop, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Normal, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Taskbar, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-03-30 18:00:23 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Notification, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2020-12-19 21:23:47 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Tooltip, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Menubar, callback) == IterationDecision::Break)
|
2019-06-21 09:19:43 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_back_to_front(WindowType::Menu, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
return for_each_visible_window_of_type_from_back_to_front(WindowType::WindowSwitcher, callback);
|
2019-03-03 17:17:05 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision WindowManager::for_each_visible_window_of_type_from_front_to_back(WindowType type, Callback callback, bool ignore_highlight)
|
2019-03-03 17:17:05 +03:00
|
|
|
{
|
2019-05-13 01:08:56 +03:00
|
|
|
if (!ignore_highlight && m_highlight_window && m_highlight_window->type() == type && m_highlight_window->is_visible()) {
|
2019-06-07 18:13:23 +03:00
|
|
|
if (callback(*m_highlight_window) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2019-03-10 04:33:43 +03:00
|
|
|
}
|
|
|
|
|
2019-03-03 17:17:05 +03:00
|
|
|
for (auto* window = m_windows_in_order.tail(); window; window = window->prev()) {
|
|
|
|
if (!window->is_visible())
|
|
|
|
continue;
|
2019-04-05 23:32:00 +03:00
|
|
|
if (window->is_minimized())
|
|
|
|
continue;
|
2019-03-03 17:17:05 +03:00
|
|
|
if (window->type() != type)
|
|
|
|
continue;
|
2019-05-13 01:08:56 +03:00
|
|
|
if (!ignore_highlight && window == m_highlight_window)
|
2019-03-10 04:33:43 +03:00
|
|
|
continue;
|
2019-06-07 18:13:23 +03:00
|
|
|
if (callback(*window) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2019-03-03 17:17:05 +03:00
|
|
|
}
|
|
|
|
return IterationDecision::Continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision WindowManager::for_each_visible_window_from_front_to_back(Callback callback)
|
2019-03-03 17:17:05 +03:00
|
|
|
{
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::WindowSwitcher, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Menu, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Menubar, callback) == IterationDecision::Break)
|
2019-06-21 09:19:43 +03:00
|
|
|
return IterationDecision::Break;
|
2020-02-06 22:03:37 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Tooltip, callback) == IterationDecision::Break)
|
2019-06-07 18:13:23 +03:00
|
|
|
return IterationDecision::Break;
|
2020-12-19 21:23:47 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Notification, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2020-03-30 18:00:23 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Taskbar, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
2020-04-18 22:10:16 +03:00
|
|
|
if (for_each_visible_window_of_type_from_front_to_back(WindowType::Normal, callback) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
|
|
|
return for_each_visible_window_of_type_from_front_to_back(WindowType::Desktop, callback);
|
2019-03-03 17:17:05 +03:00
|
|
|
}
|
2019-04-04 02:44:35 +03:00
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
void WindowManager::for_each_window_listening_to_wm_events(Callback callback)
|
2019-04-04 02:44:35 +03:00
|
|
|
{
|
|
|
|
for (auto* window = m_windows_in_order.tail(); window; window = window->prev()) {
|
|
|
|
if (!window->listens_to_wm_events())
|
|
|
|
continue;
|
2019-06-07 18:13:23 +03:00
|
|
|
if (callback(*window) == IterationDecision::Break)
|
2019-04-04 02:44:35 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2019-04-04 14:33:09 +03:00
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
void WindowManager::for_each_window(Callback callback)
|
2019-04-04 14:33:09 +03:00
|
|
|
{
|
|
|
|
for (auto* window = m_windows_in_order.tail(); window; window = window->prev()) {
|
2019-06-07 18:13:23 +03:00
|
|
|
if (callback(*window) == IterationDecision::Break)
|
2019-04-04 14:33:09 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2019-12-29 05:06:04 +03:00
|
|
|
|
|
|
|
template<typename Callback>
|
2020-02-06 22:03:37 +03:00
|
|
|
IterationDecision WindowManager::for_each_window_of_type_from_front_to_back(WindowType type, Callback callback, bool ignore_highlight)
|
2019-12-29 05:06:04 +03:00
|
|
|
{
|
|
|
|
if (!ignore_highlight && m_highlight_window && m_highlight_window->type() == type && m_highlight_window->is_visible()) {
|
|
|
|
if (callback(*m_highlight_window) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto* window = m_windows_in_order.tail(); window; window = window->prev()) {
|
|
|
|
if (window->type() != type)
|
|
|
|
continue;
|
|
|
|
if (!ignore_highlight && window == m_highlight_window)
|
|
|
|
continue;
|
|
|
|
if (callback(*window) == IterationDecision::Break)
|
|
|
|
return IterationDecision::Break;
|
|
|
|
}
|
|
|
|
return IterationDecision::Continue;
|
|
|
|
}
|
2020-02-06 22:03:37 +03:00
|
|
|
|
|
|
|
}
|