namespace efl_viewmgr
{
+
+/**
+ * @class ui_controller
+ *
+ * @ingroup viewmgr
+ *
+ * @brief UI Controller. This is a class for handling of life-cycle events from user side.
+ */
class ui_controller: public viewmgr::ui_controller_interface
{
public:
+ ///Destructor.
virtual ~ui_controller();
+ /**
+ * @brief Return a view which is matched with controller
+ *
+ * @return The view which is matched with controller
+ *
+ * @note User can set a controller 2 ways, 1. send a controller instance when view created,
+ * 2. call set_view() method with controller instance.
+ *
+ * @see set_view()
+ */
+
ui_view *get_view();
+
+ /** @brief load callback.
+ *
+ * @note Now, this view is moving onto the screen. Get ready for this view. If this view content is alive, load callback won't be called.
+ * In the most cases, this callback will be triggered with this step load -> inactive -> active.
+ */
virtual void load() {}
+
+ /** @brief unload callback.
+ *
+ * @note Remove resources with regards to this view for saving memory or keep the content for performance. It's up to your scenario.
+ * Unload will be called just right before when the view is going to be deleted by popping or it's piled under the more than one view.
+ * If the view content is not alive, the unload won't be called.
+ * In the most cases, this callback will be triggered with this step. inactive -> unload -> destroy
+ */
virtual void unload() {}
+
+ /** @brief active callback.
+ *
+ * @note View is on active state after show transition is finished.
+ * From whatever the state, if the view is on the screen, the active callback will be called.
+ * In the most cases, this callback will be triggered with this step. load -> inactive -> active
+ */
virtual void active() {}
+
+ /** @brief inactive callback.
+ *
+ * @note View is on inactive state. Get ready for unload. Hide transition may be triggered at this point.
+ * Inactive state is triggered on this scenario that the view is still visible but it's not interactive with users.
+ * In the most cases, when view is going to be popped or destroyed or pushed one more depth, the inactive state will be triggered.
+ * Some UI controls such as a center popup or a menu popup blocks the view, this view may be inactive but still visible in someway (with transparency)
+ */
virtual void inactive() {}
+
+ /** @brief pause callback.
+ *
+ * @note When the system blocks the application running in cases such as phone call, system notification, switching applications ...
+ * When Window turns to deactivate. (@see ui_viewmgr_base :: deactivate()).
+ * If the view were inactive or unload state, the pause won't be called.
+ */
virtual void pause() {}
+
+ /** @brief resume callback.
+ *
+ * @note View is turning back to the active state again from pause.
+ * When the system allows the application turns to activate.
+ * When the Window turns to activate. (@see ui_viewmgr_base :: activate())
+ */
virtual void resume() {}
+
+ /** @brief destroy callback.
+ *
+ * @note When this view is on destroying by popping or deleting.
+ */
virtual void destroy() {}
virtual bool back() { return true; }
{
class ui_controller;
+/**
+ * @class ui_view
+ *
+ * @ingroup viewmgr
+ *
+ * @brief UI View Class. This is the class of view. A view must have one content instance which represents a view for a current screen.
+ * UI View may have it's own show/hide transition styles. That means, it's available that views have different show/hide effects on demands.
+ * It's not mandatory but view should describe the transitions in this class.
+ *
+ * @warning When the transitions are finished, the view must to call ui_viewmgr_interface :: _push_finished(), ui_viewmgr_interface :: _pop_finished() in order that
+ * The ui_viewmgr_interface keeps the view states exactly.
+ */
class ui_view: public viewmgr::ui_view_interface
{
friend class ui_viewmgr;
public:
+ ///Constructor.
ui_view(ui_controller *controller, const char *name = NULL, const char *style = NULL);
+
+ ///Destructor.
virtual ~ui_view();
+ /** @brief This is for replacing or setting a content of the view.
+ *
+ * @param content a new content. It allows @c NULL for canceling the previous content.
+ *
+ * @return A previous content. If it wasn't, return value will be @c NULL.
+ */
virtual Evas_Object *set_content(Evas_Object *content);
+
+ /** @brief Get a base layout of viewmgr.
+ */
virtual Evas_Object *get_base();
virtual void back();
+ /** @brief Set the indicator mode.
+ *
+ * @param indicator The mode to set, one of #ui_view_indicator.
+ */
void set_indicator(ui_view_indicator indicator);
protected:
+ /** @brief Unload current view's content
+ *
+ * @note Make this view's content as NULL, then destroy content.
+ */
virtual void unload_content();
+
+ /** @brief Get a parent object of view.
+ *
+ * @note This is calling viewmgr get_base() method internally.
+ *
+ * @return base layout of viewmgr.
+ */
Evas_Object *get_parent();
};
class ui_view;
+/**
+ * @class ui_viewmgr
+ *
+ * @ingroup viewmgr
+ *
+ * @brief This is a class of viewmgr. One viewmgr represents a window which contains multiple views.
+ * A viewmgr manages not only views life-cycle but constructs basic infrastructures such as key events handling, transition effects, transient views.
+ * This interface guide you a basic policy of a view manager.
+ *
+ * @warning viewmgr will remove all containing views when it's destroyed.
+ */
class ui_viewmgr: public viewmgr::ui_viewmgr_interface
{
friend class ui_view;
private:
- Evas_Object *win;
- Evas_Object *conform;
- Evas_Object *layout;
+ Evas_Object *win; //This is acting like a base object of viewmgr.
+ Evas_Object *conform; //Conformant for viewmgr.
+ Evas_Object *layout; //Viewmgr's base layout.
ui_key_listener *key_listener; //HW Key Handler such as "BACK" key...
- ui_view_indicator indicator;
+ ui_view_indicator indicator; //Mode of indicator.
+ /**
+ * @brief Create a conformant.
+ *
+ * @param win viewmgr's window object. this will be parent of conformant object.
+ *
+ * @return @c true success or @c false not.
+ */
bool create_conformant(Evas_Object *win);
+
+ /**
+ * @brief Create a base layout.
+ *
+ * @param conform viewmgr's conformant object. this will be parent of layout object.
+ *
+ * @return @c true success or @c false not.
+ */
bool create_base_layout(Evas_Object *conform);
+
+ /** @brief Set the indicator mode.
+ *
+ * @param indicator The mode to set, one of #ui_view_indicator.
+ */
bool set_indicator(ui_view_indicator indicator);
protected:
ui_viewmgr(const char *pkg, ui_key_listener *key_listener);
+ /** @brief Get a base layout of viewmgr.
+ */
Evas_Object *get_base()
{
return this->layout;
}
public:
+ ///Constructor.
ui_viewmgr(const char *pkg);
+ ///Destructor.
virtual ~ui_viewmgr();
+ /**
+ * @brief Activate this view manager.
+ *
+ * @note viewmgr window and views will be shown once activate() is called. Usually this activate() should be called after applications set their all views
+ * on initialization time.
+ *
+ * @return @c true on success or @c false otherwise.
+ *
+ * @see deactivate()
+ */
virtual bool activate();
+
+ /**
+ * @brief Deactivate this view manager.
+ *
+ * @note viewmgr window and views will be hidden once deactivate() is called. deactivate() behavior is up ui system, but usually it hides(unmap)
+ * current window in order that application go background.
+ *
+ * @return @c true success or @c false not.
+ *
+ * @see activate()
+ */
virtual bool deactivate();
+
+ /**
+ * @brief Push a new view into this viewmgr. This function is used for when application switches a current view to a new one.
+ *
+ * @note Normally, the current view will be hidden by a new view. In default, when user calls this API, view will be switched to @p view instantly,
+ * only when viewmgr state is activated. Otherwise, the @p view will be shown later when viewmgr is activated. push_view() is designed for providing
+ * view transition effect. If you want push view instantly without any transition, you could use insert_view_before() or insert_view_after().
+ * If you want to pop the current view, the please use pop_view().
+ *
+ * @param view A view to insert in the viewmgr view list.
+ *
+ * @return @p view, @c NULL when it fails to push a @p view.
+ *
+ * @see activated()
+ * @see insert_view_before()
+ * @see insert_view_after()
+ * @see pop_view()
+ */
virtual ui_view *push_view(ui_view *view);
+
+ /**
+ * @brief Push a new view into this viewmgr. This function is used for when application switches a current view to a new one.
+ *
+ * @note Normally, the current view will be hidden by a new view. In default, when user calls this API, view will be switched to @p view instantly,
+ * only when viewmgr state is activated. Otherwise, the @p view will be shown later when viewmgr is activated. push_view() is designed for providing
+ * view transition effect. If you want push view instantly without any transition, you could use insert_view_before() or insert_view_after().
+ * If you want to pop the current view, the please use pop_view().
+ *
+ * @param view A view to insert in the viewmgr view list.
+ *
+ * @return @p view, @c NULL when it fails to push a @p view.
+ *
+ * @see activated()
+ * @see insert_view_before()
+ * @see insert_view_after()
+ * @see pop_view()
+ */
virtual bool pop_view();
+ /** @brief Get a window object of viewmgr.
+ */
Evas_Object *get_window()
{
return this->win;
}
+ /** @brief Get a conformant object of viewmgr.
+ */
Evas_Object *get_conformant()
{
return this->conform;
}
+ /** @brief Get a last view of current view stack.
+ */
ui_view *get_last_view();
};
}
class ui_view_interface;
/**
- * @class ui_controller_interface
+ * @class ui_controller_interface.
*
* @ingroup viewmgr
*
void set_view(ui_view_interface *view);
protected:
+ /**
+ * @brief Return a view which is matched with controller
+ *
+ * @return The view which is matched with controller
+ *
+ * @note User can set a controller 2 ways, 1. send a controller instance when view created,
+ * 2. call set_view() method with controller instance.
+ *
+ * @see set_view()
+ */
ui_view_interface *get_view()
{
return this->view;
}
public:
+ ///Constructor.
ui_controller_interface() :
view(NULL)
{
}
+
+ ///Destructor.
virtual ~ui_controller_interface()
{
}
- /** @brief load callback
+ /** @brief load callback.
*
* @note Now, this view is moving onto the screen. Get ready for this view. If this view content is alive, load callback won't be called.
* In the most cases, this callback will be triggered with this step load -> inactive -> active.
*/
virtual void load() = 0;
- /** @brief unload callback
+ /** @brief unload callback.
*
* @note Remove resources with regards to this view for saving memory or keep the content for performance. It's up to your scenario.
* Unload will be called just right before when the view is going to be deleted by popping or it's piled under the more than one view.
*/
virtual void unload() = 0;
- /** @brief active callback
+ /** @brief active callback.
*
* @note View is on active state after show transition is finished.
* From whatever the state, if the view is on the screen, the active callback will be called.
*/
virtual void active() = 0;
- /** @brief inactive callback
+ /** @brief inactive callback.
*
* @note View is on inactive state. Get ready for unload. Hide transition may be triggered at this point.
* Inactive state is triggered on this scenario that the view is still visible but it's not interactive with users.
*/
virtual void inactive() = 0;
- /** @brief pause callback
+ /** @brief pause callback.
*
* @note When the system blocks the application running in cases such as phone call, system notification, switching applications ...
- * When Window turns to deactivate. (@see ui_viewmgr_base :: deactivate())
+ * When Window turns to deactivate. (@see ui_viewmgr_base :: deactivate()).
* If the view were inactive or unload state, the pause won't be called.
*/
virtual void pause() = 0;
- /** @brief resume callback
+ /** @brief resume callback.
*
* @note View is turning back to the active state again from pause.
* When the system allows the application turns to activate.
*/
virtual void resume() = 0;
- /** @brief destroy callback
+ /** @brief destroy callback.
*
* @note When this view is on destroying by popping or deleting.
*/
*
* @ingroup viewmgr
*
- * @brief UI View Base Class. This is the base class of view. A view must have one content instance which represents a view for a current screen.
- * UI View may have it's own show/hide transition styles. That means, it's available that views have different show/hide effects on demands.
- * It's not mandatory but view should describe the transitions in this class.
+ * @brief UI View Base Class. This is the base class of view. A view must have one content instance which represents a view for a current screen.
+ * UI View may have it's own show/hide transition styles. That means, it's available that views have different show/hide effects on demands.
+ * It's not mandatory but view should describe the transitions in this class.
*
- * @warning When the transitions are finished, the view must to call ui_viewmgr_interface :: _push_finished(), ui_viewmgr_interface :: _pop_finished() in order that
- * The ui_viewmgr_interface keeps the view states exactly.
+ * @warning When the transitions are finished, the view must to call ui_viewmgr_interface :: _push_finished(), ui_viewmgr_interface :: _pop_finished() in order that
+ * The ui_viewmgr_interface keeps the view states exactly.
*/
class ui_view_interface
{
};
T content; ///< A content instance for a screen as a view.
- ui_controller_interface *controller; ///< View life-cycle controller interface.
- string name; ///< View name
- string style; ///< View style name.
- ui_viewmgr_interface *viewmgr; ///< Viewmgr which this view belongs to.
- ui_view_state state; ///< View state
- ui_view_indicator indicator; ///< View indicator mode
+ ui_controller_interface *controller; ///< View life-cycle controller interface.
+ string name; ///< View name.
+ string style; ///< View style name.
+ ui_viewmgr_interface *viewmgr; ///< Viewmgr which this view belongs to.
+ ui_view_state state; ///< View state.
+ ui_view_indicator indicator; ///< View indicator mode.
bool event_block; ///< State of event block.
bool removable_content; ///< When this value is true, view removes it's content internally on unload state.
protected:
- /** @brief toggle event block
+ /** @brief toggle event block.
*
* @note This interface is designed for toggling touch event on view transition.
* ui_viewmgr_interface will call this interface for notifying event blocking toggling on transition time.
*
* @param block @c true, when blocking is enabled, otherwise @c false.
- *
*/
virtual void set_event_block(bool block);
- /** @brief view load state
+ /** @brief view load state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void load();
- /** @brief view unload state
+ /** @brief view unload state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void unload();
- /** @brief view active state
+ /** @brief view active state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void active();
- /** @brief view inactive state
+ /** @brief view inactive state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void inactive();
- /** @brief view pause state
+ /** @brief view pause state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void pause();
- /** @brief view resume state
+ /** @brief view resume state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void resume();
- /** @brief view destroy state
+ /** @brief view destroy state.
*
- * @note this state will be triggered by ui_viewmgr_interface
+ * @note this state will be triggered by ui_viewmgr_interface.
*
* @see ui_controller_interface for this state in detail.
*/
virtual void destroy();
+ //Make this view's content as NULL, then destroy content.
virtual void unload_content() = 0;
- /// Return the state of event block.
+ /** @brief Return the state of event block.
+ *
+ * @see set_event_block()
+ */
bool get_event_block()
{
return this->event_block;
return this->controller;
}
- /// Return a viewmgr which this view is belonging to
+ /** @brief Return a viewmgr which this view is belonging to.
+ */
ui_viewmgr_interface *get_viewmgr()
{
return this->viewmgr;
/** @brief This is for replacing or setting a controller of the view.
*
+ * @return A previous controller. If it wasn't, the return value will be @c NULL.
+ * @note this state will be triggered by ui_viewmgr_interface.
* @param controller a new controller. It allows @c NULL for canceling the previous controller.
- * @return A previous controller. If it wasn't, the return value will be @c NULL
*
* @warning Be aware deletion of controller passed here will be taken cover by ui_view_interface.
* If you want to keep the controller for any reasons, please unset it using set_controller() before ui_view_interface is deleted.
* For instance, the type could be Evas_Object * in EFL and Layer * in Dali.
*
* @param content a new content. It allows @c NULL for canceling the previous content.
- * @return A previous content. If it wasn't, return value will be @c NULL
+ *
+ * @return A previous content. If it wasn't, return value will be @c NULL.
*/
T set_content(T content);
/** @brief set style of the view.
*
* @note style is reserved for supporting various kinds of view as well as it's transition effects.
- * The actual behaviors with this style is up to your frameworks. Default value of the style is NULL.
+ * The actual behaviors with this style is up to your frameworks. Default value of the style is NULL.
*
* @param style a new style name.
+ *
* @return true if the given @c style is available, otherwise false.
*
* @warning When you override this member function, you should implement the logic to check the given style name is available or not.
* If your framework doesn't support any styles then just allow a @c NULL argument and return true. Otherwise return false.
- *
*/
bool set_style(const char *style);
+ /** @brief set name of the view.
+ *
+ * @note A view can gets a specific name. default value of the name is NULL.
+ *
+ * @param name a new name of view.
+ *
+ * @return true if the given @c name is available, otherwise false.
+ *
+ * @warning When you override this member function, you should check the name duplicate with other view or not.
+ */
bool set_name(const char *name);
- /** @brief set content removable
+ /** @brief set content removable.
*
* @param removable if @p removable is @c true, content of this view will be removed on unload state. @c false otherwise.
*
* @warning You should not remove a view content manually on unload status if removable content is set.
- *
*/
void set_removable_content(bool removable);
+ /** @brief set the indicator of the view with mode.
+ *
+ * @param indicator The mode to set, one of #ui_view_indicator.
+ */
void set_indicator(ui_view_indicator indicator);
- /// Return a style name of this view.
+ /** @brief Return a style name of this view.
+ *
+ * @return style name of view.
+ */
const char *get_style()
{
return this->style.c_str();
}
+ /** @brief Return a name of this view.
+ *
+ * @return name of view.
+ */
const char *get_name()
{
return this->name.c_str();
}
- /// Return the content instance of this view.
+ /** @brief Return a content instance of this view.
+ *
+ * @return content of view.
+ */
T get_content()
{
return this->content;
}
- /// Return the state of this view.
+ /** @brief Return a state of this view.
+ *
+ * #return current state of view.
+ */
ui_view_state get_state()
{
return this->state;
}
- /// Return the state of removeable content.
+
+
+ /** @brief Return a state of removeable content.
+ *
+ * @return true if the view's content is removable, otherwise false.
+ */
bool get_removable_content()
{
return this->removable_content;
}
- /// Return the indicator mode of this view.
+ /** @brief Return the indicator mode of this view.
+ *
+ * @return indicator state of view.
+ */
ui_view_indicator get_indicator()
{
return this->indicator;
* @ingroup viewmgr
*
* @brief This is a interface class of viewmgr. One viewmgr represents a window which contains multiple views.
- * A viewmgr manages not only views life-cycle but constructs basic infrastructures such as key event handlings, transition effects, transient views.
+ * A viewmgr manages not only views life-cycle but constructs basic infrastructures such as key events handling, transition effects, transient views.
* This interface guide you a basic policy of a view manager.
*
* @warning viewmgr will remove all containing views when it's destroyed.
private:
static bool soft_key; //If system doesn't support HW back key, then this value is @c true.
- static bool event_block; //Event block on view transition. This value should be configurable by system.
+ static bool event_block; //Event block on view transition. This value should be configurable by system.
list<ui_view_interface*> view_list; //View list.
bool activated; //Activated status of this viewmgr.
* @brief Connect a given view to this viewmgr.
*
* @param view A view to connect to this viewmgr which means the @p view is to belong to this viewmgr.
+ *
* @return @c true success or @c false not.
*
* @warning If the given view is already connected to a viewmgr, this call will be failed.
* @brief Disconnect a given view from this viewmgr.
*
* @param view A view to disconnect from this viewmgr.
+ *
* @return @c true on success or @c false otherwise.
*
* @see connect_view()
/**
* @brief Toggle event blocking to the given view.
*
- * @param view A view to toggle event blocking
- * @param block @c true is blocking event, otherwise @c false.
- *
* @note If the event is blocked, product users won't be able to enter any inputs to this @p view. These inputs are mouse clicks, key press,
* screen touches, etc. Event if this function is called, @p view will be event-blocked only when system requires event blocking.
* Most of the times, This function should be used on transition. @see also push_view(), push_view_finished(), pop_view(), pop_view_finished().
+ *
+ * @param view A view to toggle event blocking.
+ * @param block @c true is blocking event, otherwise @c false.
*/
void set_event_block(ui_view_interface *view, bool block);
* @brief This function is designed for finishing process of push transition.
*
* @param view A view which is finished pushing.
+ *
* @return @c true on success or @c false otherwise.
*
* @warning This function must be called when push transition is finished.
/**
* @brief This function is designed for finishing process for pop transition.
*
- * @note If a new view is pushed
+ * @note If a new view is pushed.
+ *
* @param view A view which is finished popping.
+ *
* @return @c true on success or @c false otherwise.
*
* @warning This function must be called when push transition is finished.
* @note Normally, the current view will be hidden by a new view. In default, when user calls this API, view will be switched to @p view instantly,
* only when viewmgr state is activated. Otherwise, the @p view will be shown later when viewmgr is activated. push_view() is designed for providing
* view transition effect. If you want push view instantly without any transition, you could use insert_view_before() or insert_view_after().
- * If you want to pop the current view, the please use pop_view()
+ * If you want to pop the current view, the please use pop_view().
+ *
+ * @param view A view to insert at the end of viewmgr view list.
*
* @return @p view, @c NULL when it fails to push a @p view.
*
bool pop_view();
/**
- * @brief Insert a view in this viewmgr view list. Specifically, insert a given @p view right before of the given view, @before
+ * @brief Insert a view in this viewmgr view list. Specifically, insert a given @p view right before of the given view, @before.
*
* @param view A view to insert in the viewmgr view list.
* @param before A view that will be just inserted after @p view. If you pass @c NULL, @p view will be inserted at the front of the view list.
- * @return @c true on success or @c false otherwise.
*
+ * @return @c true on success or @c false otherwise.
*/
bool insert_view_before(ui_view_interface *view, ui_view_interface *before);
/**
- * @brief Insert a view in this viewmgr view list. Specifically, insert a given @p view right after of the given view, @after
+ * @brief Insert a view in this viewmgr view list. Specifically, insert a given @p view right after of the given view, @after.
*
- * @param view A view to insert in the viewmgr view list
+ * @param view A view to insert in the viewmgr view list.
* @param after A view that will be just inserted before the @p view. If you pass @c NULL, @p view will be inserted at the end of the view list.
- * @return @c true on success or @c false otherwise.
*
+ * @return @c true on success or @c false otherwise.
*/
bool insert_view_after(ui_view_interface *view, ui_view_interface *after);
/**
* @brief Remove the given view from this viewmgr view list.
*
+ * @param view A view to remove from the viewmgr view list.
+ *
* @return @c true on success or @c false otherwise.
*
* @see insert_view_before()
* @brief Return a view which is matched with the index @p idx.
*
* @param idx A index of the view which you are looking for.
- * @return The view which index is matched with @p idx
+ *
+ * @return The view which index is matched with @p idx.
* If there were no views with index @p idx, @c NULL will be returned.
*
* @note You could use the index as the page numbers of the views.
* @note Every view have their names as their own identifiers.
*
* @param name The name of the view which you are looking for.
+ *
* @return The view which name is matched with @p name.
* If there were no views name matched, @c NULL will be returned.
*
* You could use this function to query the given @p view list order.
*
* @param view A view to query the index.
+ *
* @return An index of the give @p view on success, otherwise, -1.
*
* @warning The index number of views are variable since the view list is variable.
int get_view_index(const ui_view_interface *view);
public:
- ///Constructor
+ ///Constructor.
ui_viewmgr_interface();
- ///Destructor
+ ///Destructor.
virtual ~ui_viewmgr_interface();
/**
* @brief Activate this view manager.
*
- * @note viewmgr window and views will be shown once activate() is called. Usually this activate() should be called after applications set their all views
- * on initialization time.
+ * @note viewmgr window and views will be shown once activate() is called. Usually this activate() should be called after applications set their all views
+ * on initialization time.
*
* @return @c true on success or @c false otherwise.
*
/**
* @brief Deactivate this view manager.
*
- * @note viewmgr window and views will be hidden once deactivate() is called. deactivate() behavior is up ui system, but usually it hides(unmap)
- * current window in order that application go background.
+ * @note viewmgr window and views will be hidden once deactivate() is called. deactivate() behavior is up ui system, but usually it hides(unmap)
+ * current window in order that application go background.
*
* @return @c true success or @c false not.
*
- * @see deactivate()
+ * @see activate()
*/
bool deactivate();
*
* @return @c true if viewmgr is active, @c false otherwise.
*
- * @see activate()
- * @see deactivate()
+ * @see activate()
+ * @see deactivate()
*/
bool is_activated();
/**
* @brief Return whether soft key is required or not.
*
- * @note Soft key is kind of like the software back button. It's used for product users to change current view to a previous view (pop).
+ * @note Soft key is kind of like the software back button. It's used for product users to change current view to a previous view (pop).
* If a device doesn't have any hardware back buttons, Soft back key is necessary which means this function will return @c true.
* Some devices may needs software back key as well as hardware back key at the same time. That decision is up to product design.
* And soft_key initial value should read from the system configuration.
projects / platform / core / uifw / ui-viewmgr.git / commitdiff