C++ DLEAVE_FUNCTION函数代码示例

/**
 * @param win: window to set transient
 * @param forwin: the window to be transient for
 * @return Returns no value.
 * @brief Sets a window to be transient for another window.
 */
void
ewl_window_transient_for(Ewl_Window *win, Ewl_Window *forwin)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(win);
        DCHECK_TYPE(win, EWL_WINDOW_TYPE);
        DCHECK_TYPE(forwin, EWL_WINDOW_TYPE);

        win->transient.ewl = forwin;
        win->flags &= ~EWL_WINDOW_TRANSIENT_FOREIGN;

        /* if there is no forwin remove the transient for state
         * and update the window, if it already exists */
        if (!forwin) {
                win->flags &= ~EWL_WINDOW_TRANSIENT;
                if (win->window)
                        ewl_engine_window_transient_for(win);

                DRETURN(DLEVEL_STABLE);
        }

        win->flags |= EWL_WINDOW_TRANSIENT;

        if (win->window) {
                if (forwin->window)
                        ewl_engine_window_transient_for(win);
                else
                        ewl_callback_append(EWL_WIDGET(forwin),
                                            EWL_CALLBACK_REALIZE,
                                            ewl_window_cb_realize_parent,
                                            win);
        }

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @return Returns no value
 * @brief Called when the icon theme is changed so we can clean up any
 * caching we have in place
 */
void
ewl_icon_theme_theme_change(void)
{
        const char *icon_theme;

        DENTER_FUNCTION(DLEVEL_STABLE);

        icon_theme = ewl_config_string_get(ewl_config, EWL_CONFIG_THEME_ICON_THEME);

        /* check if this is an edje theme */
        if (icon_theme && (!strncasecmp(icon_theme + (strlen(icon_theme) - 4),
                                              ".edj", 4)))
                ewl_icon_theme_is_edje = 1;
        else
                ewl_icon_theme_is_edje = 0;

        /* destroy the cache and re-create it */
        IF_FREE_HASH(ewl_icon_theme_cache);

        ewl_icon_theme_cache = ecore_hash_new(ecore_str_hash, ecore_str_compare);
        ecore_hash_free_key_cb_set(ewl_icon_theme_cache, ewl_icon_theme_cb_free);
        ecore_hash_free_value_cb_set(ewl_icon_theme_cache, free);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @internal
 * @param tx: The context to print
 * @param indent: The indent level to use
 * @return Returns no value
 * @brief Prints out the context information
 **/
void
ewl_text_context_print(Ewl_Text_Context *tx, const char *indent)
{
        const char *t, *s;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(tx);

        if (!tx->font) t = "";
        else t = tx->font;

        if (!tx->font_source) s = "";
        else s = tx->font_source;

        printf("%sfont: %s (source: %s)\n"
                "%ssize %d\n"
                "%sstyle %d\n"
                "%salign %d\n"
                "%swrap %d\n"
                "%sred %d\n"
                "%sgreen %d\n"
                "%sblue %d\n"
                "%salpha %d",
                        indent, t, s, indent, tx->size, indent,
                        tx->styles, indent, tx->align,
                        indent, tx->wrap, indent, tx->color.r,
                        indent, tx->color.g, indent, tx->color.b,
                        indent, tx->color.a);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param menu: the menu to work with
 * @return Returns no value
 * @brief Expand the popup portion of the menu
 */
void
ewl_menu_expand(Ewl_Menu *menu)
{
        Ewl_Menu_Item *item;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(menu);
        DCHECK_TYPE(menu, EWL_MENU_TYPE);

        item = EWL_MENU_ITEM(menu);

        /* nothing to do if the popup is already visible */
        if (VISIBLE(menu->popup))
                DRETURN(DLEVEL_STABLE);

        ewl_widget_show(menu->popup);
        ewl_window_raise(EWL_WINDOW(menu->popup));

        if (item->inmenu) {
                Ewl_Context_Menu *cm;

                cm = EWL_CONTEXT_MENU(item->inmenu);
                cm->open_menu = EWL_WIDGET(menu);
        }
        else
                ewl_widget_focus_send(menu->popup);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @internal
 * @param w: The widget to work with
 * @ev_data: The Ewl_Event_Mouse_Down data
 * @param data: The scrollport
 * @return Returns no value
 * @brief The mouse down function for kinetic scrolling
 */
static void
ewl_scrollport_kinetic_cb_mouse_down_embedded(Ewl_Widget *w, void *ev,
                void *data)
{
        Ewl_Scrollport *s;
        Ewl_Event_Mouse *md;
        Ewl_Scrollport_Kinetic_Info_Embedded *info;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(ev);
        DCHECK_PARAM_PTR(data);
        DCHECK_TYPE(w, EWL_WIDGET_TYPE);

        s = EWL_SCROLLPORT(data);
        md = EWL_EVENT_MOUSE(ev);
        info = s->kinfo->extra;
        s->kinfo->clicked = !!TRUE;
        s->kinfo->active = !!FALSE;

        memset(&(info->back[0]), 0, sizeof(info->back[0]) * HIST_NUM);
        info->back[0].x = md->x;
        info->back[0].y = md->y;
        info->back[0].time = ecore_time_get();
        info->xs = md->x;
        info->ys = md->y;

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param p: The popup to set the follow widget
 * @param w: The widget to follow
 * @return Returns no value
 * @brief Set the follow widget of the popup
 */
void
ewl_popup_follow_set(Ewl_Popup *p, Ewl_Widget *w)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(p);
        DCHECK_TYPE(p, EWL_POPUP_TYPE);

        if (p->follow == w)
                DRETURN(DLEVEL_STABLE);

        if (p->follow) {
                ewl_callback_del_with_data(p->follow, EWL_CALLBACK_DESTROY,
                                                ewl_popup_cb_follow_destroy, p);
                ewl_callback_del_with_data(p->follow, EWL_CALLBACK_CONFIGURE,
                                                ewl_popup_cb_follow_configure,
                                                p);
        }

        if (w) {
                ewl_callback_prepend(w, EWL_CALLBACK_DESTROY,
                                        ewl_popup_cb_follow_destroy, p);
                ewl_callback_append(w, EWL_CALLBACK_CONFIGURE,
                                        ewl_popup_cb_follow_configure, p);
        }

        p->follow = w;

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param ps: the ps to change the orientation
 * @param o: the orientation
 * @return Returns no value.
 * @brief Set an orientation of the document
 *
 * Sets an orientation @p o of the document
 */
void
ewl_ps_orientation_set(Ewl_Ps *ps, Eps_Page_Orientation o)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(ps);
        DCHECK_TYPE(ps, EWL_PS_TYPE);

        if (!ps->ps_page || (eps_page_orientation_get(ps->ps_page) == o))
                DLEAVE_FUNCTION(DLEVEL_STABLE);

        ps->dirty = 1;
        eps_page_orientation_set(ps->ps_page, o);
        ewl_widget_configure(EWL_WIDGET(ps));

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param e: The Ewl_Entry to set the editable status of
 * @param editable: The value to set for the editable flag
 * @return Returns no value
 * @brief Set if the entry is editable or not
 */
void
ewl_entry_editable_set(Ewl_Entry *e, unsigned int editable)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(e);
        DCHECK_TYPE(e, EWL_ENTRY_TYPE);

        if (e->editable == !!editable)
                DRETURN(DLEVEL_STABLE);

        e->editable = !!editable;

        if (e->editable)
        {
                ewl_callback_append(EWL_WIDGET(e), EWL_CALLBACK_KEY_DOWN,
                                                ewl_entry_cb_key_down, NULL);

                if (ewl_widget_state_has(EWL_WIDGET(e), EWL_STATE_FOCUSED))
                        ewl_widget_show(e->cursor);

                ewl_widget_state_add(EWL_WIDGET(e), EWL_STATE_ON);
        }
        else
        {
                ewl_callback_del(EWL_WIDGET(e), EWL_CALLBACK_KEY_DOWN,
                                                ewl_entry_cb_key_down);

                if (ewl_widget_state_has(EWL_WIDGET(e), EWL_STATE_FOCUSED))
                        ewl_widget_hide(e->cursor);

                ewl_widget_state_remove(EWL_WIDGET(e), EWL_STATE_ON);
        }

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param sp: The Ewl_Spectrum to set the hsv value into
 * @param h: The hue to set
 * @param s: The saturation to set
 * @param v: The value to set
 * @return Returns no value
 * @brief Set the HSV values for the spectrum
 */
void
ewl_spectrum_hsv_set(Ewl_Spectrum *sp, double h, double s, double v)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(sp);
        DCHECK_TYPE(sp, EWL_SPECTRUM_TYPE);

        sp->hsv.h = h;
        sp->hsv.s = s;
        sp->hsv.v = v;

        if (sp->hsv.h > 360) sp->hsv.h = 360.0;
        if (sp->hsv.h <= 0) sp->hsv.h = 360.0;

        if (sp->hsv.s > 1.0) sp->hsv.s = 1.0;
        if (sp->hsv.s < 0.0) sp->hsv.s = 0.0;

        if (sp->hsv.v > 1.0) sp->hsv.v = 1.0;
        if (sp->hsv.v < 0.0) sp->hsv.v = 0.0;

        ewl_spectrum_rgb_from_hsv(sp);
        sp->dirty = TRUE;
        ewl_widget_configure(EWL_WIDGET(sp));

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param menu: The menu to setup
 * @param info: The info to set into the menu
 * @return Returns no value
 * @brief Initializes @a menu with @a info
 */
void
ewl_menu_from_info(Ewl_Menu *menu, Ewl_Menu_Info *info)
{
        int i;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(menu);
        DCHECK_PARAM_PTR(info);
        DCHECK_TYPE(menu, EWL_MENU_TYPE);

        for (i = 0; info[i].name != NULL; i++)
        {
                Ewl_Widget *item;

                item = ewl_menu_item_new();
                ewl_button_label_set(EWL_BUTTON(item), info[i].name);
                ewl_button_image_set(EWL_BUTTON(item), info[i].img, NULL);
                ewl_container_child_append(EWL_CONTAINER(menu), item);

                if (info[i].cb)
                        ewl_callback_append(item, EWL_CALLBACK_CLICKED,
                                                        info[i].cb, NULL);
                ewl_widget_show(item);
        }

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param s: The separator to set the orientation on
 * @param o: The orientation to set on the separator
 * @return Returns no value
 * @brief Set the orientation of the separator
 */
void
ewl_separator_orientation_set(Ewl_Separator *s, Ewl_Orientation o)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(s);
        DCHECK_TYPE(s, EWL_SEPARATOR_TYPE);

        if (s->orientation == o)
                DRETURN(DLEVEL_STABLE);

        s->orientation = o;

        if (o == EWL_ORIENTATION_HORIZONTAL) {
                ewl_widget_appearance_set(EWL_WIDGET(s), "hseparator");
                ewl_object_fill_policy_set(EWL_OBJECT(s),
                                           EWL_FLAG_FILL_HFILL |
                                           EWL_FLAG_FILL_HSHRINKABLE);
        }
        else {
                ewl_widget_appearance_set(EWL_WIDGET(s), "vseparator");
                ewl_object_fill_policy_set(EWL_OBJECT(s),
                                           EWL_FLAG_FILL_VFILL |
                                           EWL_FLAG_FILL_VSHRINKABLE);
        }

        ewl_widget_configure(EWL_WIDGET(s));

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @internal
 * @param c: The container to work with
 * @param w: The widget to work with
 * @return Returns no value
 * @brief The child add callback
 */
void
ewl_notebook_cb_child_add(Ewl_Container *c, Ewl_Widget *w)
{
        Ewl_Notebook *n;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(c);
        DCHECK_PARAM_PTR(w);
        DCHECK_TYPE(c, EWL_CONTAINER_TYPE);
        DCHECK_TYPE(w, EWL_WIDGET_TYPE);

        n = EWL_NOTEBOOK(EWL_WIDGET(c)->parent);

        /* stick a null tab in there so that it at least shows up */
        ewl_notebook_page_tab_widget_set(n, w, NULL);

        /* we have no current page, make it this one */
        if (!n->cur_page)
        {
                ewl_notebook_visible_page_set(n, w);
                ewl_widget_show(w);
        }

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @internal
 * @return Returns no value
 * @brief Shuts the context system down
 */
void
ewl_text_context_shutdown(void)
{
        DENTER_FUNCTION(DLEVEL_STABLE);

        IF_FREE_HASH(context_hash);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @internal
 * @param tx: The context to work with
 * @return Returns no value
 * @brief Acquires a reference to the given context
 */
void
ewl_text_context_acquire(Ewl_Text_Context *tx)
{
        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(tx);

        tx->ref_count ++;

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}

/**
 * @param ps: the ps widget
 * @return Returns  no value.
 * @brief go to the next page and render it
 */
void
ewl_ps_page_next(Ewl_Ps *ps)
{
        int page;

        DENTER_FUNCTION(DLEVEL_STABLE);
        DCHECK_PARAM_PTR(ps);
        DCHECK_TYPE(ps, EWL_PS_TYPE);

        if (!ps->ps_page)
                DLEAVE_FUNCTION(DLEVEL_STABLE);

        page = eps_page_page_get(ps->ps_page);
        if (page < (eps_document_page_count_get(ps->ps_document) - 1))
                page++;
        ewl_ps_page_set(ps, page);

        DLEAVE_FUNCTION(DLEVEL_STABLE);
}