ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-25 16:31:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8cb0dc9c16
genode/repos/os/include/nitpicker_session/connection.h

120 lines
3.0 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
{
Adapt low-level components to new parent interface This patch adjusts the components of the os repository as well as device drivers to the new parent interface. Issue #2120
2016-11-06 13:27:26 +00:00
public:
Adapt high-level components to new parent API This patch adjusts the various users of the 'Child' API to the changes on the account of the new non-blocking parent interface. It also removes the use of the no-longer-available 'Connection::KEEP_OPEN' feature. With the adjustment, we took the opportunity to redesign several components to fit the non-blocking execution model much better, in particular the demo applications. Issue #2120
2016-11-23 16:07:49 +00:00
enum { RAM_QUOTA = 36*1024UL };
Adapt low-level components to new parent interface This patch adjusts the components of the os repository as well as device drivers to the new parent interface. Issue #2120
2016-11-06 13:27:26 +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
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
*/
Pass Env & as first argument to connection objects This patch supplements each existing connection type with an new constructor that is meant to replace the original one. The new one takes a reference to the component's environment as argument and thereby does not rely on the presence of the globally accessible 'env()' interface. The original constructors are marked as deprecated. Once we have completely abolished the use of the global 'env()', we will remove them. Fixes #1960
2016-05-10 15:24:51 +00:00
Session_capability _connect(Genode::Parent &parent, 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;
Adapt low-level components to new parent interface This patch adjusts the components of the os repository as well as device drivers to the new parent interface. Issue #2120
2016-11-06 13:27:26 +00:00
Arg_string::set_arg(argbuf, sizeof(argbuf), "ram_quota", RAM_QUOTA);
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
Pass Env & as first argument to connection objects This patch supplements each existing connection type with an new constructor that is meant to replace the original one. The new one takes a reference to the component's environment as argument and thereby does not rely on the presence of the globally accessible 'env()' interface. The original constructors are marked as deprecated. Once we have completely abolished the use of the global 'env()', we will remove them. Fixes #1960
2016-05-10 15:24:51 +00:00
return session(parent, argbuf);
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
}
public:
/**
* Constructor
*/
Pass Env & as first argument to connection objects This patch supplements each existing connection type with an new constructor that is meant to replace the original one. The new one takes a reference to the component's environment as argument and thereby does not rely on the presence of the globally accessible 'env()' interface. The original constructors are marked as deprecated. Once we have completely abolished the use of the global 'env()', we will remove them. Fixes #1960
2016-05-10 15:24:51 +00:00
Connection(Genode::Env &env, char const *label = "")
:
/* establish nitpicker session */
Genode::Connection<Session>(env, _connect(env.parent(), label)),
Warn about the use of deprecated env() function This patch enables warnings if one of the deprecate functions that rely in the implicit use of the global Genode::env() accessor are called. For the time being, some places within the base framework continue to rely on the global function while omitting the warning by calling 'env_deprecated' instead of 'env'. Issue #1987
2017-01-09 14:18:49 +00:00
Session_client(env.rm(), cap()),
Pass Env & as first argument to connection objects This patch supplements each existing connection type with an new constructor that is meant to replace the original one. The new one takes a reference to the component's environment as argument and thereby does not rely on the presence of the globally accessible 'env()' interface. The original constructors are marked as deprecated. Once we have completely abolished the use of the global 'env()', we will remove them. Fixes #1960
2016-05-10 15:24:51 +00:00
/* request frame-buffer and input sub sessions */
_framebuffer(framebuffer_session()),
Warn about the use of deprecated env() function This patch enables warnings if one of the deprecate functions that rely in the implicit use of the global Genode::env() accessor are called. For the time being, some places within the base framework continue to rely on the global function while omitting the warning by calling 'env_deprecated' instead of 'env'. Issue #1987
2017-01-09 14:18:49 +00:00
_input(env.rm(), input_session())
Pass Env & as first argument to connection objects This patch supplements each existing connection type with an new constructor that is meant to replace the original one. The new one takes a reference to the component's environment as argument and thereby does not rely on the presence of the globally accessible 'env()' interface. The original constructors are marked as deprecated. Once we have completely abolished the use of the global 'env()', we will remove them. Fixes #1960
2016-05-10 15:24:51 +00:00
{ }
/**
* Constructor
*
* \noapi
* \deprecated Use the constructor with 'Env &' as first
* argument instead
*/
Warn about the use of deprecated env() function This patch enables warnings if one of the deprecate functions that rely in the implicit use of the global Genode::env() accessor are called. For the time being, some places within the base framework continue to rely on the global function while omitting the warning by calling 'env_deprecated' instead of 'env'. Issue #1987
2017-01-09 14:18:49 +00:00
Connection(char const *label = "") __attribute__((deprecated))
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 */
Warn about the use of deprecated env() function This patch enables warnings if one of the deprecate functions that rely in the implicit use of the global Genode::env() accessor are called. For the time being, some places within the base framework continue to rely on the global function while omitting the warning by calling 'env_deprecated' instead of 'env'. Issue #1987
2017-01-09 14:18:49 +00:00
Genode::Connection<Session>(_connect(*Genode::env_deprecated()->parent(), label)),
Session_client(*Genode::env_deprecated()->rm_session(), cap()),
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
/* request frame-buffer and input sub sessions */
_framebuffer(framebuffer_session()),
Warn about the use of deprecated env() function This patch enables warnings if one of the deprecate functions that rely in the implicit use of the global Genode::env() accessor are called. For the time being, some places within the base framework continue to rely on the global function while omitting the warning by calling 'env_deprecated' instead of 'env'. Issue #1987
2017-01-09 14:18:49 +00:00
_input(*Genode::env_deprecated()->rm_session(), input_session())
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
{ }
void buffer(Framebuffer::Mode mode, bool use_alpha)
{
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) {
Adapt low-level components to new parent interface This patch adjusts the components of the os repository as well as device drivers to the new parent interface. Issue #2120
2016-11-06 13:27:26 +00:00
this->upgrade_ram(upgrade);
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
_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
*/
transition Input infrastructure to new base API * Supply Env to Input::Session_component * Attach input event dataspace at Input::Client * Process input events by lambda rather than pointer * Supply Env and a label to Input::Connection * Wm serves valid input_session to decorator * Per-source signal handling at input_merger * Base API update for dummy_input_drv, test_input * Input API update for launcher, menu_view, terminal, mupdf, sdl, seoul, virtualbox Ref #1987
2016-09-12 16:41:37 +00:00
Input::Session_client *input() { return &_input; }
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
/**
* 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