nexposee.qc

Go to the documentation of this file.

#include "nexposee.qh"

    void Nexposee_close(entity me)
    {
        // user must override this
    }

    void ExposeeCloseButton_Click(entity button, entity other)
    {
        other.selectedChild = other.focusedChild;
        other.setFocus(other, NULL);
        other.animationState = 3;
    }

    void Nexposee_resizeNotify(entity me, vector relOrigin, vector relSize, vector absOrigin, vector absSize)
    {
        me.calc(me);
        me.resizeNotifyLie(me, relOrigin, relSize, absOrigin, absSize, Nexposee_initialOrigin, Nexposee_initialSize, Nexposee_initialFontScale);
    }

    void Nexposee_Calc_Scale(entity me, float scale)
    {
        entity e;
        for (e = me.firstChild; e; e = e.nextSibling)
        {
            e.Nexposee_smallOrigin = (e.Nexposee_initialOrigin - e.Nexposee_scaleCenter) * scale + e.Nexposee_scaleCenter;
            e.Nexposee_smallSize = e.Nexposee_initialSize * scale;
            if (e.Nexposee_align.x > 0) e.Nexposee_smallOrigin_x = 1 - e.Nexposee_align.x * scale;
            if (e.Nexposee_align.x < 0) e.Nexposee_smallOrigin_x = -e.Nexposee_smallSize.x + e.Nexposee_align.x * scale;
            if (e.Nexposee_align.y > 0) e.Nexposee_smallOrigin_y = 1 - e.Nexposee_align.y * scale;
            if (e.Nexposee_align.y < 0) e.Nexposee_smallOrigin_y = -e.Nexposee_smallSize.y + e.Nexposee_align.y * scale;
        }
    }

    void Nexposee_calc(entity me)
    {
        /*
         * patented by Apple
         * can't put that here ;)
         */
        float scale;
        entity e, e2;
        vector emins, emaxs, e2mins, e2maxs;

        for (scale = 0.7; ; scale *= 0.99)
        {
            Nexposee_Calc_Scale(me, scale);

            for (e = me.firstChild; e; e = e.nextSibling)
            {
                emins = e.Nexposee_smallOrigin;
                emaxs = emins + e.Nexposee_smallSize;
                for (e2 = e.nextSibling; e2; e2 = e2.nextSibling)
                {
                    e2mins = e2.Nexposee_smallOrigin;
                    e2maxs = e2mins + e2.Nexposee_smallSize;

                    // two intervals [amins, amaxs] and [bmins, bmaxs] overlap if:
                    //   amins < bmins < amaxs < bmaxs
                    // for which suffices
                    //   bmins < amaxs
                    //   amins < bmaxs
                    if ((e2mins.x - emaxs.x) * (emins.x - e2maxs.x) > 0)     // x overlap
                        if ((e2mins.y - emaxs.y) * (emins.y - e2maxs.y) > 0) // y overlap
                            goto have_overlap;
                }
            }

            break;
LABEL(have_overlap)
        }

        scale *= 0.95;

        Nexposee_Calc_Scale(me, scale);
    }

    void Nexposee_setNexposee(entity me, entity other, vector scalecenter, float a0, float a1)
    {
        other.Nexposee_scaleCenter = scalecenter;
        other.Nexposee_smallAlpha = a0;
        me.setAlphaOf(me, other, a0);
        other.Nexposee_mediumAlpha = a1;
    }

    void Nexposee_draw(entity me)
    {
        float a;
        float a0;
        entity e;
        float f;
        vector fs;

        if (me.animationState == -1) me.animationState = 0;

        f = min(1, frametime * 5);
        switch (me.animationState)
        {
            case 0:
                me.animationFactor = 0;
                break;
            case 1:
                me.animationFactor += f;
                if (me.animationFactor >= 1)
                {
                    me.animationFactor = 1;
                    me.animationState = 2;
                    SUPER(Nexposee).setFocus(me, me.selectedChild);
                }
                break;
            case 2:
                me.animationFactor = 1;
                break;
            case 3:
                me.animationFactor -= f;
                me.mouseFocusedChild = me.itemFromPoint(me, me.mousePosition);
                if (me.animationFactor <= 0)
                {
                    me.animationFactor = 0;
                    me.animationState = 0;
                    me.selectedChild = me.mouseFocusedChild;
                }
                break;
        }

        f = min(1, frametime * 10);
        for (e = me.firstChild; e; e = e.nextSibling)
        {
            if (e == me.selectedChild)
            {
                e.Container_origin = e.Nexposee_smallOrigin * (1 - me.animationFactor) + e.Nexposee_initialOrigin * me.animationFactor;
                e.Container_size = e.Nexposee_smallSize * (1 - me.animationFactor) + e.Nexposee_initialSize * me.animationFactor;
                e.Nexposee_animationFactor = me.animationFactor;
                a0 = e.Nexposee_mediumAlpha;
                if (me.animationState == 3)
                    if (e != me.mouseFocusedChild) a0 = e.Nexposee_smallAlpha;
                a = a0 * (1 - me.animationFactor) + me.animationFactor;
            }
            else
            {
                // minimum theSize counts
                e.Container_origin = e.Nexposee_smallOrigin;
                e.Container_size = e.Nexposee_smallSize;
                e.Nexposee_animationFactor = 0;
                a = e.Nexposee_smallAlpha * (1 - me.animationFactor);
            }
            me.setAlphaOf(me, e, e.Container_alpha * (1 - f) + a * f);

            fs = globalToBoxSize(e.Container_size, e.Nexposee_initialSize);
            e.Container_fontscale_x = fs.x * e.Nexposee_initialFontScale.x;
            e.Container_fontscale_y = fs.y * e.Nexposee_initialFontScale.y;
        }

        SUPER(Nexposee).draw(me);
    }

    METHOD(Nexposee, mousePress, bool(Nexposee this, vector pos))
    {
        if (this.animationState == 0)
        {
            this.mouseFocusedChild = NULL;
            Nexposee_mouseMove(this, pos);
            if (this.mouseFocusedChild)
            {
                m_play_click_sound(MENU_SOUND_OPEN);
                this.animationState = 1;
                SUPER(Nexposee).setFocus(this, NULL);
            }
            else
            {
                this.close(this);
            }
            return true;
        }
        else if (this.animationState == 2)
        {
            if (!(SUPER(Nexposee).mousePress(this, pos)))
            {
                m_play_click_sound(MENU_SOUND_CLOSE);
                this.animationState = 3;
                SUPER(Nexposee).setFocus(this, NULL);
            }
            return true;
        }
        return false;
    }

    float Nexposee_mouseRelease(entity me, vector pos)
    {
        if (me.animationState == 2) return SUPER(Nexposee).mouseRelease(me, pos);
        return 0;
    }

    float Nexposee_mouseDrag(entity me, vector pos)
    {
        if (me.animationState == 2) return SUPER(Nexposee).mouseDrag(me, pos);
        return 0;
    }

    float Nexposee_mouseMove(entity me, vector pos)
    {
        entity e;
        me.mousePosition = pos;
        e = me.mouseFocusedChild;
        me.mouseFocusedChild = me.itemFromPoint(me, pos);
        if (me.animationState == 2) return SUPER(Nexposee).mouseMove(me, pos);
        if (me.animationState == 0)
        {
            if (me.mouseFocusedChild)
                if (me.mouseFocusedChild != e || me.mouseFocusedChild != me.selectedChild) me.selectedChild = me.mouseFocusedChild;
            return 1;
        }
        return 0;
    }

    float Nexposee_keyUp(entity me, float scan, float ascii, float shift)
    {
        if (me.animationState == 2) return SUPER(Nexposee).keyUp(me, scan, ascii, shift);
        return 0;
    }

    float Nexposee_keyDown(entity me, float scan, float ascii, float shift)
    {
        float nexposeeKey = 0;
        if (me.animationState == 2)
            if (SUPER(Nexposee).keyDown(me, scan, ascii, shift)) return 1;
        if (scan == K_TAB)
        {
            if (me.animationState == 0)
            {
                if (shift & S_SHIFT)
                {
                    if (me.selectedChild) me.selectedChild = me.selectedChild.prevSibling;
                    if (!me.selectedChild) me.selectedChild = me.lastChild;
                }
                else
                {
                    if (me.selectedChild) me.selectedChild = me.selectedChild.nextSibling;
                    if (!me.selectedChild) me.selectedChild = me.firstChild;
                }
            }
        }
        switch (me.animationState)
        {
            default:
            case 0:
            case 3:
                nexposeeKey = ((scan == K_SPACE) || (scan == K_ENTER) || (scan == K_KP_ENTER));
                break;
            case 1:
            case 2:
                nexposeeKey = (scan == K_ESCAPE);
                break;
        }
        if (nexposeeKey)
        {
            switch (me.animationState)
            {
                default:
                case 0:
                case 3:
                    m_play_click_sound(MENU_SOUND_OPEN);
                    me.animationState = 1;
                    break;
                case 1:
                case 2:
                    m_play_click_sound(MENU_SOUND_CLOSE);
                    me.animationState = 3;
                    break;
            }
            if (me.focusedChild) me.selectedChild = me.focusedChild;
            if (!me.selectedChild) me.animationState = 0;
            SUPER(Nexposee).setFocus(me, NULL);
            return 1;
        }
        return 0;
    }

    void Nexposee_addItem(entity me, entity other, vector theOrigin, vector theSize, float theAlpha)
    {
        SUPER(Nexposee).addItem(me, other, theOrigin, theSize, theAlpha);
        other.Nexposee_initialFontScale = other.Container_fontscale;
        other.Nexposee_initialSize = other.Container_size;
        other.Nexposee_initialOrigin = other.Container_origin;
        other.Nexposee_initialAlpha = other.Container_alpha;
        if (other.Nexposee_initialFontScale == '0 0 0') other.Nexposee_initialFontScale = '1 1 0';
    }

    void Nexposee_focusEnter(entity me)
    {
        if (me.animationState == 2) SUPER(Nexposee).setFocus(me, me.selectedChild);
    }

    void Nexposee_pullNexposee(entity me, entity other, vector theAlign)
    {
        other.Nexposee_align = theAlign;
    }