src/gigedit/ManagedWindow.cpp

/*
    Copyright (c) 2016 Christian Schoenebeck
    
    This file is part of "gigedit" and released under the terms of the
    GNU General Public License version 2.
*/

#include "ManagedWindow.h"
#include <typeinfo>
#include <glib.h>
#include "global.h"

///////////////////////////////////////////////////////////////////////////
// class 'ManagedWindow'

ManagedWindow::ManagedWindow() : m_listenOnConfigureEvents(false)
{
    if (!Settings::singleton()->autoRestoreWindowDimension)
        return;

    Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
        sigc::mem_fun(*this, &ManagedWindow::restoreWindowDimensions),
        0
    );
    //HACK: Gtk does not support to distinguish between user caused window resize/move and programmtical window resize/move, so as a workaround we ignore such events for a certain amount of time while this window is constructing
    Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
        sigc::mem_fun(*this, &ManagedWindow::enableListeningConfigureEvents),
        300
    );
}

bool ManagedWindow::on_configure_event(GdkEventConfigure* e) {
    //printf("on_configure_event x=%d y=%d w=%d h=%d\n", e->x, e->y, e->width, e->height);
    if (m_listenOnConfigureEvents) {
        //printf("reset event throttle timer\n");
        // invalidate timer (so it won't fire)
        if (m_eventThrottleTimer) m_eventThrottleTimer->destroy();
        // restart timer
        m_eventThrottleTimer = Glib::TimeoutSource::create(300);
        m_eventThrottleTimer->connect(
            sigc::bind(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(*this, &ManagedWindow::saveWindowDimensions),
                            e->height
                        ),
                        e->width
                    ),
                    e->y
                ),
                e->x
            )
        );
        m_eventThrottleTimer->attach(Glib::MainContext::get_default());
    }
    return Gtk::Window::on_configure_event(e);
}

bool ManagedWindow::saveWindowDimensions(int x, int y, int w, int h) {
    printf("saveWindowDimensions(%d,%d,%d,%d)\n",x,y,w,h);
    if (*windowSettingX() != x) *windowSettingX() = x;
    if (*windowSettingY() != y) *windowSettingY() = y;
    if (*windowSettingWidth() != w) *windowSettingWidth() = w;
    if (*windowSettingHeight() != h) *windowSettingHeight() = h;
    return false; // kill timeout which called this method
}

void ManagedWindow::restoreWindowDimensions() {
    int x = *windowSettingX();
    int y = *windowSettingY();
    int w = *windowSettingWidth();
    int h = *windowSettingHeight();
    printf("restoreWindowDimensions(%d,%d,%d,%d)\n",x,y,w,h);
    if (x >= 0 && y >= 0) move(x, y);
    if (w > 0 && h > 0) resize(w, h);
}

///////////////////////////////////////////////////////////////////////////
// class 'ManagedDialog'

ManagedDialog::ManagedDialog()
    : Gtk::Dialog(), m_listenOnConfigureEvents(false)
{
    initManagedDialog();
}

ManagedDialog::ManagedDialog(const Glib::ustring& title, bool modal)
    : Gtk::Dialog(title, modal), m_listenOnConfigureEvents(false)
{
    initManagedDialog();
}

ManagedDialog::ManagedDialog(const Glib::ustring& title, Gtk::Window& parent, bool modal)
    : Gtk::Dialog(title, parent, modal), m_listenOnConfigureEvents(false)
{
    initManagedDialog();
}

// ManagedDialog::ManagedDialog(const Glib::ustring& title, Gtk::DialogFlags flags)
//     : Gtk::Dialog(title, flags), m_listenOnConfigureEvents(false)
// {
//     initManagedDialog();
// }

void ManagedDialog::initManagedDialog() {
    if (!Settings::singleton()->autoRestoreWindowDimension)
        return;

    Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
        sigc::mem_fun(*this, &ManagedDialog::restoreWindowDimensions),
        0
    );
    //HACK: Gtk does not support to distinguish between user caused window resize/move and programmtical window resize/move, so as a workaround we ignore such events for a certain amount of time while this window is constructing
    Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
        sigc::mem_fun(*this, &ManagedDialog::enableListeningConfigureEvents),
        300
    );
}

bool ManagedDialog::on_configure_event(GdkEventConfigure* e) {
    //printf("on_configure_event x=%d y=%d w=%d h=%d\n", e->x, e->y, e->width, e->height);
    if (m_listenOnConfigureEvents) {
        //printf("reset event throttle timer\n");
        // invalidate timer (so it won't fire)
        if (m_eventThrottleTimer) m_eventThrottleTimer->destroy();
        // restart timer
        m_eventThrottleTimer = Glib::TimeoutSource::create(300);
        m_eventThrottleTimer->connect(
            sigc::bind(
                sigc::bind(
                    sigc::bind(
                        sigc::bind(
                            sigc::mem_fun(*this, &ManagedDialog::saveWindowDimensions),
                            e->height
                        ),
                        e->width
                    ),
                    e->y
                ),
                e->x
            )
        );
        m_eventThrottleTimer->attach(Glib::MainContext::get_default());
    }
    return Gtk::Dialog::on_configure_event(e);
}

bool ManagedDialog::saveWindowDimensions(int x, int y, int w, int h) {
    printf("saveDialogDimensions(%d,%d,%d,%d)\n",x,y,w,h);
    if (*windowSettingX() != x) *windowSettingX() = x;
    if (*windowSettingY() != y) *windowSettingY() = y;
    if (*windowSettingWidth() != w) *windowSettingWidth() = w;
    if (*windowSettingHeight() != h) *windowSettingHeight() = h;
    return false; // kill timeout which called this method
}

void ManagedDialog::restoreWindowDimensions() {
    int x = *windowSettingX();
    int y = *windowSettingY();
    int w = *windowSettingWidth();
    int h = *windowSettingHeight();
    printf("restoreDialogDimensions(%d,%d,%d,%d)\n",x,y,w,h);
    if (x >= 0 && y >= 0) move(x, y);
    if (w > 0 && h >= 0) resize(w, h);
}
1	schoenebeck	2893	/*
2			Copyright (c) 2016 Christian Schoenebeck
3
4			This file is part of "gigedit" and released under the terms of the
5			GNU General Public License version 2.
6			*/
7
8			#include "ManagedWindow.h"
9			#include <typeinfo>
10			#include <glib.h>
11			#include "global.h"
12
13	schoenebeck	2894	///////////////////////////////////////////////////////////////////////////
14			// class 'ManagedWindow'
15
16	schoenebeck	2893	ManagedWindow::ManagedWindow() : m_listenOnConfigureEvents(false)
17			{
18	schoenebeck	2918	if (!Settings::singleton()->autoRestoreWindowDimension)
19			return;
20
21	schoenebeck	2893	Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
22			sigc::mem_fun(*this, &ManagedWindow::restoreWindowDimensions),
23			0
24			);
25			//HACK: Gtk does not support to distinguish between user caused window resize/move and programmtical window resize/move, so as a workaround we ignore such events for a certain amount of time while this window is constructing
26			Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
27			sigc::mem_fun(*this, &ManagedWindow::enableListeningConfigureEvents),
28			300
29			);
30			}
31
32			bool ManagedWindow::on_configure_event(GdkEventConfigure* e) {
33			//printf("on_configure_event x=%d y=%d w=%d h=%d\n", e->x, e->y, e->width, e->height);
34			if (m_listenOnConfigureEvents) {
35			//printf("reset event throttle timer\n");
36			// invalidate timer (so it won't fire)
37			if (m_eventThrottleTimer) m_eventThrottleTimer->destroy();
38			// restart timer
39			m_eventThrottleTimer = Glib::TimeoutSource::create(300);
40			m_eventThrottleTimer->connect(
41			sigc::bind(
42			sigc::bind(
43			sigc::bind(
44			sigc::bind(
45			sigc::mem_fun(*this, &ManagedWindow::saveWindowDimensions),
46			e->height
47			),
48			e->width
49			),
50			e->y
51			),
52			e->x
53			)
54			);
55			m_eventThrottleTimer->attach(Glib::MainContext::get_default());
56			}
57			return Gtk::Window::on_configure_event(e);
58			}
59
60			bool ManagedWindow::saveWindowDimensions(int x, int y, int w, int h) {
61			printf("saveWindowDimensions(%d,%d,%d,%d)\n",x,y,w,h);
62			if (windowSettingX() != x) windowSettingX() = x;
63			if (windowSettingY() != y) windowSettingY() = y;
64			if (windowSettingWidth() != w) windowSettingWidth() = w;
65			if (windowSettingHeight() != h) windowSettingHeight() = h;
66			return false; // kill timeout which called this method
67			}
68
69			void ManagedWindow::restoreWindowDimensions() {
70			int x = *windowSettingX();
71			int y = *windowSettingY();
72			int w = *windowSettingWidth();
73			int h = *windowSettingHeight();
74			printf("restoreWindowDimensions(%d,%d,%d,%d)\n",x,y,w,h);
75			if (x >= 0 && y >= 0) move(x, y);
76	schoenebeck	2894	if (w > 0 && h > 0) resize(w, h);
77	schoenebeck	2893	}
78	schoenebeck	2894
79			///////////////////////////////////////////////////////////////////////////
80			// class 'ManagedDialog'
81
82			ManagedDialog::ManagedDialog()
83			: Gtk::Dialog(), m_listenOnConfigureEvents(false)
84			{
85			initManagedDialog();
86			}
87
88			ManagedDialog::ManagedDialog(const Glib::ustring& title, bool modal)
89			: Gtk::Dialog(title, modal), m_listenOnConfigureEvents(false)
90			{
91			initManagedDialog();
92			}
93
94			ManagedDialog::ManagedDialog(const Glib::ustring& title, Gtk::Window& parent, bool modal)
95			: Gtk::Dialog(title, parent, modal), m_listenOnConfigureEvents(false)
96			{
97			initManagedDialog();
98			}
99
100			// ManagedDialog::ManagedDialog(const Glib::ustring& title, Gtk::DialogFlags flags)
101			// : Gtk::Dialog(title, flags), m_listenOnConfigureEvents(false)
102			// {
103			// initManagedDialog();
104			// }
105
106			void ManagedDialog::initManagedDialog() {
107	schoenebeck	2918	if (!Settings::singleton()->autoRestoreWindowDimension)
108			return;
109
110	schoenebeck	2894	Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
111			sigc::mem_fun(*this, &ManagedDialog::restoreWindowDimensions),
112			0
113			);
114			//HACK: Gtk does not support to distinguish between user caused window resize/move and programmtical window resize/move, so as a workaround we ignore such events for a certain amount of time while this window is constructing
115			Glib::signal_idle().connect_once( // timeout starts given amount of ms after the main loop became idle again ...
116			sigc::mem_fun(*this, &ManagedDialog::enableListeningConfigureEvents),
117			300
118			);
119			}
120
121			bool ManagedDialog::on_configure_event(GdkEventConfigure* e) {
122			//printf("on_configure_event x=%d y=%d w=%d h=%d\n", e->x, e->y, e->width, e->height);
123			if (m_listenOnConfigureEvents) {
124			//printf("reset event throttle timer\n");
125			// invalidate timer (so it won't fire)
126			if (m_eventThrottleTimer) m_eventThrottleTimer->destroy();
127			// restart timer
128			m_eventThrottleTimer = Glib::TimeoutSource::create(300);
129			m_eventThrottleTimer->connect(
130			sigc::bind(
131			sigc::bind(
132			sigc::bind(
133			sigc::bind(
134			sigc::mem_fun(*this, &ManagedDialog::saveWindowDimensions),
135			e->height
136			),
137			e->width
138			),
139			e->y
140			),
141			e->x
142			)
143			);
144			m_eventThrottleTimer->attach(Glib::MainContext::get_default());
145			}
146	schoenebeck	2918	return Gtk::Dialog::on_configure_event(e);
147	schoenebeck	2894	}
148
149			bool ManagedDialog::saveWindowDimensions(int x, int y, int w, int h) {
150			printf("saveDialogDimensions(%d,%d,%d,%d)\n",x,y,w,h);
151			if (windowSettingX() != x) windowSettingX() = x;
152			if (windowSettingY() != y) windowSettingY() = y;
153			if (windowSettingWidth() != w) windowSettingWidth() = w;
154			if (windowSettingHeight() != h) windowSettingHeight() = h;
155			return false; // kill timeout which called this method
156			}
157
158			void ManagedDialog::restoreWindowDimensions() {
159			int x = *windowSettingX();
160			int y = *windowSettingY();
161			int w = *windowSettingWidth();
162			int h = *windowSettingHeight();
163			printf("restoreDialogDimensions(%d,%d,%d,%d)\n",x,y,w,h);
164			if (x >= 0 && y >= 0) move(x, y);
165			if (w > 0 && h >= 0) resize(w, h);
166			}