enlightenment
/
eflxx
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

new elementaryxx API with more namespaces 

SVN revision: 44049
This commit is contained in:
Andreas Volz 2009-11-29 22:22:30 +00:00
parent 6b056f4643
commit 6ac01e3588
104 changed files with 2259 additions and 2262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
elementaryxx/include/elementaryxx/Anchorblock.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef ELMXX_ANCHORBLOCK_H
#define ELMXX_ANCHORBLOCK_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorblock_Info
*/
class Anchorblock : public Object
{
public:
static Anchorblock *factory (Evasxx::Object &parent);
private:
Anchorblock (); // forbid standard constructor
Anchorblock (const Anchorblock&); // forbid copy constructor
Anchorblock (Evasxx::Object &parent); // private construction -> use factory ()
~Anchorblock (); // forbid direct delete -> use ElmWidget::destroy()
void setText (const std::string &text);
void setHoverParent (Evasxx::Object &parent);
void setHoverStyle (const std::string &style);
void endHover ();
};
} // end namespace Elmxx
#endif // ELMXX_ANCHORBLOCK_H

35
elementaryxx/include/elementaryxx/Anchorview.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef ELMXX_ANCHORVIEW_H
#define ELMXX_ANCHORVIEW_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorview_Info
*/
class Anchorview : public Object
{
public:
static Anchorview *factory (Evasxx::Object &parent);
private:
Anchorview (); // forbid standard constructor
Anchorview (const Anchorview&); // forbid copy constructor
Anchorview (Evasxx::Object &parent); // private construction -> use factory ()
~Anchorview (); // forbid direct delete -> use ElmWidget::destroy()
void setText (const std::string &text);
void setHoverParent (Evasxx::Object &parent);
void setHoverStyle (const std::string &style);
void endHover ();
};
} // end namespace Elmxx
#endif // ELMXX_ANCHORVIEW_H

16
elementaryxx/include/elementaryxx/ElmApplication.h → elementaryxx/include/elementaryxx/Application.h
View File

@ -1,18 +1,18 @@
#ifndef ELM_APPLICATION_H
#define ELM_APPLICATION_H
#ifndef ELMXX_APPLICATION_H
#define ELMXX_APPLICATION_H
/* STL */
#include <string>
/* EFL++ */
namespace efl {
namespace Elmxx {
class ElmApplication
class Application
{
public:
ElmApplication (int argc, char **argv);
virtual ~ElmApplication ();
Application (int argc, char **argv);
virtual ~Application ();
static void run ();
static void exit ();
@ -28,6 +28,6 @@ public:
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_APPLICATION_H
#endif // ELMXX_APPLICATION_H

34
elementaryxx/include/elementaryxx/Background.h Normal file
View File

@ -0,0 +1,34 @@
#ifndef ELMXX_BACKGROUND_H
#define ELMXX_BACKGROUND_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Background : public Object
{
public:
static Background *factory (Evasxx::Object &parent);
void setFile (const std::string &file);
/*!
* FIXME: do bool return here?
* @see Image::setFile
*/
void setFile (const std::string &file, const std::string &group);
private:
Background (); // forbid standard constructor
Background (const Background&); // forbid copy constructor
Background (Evasxx::Object &parent); // private construction -> use factory ()
~Background (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_BACKGROUND_H

48
elementaryxx/include/elementaryxx/Box.h Normal file
View File

@ -0,0 +1,48 @@
#ifndef ELMXX_BOX_H
#define ELMXX_BOX_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Box : public Object
{
public:
static Box *factory (Evasxx::Object &parent);
private:
Box (); // forbid standard constructor
Box (const Box&); // forbid copy constructor
Box (Evasxx::Object &parent); // private construction -> use factory ()
~Box (); // forbid direct delete -> use Object::destroy()
public:
enum Orientation
{
Horizontal,
Vertical
};
void setOrientation (Box::Orientation orient);
void setHomogenous (bool homogenous);
void packStart (const Evasxx::Object &subobj);
void packEnd (const Evasxx::Object &subobj);
void packBefore (const Evasxx::Object &subobj, const Evasxx::Object &before);
void packAfter (const Evasxx::Object &subobj, const Evasxx::Object &after);
};
} // end namespace Elmxx
#endif // ELMXX_BOX_H

39
elementaryxx/include/elementaryxx/Bubble.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef ELMXX_BUBBLE_H
#define ELMXX_BUBBLE_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Bubble : public Object
{
public:
static Bubble *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setInfo (const std::string &info);
void setContent (const Evasxx::Object &content);
void setIcon (const Evasxx::Object &icon);
void setCorner (const std::string &corner);
private:
Bubble (); // forbid standard constructor
Bubble (const Bubble&); // forbid copy constructor
Bubble (Evasxx::Object &parent); // private construction -> use factory ()
~Bubble (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_BUBBLE_H

42
elementaryxx/include/elementaryxx/Button.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef ELMXX_BUTTON_H
#define ELMXX_BUTTON_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "clicked" - the user clicked the button
*
* available styles:
* default
* hoversel_vertical
* hoversel_vertical_entry
*/
class Button : public Object
{
public:
static Button *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setIcon (const Evasxx::Object &icon);
private:
Button (); // forbid standard constructor
Button (const Button&); // forbid copy constructor
Button (Evasxx::Object &parent); // private construction -> use factory ()
~Button (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_BUTTON_H

46
elementaryxx/include/elementaryxx/Check.h Normal file
View File

@ -0,0 +1,46 @@
#ifndef ELMXX_CHECK_H
#define ELMXX_CHECK_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "changed" - the user toggled the state
*/
class Check : public Object
{
public:
static Check *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setIcon (const Evasxx::Object &icon);
void setState (bool state);
bool getState () const;
private:
Check (); // forbid standard constructor
Check (const Check&); // forbid copy constructor
Check (Evasxx::Object &parent); // private construction -> use factory ()
~Check (); // forbid direct delete -> use Object::destroy()
};
#if 0
TODO
EAPI void elm_check_state_pointer_set(Evas_Object *obj, Evas_Bool *statep);
#endif
} // end namespace Elmxx
#endif // ELMXX_CHECK_H

57
elementaryxx/include/elementaryxx/Clock.h Normal file
View File

@ -0,0 +1,57 @@
#ifndef ELMXX_CLOCK_H
#define ELMXX_CLOCK_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "changed" - the user changed the time
*/
class Clock : public Object
{
public:
class Time
{
public:
Time () :
hrs (0), min (0), sec (0) {}
Time (int hrs, int min, int sec) :
hrs (this->hrs), min (this->min), sec (this->sec) {}
int hrs;
int min;
int sec;
};
static Clock *factory (Evasxx::Object &parent);
void setTime (const Clock::Time &time);
const Clock::Time getTime ();
void setEdit (bool edit);
void setShowAmPm (bool am_pm);
void setShowSeconds (bool seconds);
private:
Clock (); // forbid standard constructor
Clock (const Clock&); // forbid copy constructor
Clock (Evasxx::Object &parent); // private construction -> use factory ()
~Clock (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_CLOCK_H

58
elementaryxx/include/elementaryxx/Elementaryxx.h
View File

@ -7,35 +7,35 @@
* #include "Elementaryxx.h".
*/
#include "ElmApplication.h"
#include "ElmObject.h"
#include "ElmWindow.h"
#include "ElmButton.h"
#include "ElmClock.h"
#include "ElmScroller.h"
#include "ElmToggle.h"
#include "ElmEntry.h"
#include "ElmSlider.h"
#include "ElmLabel.h"
#include "ElmBackground.h"
#include "ElmRadio.h"
#include "ElmImage.h"
#include "ElmIcon.h"
#include "ElmBubble.h"
#include "ElmBox.h"
#include "ElmFrame.h"
#include "ElmList.h"
#include "ElmListItem.h"
#include "ElmTable.h"
#include "ElmLayout.h"
#include "ElmHover.h"
#include "ElmNotepad.h"
#include "ElmCheck.h"
#include "ElmAnchorview.h"
#include "ElmAnchorblock.h"
#include "ElmSpinner.h"
#include "ElmProgressbar.h"
#include "ElmPanel.h"
#include "Application.h"
#include "Object.h"
#include "Window.h"
#include "Button.h"
#include "Clock.h"
#include "Scroller.h"
#include "Toggle.h"
#include "Entry.h"
#include "Slider.h"
#include "Label.h"
#include "Background.h"
#include "Radio.h"
#include "Image.h"
#include "Icon.h"
#include "Bubble.h"
#include "Box.h"
#include "Frame.h"
#include "List.h"
#include "ListItem.h"
#include "Table.h"
#include "Layout.h"
#include "Hover.h"
#include "Notepad.h"
#include "Check.h"
#include "Anchorview.h"
#include "Anchorblock.h"
#include "Spinner.h"
#include "Progressbar.h"
#include "Panel.h"
#endif // ELEMENTARYXX_H

35
elementaryxx/include/elementaryxx/ElmAnchorblock.h
View File

@ -1,35 +0,0 @@
#ifndef ELM_ANCHORBLOCK_H
#define ELM_ANCHORBLOCK_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorblock_Info
*/
class ElmAnchorblock : public ElmObject
{
public:
static ElmAnchorblock *factory (EvasObject &parent);
private:
ElmAnchorblock (); // forbid standard constructor
ElmAnchorblock (const ElmAnchorblock&); // forbid copy constructor
ElmAnchorblock (EvasObject &parent); // private construction -> use factory ()
~ElmAnchorblock (); // forbid direct delete -> use ElmWidget::destroy()
void setText (const std::string &text);
void setHoverParent (EvasObject &parent);
void setHoverStyle (const std::string &style);
void endHover ();
};
} // end namespace efl
#endif // ELM_ANCHORBLOCK_H

35
elementaryxx/include/elementaryxx/ElmAnchorview.h
View File

@ -1,35 +0,0 @@
#ifndef ELM_ANCHORVIEW_H
#define ELM_ANCHORVIEW_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchorview_Info
*/
class ElmAnchorview : public ElmObject
{
public:
static ElmAnchorview *factory (EvasObject &parent);
private:
ElmAnchorview (); // forbid standard constructor
ElmAnchorview (const ElmAnchorview&); // forbid copy constructor
ElmAnchorview (EvasObject &parent); // private construction -> use factory ()
~ElmAnchorview (); // forbid direct delete -> use ElmWidget::destroy()
void setText (const std::string &text);
void setHoverParent (EvasObject &parent);
void setHoverStyle (const std::string &style);
void endHover ();
};
} // end namespace efl
#endif // ELM_ANCHORVIEW_H

34
elementaryxx/include/elementaryxx/ElmBackground.h
View File

@ -1,34 +0,0 @@
#ifndef ELM_BACKGROUND_H
#define ELM_BACKGROUND_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmBackground : public ElmObject
{
public:
static ElmBackground *factory (EvasObject &parent);
void setFile (const std::string &file);
/*!
* FIXME: do bool return here?
* @see ElmImage::setFile
*/
void setFile (const std::string &file, const std::string &group);
private:
ElmBackground (); // forbid standard constructor
ElmBackground (const ElmBackground&); // forbid copy constructor
ElmBackground (EvasObject &parent); // private construction -> use factory ()
~ElmBackground (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_BACKGROUND_H

48
elementaryxx/include/elementaryxx/ElmBox.h
View File

@ -1,48 +0,0 @@
#ifndef ELM_BOX_H
#define ELM_BOX_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmBox : public ElmObject
{
public:
static ElmBox *factory (EvasObject &parent);
private:
ElmBox (); // forbid standard constructor
ElmBox (const ElmBox&); // forbid copy constructor
ElmBox (EvasObject &parent); // private construction -> use factory ()
~ElmBox (); // forbid direct delete -> use ElmObject::destroy()
public:
enum Orientation
{
Horizontal,
Vertical
};
void setOrientation (ElmBox::Orientation orient);
void setHomogenous (bool homogenous);
void packStart (const EvasObject &subobj);
void packEnd (const EvasObject &subobj);
void packBefore (const EvasObject &subobj, const EvasObject &before);
void packAfter (const EvasObject &subobj, const EvasObject &after);
};
} // end namespace efl
#endif // ELM_BOX_H

39
elementaryxx/include/elementaryxx/ElmBubble.h
View File

@ -1,39 +0,0 @@
#ifndef ELM_BUBBLE_H
#define ELM_BUBBLE_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmBubble : public ElmObject
{
public:
static ElmBubble *factory (EvasObject &parent);
void setLabel (const std::string &label);
void setInfo (const std::string &info);
void setContent (const EvasObject &content);
void setIcon (const EvasObject &icon);
void setCorner (const std::string &corner);
private:
ElmBubble (); // forbid standard constructor
ElmBubble (const ElmBubble&); // forbid copy constructor
ElmBubble (EvasObject &parent); // private construction -> use factory ()
~ElmBubble (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_BUBBLE_H

42
elementaryxx/include/elementaryxx/ElmButton.h
View File

@ -1,42 +0,0 @@
#ifndef ELM_BUTTON_H
#define ELM_BUTTON_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "clicked" - the user clicked the button
*
* available styles:
* default
* hoversel_vertical
* hoversel_vertical_entry
*/
class ElmButton : public ElmObject
{
public:
static ElmButton *factory (EvasObject &parent);
void setLabel (const std::string &label);
void setIcon (const EvasObject &icon);
private:
ElmButton (); // forbid standard constructor
ElmButton (const ElmButton&); // forbid copy constructor
ElmButton (EvasObject &parent); // private construction -> use factory ()
~ElmButton (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_BUTTON_H

46
elementaryxx/include/elementaryxx/ElmCheck.h
View File

@ -1,46 +0,0 @@
#ifndef ELM_CHECK_H
#define ELM_CHECK_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "changed" - the user toggled the state
*/
class ElmCheck : public ElmObject
{
public:
static ElmCheck *factory (EvasObject &parent);
void setLabel (const std::string &label);
void setIcon (const EvasObject &icon);
void setState (bool state);
bool getState () const;
private:
ElmCheck (); // forbid standard constructor
ElmCheck (const ElmCheck&); // forbid copy constructor
ElmCheck (EvasObject &parent); // private construction -> use factory ()
~ElmCheck (); // forbid direct delete -> use ElmObject::destroy()
};
#if 0
TODO
EAPI void elm_check_state_pointer_set(Evas_Object *obj, Evas_Bool *statep);
#endif
} // end namespace efl
#endif // ELM_CHECK_H

57
elementaryxx/include/elementaryxx/ElmClock.h
View File

@ -1,57 +0,0 @@
#ifndef ELM_CLOCK_H
#define ELM_CLOCK_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "changed" - the user changed the time
*/
class ElmClock : public ElmObject
{
public:
class Time
{
public:
Time () :
hrs (0), min (0), sec (0) {}
Time (int hrs, int min, int sec) :
hrs (this->hrs), min (this->min), sec (this->sec) {}
int hrs;
int min;
int sec;
};
static ElmClock *factory (EvasObject &parent);
void setTime (const ElmClock::Time &time);
const ElmClock::Time getTime ();
void setEdit (bool edit);
void setShowAmPm (bool am_pm);
void setShowSeconds (bool seconds);
private:
ElmClock (); // forbid standard constructor
ElmClock (const ElmClock&); // forbid copy constructor
ElmClock (EvasObject &parent); // private construction -> use factory ()
~ElmClock (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_CLOCK_H

43
elementaryxx/include/elementaryxx/ElmFrame.h
View File

@ -1,43 +0,0 @@
#ifndef ELM_FRAME_H
#define ELM_FRAME_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* available styles:
* default
* pad_small
* pad_medium
* pad_large
* pad_huge
* outdent_top
* outdent_bottom
*/
class ElmFrame : public ElmObject
{
public:
static ElmFrame *factory (EvasObject &parent);
void setLabel (const std::string &label);
void setContent (const EvasObject &content);
private:
ElmFrame (); // forbid standard constructor
ElmFrame (const ElmFrame&); // forbid copy constructor
ElmFrame (EvasObject &parent); // private construction -> use factory ()
~ElmFrame (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_FRAME_H

42
elementaryxx/include/elementaryxx/ElmHover.h
View File

@ -1,42 +0,0 @@
#ifndef ELM_HOVER_H
#define ELM_HOVER_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*! smart callbacks called:
* "clicked" - the user clicked the empty space in the hover to dismiss
*
* available styles:
* default
* popout
* hoversel_vertical
*/
class ElmHover : public ElmObject
{
public:
static ElmHover *factory (EvasObject &parent);
void setTarget (const EvasObject &target);
void setParent (const EvasObject &parent);
void setContent (const std::string &swallow, const EvasObject &content);
const string getBestContentLocation (Elm_Hover_Axis prefAxis) const;
private:
ElmHover (); // forbid standard constructor
ElmHover (const ElmHover&); // forbid copy constructor
ElmHover (EvasObject &parent); // private construction -> use factory ()
~ElmHover (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_HOVER_H

31
elementaryxx/include/elementaryxx/ElmLabel.h
View File

@ -1,31 +0,0 @@
#ifndef ELM_LABEL_H
#define ELM_LABEL_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmLabel : public ElmObject
{
public:
static ElmLabel *factory (EvasObject &parent);
void setLabel (const std::string &label);
private:
ElmLabel (); // forbid standard constructor
ElmLabel (const ElmLabel&); // forbid copy constructor
ElmLabel (EvasObject &parent); // private construction -> use factory ()
~ElmLabel (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_LABEL_H

36
elementaryxx/include/elementaryxx/ElmLayout.h
View File

@ -1,36 +0,0 @@
#ifndef ELM_LAYOUT_H
#define ELM_LAYOUT_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmLayout : public ElmObject
{
public:
static ElmLayout *factory (EvasObject &parent);
bool setFile (const std::string &file);
bool setFile (const std::string &file, const std::string &group);
void setContent (const std::string &swallow, const EvasObject &content);
//EAPI Evas_Object *elm_layout_edje_get(const Evas_Object *obj);
private:
ElmLayout (); // forbid standard constructor
ElmLayout (const ElmLayout&); // forbid copy constructor
ElmLayout (EvasObject &parent); // private construction -> use factory ()
~ElmLayout (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_LAYOUT_H

28
elementaryxx/include/elementaryxx/ElmNotepad.h
View File

@ -1,28 +0,0 @@
#ifndef ELM_NOTEPAD_H
#define ELM_NOTEPAD_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmNotepad : public ElmObject
{
public:
static ElmNotepad *factory (EvasObject &parent);
void setFile (const std::string &file, Elm_Text_Format format);
private:
ElmNotepad (); // forbid standard constructor
ElmNotepad (const ElmNotepad&); // forbid copy constructor
ElmNotepad (EvasObject &parent); // private construction -> use factory ()
~ElmNotepad (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_NOTEPAD_H

30
elementaryxx/include/elementaryxx/ElmPanel.h
View File

@ -1,30 +0,0 @@
#ifndef ELM_PANEL_H
#define ELM_PANEL_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmPanel : public ElmObject
{
public:
static ElmPanel *factory (EvasObject &parent);
private:
ElmPanel (); // forbid standard constructor
ElmPanel (const ElmPanel&); // forbid copy constructor
ElmPanel (EvasObject &parent); // private construction -> use factory ()
~ElmPanel (); // forbid direct delete -> use ElmWidget::destroy()
public:
void setOrientation (Elm_Panel_Orient orient);
void setContent (EvasObject &content);
};
} // end namespace efl
#endif // ELM_PANEL_H

50
elementaryxx/include/elementaryxx/ElmRadio.h
View File

@ -1,50 +0,0 @@
#ifndef ELM_RADIO_H
#define ELM_RADIO_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "changed" - the user toggled the state
*/
class ElmRadio : public ElmObject
{
public:
static ElmRadio *factory (EvasObject &parent);
void setLabel (const std::string &label);
void setIcon (const EvasObject &icon);
void addGroup (const EvasObject &group);
void setStateValue (int value);
void setValue (int value);
int getValue () const;
private:
ElmRadio (); // forbid standard constructor
ElmRadio (const ElmRadio&); // forbid copy constructor
ElmRadio (EvasObject &parent); // private construction -> use factory ()
~ElmRadio (); // forbid direct delete -> use ElmObject::destroy()
};
#if 0
TODO
EAPI void elm_radio_value_pointer_set(Evas_Object *obj, int *valuep);
#endif
} // end namespace efl
#endif // ELM_RADIO_H

51
elementaryxx/include/elementaryxx/ElmScroller.h
View File

@ -1,51 +0,0 @@
#ifndef ELM_SCROLLER_H
#define ELM_SCROLLER_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
* "edge_left"
* "edge_right"
* "edge_top"
* "edge_bottom"
* "scroll"
*/
class ElmScroller : public ElmObject
{
public:
static ElmScroller *factory (EvasObject &parent);
void setContent (EvasObject &child);
void limitMinContent (bool width, bool height);
void showRegion (const Rect &rect);
void setPolicy (Elm_Scroller_Policy policyH, Elm_Scroller_Policy policyV); // TODO: is H=height and V=vertical?
const Rect getRegion () const;
const Size getChildSize () const;
void setBounce (bool hBounce, bool vBounce); // TODO: is H=height and V=vertical?
private:
ElmScroller (); // forbid standard constructor
ElmScroller (const ElmScroller&); // forbid copy constructor
ElmScroller (EvasObject &parent); // private construction -> use factory ()
~ElmScroller (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_SCROLLER_H

38
elementaryxx/include/elementaryxx/ElmSeparator.h
View File

@ -1,38 +0,0 @@
#ifndef ELM_TEMPLATE_H
#define ELM_TEMPLATE_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
/*!
* smart callbacks called:
*/
class ElmSeparator : public ElmObject
{
public:
enum Orientation
{
Horizontal,
Vertical
};
static ElmSeparator *factory (EvasObject &parent);
void setOrientation (ElmSeparator::Orientation orient);
ElmSeparator::Orientation getOrientation ();
private:
ElmSeparator (); // forbid standard constructor
ElmSeparator (const ElmSeparator&); // forbid copy constructor
ElmSeparator (EvasObject &parent); // private construction -> use factory ()
~ElmSeparator (); // forbid direct delete -> use ElmWidget::destroy()
};
} // end namespace efl
#endif // ELM_TEMPLATE_H

30
elementaryxx/include/elementaryxx/ElmTable.h
View File

@ -1,30 +0,0 @@
#ifndef ELM_TABLE_H
#define ELM_TABLE_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
namespace efl {
class ElmTable : public ElmObject
{
public:
static ElmTable *factory (EvasObject &parent);
void setHomogenous (bool homogenous);
void pack (const EvasObject &subobj, const Rect &rect);
private:
ElmTable (); // forbid standard constructor
ElmTable (const ElmTable&); // forbid copy constructor
ElmTable (EvasObject &parent); // private construction -> use factory ()
~ElmTable (); // forbid direct delete -> use ElmObject::destroy()
};
} // end namespace efl
#endif // ELM_TABLE_H

24
elementaryxx/include/elementaryxx/ElmEntry.h → elementaryxx/include/elementaryxx/Entry.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_ENTRY_H
#define ELM_ENTRY_H
#ifndef ELMXX_ENTRY_H
#define ELMXX_ENTRY_H
/* STL */
#include <string>
@ -8,9 +8,9 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
@ -25,10 +25,10 @@ namespace efl {
* "anchor,clicked" - achor called was clicked | event_info = Elm_Entry_Anchor_Info
* "activated" - when the enter key is pressed (useful for single line)
*/
class ElmEntry : public ElmObject
class Entry : public Object
{
public:
static ElmEntry *factory (EvasObject &parent);
static Entry *factory (Evasxx::Object &parent);
void setSingleLine (bool singleLine);
@ -55,12 +55,12 @@ public:
static const std::string utf8ToMarkup (const std::string &str);
private:
ElmEntry (); // forbid standard constructor
ElmEntry (const ElmEntry&); // forbid copy constructor
ElmEntry (EvasObject &parent); // private construction -> use factory ()
~ElmEntry (); // forbid direct delete -> use ElmObject::destroy()
Entry (); // forbid standard constructor
Entry (const Entry&); // forbid copy constructor
Entry (Evasxx::Object &parent); // private construction -> use factory ()
~Entry (); // forbid direct delete -> use Object::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_ENTRY_H
#endif // ELMXX_ENTRY_H

43
elementaryxx/include/elementaryxx/Frame.h Normal file
View File

@ -0,0 +1,43 @@
#ifndef ELMXX_FRAME_H
#define ELMXX_FRAME_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* available styles:
* default
* pad_small
* pad_medium
* pad_large
* pad_huge
* outdent_top
* outdent_bottom
*/
class Frame : public Object
{
public:
static Frame *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setContent (const Evasxx::Object &content);
private:
Frame (); // forbid standard constructor
Frame (const Frame&); // forbid copy constructor
Frame (Evasxx::Object &parent); // private construction -> use factory ()
~Frame (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_FRAME_H

42
elementaryxx/include/elementaryxx/Hover.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef ELMXX_HOVER_H
#define ELMXX_HOVER_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*! smart callbacks called:
* "clicked" - the user clicked the empty space in the hover to dismiss
*
* available styles:
* default
* popout
* hoversel_vertical
*/
class Hover : public Object
{
public:
static Hover *factory (Evasxx::Object &parent);
void setTarget (const Evasxx::Object &target);
void setParent (const Evasxx::Object &parent);
void setContent (const std::string &swallow, const Evasxx::Object &content);
const string getBestContentLocation (Elm_Hover_Axis prefAxis) const;
private:
Hover (); // forbid standard constructor
Hover (const Hover&); // forbid copy constructor
Hover (Evasxx::Object &parent); // private construction -> use factory ()
~Hover (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_HOVER_H

24
elementaryxx/include/elementaryxx/ElmIcon.h → elementaryxx/include/elementaryxx/Icon.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_ICON_H
#define ELM_ICON_H
#ifndef ELMXX_ICON_H
#define ELMXX_ICON_H
/* STL */
#include <string>
@ -8,18 +8,18 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
* "clicked" - the user clicked the icon
*/
class ElmIcon : public ElmObject
class Icon : public Object
{
public:
static ElmIcon *factory (EvasObject &parent);
static Icon *factory (Evasxx::Object &parent);
bool setFile (const std::string &file);
@ -38,12 +38,12 @@ public:
void setPrescale (int size);
private:
ElmIcon (); // forbid standard constructor
ElmIcon (const ElmIcon&); // forbid copy constructor
ElmIcon (EvasObject &parent); // private construction -> use factory ()
~ElmIcon (); // forbid direct delete -> use ElmObject::destroy()
Icon (); // forbid standard constructor
Icon (const Icon&); // forbid copy constructor
Icon (Evasxx::Object &parent); // private construction -> use factory ()
~Icon (); // forbid direct delete -> use Object::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_ICON_H
#endif // ELMXX_ICON_H

24
elementaryxx/include/elementaryxx/ElmImage.h → elementaryxx/include/elementaryxx/Image.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_IMAGE_H
#define ELM_IMAGE_H
#ifndef ELMXX_IMAGE_H
#define ELMXX_IMAGE_H
/* STL */
#include <string>
@ -8,18 +8,18 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
* "clicked" - the user clicked the image
*/
class ElmImage : public ElmObject
class Image : public Object
{
public:
static ElmImage *factory (EvasObject &parent);
static Image *factory (Evasxx::Object &parent);
bool setFile (const std::string &file, const std::string &group);
@ -36,12 +36,12 @@ public:
void setOrient (Elm_Image_Orient orient);
private:
ElmImage (); // forbid standard constructor
ElmImage (const ElmImage&); // forbid copy constructor
ElmImage (EvasObject &parent); // private construction -> use factory ()
~ElmImage (); // forbid direct delete -> use ElmObject::destroy()
Image (); // forbid standard constructor
Image (const Image&); // forbid copy constructor
Image (Evasxx::Object &parent); // private construction -> use factory ()
~Image (); // forbid direct delete -> use Object::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_IMAGE_H
#endif // ELMXX_IMAGE_H

31
elementaryxx/include/elementaryxx/Label.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef ELMXX_LABEL_H
#define ELMXX_LABEL_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Label : public Object
{
public:
static Label *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
private:
Label (); // forbid standard constructor
Label (const Label&); // forbid copy constructor
Label (Evasxx::Object &parent); // private construction -> use factory ()
~Label (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_LABEL_H

34
elementaryxx/include/elementaryxx/Layout.h Normal file
View File

@ -0,0 +1,34 @@
#ifndef ELMXX_LAYOUT_H
#define ELMXX_LAYOUT_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Layout : public Object
{
public:
static Layout *factory (Evasxx::Object &parent);
bool setFile (const std::string &file);
bool setFile (const std::string &file, const std::string &group);
void setContent (const std::string &swallow, const Evasxx::Object &content);
//EAPI Evas_Object *elm_layout_edje_get(const Evas_Object *obj);
private:
Layout (); // forbid standard constructor
Layout (const Layout&); // forbid copy constructor
Layout (Evasxx::Object &parent); // private construction -> use factory ()
~Layout (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_LAYOUT_H

26
elementaryxx/include/elementaryxx/ElmList.h → elementaryxx/include/elementaryxx/List.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_LIST_H
#define ELM_LIST_H
#ifndef ELMXX_LIST_H
#define ELMXX_LIST_H
/* STL */
#include <string>
@ -8,9 +8,9 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
@ -18,10 +18,10 @@ namespace efl {
* "selected" - when the user selected an item
* "unselected" - when the user unselected an item
*/
class ElmList : public ElmObject
class List : public Object
{
public:
static ElmList *factory (EvasObject &parent);
static List *factory (Evasxx::Object &parent);
void clear ();
@ -41,13 +41,13 @@ public:
Elm_List_Item *append (const std::string &label, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
Elm_List_Item *append (const std::string &label, const EvasObject &icon, const EvasObject &end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
Elm_List_Item *append (const std::string &label, const Evasxx::Object &icon, const Evasxx::Object &end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
private:
ElmList (); // forbid standard constructor
ElmList (const ElmList&); // forbid copy constructor
ElmList (EvasObject &parent); // private construction -> use factory ()
~ElmList (); // forbid direct delete -> use ElmObject::destroy()
List (); // forbid standard constructor
List (const List&); // forbid copy constructor
List (Evasxx::Object &parent); // private construction -> use factory ()
~List (); // forbid direct delete -> use Object::destroy()
};
#if 0
@ -57,6 +57,6 @@ private:
EAPI Elm_List_Item *elm_list_item_insert_after(Evas_Object *obj, Elm_List_Item *after, const char *label, Evas_Object *icon, Evas_Object *end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data);
#endif
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_LIST_H
#endif // ELMXX_LIST_H

34
elementaryxx/include/elementaryxx/ElmListItem.h → elementaryxx/include/elementaryxx/ListItem.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_LISTITEM_H
#define ELM_LISTITEM_H
#ifndef ELMXX_LISTITEM_H
#define ELMXX_LISTITEM_H
/* STL */
#include <string>
@ -8,18 +8,18 @@
#include <Elementary.h>
/* ELFxx */
#include <evasxx/EvasObject.h> // TODO: forward declaration?
#include <evasxx/Object.h> // TODO: forward declaration?
// TODO: think about List Design!!
namespace efl {
namespace Elmxx {
class ElmListItem
class ListItem
{
public:
virtual ~ElmListItem ();
virtual ~ListItem ();
static ElmListItem *factory ();
static ListItem *factory ();
void setSelected (bool selected);
@ -27,22 +27,22 @@ public:
void* getData ();
EvasObject *getIcon (); //FIXME
Evasxx::Object *getIcon (); //FIXME
EvasObject *getEnd (); //FIXME
Evasxx::Object *getEnd (); //FIXME
EvasObject *getBase (); //FIXME
Evasxx::Object *getBase (); //FIXME
const std::string getLabel ();
ElmListItem *prev (); //FIXME
ListItem *prev (); //FIXME
ElmListItem *next (); //FIXME
ListItem *next (); //FIXME
private:
ElmListItem (); // forbid standard constructor
ElmListItem (const ElmListItem&); // forbid copy constructor
//ElmListItem (EvasObject &parent); // private construction -> use factory ()
ListItem (); // forbid standard constructor
ListItem (const ListItem&); // forbid copy constructor
//ListItem (Evasxx::Object &parent); // private construction -> use factory ()
Elm_List_Item *mItem;
};
@ -62,6 +62,6 @@ private:
#endif
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_LISTITEM_H
#endif // ELMXX_LISTITEM_H

60
elementaryxx/include/elementaryxx/Makefile.am
View File

@ -1,36 +1,36 @@
libelementaryxx_HEADERS = \
ElmApplication.h \
ElmWindow.h \
Application.h \
Window.h \
Elementaryxx.h \
ElmButton.h \
ElmClock.h \
ElmScroller.h \
ElmToggle.h \
ElmEntry.h \
ElmCheck.h \
ElmIcon.h \
ElmImage.h \
ElmRadio.h \
ElmSlider.h \
ElmBubble.h \
ElmLabel.h \
ElmBackground.h \
ElmBox.h \
ElmFrame.h \
ElmList.h \
ElmListItem.h \
ElmTable.h \
ElmObject.h \
ElmLayout.h \
ElmHover.h \
ElmNotepad.h \
ElmAnchorblock.h \
ElmAnchorview.h \
ElmSpinner.h \
ElmProgressbar.h \
ElmPanel.h \
ElmSeparator.h
Button.h \
Clock.h \
Scroller.h \
Toggle.h \
Entry.h \
Check.h \
Icon.h \
Image.h \
Radio.h \
Slider.h \
Bubble.h \
Label.h \
Background.h \
Box.h \
Frame.h \
List.h \
ListItem.h \
Table.h \
Object.h \
Layout.h \
Hover.h \
Notepad.h \
Anchorblock.h \
Anchorview.h \
Spinner.h \
Progressbar.h \
Panel.h \
Separator.h
libelementaryxxdir = \
$(pkgincludedir)

28
elementaryxx/include/elementaryxx/Notepad.h Normal file
View File

@ -0,0 +1,28 @@
#ifndef ELMXX_NOTEPAD_H
#define ELMXX_NOTEPAD_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Notepad : public Object
{
public:
static Notepad *factory (Evasxx::Object &parent);
void setFile (const std::string &file, Elm_Text_Format format);
private:
Notepad (); // forbid standard constructor
Notepad (const Notepad&); // forbid copy constructor
Notepad (Evasxx::Object &parent); // private construction -> use factory ()
~Notepad (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_NOTEPAD_H

21
elementaryxx/include/elementaryxx/ElmObject.h → elementaryxx/include/elementaryxx/Object.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_OBJECT_H
#define ELM_OBJECT_H
#ifndef ELMXX_OBJECT_H
#define ELMXX_OBJECT_H
/* STL */
#include <string>
@ -8,11 +8,11 @@
#include <Elementary.h>
/* ELFxx */
#include <evasxx/EvasSmart.h>
#include <evasxx/Smart.h>
namespace efl {
namespace Elmxx {
class ElmObject : public EvasSmart
class Object : public Evasxx::Smart
{
public:
virtual void setScale (double scale);
@ -30,21 +30,20 @@ public:
void elm_object_scroll_freeze_pop(Evas_Object *obj);*/
protected:
ElmObject (); // allow only construction for child classes
virtual ~ElmObject (); // forbid direct delete -> use destroy()
Object (); // allow only construction for child classes
virtual ~Object (); // forbid direct delete -> use destroy()
void elmInit ();
void destroy ();
private:
ElmObject (const ElmObject&); // forbid copy constructor
Object (const Object&); // forbid copy constructor
void freeSignalHandler ();
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_OBJECT_H
#endif // ELMXX_OBJECT_H

30
elementaryxx/include/elementaryxx/Panel.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef ELMXX_PANEL_H
#define ELMXX_PANEL_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Panel : public Object
{
public:
static Panel *factory (Evasxx::Object &parent);
private:
Panel (); // forbid standard constructor
Panel (const Panel&); // forbid copy constructor
Panel (Evasxx::Object &parent); // private construction -> use factory ()
~Panel (); // forbid direct delete -> use ElmWidget::destroy()
public:
void setOrientation (Elm_Panel_Orient orient);
void setContent (Evasxx::Object &content);
};
} // end namespace Elmxx
#endif // ELMXX_PANEL_H

28
elementaryxx/include/elementaryxx/ElmProgressbar.h → elementaryxx/include/elementaryxx/Progressbar.h
View File

@ -1,13 +1,13 @@
#ifndef ELM_PROGRESSBAR_H
#define ELM_PROGRESSBAR_H
#ifndef ELMXX_PROGRESSBAR_H
#define ELMXX_PROGRESSBAR_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
@ -16,7 +16,7 @@ namespace efl {
* default
* wheel (simple style, no text, no progression, only pulse is available)
*/
class ElmProgressbar : public ElmObject
class Progressbar : public Object
{
public:
enum Orientation
@ -25,12 +25,12 @@ public:
Vertical
};
static ElmProgressbar *factory (EvasObject &parent);
static Progressbar *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setIcon (EvasObject &icon);
void setIcon (Evasxx::Object &icon);
void setSpanSize (Evas_Coord size);
void setOrientation (ElmProgressbar::Orientation orient);
void setOrientation (Progressbar::Orientation orient);
void setInverted (bool inverted);
void setPulse (bool pulse);
void pulse (bool state);
@ -58,12 +58,12 @@ public:
double getValue ();
private:
ElmProgressbar (); // forbid standard constructor
ElmProgressbar (const ElmProgressbar&); // forbid copy constructor
ElmProgressbar (EvasObject &parent); // private construction -> use factory ()
~ElmProgressbar (); // forbid direct delete -> use ElmWidget::destroy()
Progressbar (); // forbid standard constructor
Progressbar (const Progressbar&); // forbid copy constructor
Progressbar (Evasxx::Object &parent); // private construction -> use factory ()
~Progressbar (); // forbid direct delete -> use ElmWidget::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_PROGRESSBAR_H
#endif // ELMXX_PROGRESSBAR_H

50
elementaryxx/include/elementaryxx/Radio.h Normal file
View File

@ -0,0 +1,50 @@
#ifndef ELMXX_RADIO_H
#define ELMXX_RADIO_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "changed" - the user toggled the state
*/
class Radio : public Object
{
public:
static Radio *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setIcon (const Evasxx::Object &icon);
void addGroup (const Evasxx::Object &group);
void setStateValue (int value);
void setValue (int value);
int getValue () const;
private:
Radio (); // forbid standard constructor
Radio (const Radio&); // forbid copy constructor
Radio (Evasxx::Object &parent); // private construction -> use factory ()
~Radio (); // forbid direct delete -> use Object::destroy()
};
#if 0
TODO
EAPI void elm_radio_value_pointer_set(Evas_Object *obj, int *valuep);
#endif
} // end namespace Elmxx
#endif // ELMXX_RADIO_H

51
elementaryxx/include/elementaryxx/Scroller.h Normal file
View File

@ -0,0 +1,51 @@
#ifndef ELMXX_SCROLLER_H
#define ELMXX_SCROLLER_H
/* STL */
#include <string>
/* EFL */
#include <Elementary.h>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
* "edge_left"
* "edge_right"
* "edge_top"
* "edge_bottom"
* "scroll"
*/
class Scroller : public Object
{
public:
static Scroller *factory (Evasxx::Object &parent);
void setContent (Evasxx::Object &child);
void limitMinContent (bool width, bool height);
void showRegion (const Eflxx::Rect &rect);
void setPolicy (Elm_Scroller_Policy policyH, Elm_Scroller_Policy policyV); // TODO: is H=height and V=vertical?
const Eflxx::Rect getRegion () const;
const Eflxx::Size getChildSize () const;
void setBounce (bool hBounce, bool vBounce); // TODO: is H=height and V=vertical?
private:
Scroller (); // forbid standard constructor
Scroller (const Scroller&); // forbid copy constructor
Scroller (Evasxx::Object &parent); // private construction -> use factory ()
~Scroller (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_SCROLLER_H

38
elementaryxx/include/elementaryxx/Separator.h Normal file
View File

@ -0,0 +1,38 @@
#ifndef ELMXX_TEMPLATE_H
#define ELMXX_TEMPLATE_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
/*!
* smart callbacks called:
*/
class Separator : public Object
{
public:
enum Orientation
{
Horizontal,
Vertical
};
static Separator *factory (Evasxx::Object &parent);
void setOrientation (Separator::Orientation orient);
Separator::Orientation getOrientation ();
private:
Separator (); // forbid standard constructor
Separator (const Separator&); // forbid copy constructor
Separator (Evasxx::Object &parent); // private construction -> use factory ()
~Separator (); // forbid direct delete -> use ElmWidget::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_TEMPLATE_H

28
elementaryxx/include/elementaryxx/ElmSlider.h → elementaryxx/include/elementaryxx/Slider.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_SLIDER_H
#define ELM_SLIDER_H
#ifndef ELMXX_SLIDER_H
#define ELMXX_SLIDER_H
/* STL */
#include <string>
@ -8,9 +8,9 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
@ -19,7 +19,7 @@ namespace efl {
* change (use this if you only want to respond to a change
* once the slider is held still for a short while).
*/
class ElmSlider : public ElmObject
class Slider : public Object
{
public:
enum Orientation
@ -28,11 +28,11 @@ public:
Vertical
};
static ElmSlider *factory (EvasObject &parent);
static Slider *factory (Evasxx::Object &parent);
void setLabel (const std::string &label);
void setIcon (const EvasObject &icon);
void setIcon (const Evasxx::Object &icon);
void setSpanSize (Evas_Coord size);
@ -40,7 +40,7 @@ public:
void setIndicatorFormat (const std::string &indicator);
void setOrientation (ElmSlider::Orientation orient);
void setOrientation (Slider::Orientation orient);
void setMinMax (double min, double max);
@ -51,12 +51,12 @@ public:
void setInverted (bool inverted);
private:
ElmSlider (); // forbid standard constructor
ElmSlider (const ElmSlider&); // forbid copy constructor
ElmSlider (EvasObject &parent); // private construction -> use factory ()
~ElmSlider (); // forbid direct delete -> use ElmObject::destroy()
Slider (); // forbid standard constructor
Slider (const Slider&); // forbid copy constructor
Slider (Evasxx::Object &parent); // private construction -> use factory ()
~Slider (); // forbid direct delete -> use Object::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_SLIDER_H
#endif // ELMXX_SLIDER_H

24
elementaryxx/include/elementaryxx/ElmSpinner.h → elementaryxx/include/elementaryxx/Spinner.h
View File

@ -1,23 +1,23 @@
#ifndef ELM_SPINNER_H
#define ELM_SPINNER_H
#ifndef ELMXX_SPINNER_H
#define ELMXX_SPINNER_H
/* STL */
#include <string>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
* "changed" - when the spinner value changes
* "delay,changed" - when the spinner value changed, but a small time after a change (use this if you only want to respond to a change once the spinner is held still for a short while).
*/
class ElmSpinner : public ElmObject
class Spinner : public Object
{
public:
static ElmSpinner *factory (EvasObject &parent);
static Spinner *factory (Evasxx::Object &parent);
void setLabelFormat (const std::string &format);
const string getLabelFormat ();
@ -28,12 +28,12 @@ public:
void setWrap (bool wrap);
private:
ElmSpinner (); // forbid standard constructor
ElmSpinner (const ElmSpinner&); // forbid copy constructor
ElmSpinner (EvasObject &parent); // private construction -> use factory ()
~ElmSpinner (); // forbid direct delete -> use ElmWidget::destroy()
Spinner (); // forbid standard constructor
Spinner (const Spinner&); // forbid copy constructor
Spinner (Evasxx::Object &parent); // private construction -> use factory ()
~Spinner (); // forbid direct delete -> use ElmWidget::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_SPINNER_H
#endif // ELMXX_SPINNER_H

30
elementaryxx/include/elementaryxx/Table.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef ELMXX_TABLE_H
#define ELMXX_TABLE_H
/* STL */
#include <string>
/* ELFxx */
#include "Object.h"
namespace Elmxx {
class Table : public Object
{
public:
static Table *factory (Evasxx::Object &parent);
void setHomogenous (bool homogenous);
void pack (const Evasxx::Object &subobj, const Eflxx::Rect &rect);
private:
Table (); // forbid standard constructor
Table (const Table&); // forbid copy constructor
Table (Evasxx::Object &parent); // private construction -> use factory ()
~Table (); // forbid direct delete -> use Object::destroy()
};
} // end namespace Elmxx
#endif // ELMXX_TABLE_H

32
elementaryxx/include/elementaryxx/ElmWindow.h → elementaryxx/include/elementaryxx/Window.h
View File

@ -1,5 +1,5 @@
#ifndef ELM_WINDOW_H
#define ELM_WINDOW_H
#ifndef ELMXX_WINDOW_H
#define ELMXX_WINDOW_H
/* STL */
#include <string>
@ -8,9 +8,9 @@
#include <Elementary.h>
/* ELFxx */
#include "ElmObject.h"
#include "Object.h"
namespace efl {
namespace Elmxx {
/*!
* smart callbacks called:
@ -18,17 +18,17 @@ namespace efl {
* "focus-in" - window got focus
* "focus-out" - window lost focus
*/
class ElmWindow : public ElmObject
class Window : public Object
{
public:
static ElmWindow* factory (const std::string &name, Elm_Win_Type type);
static Window* factory (const std::string &name, Elm_Win_Type type);
/*!
* Contructor for a EwlWindow that has a parent window.
* The function ecore_x_icccm_transient_for_set is used to specify that a window
* is transient for another top-level window and should be handled accordingly.
*/
static ElmWindow* factory (EvasObject &parent, const std::string &name, Elm_Win_Type type);
static Window* factory (Evasxx::Object &parent, const std::string &name, Elm_Win_Type type);
void setTitle (const std::string &title);
@ -64,23 +64,23 @@ public:
//void setKeyboardWin (bool isKeyboard); // FIXME: is* name?
void addObjectResize (const EvasObject &subobj);
void addObjectResize (const Evasxx::Object &subobj);
void delObjectResize (const EvasObject &subobj);
void delObjectResize (const Evasxx::Object &subobj);
private:
ElmWindow (); // forbid standard constructor
ElmWindow (const ElmWindow&); // forbid copy constructor
Window (); // forbid standard constructor
Window (const Window&); // forbid copy constructor
// private construction -> use factory ()
ElmWindow (const std::string &name, Elm_Win_Type type);
ElmWindow (EvasObject &parent, const std::string &name, Elm_Win_Type type);
~ElmWindow (); // forbid direct delete -> use ElmObject::destroy()
Window (const std::string &name, Elm_Win_Type type);
Window (Evasxx::Object &parent, const std::string &name, Elm_Win_Type type);
~Window (); // forbid direct delete -> use Object::destroy()
};
} // end namespace efl
} // end namespace Elmxx
#endif // ELM_WINDOW_H
#endif // ELMXX_WINDOW_H
#if 0
// TODO

45
elementaryxx/src/Anchorblock.cpp Normal file
View File

@ -0,0 +1,45 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Anchorblock.h"
using namespace std;
namespace Elmxx {
Anchorblock::Anchorblock (Evasxx::Object &parent)
{
o = elm_anchorblock_add (parent.obj ());
elmInit ();
}
Anchorblock::~Anchorblock () {}
Anchorblock *Anchorblock::factory (Evasxx::Object &parent)
{
return new Anchorblock (parent);
}
void Anchorblock::setText (const std::string &text)
{
elm_anchorblock_text_set (o, text.c_str ());
}
void Anchorblock::setHoverParent (Evasxx::Object &parent)
{
elm_anchorblock_hover_parent_set (o, parent.obj ());
}
void Anchorblock::setHoverStyle (const std::string &style)
{
elm_anchorblock_hover_style_set (o, style.c_str ());
}
void Anchorblock::endHover ()
{
elm_anchorblock_hover_end (o);
}
} // end namespace Elmxx

45
elementaryxx/src/Anchorview.cpp Normal file
View File

@ -0,0 +1,45 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Anchorview.h"
using namespace std;
namespace Elmxx {
Anchorview::Anchorview (Evasxx::Object &parent)
{
o = elm_anchorview_add (parent.obj ());
elmInit ();
}
Anchorview::~Anchorview () {}
Anchorview *Anchorview::factory (Evasxx::Object &parent)
{
return new Anchorview (parent);
}
void Anchorview::setText (const std::string &text)
{
elm_anchorview_text_set (o, text.c_str ());
}
void Anchorview::setHoverParent (Evasxx::Object &parent)
{
elm_anchorview_hover_parent_set (o, parent.obj ());
}
void Anchorview::setHoverStyle (const std::string &style)
{
elm_anchorview_hover_style_set (o, style.c_str ());
}
void Anchorview::endHover ()
{
elm_anchorview_hover_end (o);
}
} // end namespace Elmxx

44
elementaryxx/src/Application.cpp Normal file
View File

@ -0,0 +1,44 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Application.h"
/* EFL */
#include <Elementary.h>
using namespace std;
namespace Elmxx {
Application::Application (int argc, char **argv)
{
elm_init (argc, argv);
}
Application::~Application ()
{
elm_shutdown ();
}
void Application::run ()
{
elm_run ();
}
void Application::exit ()
{
elm_exit ();
}
double Application::getScale ()
{
return elm_scale_get ();
}
void Application::setScale (double scale)
{
elm_scale_set (scale);
}
} // end namespace Elmxx

35
elementaryxx/src/Background.cpp Normal file
View File

@ -0,0 +1,35 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Background.h"
using namespace std;
namespace Elmxx {
Background::Background (Evasxx::Object &parent)
{
o = elm_bg_add (parent.obj ());
elmInit ();
}
Background::~Background () {}
Background *Background::factory (Evasxx::Object &parent)
{
return new Background (parent);
}
void Background::setFile (const std::string &file)
{
elm_bg_file_set (o, file.c_str (), NULL);
}
void Background::setFile (const std::string &file, const std::string &group)
{
elm_bg_file_set (o, file.c_str (), group.c_str ());
}
} // end namespace Elmxx

26
elementaryxx/src/ElmBox.cpp → elementaryxx/src/Box.cpp
View File

@ -2,27 +2,27 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmBox.h"
#include "../include/elementaryxx/Box.h"
using namespace std;
namespace efl {
namespace Elmxx {
ElmBox::ElmBox (EvasObject &parent)
Box::Box (Evasxx::Object &parent)
{
o = elm_box_add (parent.obj ());
elmInit ();
}
ElmBox::~ElmBox () {}
Box::~Box () {}
ElmBox *ElmBox::factory (EvasObject &parent)
Box *Box::factory (Evasxx::Object &parent)
{
return new ElmBox (parent);
return new Box (parent);
}
void ElmBox::setOrientation (ElmBox::Orientation orient)
void Box::setOrientation (Box::Orientation orient)
{
switch (orient)
{
@ -35,29 +35,29 @@ void ElmBox::setOrientation (ElmBox::Orientation orient)
}
}
void ElmBox::setHomogenous (bool homogenous)
void Box::setHomogenous (bool homogenous)
{
elm_box_homogenous_set (o, homogenous);
}
void ElmBox::packStart (const EvasObject &subobj)
void Box::packStart (const Evasxx::Object &subobj)
{
elm_box_pack_start (o, subobj.obj ());
}
void ElmBox::packEnd (const EvasObject &subobj)
void Box::packEnd (const Evasxx::Object &subobj)
{
elm_box_pack_end (o, subobj.obj ());
}
void ElmBox::packBefore (const EvasObject &subobj, const EvasObject &before)
void Box::packBefore (const Evasxx::Object &subobj, const Evasxx::Object &before)
{
elm_box_pack_before (o, subobj.obj (), before.obj ());
}
void ElmBox::packAfter (const EvasObject &subobj, const EvasObject &after)
void Box::packAfter (const Evasxx::Object &subobj, const Evasxx::Object &after)
{
elm_box_pack_after (o, subobj.obj (), after.obj ());
}
} // end namespace efl
} // end namespace Elmxx

50
elementaryxx/src/Bubble.cpp Normal file
View File

@ -0,0 +1,50 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Bubble.h"
using namespace std;
namespace Elmxx {
Bubble::Bubble (Evasxx::Object &parent)
{
o = elm_bubble_add (parent.obj ());
elmInit ();
}
Bubble::~Bubble () {}
Bubble *Bubble::factory (Evasxx::Object &parent)
{
return new Bubble (parent);
}
void Bubble::setLabel (const std::string &label)
{
elm_bubble_label_set (o, label.c_str ());
}
void Bubble::setInfo (const std::string &info)
{
elm_bubble_info_set (o, info.c_str ());
}
void Bubble::setContent (const Evasxx::Object &content)
{
elm_bubble_content_set (o, content.obj ());
}
void Bubble::setIcon (const Evasxx::Object &icon)
{
elm_bubble_icon_set (o, icon.obj ());
}
void Bubble::setCorner (const std::string &corner)
{
elm_bubble_corner_set (o, corner.c_str ());
}
} // end namespace Elmxx

35
elementaryxx/src/Button.cpp Normal file
View File

@ -0,0 +1,35 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Button.h"
using namespace std;
namespace Elmxx {
Button::Button (Evasxx::Object &parent)
{
o = elm_button_add (parent.obj ());
elmInit ();
}
Button::~Button () {}
Button *Button::factory (Evasxx::Object &parent)
{
return new Button (parent);
}
void Button::setLabel (const std::string &label)
{
elm_button_label_set (o, label.c_str ());
}
void Button::setIcon (const Evasxx::Object &icon)
{
elm_button_icon_set (o, icon.obj ());
}
} // end namespace Elmxx

45
elementaryxx/src/Check.cpp Normal file
View File

@ -0,0 +1,45 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Check.h"
using namespace std;
namespace Elmxx {
Check::Check (Evasxx::Object &parent)
{
o = elm_check_add (parent.obj ());
elmInit ();
}
Check::~Check () {}
Check *Check::factory (Evasxx::Object &parent)
{
return new Check (parent);
}
void Check::setLabel (const std::string &label)
{
elm_check_label_set (o, label.c_str ());
}
void Check::setIcon (const Evasxx::Object &icon)
{
elm_check_icon_set (o, icon.obj ());
}
void Check::setState (bool state)
{
elm_check_state_set (o, state);
}
bool Check::getState () const
{
return elm_check_state_get (o);
}
} // end namespace Elmxx

52
elementaryxx/src/Clock.cpp Normal file
View File

@ -0,0 +1,52 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Clock.h"
using namespace std;
namespace Elmxx {
Clock::Clock (Evasxx::Object &parent)
{
o = elm_clock_add (parent.obj ());
elmInit ();
}
Clock::~Clock () {}
Clock *Clock::factory (Evasxx::Object &parent)
{
return new Clock (parent);
}
void Clock::setTime (const Clock::Time &time)
{
elm_clock_time_set (o, time.hrs, time.min, time.sec);
}
const Clock::Time Clock::getTime ()
{
Time time;
elm_clock_time_get (o, &time.hrs, &time.min, &time.sec);
return time;
}
void Clock::setEdit (bool edit)
{
elm_clock_edit_set (o, edit);
}
void Clock::setShowAmPm (bool am_pm)
{
elm_clock_show_am_pm_set (o, am_pm);
}
void Clock::setShowSeconds (bool seconds)
{
elm_clock_show_seconds_set (o, seconds);
}
} // end namespace Elmxx

45
elementaryxx/src/ElmAnchorblock.cpp
View File

@ -1,45 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmAnchorblock.h"
using namespace std;
namespace efl {
ElmAnchorblock::ElmAnchorblock (EvasObject &parent)
{
o = elm_anchorblock_add (parent.obj ());
elmInit ();
}
ElmAnchorblock::~ElmAnchorblock () {}
ElmAnchorblock *ElmAnchorblock::factory (EvasObject &parent)
{
return new ElmAnchorblock (parent);
}
void ElmAnchorblock::setText (const std::string &text)
{
elm_anchorblock_text_set (o, text.c_str ());
}
void ElmAnchorblock::setHoverParent (EvasObject &parent)
{
elm_anchorblock_hover_parent_set (o, parent.obj ());
}
void ElmAnchorblock::setHoverStyle (const std::string &style)
{
elm_anchorblock_hover_style_set (o, style.c_str ());
}
void ElmAnchorblock::endHover ()
{
elm_anchorblock_hover_end (o);
}
} // end namespace efl

45
elementaryxx/src/ElmAnchorview.cpp
View File

@ -1,45 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmAnchorview.h"
using namespace std;
namespace efl {
ElmAnchorview::ElmAnchorview (EvasObject &parent)
{
o = elm_anchorview_add (parent.obj ());
elmInit ();
}
ElmAnchorview::~ElmAnchorview () {}
ElmAnchorview *ElmAnchorview::factory (EvasObject &parent)
{
return new ElmAnchorview (parent);
}
void ElmAnchorview::setText (const std::string &text)
{
elm_anchorview_text_set (o, text.c_str ());
}
void ElmAnchorview::setHoverParent (EvasObject &parent)
{
elm_anchorview_hover_parent_set (o, parent.obj ());
}
void ElmAnchorview::setHoverStyle (const std::string &style)
{
elm_anchorview_hover_style_set (o, style.c_str ());
}
void ElmAnchorview::endHover ()
{
elm_anchorview_hover_end (o);
}
} // end namespace efl

44
elementaryxx/src/ElmApplication.cpp
View File

@ -1,44 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmApplication.h"
/* EFL */
#include <Elementary.h>
using namespace std;
namespace efl {
ElmApplication::ElmApplication (int argc, char **argv)
{
elm_init (argc, argv);
}
ElmApplication::~ElmApplication ()
{
elm_shutdown ();
}
void ElmApplication::run ()
{
elm_run ();
}
void ElmApplication::exit ()
{
elm_exit ();
}
double ElmApplication::getScale ()
{
return elm_scale_get ();
}
void ElmApplication::setScale (double scale)
{
elm_scale_set (scale);
}
} // end namespace efl

35
elementaryxx/src/ElmBackground.cpp
View File

@ -1,35 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmBackground.h"
using namespace std;
namespace efl {
ElmBackground::ElmBackground (EvasObject &parent)
{
o = elm_bg_add (parent.obj ());
elmInit ();
}
ElmBackground::~ElmBackground () {}
ElmBackground *ElmBackground::factory (EvasObject &parent)
{
return new ElmBackground (parent);
}
void ElmBackground::setFile (const std::string &file)
{
elm_bg_file_set (o, file.c_str (), NULL);
}
void ElmBackground::setFile (const std::string &file, const std::string &group)
{
elm_bg_file_set (o, file.c_str (), group.c_str ());
}
} // end namespace efl

50
elementaryxx/src/ElmBubble.cpp
View File

@ -1,50 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmBubble.h"
using namespace std;
namespace efl {
ElmBubble::ElmBubble (EvasObject &parent)
{
o = elm_bubble_add (parent.obj ());
elmInit ();
}
ElmBubble::~ElmBubble () {}
ElmBubble *ElmBubble::factory (EvasObject &parent)
{
return new ElmBubble (parent);
}
void ElmBubble::setLabel (const std::string &label)
{
elm_bubble_label_set (o, label.c_str ());
}
void ElmBubble::setInfo (const std::string &info)
{
elm_bubble_info_set (o, info.c_str ());
}
void ElmBubble::setContent (const EvasObject &content)
{
elm_bubble_content_set (o, content.obj ());
}
void ElmBubble::setIcon (const EvasObject &icon)
{
elm_bubble_icon_set (o, icon.obj ());
}
void ElmBubble::setCorner (const std::string &corner)
{
elm_bubble_corner_set (o, corner.c_str ());
}
} // end namespace efl

35
elementaryxx/src/ElmButton.cpp
View File

@ -1,35 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmButton.h"
using namespace std;
namespace efl {
ElmButton::ElmButton (EvasObject &parent)
{
o = elm_button_add (parent.obj ());
elmInit ();
}
ElmButton::~ElmButton () {}
ElmButton *ElmButton::factory (EvasObject &parent)
{
return new ElmButton (parent);
}
void ElmButton::setLabel (const std::string &label)
{
elm_button_label_set (o, label.c_str ());
}
void ElmButton::setIcon (const EvasObject &icon)
{
elm_button_icon_set (o, icon.obj ());
}
} // end namespace efl

45
elementaryxx/src/ElmCheck.cpp
View File

@ -1,45 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmCheck.h"
using namespace std;
namespace efl {
ElmCheck::ElmCheck (EvasObject &parent)
{
o = elm_check_add (parent.obj ());
elmInit ();
}
ElmCheck::~ElmCheck () {}
ElmCheck *ElmCheck::factory (EvasObject &parent)
{
return new ElmCheck (parent);
}
void ElmCheck::setLabel (const std::string &label)
{
elm_check_label_set (o, label.c_str ());
}
void ElmCheck::setIcon (const EvasObject &icon)
{
elm_check_icon_set (o, icon.obj ());
}
void ElmCheck::setState (bool state)
{
elm_check_state_set (o, state);
}
bool ElmCheck::getState () const
{
return elm_check_state_get (o);
}
} // end namespace efl

52
elementaryxx/src/ElmClock.cpp
View File

@ -1,52 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmClock.h"
using namespace std;
namespace efl {
ElmClock::ElmClock (EvasObject &parent)
{
o = elm_clock_add (parent.obj ());
elmInit ();
}
ElmClock::~ElmClock () {}
ElmClock *ElmClock::factory (EvasObject &parent)
{
return new ElmClock (parent);
}
void ElmClock::setTime (const ElmClock::Time &time)
{
elm_clock_time_set (o, time.hrs, time.min, time.sec);
}
const ElmClock::Time ElmClock::getTime ()
{
Time time;
elm_clock_time_get (o, &time.hrs, &time.min, &time.sec);
return time;
}
void ElmClock::setEdit (bool edit)
{
elm_clock_edit_set (o, edit);
}
void ElmClock::setShowAmPm (bool am_pm)
{
elm_clock_show_am_pm_set (o, am_pm);
}
void ElmClock::setShowSeconds (bool seconds)
{
elm_clock_show_seconds_set (o, seconds);
}
} // end namespace efl

35
elementaryxx/src/ElmFrame.cpp
View File

@ -1,35 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmFrame.h"
using namespace std;
namespace efl {
ElmFrame::ElmFrame (EvasObject &parent)
{
o = elm_frame_add (parent.obj ());
elmInit ();
}
ElmFrame::~ElmFrame () {}
ElmFrame *ElmFrame::factory (EvasObject &parent)
{
return new ElmFrame (parent);
}
void ElmFrame::setLabel (const std::string &label)
{
elm_frame_label_set (o, label.c_str ());
}
void ElmFrame::setContent (const EvasObject &content)
{
elm_frame_content_set (o, content.obj ());
}
} // end namespace efl

45
elementaryxx/src/ElmHover.cpp
View File

@ -1,45 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmHover.h"
using namespace std;
namespace efl {
ElmHover::ElmHover (EvasObject &parent)
{
o = elm_hover_add (parent.obj ());
elmInit ();
}
ElmHover::~ElmHover () {}
ElmHover *ElmHover::factory (EvasObject &parent)
{
return new ElmHover (parent);
}
void ElmHover::setTarget (const EvasObject &target)
{
elm_hover_target_set (o, target.obj ());
}
void ElmHover::setParent (const EvasObject &parent)
{
elm_hover_parent_set (o, parent.obj ());
}
void ElmHover::setContent (const std::string &swallow, const EvasObject &content)
{
elm_hover_content_set (o, swallow.c_str (), content.obj ());
}
const string ElmHover::getBestContentLocation (Elm_Hover_Axis prefAxis) const
{
return elm_hover_best_content_location_get (o, prefAxis);
}
} // end namespace efl

59
elementaryxx/src/ElmIcon.cpp
View File

@ -1,59 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmIcon.h"
using namespace std;
namespace efl {
ElmIcon::ElmIcon (EvasObject &parent)
{
o = elm_icon_add (parent.obj ());
elmInit ();
}
ElmIcon::~ElmIcon () {}
ElmIcon *ElmIcon::factory (EvasObject &parent)
{
return new ElmIcon (parent);
}
bool ElmIcon::setFile (const std::string &file)
{
return elm_icon_file_set (o, file.c_str (), NULL);
}
bool ElmIcon::setFile (const std::string &file, const std::string &group)
{
return elm_icon_file_set (o, file.c_str (), group.c_str ());
}
void ElmIcon::setStandard (const std::string &name)
{
elm_icon_standard_set (o, name.c_str ());
}
void ElmIcon::setSmooth (bool smooth)
{
elm_icon_smooth_set (o, smooth);
}
void ElmIcon::setNoScale (bool noScale)
{
elm_icon_no_scale_set (o, noScale);
}
void ElmIcon::setScale (bool scaleUp, bool scaleDown)
{
elm_icon_scale_set (o, scaleUp, scaleDown);
}
void ElmIcon::setFillOutside (bool fillOutside)
{
elm_icon_fill_outside_set (o, fillOutside);
}
void ElmIcon::setPrescale (int size)
{
elm_icon_prescale_set (o, size);
}
} // end namespace efl

60
elementaryxx/src/ElmImage.cpp
View File

@ -1,60 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmImage.h"
using namespace std;
namespace efl {
ElmImage::ElmImage (EvasObject &parent)
{
o = elm_image_add (parent.obj ());
elmInit ();
}
ElmImage::~ElmImage () {}
ElmImage *ElmImage::factory (EvasObject &parent)
{
return new ElmImage (parent);
}
bool ElmImage::setFile (const std::string &file, const std::string &group)
{
return elm_image_file_set (o, file.c_str (), group.c_str ());
}
void ElmImage::setSmooth (bool smooth)
{
elm_image_smooth_set (o, smooth);
}
void ElmImage::setNoScale (bool noScale)
{
elm_image_no_scale_set (o, noScale);
}
void ElmImage::setScale (bool scaleUp, bool scaleDown)
{
elm_image_scale_set (o, scaleUp, scaleDown);
}
void ElmImage::setFillOutside (bool fillOutside)
{
elm_image_fill_outside_set (o, fillOutside);
}
void ElmImage::setPrescale (int size)
{
elm_image_prescale_set (o, size);
}
void ElmImage::setOrient (Elm_Image_Orient orient)
{
elm_image_orient_set (o, orient);
}
} // end namespace efl

30
elementaryxx/src/ElmLabel.cpp
View File

@ -1,30 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmLabel.h"
using namespace std;
namespace efl {
ElmLabel::ElmLabel (EvasObject &parent)
{
o = elm_label_add (parent.obj ());
elmInit ();
}
ElmLabel::~ElmLabel () {}
ElmLabel *ElmLabel::factory (EvasObject &parent)
{
return new ElmLabel (parent);
}
void ElmLabel::setLabel (const std::string &label)
{
elm_label_label_set (o, label.c_str ());
}
} // end namespace efl

40
elementaryxx/src/ElmLayout.cpp
View File

@ -1,40 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmLayout.h"
using namespace std;
namespace efl {
ElmLayout::ElmLayout (EvasObject &parent)
{
o = elm_layout_add (parent.obj ());
elmInit ();
}
ElmLayout::~ElmLayout () {}
ElmLayout *ElmLayout::factory (EvasObject &parent)
{
return new ElmLayout (parent);
}
bool ElmLayout::setFile (const std::string &file)
{
return elm_layout_file_set (o, file.c_str (), NULL);
}
bool ElmLayout::setFile (const std::string &file, const std::string &group)
{
return elm_layout_file_set (o, file.c_str (), group.c_str ());
}
void ElmLayout::setContent (const std::string &swallow, const EvasObject &content)
{
elm_layout_content_set (o, swallow.c_str (), content.obj ());
}
} // end namespace efl

75
elementaryxx/src/ElmList.cpp
View File

@ -1,75 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmList.h"
using namespace std;
namespace efl {
ElmList::ElmList (EvasObject &parent)
{
o = elm_list_add (parent.obj ());
elmInit ();
}
ElmList::~ElmList () {}
ElmList *ElmList::factory (EvasObject &parent)
{
return new ElmList (parent);
}
void ElmList::clear ()
{
elm_list_clear (o);
}
void ElmList::go ()
{
elm_list_go (o);
}
void ElmList::setMultiSelect (bool multi)
{
elm_list_multi_select_set (o, multi);
}
void ElmList::setHorizontalMode (Elm_List_Mode mode)
{
elm_list_horizontal_mode_set (o, mode);
}
void ElmList::setAlwaysSelectMode (bool alwaysSelect)
{
elm_list_always_select_mode_set (o, alwaysSelect);
}
const Eina_List *ElmList::getItems ()
{
return elm_list_items_get (o);
}
Elm_List_Item *ElmList::getSelectedItem ()
{
return elm_list_selected_item_get (o);
}
const Eina_List *ElmList::getSelectedItems ()
{
return elm_list_selected_items_get (o);
}
Elm_List_Item *ElmList::append (const std::string &label, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data)
{
return elm_list_item_append (o, label.c_str (), NULL, NULL, func, data);
}
Elm_List_Item *ElmList::append (const std::string &label, const EvasObject &icon, const EvasObject &end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data)
{
return elm_list_item_append (o, label.c_str (), icon.obj (), end.obj (), func, data);
}
} // end namespace efl

68
elementaryxx/src/ElmListItem.cpp
View File

@ -1,68 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmListItem.h"
using namespace std;
namespace efl {
ElmListItem::ElmListItem ()
{
}
ElmListItem::~ElmListItem () {}
ElmListItem *ElmListItem::factory ()
{
return new ElmListItem ();
}
void ElmListItem::setSelected (bool selected)
{
elm_list_item_selected_set (mItem, selected);
}
void ElmListItem::show ()
{
elm_list_item_show (mItem);
}
void* ElmListItem::getData ()
{
}
EvasObject *ElmListItem::getIcon ()
{
}
EvasObject *ElmListItem::getEnd ()
{
}
EvasObject *ElmListItem::getBase ()
{
}
const std::string ElmListItem::getLabel ()
{
}
ElmListItem *ElmListItem::prev ()
{
}
ElmListItem *ElmListItem::next ()
{
}
} // end namespace efl

30
elementaryxx/src/ElmNotepad.cpp
View File

@ -1,30 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmNotepad.h"
using namespace std;
namespace efl {
ElmNotepad::ElmNotepad (EvasObject &parent)
{
o = elm_notepad_add (parent.obj ());
elmInit ();
}
ElmNotepad::~ElmNotepad () {}
ElmNotepad *ElmNotepad::factory (EvasObject &parent)
{
return new ElmNotepad (parent);
}
void ElmNotepad::setFile (const std::string &file, Elm_Text_Format format)
{
elm_notepad_file_set (o, file.c_str (), format);
}
} // end namespace efl

36
elementaryxx/src/ElmPanel.cpp
View File

@ -1,36 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmPanel.h"
using namespace std;
namespace efl {
ElmPanel::ElmPanel (EvasObject &parent)
{
o = elm_panel_add (parent.obj ());
elmInit ();
}
ElmPanel::~ElmPanel () {}
ElmPanel *ElmPanel::factory (EvasObject &parent)
{
return new ElmPanel (parent);
}
void ElmPanel::setOrientation (Elm_Panel_Orient orient)
{
elm_panel_orient_set (o, orient);
}
void ElmPanel::setContent (EvasObject &content)
{
elm_panel_content_set (o, content.obj ());
}
} // end namespace efl

56
elementaryxx/src/ElmRadio.cpp
View File

@ -1,56 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmRadio.h"
using namespace std;
namespace efl {
ElmRadio::ElmRadio (EvasObject &parent)
{
o = elm_radio_add (parent.obj ());
elmInit ();
}
ElmRadio::~ElmRadio () {}
ElmRadio *ElmRadio::factory (EvasObject &parent)
{
return new ElmRadio (parent);
}
void ElmRadio::setLabel (const std::string &label)
{
elm_radio_label_set (o, label.c_str ());
}
void ElmRadio::setIcon (const EvasObject &icon)
{
elm_radio_icon_set (o, icon.obj ());
}
void ElmRadio::addGroup (const EvasObject &group)
{
elm_radio_group_add (o, group.obj ());
}
void ElmRadio::setStateValue (int value)
{
elm_radio_state_value_set (o, value);
}
void ElmRadio::setValue (int value)
{
elm_radio_value_set (o, value);
}
int ElmRadio::getValue () const
{
return elm_radio_value_get (o);
}
} // end namespace efl

66
elementaryxx/src/ElmScroller.cpp
View File

@ -1,66 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmScroller.h"
using namespace std;
namespace efl {
ElmScroller::ElmScroller (EvasObject &parent)
{
o = elm_scroller_add (parent.obj ());
elmInit ();
}
ElmScroller::~ElmScroller () {}
ElmScroller *ElmScroller::factory (EvasObject &parent)
{
return new ElmScroller (parent);
}
void ElmScroller::setContent (EvasObject &child)
{
elm_scroller_content_set (o, child.obj ());
}
void ElmScroller::limitMinContent (bool width, bool height)
{
elm_scroller_content_min_limit (o, width, height);
}
void ElmScroller::showRegion (const Rect &rect)
{
elm_scroller_region_show (o, rect.x (), rect.y (), rect.width (), rect.height ());
}
void ElmScroller::setPolicy (Elm_Scroller_Policy policyH, Elm_Scroller_Policy policyV)
{
elm_scroller_policy_set (o, policyH, policyV);
}
const Rect ElmScroller::getRegion () const
{
Evas_Coord x, y, w, h;
elm_scroller_region_get (o, &x, &y, &w, &h);
return Rect (x, y, w, h);
}
const Size ElmScroller::getChildSize () const
{
Evas_Coord w, h;
elm_scroller_child_size_get (o, &w, &h);
return Size (w, h);
}
void ElmScroller::setBounce (bool hBounce, bool vBounce)
{
elm_scroller_bounce_set (o, hBounce, vBounce);
}
} // end namespace efl

61
elementaryxx/src/ElmSpinner.cpp
View File

@ -1,61 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmSpinner.h"
using namespace std;
namespace efl {
ElmSpinner::ElmSpinner (EvasObject &parent)
{
o = elm_spinner_add (parent.obj ());
elmInit ();
}
ElmSpinner::~ElmSpinner () {}
ElmSpinner *ElmSpinner::factory (EvasObject &parent)
{
return new ElmSpinner (parent);
}
void ElmSpinner::setLabelFormat (const std::string &format)
{
elm_spinner_label_format_set (o, format.c_str ());
}
const string ElmSpinner::getLabelFormat ()
{
return elm_spinner_label_format_get (o);
}
void ElmSpinner::setMinMax (double min, double max)
{
elm_spinner_min_max_set (o, min, max);
}
void ElmSpinner::setStep (double step)
{
elm_spinner_step_set (o, step);
}
void ElmSpinner::setValue (double val)
{
elm_spinner_value_set (o, val);
}
double ElmSpinner::getValue ()
{
return elm_spinner_value_get (o);
}
void ElmSpinner::setWrap (bool wrap)
{
elm_spinner_wrap_set (o, wrap);
}
} // end namespace efl

35
elementaryxx/src/ElmTable.cpp
View File

@ -1,35 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmTable.h"
using namespace std;
namespace efl {
ElmTable::ElmTable (EvasObject &parent)
{
o = elm_table_add (parent.obj ());
elmInit ();
}
ElmTable::~ElmTable () {}
ElmTable *ElmTable::factory (EvasObject &parent)
{
return new ElmTable (parent);
}
void ElmTable::setHomogenous (bool homogenous)
{
elm_table_homogenous_set (o, homogenous);
}
void ElmTable::pack (const EvasObject &subobj, const Rect &rect)
{
elm_table_pack (o, subobj.obj (), rect.x (), rect.y (), rect.width (), rect.height ());
}
} // end namespace efl

55
elementaryxx/src/ElmToggle.cpp
View File

@ -1,55 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmToggle.h"
using namespace std;
namespace efl {
ElmToggle::ElmToggle (EvasObject &parent)
{
o = elm_toggle_add (parent.obj ());
elmInit ();
}
ElmToggle::~ElmToggle () {}
ElmToggle *ElmToggle::factory (EvasObject &parent)
{
return new ElmToggle (parent);
}
void ElmToggle::setLabel (const std::string &label)
{
elm_toggle_label_set (o, label.c_str ());
}
void ElmToggle::setIcon (EvasObject &icon)
{
elm_toggle_icon_set (o, icon.obj ());
}
void ElmToggle::setLabelsStates (const std::string &onLabel, const std::string &offLabel)
{
elm_toggle_states_labels_set (o, onLabel.c_str (), offLabel.c_str ());
}
void ElmToggle::setState (bool state)
{
elm_toggle_state_set (o, state);
}
bool ElmToggle::getState () const
{
return elm_toggle_state_get (o);
}
/*void ElmToggle::setPointerState (bool statep)
{
elm_toggle_state_pointer_set (Evas_Object *obj, Evas_Bool *statep)
}*/
} // end namespace efl

122
elementaryxx/src/ElmWindow.cpp
View File

@ -1,122 +0,0 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ElmWindow.h"
using namespace std;
namespace efl {
ElmWindow* ElmWindow::factory (const std::string &name, Elm_Win_Type type)
{
return new ElmWindow (name, type);
}
ElmWindow* ElmWindow::factory (EvasObject &parent, const std::string &name, Elm_Win_Type type)
{
return new ElmWindow (parent, name, type);
}
ElmWindow::ElmWindow (const std::string &name, Elm_Win_Type type)
{
o = elm_win_add (NULL, name.c_str (), type);
elmInit ();
}
ElmWindow::ElmWindow (EvasObject &parent, const std::string &name, Elm_Win_Type type)
{
o = elm_win_add (parent.obj (), name.c_str (), type);
elmInit ();
}
ElmWindow::~ElmWindow () {}
void ElmWindow::setTitle (const std::string &title)
{
elm_win_title_set(o, title.c_str ());
}
void ElmWindow::setAutoDel (bool autodel)
{
elm_win_autodel_set(o, autodel);
}
void ElmWindow::activate ()
{
elm_win_activate(o);
}
void ElmWindow::lower ()
{
elm_win_lower(o);
}
void ElmWindow::raise ()
{
elm_win_raise(o);
}
void ElmWindow::setBorderless (bool borderless)
{
elm_win_borderless_set (o, borderless);
}
void ElmWindow::setShaped (bool shaped)
{
elm_win_shaped_set (o, shaped);
}
void ElmWindow::setAlpha (bool alpha)
{
elm_win_alpha_set (o, alpha);
}
void ElmWindow::setOverride (bool override)
{
elm_win_override_set (o, override);
}
void ElmWindow::setFullscreen (bool fullscreen)
{
elm_win_fullscreen_set (o, fullscreen);
}
void ElmWindow::setMaximized (bool maximized)
{
elm_win_maximized_set (o, maximized);
}
void ElmWindow::setIconified (bool iconified)
{
elm_win_iconified_set(o, iconified);
}
void ElmWindow::setLayer (int layer)
{
elm_win_layer_set(o, layer);
}
void ElmWindow::setRotation (int rotation)
{
elm_win_rotation_set(o, rotation);
}
void ElmWindow::setSticky (bool sticky)
{
elm_win_sticky_set(o, sticky);
}
void ElmWindow::addObjectResize (const EvasObject &subobj)
{
elm_win_resize_object_add (o, subobj.obj ());
}
void ElmWindow::delObjectResize (const EvasObject &subobj)
{
elm_win_resize_object_del (o, subobj.obj ());
}
} // end namespace efl

38
elementaryxx/src/ElmEntry.cpp → elementaryxx/src/Entry.cpp
View File

@ -2,88 +2,88 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmEntry.h"
#include "../include/elementaryxx/Entry.h"
using namespace std;
namespace efl {
namespace Elmxx {
ElmEntry::ElmEntry (EvasObject &parent)
Entry::Entry (Evasxx::Object &parent)
{
o = elm_entry_add (parent.obj ());
elmInit ();
}
ElmEntry::~ElmEntry () {}
Entry::~Entry () {}
ElmEntry *ElmEntry::factory (EvasObject &parent)
Entry *Entry::factory (Evasxx::Object &parent)
{
return new ElmEntry (parent);
return new Entry (parent);
}
void ElmEntry::setSingleLine (bool singleLine)
void Entry::setSingleLine (bool singleLine)
{
elm_entry_single_line_set (o, singleLine);
}
void ElmEntry::setPassword (bool password)
void Entry::setPassword (bool password)
{
elm_entry_password_set (o, password);
}
void ElmEntry::setText (const std::string &entry)
void Entry::setText (const std::string &entry)
{
elm_entry_entry_set (o, entry.c_str ());
}
const std::string ElmEntry::getText () const
const std::string Entry::getText () const
{
const char *tmp = elm_entry_entry_get (o);
return tmp ? tmp : string ();
}
const std::string ElmEntry::getSelection () const
const std::string Entry::getSelection () const
{
const char *tmp = elm_entry_selection_get (o);
return tmp ? tmp : string ();
}
void ElmEntry::insertText (const std::string &entry)
void Entry::insertText (const std::string &entry)
{
elm_entry_entry_insert (o, entry.c_str ());
}
void ElmEntry::setLineWrap (bool wrap)
void Entry::setLineWrap (bool wrap)
{
elm_entry_line_wrap_set (o, wrap);
}
void ElmEntry::setEditable (bool editable)
void Entry::setEditable (bool editable)
{
elm_entry_editable_set (o, editable);
}
void ElmEntry::selectNone ()
void Entry::selectNone ()
{
elm_entry_select_none (o);
}
void ElmEntry::selectAll ()
void Entry::selectAll ()
{
elm_entry_select_all (o);
}
const std::string ElmEntry::markupToUtf8 (const std::string &str)
const std::string Entry::markupToUtf8 (const std::string &str)
{
const char *tmp = elm_entry_markup_to_utf8 (str.c_str ());
return tmp ? tmp : string ();
}
const std::string ElmEntry::utf8ToMarkup (const std::string &str)
const std::string Entry::utf8ToMarkup (const std::string &str)
{
const char *tmp = elm_entry_utf8_to_markup (str.c_str ());
return tmp ? tmp : string ();
}
} // end namespace efl
} // end namespace Elmxx

35
elementaryxx/src/Frame.cpp Normal file
View File

@ -0,0 +1,35 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Frame.h"
using namespace std;
namespace Elmxx {
Frame::Frame (Evasxx::Object &parent)
{
o = elm_frame_add (parent.obj ());
elmInit ();
}
Frame::~Frame () {}
Frame *Frame::factory (Evasxx::Object &parent)
{
return new Frame (parent);
}
void Frame::setLabel (const std::string &label)
{
elm_frame_label_set (o, label.c_str ());
}
void Frame::setContent (const Evasxx::Object &content)
{
elm_frame_content_set (o, content.obj ());
}
} // end namespace Elmxx

45
elementaryxx/src/Hover.cpp Normal file
View File

@ -0,0 +1,45 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Hover.h"
using namespace std;
namespace Elmxx {
Hover::Hover (Evasxx::Object &parent)
{
o = elm_hover_add (parent.obj ());
elmInit ();
}
Hover::~Hover () {}
Hover *Hover::factory (Evasxx::Object &parent)
{
return new Hover (parent);
}
void Hover::setTarget (const Evasxx::Object &target)
{
elm_hover_target_set (o, target.obj ());
}
void Hover::setParent (const Evasxx::Object &parent)
{
elm_hover_parent_set (o, parent.obj ());
}
void Hover::setContent (const std::string &swallow, const Evasxx::Object &content)
{
elm_hover_content_set (o, swallow.c_str (), content.obj ());
}
const string Hover::getBestContentLocation (Elm_Hover_Axis prefAxis) const
{
return elm_hover_best_content_location_get (o, prefAxis);
}
} // end namespace Elmxx

59
elementaryxx/src/Icon.cpp Normal file
View File

@ -0,0 +1,59 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Icon.h"
using namespace std;
namespace Elmxx {
Icon::Icon (Evasxx::Object &parent)
{
o = elm_icon_add (parent.obj ());
elmInit ();
}
Icon::~Icon () {}
Icon *Icon::factory (Evasxx::Object &parent)
{
return new Icon (parent);
}
bool Icon::setFile (const std::string &file)
{
return elm_icon_file_set (o, file.c_str (), NULL);
}
bool Icon::setFile (const std::string &file, const std::string &group)
{
return elm_icon_file_set (o, file.c_str (), group.c_str ());
}
void Icon::setStandard (const std::string &name)
{
elm_icon_standard_set (o, name.c_str ());
}
void Icon::setSmooth (bool smooth)
{
elm_icon_smooth_set (o, smooth);
}
void Icon::setNoScale (bool noScale)
{
elm_icon_no_scale_set (o, noScale);
}
void Icon::setScale (bool scaleUp, bool scaleDown)
{
elm_icon_scale_set (o, scaleUp, scaleDown);
}
void Icon::setFillOutside (bool fillOutside)
{
elm_icon_fill_outside_set (o, fillOutside);
}
void Icon::setPrescale (int size)
{
elm_icon_prescale_set (o, size);
}
} // end namespace Elmxx

60
elementaryxx/src/Image.cpp Normal file
View File

@ -0,0 +1,60 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Image.h"
using namespace std;
namespace Elmxx {
Image::Image (Evasxx::Object &parent)
{
o = elm_image_add (parent.obj ());
elmInit ();
}
Image::~Image () {}
Image *Image::factory (Evasxx::Object &parent)
{
return new Image (parent);
}
bool Image::setFile (const std::string &file, const std::string &group)
{
return elm_image_file_set (o, file.c_str (), group.c_str ());
}
void Image::setSmooth (bool smooth)
{
elm_image_smooth_set (o, smooth);
}
void Image::setNoScale (bool noScale)
{
elm_image_no_scale_set (o, noScale);
}
void Image::setScale (bool scaleUp, bool scaleDown)
{
elm_image_scale_set (o, scaleUp, scaleDown);
}
void Image::setFillOutside (bool fillOutside)
{
elm_image_fill_outside_set (o, fillOutside);
}
void Image::setPrescale (int size)
{
elm_image_prescale_set (o, size);
}
void Image::setOrient (Elm_Image_Orient orient)
{
elm_image_orient_set (o, orient);
}
} // end namespace Elmxx

30
elementaryxx/src/Label.cpp Normal file
View File

@ -0,0 +1,30 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Label.h"
using namespace std;
namespace Elmxx {
Label::Label (Evasxx::Object &parent)
{
o = elm_label_add (parent.obj ());
elmInit ();
}
Label::~Label () {}
Label *Label::factory (Evasxx::Object &parent)
{
return new Label (parent);
}
void Label::setLabel (const std::string &label)
{
elm_label_label_set (o, label.c_str ());
}
} // end namespace Elmxx

40
elementaryxx/src/Layout.cpp Normal file
View File

@ -0,0 +1,40 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Layout.h"
using namespace std;
namespace Elmxx {
Layout::Layout (Evasxx::Object &parent)
{
o = elm_layout_add (parent.obj ());
elmInit ();
}
Layout::~Layout () {}
Layout *Layout::factory (Evasxx::Object &parent)
{
return new Layout (parent);
}
bool Layout::setFile (const std::string &file)
{
return elm_layout_file_set (o, file.c_str (), NULL);
}
bool Layout::setFile (const std::string &file, const std::string &group)
{
return elm_layout_file_set (o, file.c_str (), group.c_str ());
}
void Layout::setContent (const std::string &swallow, const Evasxx::Object &content)
{
elm_layout_content_set (o, swallow.c_str (), content.obj ());
}
} // end namespace Elmxx

75
elementaryxx/src/List.cpp Normal file
View File

@ -0,0 +1,75 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/List.h"
using namespace std;
namespace Elmxx {
List::List (Evasxx::Object &parent)
{
o = elm_list_add (parent.obj ());
elmInit ();
}
List::~List () {}
List *List::factory (Evasxx::Object &parent)
{
return new List (parent);
}
void List::clear ()
{
elm_list_clear (o);
}
void List::go ()
{
elm_list_go (o);
}
void List::setMultiSelect (bool multi)
{
elm_list_multi_select_set (o, multi);
}
void List::setHorizontalMode (Elm_List_Mode mode)
{
elm_list_horizontal_mode_set (o, mode);
}
void List::setAlwaysSelectMode (bool alwaysSelect)
{
elm_list_always_select_mode_set (o, alwaysSelect);
}
const Eina_List *List::getItems ()
{
return elm_list_items_get (o);
}
Elm_List_Item *List::getSelectedItem ()
{
return elm_list_selected_item_get (o);
}
const Eina_List *List::getSelectedItems ()
{
return elm_list_selected_items_get (o);
}
Elm_List_Item *List::append (const std::string &label, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data)
{
return elm_list_item_append (o, label.c_str (), NULL, NULL, func, data);
}
Elm_List_Item *List::append (const std::string &label, const Evasxx::Object &icon, const Evasxx::Object &end, void (*func) (void *data, Evas_Object *obj, void *event_info), const void *data)
{
return elm_list_item_append (o, label.c_str (), icon.obj (), end.obj (), func, data);
}
} // end namespace Elmxx

68
elementaryxx/src/ListItem.cpp Normal file
View File

@ -0,0 +1,68 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/ListItem.h"
using namespace std;
namespace Elmxx {
ListItem::ListItem ()
{
}
ListItem::~ListItem () {}
ListItem *ListItem::factory ()
{
return new ListItem ();
}
void ListItem::setSelected (bool selected)
{
elm_list_item_selected_set (mItem, selected);
}
void ListItem::show ()
{
elm_list_item_show (mItem);
}
void* ListItem::getData ()
{
}
Evasxx::Object *ListItem::getIcon ()
{
}
Evasxx::Object *ListItem::getEnd ()
{
}
Evasxx::Object *ListItem::getBase ()
{
}
const std::string ListItem::getLabel ()
{
}
ListItem *ListItem::prev ()
{
}
ListItem *ListItem::next ()
{
}
} // end namespace Elmxx

60
elementaryxx/src/Makefile.am
View File

@ -17,34 +17,34 @@ lib_LTLIBRARIES = \
libelementaryxx.la
libelementaryxx_la_SOURCES = \
ElmApplication.cpp \
ElmWindow.cpp \
ElmButton.cpp \
ElmClock.cpp \
ElmScroller.cpp \
ElmToggle.cpp \
ElmEntry.cpp \
ElmCheck.cpp \
ElmIcon.cpp \
ElmImage.cpp \
ElmRadio.cpp \
ElmSlider.cpp \
ElmBubble.cpp \
ElmLabel.cpp \
ElmBackground.cpp \
ElmBox.cpp \
ElmFrame.cpp \
ElmList.cpp \
ElmListItem.cpp \
ElmTable.cpp \
ElmObject.cpp \
ElmLayout.cpp \
ElmHover.cpp \
ElmNotepad.cpp \
ElmAnchorblock.cpp \
ElmAnchorview.cpp \
ElmSpinner.cpp \
ElmProgressbar.cpp \
ElmPanel.cpp \
ElmSeparator.cpp
Application.cpp \
Window.cpp \
Button.cpp \
Clock.cpp \
Scroller.cpp \
Toggle.cpp \
Entry.cpp \
Check.cpp \
Icon.cpp \
Image.cpp \
Radio.cpp \
Slider.cpp \
Bubble.cpp \
Label.cpp \
Background.cpp \
Box.cpp \
Frame.cpp \
List.cpp \
ListItem.cpp \
Table.cpp \
Object.cpp \
Layout.cpp \
Hover.cpp \
Notepad.cpp \
Anchorblock.cpp \
Anchorview.cpp \
Spinner.cpp \
Progressbar.cpp \
Panel.cpp \
Separator.cpp

30
elementaryxx/src/Notepad.cpp Normal file
View File

@ -0,0 +1,30 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Notepad.h"
using namespace std;
namespace Elmxx {
Notepad::Notepad (Evasxx::Object &parent)
{
o = elm_notepad_add (parent.obj ());
elmInit ();
}
Notepad::~Notepad () {}
Notepad *Notepad::factory (Evasxx::Object &parent)
{
return new Notepad (parent);
}
void Notepad::setFile (const std::string &file, Elm_Text_Format format)
{
elm_notepad_file_set (o, file.c_str (), format);
}
} // end namespace Elmxx

34
elementaryxx/src/ElmObject.cpp → elementaryxx/src/Object.cpp
View File

@ -2,30 +2,30 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmObject.h"
#include "../include/elementaryxx/Object.h"
/* STD */
#include <cassert>
using namespace std;
namespace efl {
namespace Elmxx {
ElmObject::ElmObject () {}
Object::Object () {}
ElmObject::~ElmObject () {}
Object::~Object () {}
void ElmObject::elmInit ()
void Object::elmInit ()
{
// check if there was a problem with object creation
assert (o);
init (); // call init() from EvasObject
init (); // call init() from Evasxx::Object
signalHandleFree.connect (sigc::mem_fun (this, &ElmObject::freeSignalHandler));
signalHandleFree.connect (sigc::mem_fun (this, &Object::freeSignalHandler));
}
void ElmObject::destroy ()
void Object::destroy ()
{
evas_object_del (o);
@ -34,7 +34,7 @@ void ElmObject::destroy ()
delete (this);
}
void ElmObject::freeSignalHandler ()
void Object::freeSignalHandler ()
{
//cout << "freeSignalHandler()" << endl;
delete (this);
@ -43,40 +43,40 @@ void ElmObject::freeSignalHandler ()
// the simple rule is that no member functions or member variables are allowed to access
}
void ElmObject::setScale (double scale)
void Object::setScale (double scale)
{
elm_object_scale_set (o, scale);
}
double ElmObject::getScale ()
double Object::getScale ()
{
return elm_object_scale_get (o);
}
void ElmObject::setStyle (const std::string &style)
void Object::setStyle (const std::string &style)
{
elm_object_style_set (o, style.c_str ());
}
const std::string ElmObject::getStyle ()
const std::string Object::getStyle ()
{
const char *tmp = elm_object_style_get (o);
return tmp ? tmp : string ();
}
void ElmObject::setDisabled (bool disabled)
void Object::setDisabled (bool disabled)
{
elm_object_disabled_set (o, disabled);
}
bool ElmObject::getDisabled ()
bool Object::getDisabled ()
{
return elm_object_disabled_get (o);
}
void ElmObject::focus ()
void Object::focus ()
{
elm_object_focus (o);
}
} // end namespace efl
} // end namespace Elmxx

36
elementaryxx/src/Panel.cpp Normal file
View File

@ -0,0 +1,36 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Panel.h"
using namespace std;
namespace Elmxx {
Panel::Panel (Evasxx::Object &parent)
{
o = elm_panel_add (parent.obj ());
elmInit ();
}
Panel::~Panel () {}
Panel *Panel::factory (Evasxx::Object &parent)
{
return new Panel (parent);
}
void Panel::setOrientation (Elm_Panel_Orient orient)
{
elm_panel_orient_set (o, orient);
}
void Panel::setContent (Evasxx::Object &content)
{
elm_panel_content_set (o, content.obj ());
}
} // end namespace Elmxx

36
elementaryxx/src/ElmProgressbar.cpp → elementaryxx/src/Progressbar.cpp
View File

@ -2,42 +2,42 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmProgressbar.h"
#include "../include/elementaryxx/Progressbar.h"
using namespace std;
namespace efl {
namespace Elmxx {
ElmProgressbar::ElmProgressbar (EvasObject &parent)
Progressbar::Progressbar (Evasxx::Object &parent)
{
o = elm_progressbar_add (parent.obj ());
elmInit ();
}
ElmProgressbar::~ElmProgressbar () {}
Progressbar::~Progressbar () {}
ElmProgressbar *ElmProgressbar::factory (EvasObject &parent)
Progressbar *Progressbar::factory (Evasxx::Object &parent)
{
return new ElmProgressbar (parent);
return new Progressbar (parent);
}
void ElmProgressbar::setLabel (const std::string &label)
void Progressbar::setLabel (const std::string &label)
{
elm_progressbar_label_set (o, label.c_str ());
}
void ElmProgressbar::setIcon (EvasObject &icon)
void Progressbar::setIcon (Evasxx::Object &icon)
{
elm_progressbar_icon_set (o, icon.obj ());
}
void ElmProgressbar::setSpanSize (Evas_Coord size)
void Progressbar::setSpanSize (Evas_Coord size)
{
elm_progressbar_span_size_set (o, size);
}
void ElmProgressbar::setOrientation (ElmProgressbar::Orientation orient)
void Progressbar::setOrientation (Progressbar::Orientation orient)
{
switch (orient)
{
@ -50,39 +50,39 @@ void ElmProgressbar::setOrientation (ElmProgressbar::Orientation orient)
}
}
void ElmProgressbar::setInverted (bool inverted)
void Progressbar::setInverted (bool inverted)
{
elm_progressbar_inverted_set (o, inverted);
}
void ElmProgressbar::setPulse (bool pulse)
void Progressbar::setPulse (bool pulse)
{
elm_progressbar_pulse_set (o, pulse);
}
void ElmProgressbar::pulse (bool state)
void Progressbar::pulse (bool state)
{
elm_progressbar_pulse (o, state);
}
void ElmProgressbar::setUnitFormat (const std::string &format)
void Progressbar::setUnitFormat (const std::string &format)
{
elm_progressbar_unit_format_set (o, format.c_str ());
}
void ElmProgressbar::hideUnitFormat ()
void Progressbar::hideUnitFormat ()
{
elm_progressbar_unit_format_set (o, NULL);
}
void ElmProgressbar::setValue (double val)
void Progressbar::setValue (double val)
{
elm_progressbar_value_set (o, val);
}
double ElmProgressbar::getValue ()
double Progressbar::getValue ()
{
return elm_progressbar_value_get (o);
}
} // end namespace efl
} // end namespace Elmxx

56
elementaryxx/src/Radio.cpp Normal file
View File

@ -0,0 +1,56 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Radio.h"
using namespace std;
namespace Elmxx {
Radio::Radio (Evasxx::Object &parent)
{
o = elm_radio_add (parent.obj ());
elmInit ();
}
Radio::~Radio () {}
Radio *Radio::factory (Evasxx::Object &parent)
{
return new Radio (parent);
}
void Radio::setLabel (const std::string &label)
{
elm_radio_label_set (o, label.c_str ());
}
void Radio::setIcon (const Evasxx::Object &icon)
{
elm_radio_icon_set (o, icon.obj ());
}
void Radio::addGroup (const Evasxx::Object &group)
{
elm_radio_group_add (o, group.obj ());
}
void Radio::setStateValue (int value)
{
elm_radio_state_value_set (o, value);
}
void Radio::setValue (int value)
{
elm_radio_value_set (o, value);
}
int Radio::getValue () const
{
return elm_radio_value_get (o);
}
} // end namespace Elmxx

66
elementaryxx/src/Scroller.cpp Normal file
View File

@ -0,0 +1,66 @@
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "../include/elementaryxx/Scroller.h"
using namespace std;
namespace Elmxx {
Scroller::Scroller (Evasxx::Object &parent)
{
o = elm_scroller_add (parent.obj ());
elmInit ();
}
Scroller::~Scroller () {}
Scroller *Scroller::factory (Evasxx::Object &parent)
{
return new Scroller (parent);
}
void Scroller::setContent (Evasxx::Object &child)
{
elm_scroller_content_set (o, child.obj ());
}
void Scroller::limitMinContent (bool width, bool height)
{
elm_scroller_content_min_limit (o, width, height);
}
void Scroller::showRegion (const Eflxx::Rect &rect)
{
elm_scroller_region_show (o, rect.x (), rect.y (), rect.width (), rect.height ());
}
void Scroller::setPolicy (Elm_Scroller_Policy policyH, Elm_Scroller_Policy policyV)
{
elm_scroller_policy_set (o, policyH, policyV);
}
const Eflxx::Rect Scroller::getRegion () const
{
Evas_Coord x, y, w, h;
elm_scroller_region_get (o, &x, &y, &w, &h);
return Eflxx::Rect (x, y, w, h);
}
const Eflxx::Size Scroller::getChildSize () const
{
Evas_Coord w, h;
elm_scroller_child_size_get (o, &w, &h);
return Eflxx::Size (w, h);
}
void Scroller::setBounce (bool hBounce, bool vBounce)
{
elm_scroller_bounce_set (o, hBounce, vBounce);
}
} // end namespace Elmxx

18
elementaryxx/src/ElmSeparator.cpp → elementaryxx/src/Separator.cpp
View File

@ -2,27 +2,27 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmSeparator.h"
#include "../include/elementaryxx/Separator.h"
using namespace std;
namespace efl {
namespace Elmxx {
ElmSeparator::ElmSeparator (EvasObject &parent)
Separator::Separator (Evasxx::Object &parent)
{
o = elm_separator_add (parent.obj ());
elmInit ();
}
ElmSeparator::~ElmSeparator () {}
Separator::~Separator () {}
ElmSeparator *ElmSeparator::factory (EvasObject &parent)
Separator *Separator::factory (Evasxx::Object &parent)
{
return new ElmSeparator (parent);
return new Separator (parent);
}
void ElmSeparator::setOrientation (ElmSeparator::Orientation orient)
void Separator::setOrientation (Separator::Orientation orient)
{
switch (orient)
{
@ -35,7 +35,7 @@ void ElmSeparator::setOrientation (ElmSeparator::Orientation orient)
}
}
ElmSeparator::Orientation ElmSeparator::getOrientation ()
Separator::Orientation Separator::getOrientation ()
{
bool horizontal = elm_separator_horizontal_get (o);
@ -50,4 +50,4 @@ ElmSeparator::Orientation ElmSeparator::getOrientation ()
}
}
} // end namespace efl
} // end namespace Elmxx

34
elementaryxx/src/ElmSlider.cpp → elementaryxx/src/Slider.cpp
View File

@ -2,52 +2,52 @@
#include <config.h>
#endif
#include "../include/elementaryxx/ElmSlider.h"
#include "../include/elementaryxx/Slider.h"
using namespace std;
namespace efl {
namespace Elmxx {
ElmSlider::ElmSlider (EvasObject &parent)
Slider::Slider (Evasxx::Object &parent)
{
o = elm_slider_add (parent.obj ());
elmInit ();
}
ElmSlider::~ElmSlider () {}
Slider::~Slider () {}
ElmSlider *ElmSlider::factory (EvasObject &parent)
Slider *Slider::factory (Evasxx::Object &parent)
{
return new ElmSlider (parent);
return new Slider (parent);
}
void ElmSlider::setLabel (const std::string &label)
void Slider::setLabel (const std::string &label)
{
elm_slider_label_set (o, label.c_str ());
}
void ElmSlider::setIcon (const EvasObject &icon)
void Slider::setIcon (const Evasxx::Object &icon)
{
elm_slider_icon_set (o, icon.obj ());
}
void ElmSlider::setSpanSize (Evas_Coord size)
void Slider::setSpanSize (Evas_Coord size)
{
elm_slider_span_size_set (o, size);
}
void ElmSlider::setUnitFormat (const std::string &format)
void Slider::setUnitFormat (const std::string &format)
{
elm_slider_unit_format_set (o, format.c_str ());
}
void ElmSlider::setIndicatorFormat (const std::string &indicator)
void Slider::setIndicatorFormat (const std::string &indicator)
{
elm_slider_indicator_format_set (o, indicator.c_str ());
}
void ElmSlider::setOrientation (ElmSlider::Orientation orient)
void Slider::setOrientation (Slider::Orientation orient)
{
switch (orient)
{
@ -60,24 +60,24 @@ void ElmSlider::setOrientation (ElmSlider::Orientation orient)
}
}
void ElmSlider::setMinMax (double min, double max)
void Slider::setMinMax (double min, double max)
{
elm_slider_min_max_set (o, min, max);
}
void ElmSlider::setValue (double val)
void Slider::setValue (double val)
{
elm_slider_value_set (o, val);
}
double ElmSlider::getValue () const
double Slider::getValue () const
{
return elm_slider_value_get (o);
}
void ElmSlider::setInverted (bool inverted)
void Slider::setInverted (bool inverted)
{
elm_slider_inverted_set (o, inverted);
}
} // end namespace efl
} // end namespace Elmxx

Some files were not shown because too many files have changed in this diff Show More