Window.h

/***********************************************************************
    created:    21/2/2004
    author:     Paul D Turner

    purpose:    Defines abstract base class for Window objects
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2012 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/

#ifndef _CEGUIWindow_h_
#define _CEGUIWindow_h_

#include "CEGUI/Base.h"
#include "CEGUI/NamedElement.h"
#include "CEGUI/Vector.h"
#include "CEGUI/Quaternion.h"
#include "CEGUI/Rect.h"
#include "CEGUI/Size.h"
#include "CEGUI/EventSet.h"
#include "CEGUI/PropertySet.h"
#include "CEGUI/TplWindowProperty.h"
#include "CEGUI/System.h"
#include "CEGUI/GUIContext.h"
#include "CEGUI/InputEvent.h"
#include "CEGUI/UDim.h"
#include "CEGUI/WindowRenderer.h"
#include "CEGUI/TextUtils.h"
#include "CEGUI/BasicRenderedStringParser.h"
#include "CEGUI/DefaultRenderedStringParser.h"
#include <vector>
#include <set>

#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4251)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{

enum WindowUpdateMode
{
    WUM_ALWAYS,
    WUM_NEVER,
    WUM_VISIBLE
};

template<>
class PropertyHelper<WindowUpdateMode>
{
public:
    typedef WindowUpdateMode return_type;
    typedef return_type safe_method_return_type;
    typedef WindowUpdateMode pass_type;
    typedef String string_return_type;

    static const String& getDataTypeName()
    {
        static String type("WindowUpdateMode");

        return type;
    }

    static return_type fromString(const String& str)
    {
    
        if (str == "Always")
        {
            return WUM_ALWAYS;
        }
        else if (str == "Never")
        {
            return WUM_NEVER;
        }
        else
        {
            return WUM_VISIBLE;
        }
    }

    static string_return_type toString(pass_type val)
    {
        if (val == WUM_ALWAYS)
        {
            return "Always";
        }
        else if (val == WUM_NEVER)
        {
            return "Never";
        }
        else if (val == WUM_VISIBLE)
        {
            return "Visible";
        }
        else
        {
            assert(false && "Invalid Window Update Mode");
            return "Always";
        }
    }
};


class CEGUIEXPORT Window :
    public NamedElement
{
public:
    /*************************************************************************
        Event name constants
    *************************************************************************/
    static const String EventNamespace;

    // generated internally by Window
    static const String EventUpdated;
    
    static const String EventTextChanged;
    static const String EventFontChanged;
    static const String EventAlphaChanged;
    static const String EventIDChanged;
    static const String EventActivated;
    static const String EventDeactivated;
    static const String EventShown;
    static const String EventHidden;
    static const String EventEnabled;
    static const String EventDisabled;
    static const String EventClippedByParentChanged;
    static const String EventDestroyedByParentChanged;
    static const String EventInheritsAlphaChanged;
    static const String EventAlwaysOnTopChanged;
    static const String EventInputCaptureGained;
    static const String EventInputCaptureLost;
    static const String EventInvalidated;
    static const String EventRenderingStarted;
    static const String EventRenderingEnded;
    static const String EventDestructionStarted;
    static const String EventDragDropItemEnters;
    static const String EventDragDropItemLeaves;
    static const String EventDragDropItemDropped;
    static const String EventWindowRendererAttached;
    static const String EventWindowRendererDetached;
    static const String EventTextParsingChanged;
    static const String EventMarginChanged;

    // generated externally (inputs)
    static const String EventMouseEntersArea;
    static const String EventMouseLeavesArea;
    static const String EventMouseEntersSurface;
    static const String EventMouseLeavesSurface;
    static const String EventMouseMove;
    static const String EventMouseWheel;
    static const String EventMouseButtonDown;
    static const String EventMouseButtonUp;
    static const String EventMouseClick;
    static const String EventMouseDoubleClick;
    static const String EventMouseTripleClick;
    static const String EventKeyDown;
    static const String EventKeyUp;
    static const String EventCharacterKey;

    /*************************************************************************
        Child Widget name suffix constants
    *************************************************************************/
    static const String TooltipNameSuffix;

    // XML element and attribute names that relate to Window.
        static const String WindowXMLElementName;
    static const String AutoWindowXMLElementName;
    static const String UserStringXMLElementName;
        static const String WindowTypeXMLAttributeName;
        static const String WindowNameXMLAttributeName;
    static const String AutoWindowNamePathXMLAttributeName;
    static const String UserStringNameXMLAttributeName;
    static const String UserStringValueXMLAttributeName;

    Window(const String& type, const String& name);

    virtual ~Window(void);

    const String& getType(void) const;

    bool    isDestroyedByParent(void) const    {return d_destroyedByParent;}

    bool isAlwaysOnTop(void) const  {return d_alwaysOnTop;}

    bool isDisabled() const;

    bool isEffectiveDisabled() const;

    bool isVisible() const;

    bool isEffectiveVisible() const;

    bool isActive(void) const;

    bool isClippedByParent(void) const {return d_clippedByParent;}

    uint getID(void) const {return d_ID;}

    using NamedElement::isChild;
    bool isChild(uint ID) const;

    bool isChildRecursive(uint ID) const;


    inline Window* getChildAtIdx(size_t idx) const
    {
        return static_cast<Window*>(getChildElementAtIdx(idx));
    }
    
    inline Window* getChild(const String& name_path) const
    {
        return static_cast<Window*>(getChildElement(name_path));
    }

    inline Window* getChildRecursive(const String& name) const
    {
        return static_cast<Window*>(getChildElementRecursive(name));
    }

    Window* getChild(uint ID) const;

    Window* getChildRecursive(uint ID) const;

    Window* getActiveChild(void);
    const Window* getActiveChild(void) const;

    using NamedElement::isAncestor;
    bool isAncestor(uint ID) const;

    const Font* getFont(bool useDefault = true) const;

    const String& getText(void) const {return d_textLogical;}

    const String& getTextVisual() const;

    bool inheritsAlpha(void) const  {return d_inheritsAlpha;}

    float getAlpha(void) const  {return d_alpha;}

    float getEffectiveAlpha(void) const;

    const Rectf& getOuterRectClipper() const;

    const Rectf& getInnerRectClipper() const;

    const Rectf& getClipRect(const bool non_client = false) const;

    const Rectf& getHitTestRect() const;

    Window* getCaptureWindow() const
        {return getGUIContext().getInputCaptureWindow();}

    bool isCapturedByThis(void) const   {return getCaptureWindow() == this;}

    bool isCapturedByAncestor(void) const
    {return isAncestor(getCaptureWindow());}

    bool isCapturedByChild(void) const  {return isChild(getCaptureWindow());}

    virtual bool isHit(const Vector2f& position,
                       const bool allow_disabled = false) const;

    Window* getChildAtPosition(const Vector2f& position) const;

    Window* getTargetChildAtPosition(const Vector2f& position, 
                                     const bool allow_disabled = false) const;

    inline Window* getParent() const
    {
        return static_cast<Window*>(getParentElement());
    }

    const Image* getMouseCursor(bool useDefault = true) const;

    void* getUserData(void) const   {return d_userData;}

    bool restoresOldCapture(void) const     {return d_restoreOldCapture;}

    bool isZOrderingEnabled(void) const;

    bool wantsMultiClickEvents(void) const;

    bool isMouseAutoRepeatEnabled(void) const;

    float getAutoRepeatDelay(void) const;

    float getAutoRepeatRate(void) const;

    bool distributesCapturedInputs(void) const;

    bool isUsingDefaultTooltip(void) const;

    Tooltip* getTooltip(void) const;

    String getTooltipType(void) const;

    const String& getTooltipText(void) const;

    bool inheritsTooltipText(void) const;

    bool isRiseOnClickEnabled(void) const   { return d_riseOnClick; }

    GeometryBuffer& getGeometryBuffer();

    const String& getLookNFeel() const;

    bool getModalState(void) const
    {return(getGUIContext().getModalWindow() == this);}

    const String& getUserString(const String& name) const;

    bool isUserStringDefined(const String& name) const;

    Window* getActiveSibling();

    bool isMousePassThroughEnabled(void) const  {return d_mousePassThroughEnabled;}

    bool isAutoWindow(void) const   {return d_autoWindow;}

    bool isWritingXMLAllowed(void) const    {return d_allowWriteXML;}

    bool isDragDropTarget() const;

    void getRenderingContext(RenderingContext& ctx) const;

    virtual void getRenderingContext_impl(RenderingContext& ctx) const;

    RenderingSurface* getRenderingSurface() const;

    RenderingSurface& getTargetRenderingSurface() const;

    bool isUsingAutoRenderingSurface() const;

    const Window* getRootWindow() const;
    Window* getRootWindow();

    virtual void initialiseComponents(void) {}

    void setDestroyedByParent(bool setting);

    void setAlwaysOnTop(bool setting);

    void setEnabled(bool setting);

    void setDisabled(bool setting);

    void enable(void)   {setEnabled(true);}

    void disable(void)  {setEnabled(false);}

    void setVisible(bool setting);

    void show(void)     {setVisible(true);}

    void hide(void)     {setVisible(false);}

    void activate(void);

    void deactivate(void);

    void setClippedByParent(bool setting);

    void setID(uint ID);

    void setText(const String& text);

    void insertText(const String& text, const String::size_type position);

    void appendText(const String& text);

    void setFont(const Font* font);

    void setFont(const String& name);

    using NamedElement::removeChild;
    void removeChild(uint ID);

    Window* createChild(const String& type, const String& name = "");

    void destroyChild(Window* wnd);

    void destroyChild(const String& name_path);
    
    void moveToFront();

    void moveToBack();

    void moveInFront(const Window* const window);

    void moveBehind(const Window* const window);
    
    size_t getZIndex() const;

    bool isInFront(const Window& wnd) const;

    bool isBehind(const Window& wnd) const;

    bool captureInput(void);

    void releaseInput(void);

    void setRestoreOldCapture(bool setting);

    void setAlpha(const float alpha);

    void setInheritsAlpha(bool setting);

    void invalidate(void);

    void invalidate(const bool recursive);

    void setMouseCursor(const Image* image);

    void setMouseCursor(const String& name);

    void setUserData(void* user_data)   {d_userData = user_data;}
    
    void    setZOrderingEnabled(bool setting);
    
    void setWantsMultiClickEvents(bool setting);

    void setMouseAutoRepeatEnabled(bool setting);

    void setAutoRepeatDelay(float delay);

    void setAutoRepeatRate(float rate);

    void setDistributesCapturedInputs(bool setting);

    void notifyDragDropItemEnters(DragContainer* item);

    void notifyDragDropItemLeaves(DragContainer* item);

    void notifyDragDropItemDropped(DragContainer* item);

    virtual void destroy(void);

    void setTooltip(Tooltip* tooltip);

    void setTooltipType(const String& tooltipType);

    void setTooltipText(const String& tip);

    void setInheritsTooltipText(bool setting);

    void setRiseOnClickEnabled(bool setting)    { d_riseOnClick = setting; }

    virtual void setLookNFeel(const String& look);

    void setModalState(bool state);

    virtual void performChildWindowLayout(bool nonclient_sized_hint = false,
                                          bool client_sized_hint = false);

    void setUserString(const String& name, const String& value);

    void render();

    virtual void update(float elapsed);
    
    virtual bool performCopy(Clipboard& clipboard);
    
    virtual bool performCut(Clipboard& clipboard);
    
    virtual bool performPaste(Clipboard& clipboard);

    virtual void writeXMLToStream(XMLSerializer& xml_stream) const;

    virtual void beginInitialisation(void)     {d_initialising = true;}

    virtual void endInitialisation(void)       {d_initialising = false;}

    void setMousePassThroughEnabled(bool setting)   {d_mousePassThroughEnabled = setting;}

    void setWindowRenderer(const String& name);

    WindowRenderer* getWindowRenderer(void) const;

    const String& getWindowRendererName() const;

    void setWritingXMLAllowed(bool allow)   {d_allowWriteXML = allow;}

    virtual void notifyScreenAreaChanged(bool recursive = true);

    void setFalagardType(const String& type, const String& rendererType = "");

    void setDragDropTarget(bool setting);

    void setRenderingSurface(RenderingSurface* surface);

    void invalidateRenderingSurface();

    void setUsingAutoRenderingSurface(bool setting);

    const RenderedString& getRenderedString() const;
    RenderedStringParser* getCustomRenderedStringParser() const;
    void setCustomRenderedStringParser(RenderedStringParser* parser);
    virtual RenderedStringParser& getRenderedStringParser() const;
    bool isTextParsingEnabled() const;
    void setTextParsingEnabled(const bool setting);

    virtual void setMargin(const UBox& margin);
    const UBox& getMargin() const;

    Vector2f getUnprojectedPosition(const Vector2f& pos) const;

    const BidiVisualMapping* getBidiVisualMapping() const
        {return d_bidiVisualMapping;}

    void banPropertyFromXML(const String& property_name);

    void unbanPropertyFromXML(const String& property_name);

    bool isPropertyBannedFromXML(const String& property_name) const;

    void banPropertyFromXML(const Property* property);

    void unbanPropertyFromXML(const Property* property);

    bool isPropertyBannedFromXML(const Property* property) const;

    void setUpdateMode(const WindowUpdateMode mode);

    WindowUpdateMode getUpdateMode() const;

    void setMouseInputPropagationEnabled(const bool enabled);

    bool isMouseInputPropagationEnabled() const;

    Window* clone(const bool deepCopy = true) const;

    virtual void clonePropertiesTo(Window& target) const;
    virtual void cloneChildWidgetsTo(Window& target) const;

    GUIContext& getGUIContext() const;
    void setGUIContext(GUIContext* context);

    void syncTargetSurface();

    void setAutoWindow(bool is_auto);

    bool isMouseContainedInArea() const;

    // overridden from Element
    const Sizef& getRootContainerSize() const;

protected:
    // friend classes for construction / initialisation purposes (for now)
    friend class System;
    friend class WindowManager;
    friend class GUIContext;

    /*************************************************************************
        Event trigger methods
    *************************************************************************/
    virtual void onSized(ElementEventArgs& e);

    virtual void onMoved(ElementEventArgs& e);
    
    virtual void onRotated(ElementEventArgs& e);

    virtual void onTextChanged(WindowEventArgs& e);

    virtual void onFontChanged(WindowEventArgs& e);

    virtual void onAlphaChanged(WindowEventArgs& e);

    virtual void onIDChanged(WindowEventArgs& e);

    virtual void onShown(WindowEventArgs& e);

    virtual void onHidden(WindowEventArgs& e);

    virtual void onEnabled(WindowEventArgs& e);

    virtual void onDisabled(WindowEventArgs& e);

    virtual void onClippingChanged(WindowEventArgs& e);

    virtual void onParentDestroyChanged(WindowEventArgs& e);

    virtual void onInheritsAlphaChanged(WindowEventArgs& e);

    virtual void onAlwaysOnTopChanged(WindowEventArgs& e);

    virtual void onCaptureGained(WindowEventArgs& e);

    virtual void onCaptureLost(WindowEventArgs& e);

    virtual void onInvalidated(WindowEventArgs& e);

    virtual void onRenderingStarted(WindowEventArgs& e);

    virtual void onRenderingEnded(WindowEventArgs& e);

    virtual void onZChanged(WindowEventArgs& e);

    virtual void onDestructionStarted(WindowEventArgs& e);

    virtual void onActivated(ActivationEventArgs& e);

    virtual void onDeactivated(ActivationEventArgs& e);

    virtual void onParentSized(ElementEventArgs& e);

    virtual void onChildAdded(ElementEventArgs& e);

    virtual void onChildRemoved(ElementEventArgs& e);

    virtual void onMouseEntersArea(MouseEventArgs& e);

    virtual void onMouseLeavesArea(MouseEventArgs& e);

    virtual void onMouseEnters(MouseEventArgs& e);

    virtual void onMouseLeaves(MouseEventArgs& e);

    virtual void onMouseMove(MouseEventArgs& e);

    virtual void onMouseWheel(MouseEventArgs& e);

    virtual void onMouseButtonDown(MouseEventArgs& e);

    virtual void onMouseButtonUp(MouseEventArgs& e);

    virtual void onMouseClicked(MouseEventArgs& e);

    virtual void onMouseDoubleClicked(MouseEventArgs& e);

    virtual void onMouseTripleClicked(MouseEventArgs& e);

    virtual void onKeyDown(KeyEventArgs& e);

    virtual void onKeyUp(KeyEventArgs& e);

    virtual void onCharacter(KeyEventArgs& e);

    virtual void onDragDropItemEnters(DragDropEventArgs& e);

    virtual void onDragDropItemLeaves(DragDropEventArgs& e);

    virtual void onDragDropItemDropped(DragDropEventArgs& e);

    virtual void onWindowRendererAttached(WindowEventArgs& e);

    virtual void onWindowRendererDetached(WindowEventArgs& e);

    virtual void onTextParsingChanged(WindowEventArgs& e);

    virtual void onMarginChanged(WindowEventArgs& e);

    /*************************************************************************
        Implementation Functions
    *************************************************************************/
    virtual void updateSelf(float elapsed);

    virtual void drawSelf(const RenderingContext& ctx);

    void bufferGeometry(const RenderingContext& ctx);

    void queueGeometry(const RenderingContext& ctx);

    virtual void populateGeometryBuffer()  {}

    virtual void setParent(Element* parent);

    void generateAutoRepeatEvent(MouseButton button);

    virtual bool validateWindowRenderer(const WindowRenderer* renderer) const;

    bool isPropertyAtDefault(const Property* property) const;

    void notifyClippingChanged(void);

    void allocateRenderingWindow();

    void releaseRenderingWindow();

    void initialiseClippers(const RenderingContext& ctx);

    virtual void setArea_impl(const UVector2& pos, const USize& size, bool topLeftSizing = false, bool fireEvents = true);
    
    virtual void cleanupChildren(void);

    virtual void addChild_impl(Element* element);

    virtual void removeChild_impl(Element* element);

    virtual void onZChange_impl(void);

    void    addWindowProperties(void);

    virtual bool moveToFront_impl(bool wasClicked);

    void addWindowToDrawList(Window& wnd, bool at_back = false);

    void removeWindowFromDrawList(const Window& wnd);
    
    bool isTopOfZOrder() const;

    void updateGeometryRenderSettings();

    void transferChildSurfaces();

    Rectf getParentElementClipIntersection(const Rectf& unclipped_area) const;

    void invalidate_impl(const bool recursive);

    const Window* getWindowAttachedToCommonAncestor(const Window& wnd) const;

    virtual Rectf getUnclippedInnerRect_impl(bool skipAllPixelAlignment) const;
    virtual Rectf getOuterRectClipper_impl() const;
    virtual Rectf getInnerRectClipper_impl() const;
    virtual Rectf getHitTestRect_impl() const;
    
    virtual int writePropertiesXML(XMLSerializer& xml_stream) const;
    virtual int writeChildWindowsXML(XMLSerializer& xml_stream) const;
    virtual bool writeAutoChildWindowXML(XMLSerializer& xml_stream) const;

    virtual void banPropertiesForAutoWindow();

    virtual bool handleFontRenderSizeChange(const EventArgs& args);

    // mark the rect caches defined on Window invalid (does not affect Element)
    void markCachedWindowRectsInvalid();
    void layoutLookNFeelChildWidgets();

    Window* getChildAtPosition(const Vector2f& position,
                               bool (Window::*hittestfunc)(const Vector2f&, bool) const,
                               bool allow_disabled = false) const;

    bool isHitTargetWindow(const Vector2f& position, bool allow_disabled) const;

    /*************************************************************************
        Properties for Window base class
    *************************************************************************/

    static
    class WindowRendererProperty : public TplWindowProperty<Window, String>
    {
    public:
        WindowRendererProperty();
        void writeXMLToStream(const PropertyReceiver* receiver,
                              XMLSerializer& xml_stream) const;
    } d_windowRendererProperty;

    static
    class LookNFeelProperty : public TplWindowProperty<Window, String>
    {
    public:
        LookNFeelProperty();
        void writeXMLToStream(const PropertyReceiver* receiver,
                              XMLSerializer& xml_stream) const;
    } d_lookNFeelProperty;

    /*************************************************************************
        Implementation Data
    *************************************************************************/
    typedef std::vector<Window*
        CEGUI_VECTOR_ALLOC(Window*)> ChildDrawList;
    typedef std::map<String, String, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, String)> UserStringMap;
    typedef std::set<String, StringFastLessCompare
        CEGUI_SET_ALLOC(String)> BannedXMLPropertySet;

    const String d_type;
    String d_falagardType;
    bool d_autoWindow;

    bool d_initialising;
    bool d_destructionStarted;
    bool d_enabled;
    bool d_visible;
    bool d_active;

    ChildDrawList d_drawList;
    bool d_destroyedByParent;

    bool d_clippedByParent;

    String d_lookName;
    WindowRenderer* d_windowRenderer;
    GeometryBuffer* d_geometry;
    RenderingSurface* d_surface;
    mutable bool d_needsRedraw;
    bool d_autoRenderingWindow;

    const Image* d_mouseCursor;

    float d_alpha;
    bool d_inheritsAlpha;

    Window* d_oldCapture;
    bool d_restoreOldCapture;
    bool d_distCapturedInputs;

    const Font* d_font;
    String d_textLogical;
    BidiVisualMapping* d_bidiVisualMapping;
    mutable bool d_bidiDataValid;
    mutable RenderedString d_renderedString;
    mutable bool d_renderedStringValid;
    static BasicRenderedStringParser d_basicStringParser;
    static DefaultRenderedStringParser d_defaultStringParser;
    RenderedStringParser* d_customStringParser;
    bool d_textParsingEnabled;

    UBox d_margin;

    uint d_ID;
    void* d_userData;
    UserStringMap d_userStrings;

    bool d_alwaysOnTop;
    bool d_riseOnClick;
    bool d_zOrderingEnabled;

    bool d_wantsMultiClicks;
    bool d_mousePassThroughEnabled;
    bool d_autoRepeat;
    float d_repeatDelay;
    float d_repeatRate;
    MouseButton d_repeatButton;
    bool d_repeating;
    float d_repeatElapsed;

    bool d_dragDropTarget;

    String d_tooltipText;
    Tooltip* d_customTip;
    bool d_weOwnTip;
    bool d_inheritsTipText;

    bool d_allowWriteXML;
    BannedXMLPropertySet d_bannedXMLProperties;

    mutable Rectf d_outerRectClipper;
    mutable Rectf d_innerRectClipper;
    mutable Rectf d_hitTestRect;

    mutable bool d_outerRectClipperValid;
    mutable bool d_innerRectClipperValid;
    mutable bool d_hitTestRectValid;

    WindowUpdateMode d_updateMode;

    bool d_propagateMouseInputs;

    GUIContext* d_guiContext;

    bool d_containsMouse;

private:
    /*************************************************************************
        May not copy or assign Window objects
    *************************************************************************/
    Window(const Window&): NamedElement() {}
    Window& operator=(const Window&) {return *this;}

    const Font* property_getFont() const;
    const Image* property_getMouseCursor() const;

    Event::ScopedConnection d_fontRenderSizeChangeConnection;
};

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#   pragma warning(pop)
#endif

#endif  // end of guard _CEGUIWindow_h_