actor.h

Go to the documentation of this file.

// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _CLUTTERMM_ACTOR_H
#define _CLUTTERMM_ACTOR_H


#include <glibmm.h>

/* Copyright (C) 2007 The cluttermm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <glibmm/object.h>
#include <cluttermm/color.h>
#include <cluttermm/scriptable.h>
#include <clutter/clutter-event.h> //For Clutter*Event
 

#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _ClutterActor ClutterActor;
typedef struct _ClutterActorClass ClutterActorClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


namespace Clutter
{ class Actor_Class; } // namespace Clutter
namespace Clutter
{

typedef ClutterEvent Event;
typedef ClutterButtonEvent ButtonEvent;
typedef ClutterKeyEvent KeyEvent;
typedef ClutterMotionEvent MotionEvent;
typedef ClutterScrollEvent ScrollEvent;
typedef ClutterCrossingEvent CrossingEvent;


class Actor : public Glib::Object, public Scriptable
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  typedef Actor CppObjectType;
  typedef Actor_Class CppClassType;
  typedef ClutterActor BaseObjectType;
  typedef ClutterActorClass BaseClassType;

private:  friend class Actor_Class;
  static CppClassType actor_class_;

private:
  // noncopyable
  Actor(const Actor&);
  Actor& operator=(const Actor&);

protected:
  explicit Actor(const Glib::ConstructParams& construct_params);
  explicit Actor(ClutterActor* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:
  virtual ~Actor();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  static GType get_type()      G_GNUC_CONST;
  static GType get_base_type() G_GNUC_CONST;
#endif

  ClutterActor*       gobj()       { return reinterpret_cast<ClutterActor*>(gobject_); }

  const ClutterActor* gobj() const { return reinterpret_cast<ClutterActor*>(gobject_); }

  ClutterActor* gobj_copy();

private:

  
protected:
  Actor();

public:
  //There is no create() because this is an abstract base class.
  //_WRAP_CREATE()
  
  
  void show();
  
  void show_all();
  
  void hide();
  
  void hide_all();
  
  void realize();
  
  void unrealize();
  
  void paint();
  
  void queue_redraw();

  //TODO: Check that we don't want to wrap this: _WRAP_METHOD(void destroy(), clutter_actor_destroy)

  //TODO: If these are output parameters, then they probably need to be hand-coded:
  //TODO: _WRAP_METHOD(void request_coords(const Glib::RefPtr<ActorBox>& box), clutter_actor_request_coords)
  //TODO: _WRAP_METHOD(void query_coords(const Glib::RefPtr<ActorBox>& box), clutter_actor_query_coords)
  
  void set_geometry(const ClutterGeometry *geometry);
  
  void get_geometry(ClutterGeometry *geometry);
  
  void get_coords(int *x_1, int *y_1, int *x_2, int *y_2) const;
  
  void set_size(int width, int height);
  
  void set_sizeu(Unit width, Unit height);
  
  void get_position(int& x, int& y);
  
  void get_positionu(Unit& x, Unit& y);
  
  void set_position(int x, int y);
  
  void set_positionu(Unit x, Unit y);
  
  void get_abs_position(int& x, int& y) const;
  
  guint get_width() const;
  
  Unit get_widthu() const;
  
  guint get_height() const;
  
  Unit get_heightu() const;
  
  void set_width(guint width);
  
  void set_widthu(Unit width);
  
  void set_height(guint height);
  
  void set_heightu(Unit height);

  
  void set_x(int x);
  
  void set_xu(Unit x);
  
  int get_x() const;
  
  Unit get_xu() const;
  
  void set_y(int y);
  
  void set_yu(Unit y);
  
  int get_y() const;
  
  Unit get_yu() const;
  
  void set_reactive(bool reactive = true);
  
  bool get_reactive() const;

  
  void set_rotation(RotateAxis axis, double angle, int x, int y, int z);
  
  void set_rotationx(RotateAxis axis, Fixed angle, int x, int y, int z);
  
  double get_rotation(RotateAxis axis, int& x, int& y, int& z) const;
  
  Fixed get_rotationx(RotateAxis axis, int& x, int& y, int& z) const;
  
  void set_opacity (guint8 opacity);
  
  guint8 get_opacity() const;
  
  void set_name(const gchar           *name);
  
  Glib::ustring get_name() const;
  
  guint32 get_gid() const;
  
  void set_clip(int xoff, int yoff, int width, int height);
  
  void get_clip(int& xoff, int& yoff, int& width, int& height);
  
  void set_clipu(Unit xoff, Unit yoff, Unit width, Unit height);
  
  void get_clipu(Unit& xoff, Unit& yoff, Unit& width, Unit& height);
  
  void remove_clip();
  
  bool has_clip() const;
  
  void set_parent(const Glib::RefPtr<Actor>& parent);
  
  Glib::RefPtr<Actor> get_parent();
  
  Glib::RefPtr<const Actor> get_parent() const;
  
  void reparent(const Glib::RefPtr<Actor>& new_parent);
  
  void unparent();
  
  void raise(const Glib::RefPtr<Actor>& below);
  
  void lower(const Glib::RefPtr<Actor>& above);
  
  void raise_top ();
  
  void lower_bottom();
  
  void set_depth(int depth);
  
  void set_depthu(Unit depth);
  
  int get_depth() const;
  
  Unit get_depthu() const;
  
  void set_scalex(Fixed scale_x, Fixed scale_y);
  
  void set_scale(double scale_x, double scale_y);
  
  void get_scalex(Fixed& scale_x, Fixed& scale_y) const;
  
  void get_scale(double& scale_x, double& scale_y) const;

  //TODO:: removed? _WRAP_METHOD(void set_scale_with_gravityx(Fixed scale_x, Fixed scale_y, ClutterGravity gravity), clutter_actor_set_scale_with_gravityx)

  //TODO:: removed? _WRAP_METHOD(void set_scale_with_gravity(float scale_x, float scale_y, ClutterGravity gravity), clutter_actor_set_scale_with_gravity)

  
  void get_abs_size(guint& width, guint& height) const;
  
  void get_size(guint& width, guint& height) const;
  
  void get_sizeu(Unit& width, Unit& height) const;
  
  void move_by(int dx, int dy);
  
  void move_byu(Unit dx, Unit dy);

  //TODO: _WRAP_METHOD(void get_vertices(ClutterVertex verts[4]) const, clutter_actor_get_vertices)

//TODO: typedef (or wrap) ClutterVertex.
 

  void apply_transform_to_point(const ClutterVertex& point, ClutterVertex& vertex);
  
  void transform_stage_point(Unit x, Unit y, Unit& x_out, Unit& y_out);


  bool event(ClutterEvent* event, bool capture);
  //TODO: _WRAP_METHOD(Glib::RefPtr<Actor> clutter_get_actor_by_gid(guint32 id), clutter_get_actor_by_gid)
  //TODO: _WRAP_METHOD(Glib::RefPtr<const Actor> clutter_get_actor_by_gid(guint32 id) const, clutter_get_actor_by_gid, constversion)

  
  void set_anchor_point(int anchor_x, int anchor_y);
  
  void get_anchor_point(int& anchor_x, int& anchor_y) const;
  
  void set_anchor_pointu(Unit anchor_x, Unit anchor_y);
  
  void get_anchor_pointu(Unit& anchor_x, Unit& anchor_y);
  
  void set_anchor_point_from_gravity(ClutterGravity gravity);

// signals
  
  Glib::SignalProxy1< bool,ButtonEvent* > signal_button_press_event();

  
  Glib::SignalProxy1< bool,ButtonEvent* > signal_button_release_event();

  
  Glib::SignalProxy1< bool,MotionEvent* > signal_motion_event();

  
  Glib::SignalProxy1< bool,CrossingEvent* > signal_leave_event();

  
  Glib::SignalProxy0< void > signal_show();

  
  Glib::SignalProxy0< void > signal_hide();

  
  Glib::SignalProxy0< void > signal_destroy();

  
  Glib::SignalProxy1< bool,KeyEvent* > signal_key_release_event();

  
  Glib::SignalProxy1< bool,CrossingEvent* > signal_enter_event();

  
  Glib::SignalProxy1< bool,Event* > signal_event();

  
  Glib::SignalProxy0< void > signal_focus_out();

  
  Glib::SignalProxy0< void > signal_focus_in();

  //TODO: _WRAP_SIGNAL(void parent_set(const Glib::RefPtr<Actor>& old_parent), "parent_set")
  
  Glib::SignalProxy1< bool,ScrollEvent* > signal_scroll_event();

  
  Glib::SignalProxy1< bool,KeyEvent* > signal_key_press_event();

  
  Glib::SignalProxy1< bool,Event* > signal_captured_event();


  protected:
  // according to the clutter docs, these functions should never be called
  // directly and are only for subclasses
  
  void pick(const Color& color);
  
  bool should_pick_paint() const;


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:
#ifdef GLIBMM_VFUNCS_ENABLED
#endif //GLIBMM_VFUNCS_ENABLED

protected:
  //GTK+ Virtual Functions (override these to change behaviour):
#ifdef GLIBMM_VFUNCS_ENABLED
#endif //GLIBMM_VFUNCS_ENABLED

  //Default Signal Handlers::
#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  virtual bool on_button_press_event(ButtonEvent* event);
  virtual bool on_button_release_event(ButtonEvent* event);
  virtual bool on_motion_event(MotionEvent* event);
  virtual bool on_leave_event(CrossingEvent* event);
  virtual void on_show();
  virtual void on_hide();
  virtual void on_destroy();
  virtual bool on_key_release_event(KeyEvent* event);
  virtual bool on_enter_event(CrossingEvent* event);
  virtual bool on_event(Event* event);
  virtual void on_focus_out();
  virtual void on_focus_in();
  virtual bool on_scroll_event(ScrollEvent* event);
  virtual bool on_key_press_event(KeyEvent* event);
  virtual bool on_captured_event(Event* event);
#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED


};

} // namespace Clutter


namespace Glib
{
  Glib::RefPtr<Clutter::Actor> wrap(ClutterActor* object, bool take_copy = false);
}


#endif /* _CLUTTERMM_ACTOR_H */