ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-20 14:13:09 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3087b72438
genode/repos/os/include/nitpicker_session/connection.h

107 lines
2.6 KiB
C
Raw Normal View History

Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
/*
* \brief Connection to Nitpicker service
* \author Norman Feske
* \date 2008-08-22
*/
/*
Update copyright headers to 2013
2013-01-10 20:44:47 +00:00
* Copyright (C) 2008-2013 Genode Labs GmbH
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _INCLUDE__NITPICKER_SESSION__CONNECTION_H_
#define _INCLUDE__NITPICKER_SESSION__CONNECTION_H_
#include <nitpicker_session/client.h>
#include <framebuffer_session/client.h>
#include <input_session/client.h>
#include <util/arg_string.h>
#include <base/connection.h>
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
namespace Nitpicker { class Connection; }
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
class Nitpicker::Connection : public Genode::Connection<Session>,
public Session_client
{
private:
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
Framebuffer::Session_client _framebuffer;
Input::Session_client _input;
nitpicker: let 'Connection' track donated quota This patch adds support for the consecutive re-dimensioning the virtual framebuffer. When changing the buffer size, the session gets upgraded by the missing portion of the quota instead of donating the whole size of the new buffer each time.
2014-06-12 10:25:38 +00:00
Genode::size_t _session_quota = 0;
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
/**
* Create session and return typed session capability
*/
nitpicker: Layers and client-side mouse cursor This patch introduces a mandatory layer attribute to domains. The layer ordering is superimposed on the stacking order of the views. The top-most layer can be assigned to a pointer-managing client. An example for such a pointer is located at os/src/app/pointer. It replaces the formerly built-in nitpicker mouse cursor. The new layering mechanism replaces the former "stay-top" session argument. So the Nitpicker::Connection no longer takes the stay-top flag as the first argument.
2014-07-02 20:00:15 +00:00
Session_capability _connect(char const *label)
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
{
enum { ARGBUF_SIZE = 128 };
char argbuf[ARGBUF_SIZE];
argbuf[0] = 0;
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
nitpicker: Add label arg to connection constructor
2014-06-17 12:04:38 +00:00
if (Genode::strlen(label) > 0)
Genode::snprintf(argbuf, sizeof(argbuf), "label=\"%s\"", label);
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
/*
* Declare ram-quota donation
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
*/
Generalization of nitpicker's graphics backend This patch re-arranges nitpicker's graphics backend in a more modular and expandable way. Generalized versions of the 'Canvas', 'Chunky_canvas', and 'Pixel_*' classes have been moved to 'os/include/util/' and 'os/include/os'. The only remaining parts that are specific to nitpicker's needs are a few drawing functions, each located in a distinct header at 'os/include/nitpicker_gfx/'.
2013-12-28 21:29:30 +00:00
using Genode::Arg_string;
nitpicker: Reworked session interface This patch changes nitpicker's session interface to use session-local view handles instead of view capabilities. This enables the batching of multiple view operations into one atomic update.
2014-06-06 15:26:53 +00:00
enum { SESSION_METADATA = 36*1024 };
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
Arg_string::set_arg(argbuf, sizeof(argbuf), "ram_quota", SESSION_METADATA);
return session(argbuf);
}
public:
/**
* Constructor
*/
nitpicker: Layers and client-side mouse cursor This patch introduces a mandatory layer attribute to domains. The layer ordering is superimposed on the stacking order of the views. The top-most layer can be assigned to a pointer-managing client. An example for such a pointer is located at os/src/app/pointer. It replaces the formerly built-in nitpicker mouse cursor. The new layering mechanism replaces the former "stay-top" session argument. So the Nitpicker::Connection no longer takes the stay-top flag as the first argument.
2014-07-02 20:00:15 +00:00
Connection(char const *label = "")
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
:
/* establish nitpicker session */
nitpicker: Layers and client-side mouse cursor This patch introduces a mandatory layer attribute to domains. The layer ordering is superimposed on the stacking order of the views. The top-most layer can be assigned to a pointer-managing client. An example for such a pointer is located at os/src/app/pointer. It replaces the formerly built-in nitpicker mouse cursor. The new layering mechanism replaces the former "stay-top" session argument. So the Nitpicker::Connection no longer takes the stay-top flag as the first argument.
2014-07-02 20:00:15 +00:00
Genode::Connection<Session>(_connect(label)),
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
Session_client(cap()),
/* request frame-buffer and input sub sessions */
_framebuffer(framebuffer_session()),
_input(input_session())
{ }
void buffer(Framebuffer::Mode mode, bool use_alpha)
{
enum { ARGBUF_SIZE = 128 };
char argbuf[ARGBUF_SIZE];
argbuf[0] = 0;
nitpicker: let 'Connection' track donated quota This patch adds support for the consecutive re-dimensioning the virtual framebuffer. When changing the buffer size, the session gets upgraded by the missing portion of the quota instead of donating the whole size of the new buffer each time.
2014-06-12 10:25:38 +00:00
Genode::size_t const needed = ram_quota(mode, use_alpha);
Genode::size_t const upgrade = needed > _session_quota
? needed - _session_quota
: 0;
if (upgrade > 0) {
Genode::Arg_string::set_arg(argbuf, sizeof(argbuf), "ram_quota",
upgrade);
Genode::env()->parent()->upgrade(cap(), argbuf);
_session_quota += upgrade;
}
nitpicker: Late allocation of virtual framebuffer This patch changes the interface of Nitpicker to support dynamically dimensioned virtual frame buffers. This solves two problems: First, it enables a client to create a connection to nitpicker without donating much session quota in advance. The old interface required each screen-size-dependent client to donate as much memory as needed to allocate a screen-sized virtual framebuffer. For clients that are interested int the screen size but cover just a small portion of the screen (e.g., a banner, a menu, an applet that sits in the screen corner), this overprovisioning is painful. The new interface allows such clients to upgrade the session quota for an existing session as needed. Second, because each nitpicker session used to have a virtual frame buffer with a fixed size over the lifetime of the session, a client that wanted to implement a variable-sized window had to either vastly overprovide resources (by opening a session as large as the screen just in order to be prepared for the worst case of a maximized window), or it had to replace the session by a new one (thereby discarding the stacking order of the old views) each time the window changes its dimensions. The new interface accommodates such clients much better.
2013-10-14 19:31:14 +00:00
Session_client::buffer(mode, use_alpha);
}
/**
* Return sub session for Nitpicker's input service
*/
Input::Session *input() { return &_input; }
/**
* Return sub session for session's frame buffer
*/
Framebuffer::Session *framebuffer() { return &_framebuffer; }
};
Imported Genode release 11.11
2011-12-22 15:19:25 +00:00
#endif /* _INCLUDE__NITPICKER_SESSION__CONNECTION_H_ */
Reference in New Issue Copy Permalink