goos

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
#pragma once
 
#include <l4/sys/capability>
#include <l4/re/dataspace>
#include <l4/re/video/colors>
#include <l4/sys/cxx/ipc_iface>
 
namespace L4Re { namespace Video {
 
class L4_EXPORT Goos;
 
class L4_EXPORT View
{
private:
  friend class Goos;
 
  L4::Cap<Goos> _goos;
  unsigned _view_idx;
 
  View(l4_cap_idx_t goos, unsigned idx)
  : _goos(goos), _view_idx(_goos.is_valid() ? idx : ~0U) {}
 
  unsigned view_index() const noexcept
  { return _goos.is_valid() ? _view_idx : ~0U; }
 
public:
  View() : _goos(L4::Cap<Goos>::Invalid), _view_idx(~0U) {}
 
  enum Flags
  {
    F_none               = 0x00, 
    F_set_buffer         = 0x01, 
    F_set_buffer_offset  = 0x02, 
    F_set_bytes_per_line = 0x04, 
    F_set_pixel          = 0x08, 
    F_set_position       = 0x10, 
    F_dyn_allocated      = 0x20, 
    F_set_background     = 0x40, 
    F_set_flags          = 0x80, 
 
    F_fully_dynamic      =   F_set_buffer | F_set_buffer_offset | F_set_bytes_per_line
                           | F_set_pixel | F_set_position | F_dyn_allocated,
  };
 
  enum V_flags
  {
    F_above              = 0x1000,  
    F_flags_mask         = 0xff000, 
  };
 
  struct Info
  {
    unsigned flags               = 0;  
    unsigned view_index          = 0;  
 
    unsigned long xpos           = 0;  
    unsigned long ypos           = 0;  
    unsigned long width          = 0;  
    unsigned long height         = 0;  
    unsigned long buffer_offset  = 0;  
    unsigned long bytes_per_line = 0;  
    Pixel_info pixel_info;             
    unsigned buffer_index        = 0;  
 
    bool has_static_buffer() const { return !(flags & F_set_buffer); }
    bool has_static_buffer_offset() const { return !(flags & F_set_buffer_offset); }
 
    bool has_set_buffer() const { return flags & F_set_buffer; }
    bool has_set_buffer_offset() const { return flags & F_set_buffer_offset; }
    bool has_set_bytes_per_line() const { return flags & F_set_bytes_per_line; }
    bool has_set_pixel() const { return flags & F_set_pixel; }
    bool has_set_position() const { return flags & F_set_position; }
 
    template< typename OUT >
    void dump(OUT &s) const
    {
      s.printf("View::Info:\n"
               "  flags: %x\n"
               "  size:  %ldx%ld\n"
               "  pos:   %ldx%ld\n"
               "  bytes_per_line: %ld\n"
               "  buffer_offset:  %lx\n"
               "  ",
               flags, width, height, xpos, ypos,
               bytes_per_line, buffer_offset);
      pixel_info.dump(s);
      s.printf("\n");
    }
  };
 
  int info(Info *info) const noexcept;
 
  int set_info(Info const &info) const noexcept;
 
  int set_viewport(int scr_x, int scr_y, int w, int h, unsigned long buf_offset) const noexcept;
 
  int stack(View const &pivot, bool behind = true) const noexcept;
 
  int push_top() const noexcept
  { return stack(View(), true); }
 
  int push_bottom() const noexcept
  { return stack(View(), false); }
 
  int refresh(int x, int y, int w, int h) const noexcept;
 
  bool valid() const { return _goos.is_valid(); }
};
 
 
class L4_EXPORT Goos :
  public L4::Kobject_t<Goos, L4::Kobject, L4RE_PROTO_GOOS>
{
public:
  enum Flags
  {
    F_auto_refresh    = 0x01, 
    F_pointer         = 0x02, 
    F_dynamic_views   = 0x04, 
    F_dynamic_buffers = 0x08, 
  };
 
  struct Info
  {
    unsigned long width;          
    unsigned long height;         
    unsigned flags;               
    unsigned num_static_views;    
    unsigned num_static_buffers;  
    Pixel_info pixel_info;        
 
    bool auto_refresh() const { return flags & F_auto_refresh; }
    bool has_pointer() const { return flags & F_pointer; }
    bool has_dynamic_views() const { return flags & F_dynamic_views; }
    bool has_dynamic_buffers() const { return flags & F_dynamic_buffers; }
 
    Info()
    : width(0), height(0), flags(0), num_static_views(0),
      num_static_buffers(0) {}
  };
 
  L4_INLINE_RPC(long, info, (Info *info));
 
  L4_RPC(long, get_static_buffer, (unsigned idx,
                                   L4::Ipc::Out<L4::Cap<L4Re::Dataspace> > rbuf));
 
  L4_RPC(long, create_buffer, (unsigned long size,
                               L4::Ipc::Out<L4::Cap<L4Re::Dataspace> > rbuf));
 
  L4_INLINE_RPC(long, delete_buffer, (unsigned idx));
 
  // Use a wrapper for this RPC as we enacapsulate the View
  L4_INLINE_RPC_NF(long, create_view, ());
 
  int create_view(View *view, l4_utcb_t *utcb = l4_utcb()) const noexcept
  {
    long r = create_view_t::call(c(), utcb);
    if (r < 0)
      return r;
    *view = View(cap(), r);
    return r;
  }
 
  // Use a wrapper as Views are encapsulated
  L4_INLINE_RPC_NF(long, delete_view, (unsigned index));
 
  int delete_view(View const &v, l4_utcb_t *utcb = l4_utcb()) const noexcept
  {
    return delete_view_t::call(c(), v._view_idx, utcb);
  }
 
  View view(unsigned index) const noexcept;
 
  L4_INLINE_RPC(long, refresh, (int x, int y, int w, int h));
 
  // those are used by the View
  L4_INLINE_RPC(long, view_info, (unsigned index, View::Info *info));
  L4_INLINE_RPC(long, set_view_info, (unsigned index, View::Info const &info));
  L4_INLINE_RPC(long, view_stack, (unsigned index, unsigned pivit, bool behind));
  L4_INLINE_RPC(long, view_refresh, (unsigned index, int x, int y, int w, int h));
 
  typedef L4::Typeid::Rpcs<
    info_t, get_static_buffer_t, create_buffer_t, create_view_t, delete_buffer_t,
    delete_view_t, view_info_t, set_view_info_t, view_stack_t, view_refresh_t,
    refresh_t
  > Rpcs;
};
 
inline View
Goos::view(unsigned index) const noexcept
{ return View(cap(), index); }
 
inline int
View::info(Info *info) const noexcept
{ return _goos->view_info(_view_idx, info); }
 
inline int
View::set_info(Info const &info) const noexcept
{ return _goos->set_view_info(_view_idx, info); }
 
inline int
View::stack(View const &pivot, bool behind) const noexcept
{ return _goos->view_stack(_view_idx, pivot._view_idx, behind); }
 
inline int
View::refresh(int x, int y, int w, int h) const noexcept
{ return _goos->view_refresh(_view_idx, x, y, w, h); }
 
inline int
View::set_viewport(int scr_x, int scr_y, int w, int h,
                   unsigned long buf_offset) const noexcept
{
  Info i;
  i.flags = F_set_buffer_offset | F_set_position;
  i.buffer_offset = buf_offset;
  i.buffer_index = 0;
  i.view_index = 0;
  i.bytes_per_line = 0;
  i.pixel_info = Pixel_info();
  i.xpos = scr_x;
  i.ypos = scr_y;
  i.width = w;
  i.height = h;
  return set_info(i);
}
 
}}