text:
namespace tgui
{
    class Label;
    class ListBoxRenderer;

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// @brief List box widget
    ///
    /// Signals:
    ///     - ItemSelected (a new item was selected)
    ///         * Optional parameter sf::String: Name of the item (the text that is visible)
    ///         * Optional parameters sf::String and sf::String: Name and id of the item
    ///         * Uses Callback member 'text' and 'itemId'
    ///
    ///     - MousePressed (left mouse went down on top of an item
    ///         * Optional parameter sf::String: Name of the item (the text that is visible)
    ///         * Optional parameters sf::String and sf::String: Name and id of the item
    ///         * Uses Callback member 'text' and 'itemId'
    ///
    ///     - MouseReleased (left mouse went up on top of an item after it went down on of the items of the list box)
    ///         * Optional parameter sf::String: Name of the item (the text that is visible)
    ///         * Optional parameters sf::String and sf::String: Name and id of the item
    ///         * Uses Callback member 'text' and 'itemId'
    ///
    ///     - DoubleClicked (double clicked on an item with the left mouse button)
    ///         * Optional parameter sf::String: Name of the item (the text that is visible)
    ///         * Optional parameters sf::String and sf::String: Name and id of the item
    ///         * Uses Callback member 'text' and 'itemId'
    ///
    ///     - Inherited signals from Widget
    ///
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    class TGUI_API ListBox : public Widget
    {
      public:

        typedef std::shared_ptr<ListBox> Ptr; ///< Shared widget pointer
        typedef std::shared_ptr<const ListBox> ConstPtr; ///< Shared constant widget pointer

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Default constructor
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ListBox();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Copy constructor
        ///
        /// @param copy  Instance to copy
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ListBox(const ListBox& copy);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Overload of assignment operator
        ///
        /// @param right  Instance to assign
        ///
        /// @return Reference to itself
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ListBox& operator= (const ListBox& right);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Makes a copy of another list box
        ///
        /// @param listBox  The other list box
        ///
        /// @return The new list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        static ListBox::Ptr copy(ListBox::ConstPtr listBox);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
        ///
        /// @return Reference to the renderer
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        std::shared_ptr<ListBoxRenderer> getRenderer() const
        {
            return std::static_pointer_cast<ListBoxRenderer>(m_renderer);
        }

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the position of the widget
        ///
        /// This function completely overwrites the previous position.
        /// See the move function to apply an offset based on the previous position instead.
        /// The default position of a transformable widget is (0, 0).
        ///
        /// @param position  New position
        ///
        /// @see move, getPosition
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setPosition(const Layout2d& position) override;
        using Transformable::setPosition;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the size of the list box.
        ///
        /// @param size  The new size of the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setSize(const Layout2d& size) override;
        using Transformable::setSize;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the full size of the list box
        ///
        /// The size returned by this function includes the borders.
        ///
        /// @return Full size of the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual sf::Vector2f getFullSize() const override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the font of the text in the widget.
        ///
        /// @param font  The new font.
        ///
        /// When you don't call this function then the font from the parent widget will be used.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setFont(const Font& font) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Adds an item to the list.
        ///
        /// @param itemName  The name of the item you want to add (this is the text that will be displayed inside the list box)
        /// @param id        Optional unique id given to this item for the purpose to later identifying this item.
        ///
        /// @return
        ///         - true when the item was successfully added
        ///         - false when the list box is full (you have set a maximum item limit and you are trying to add more items)
        ///         - false when there is no scrollbar and you try to have more items than fit inside the list box
        ///
        /// @see setMaximumItems
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool addItem(const sf::String& itemName, const sf::String& id = "");

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Selects an item in the list box.
        ///
        /// @param itemName  The item you want to select
        ///
        /// In case the names are not unique, the first item with that name will be selected.
        ///
        /// @return
        ///         - true on success
        ///         - false when none of the items matches the name
        ///
        /// @see setSelectedItemById
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool setSelectedItem(const sf::String& itemName);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Selects an item in the list box.
        ///
        /// @param id  Unique id passed to addItem
        ///
        /// In case the id would not be unique, the first item with that id will be selected.
        ///
        /// @return
        ///         - true on success
        ///         - false when none of the items has the given id
        ///
        /// @see setSelectedItem
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool setSelectedItemById(const sf::String& id);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Selects an item in the list box.
        ///
        /// @param index  Index of the item in the list box
        ///
        /// @return
        ///         - true on success
        ///         - false when the index was too high
        ///
        /// @see setSelectedItem
        /// @see setSelectedItemById
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool setSelectedItemByIndex(std::size_t index);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Deselects the selected item.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void deselectItem();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Removes the item from the list with the given name.
        ///
        /// @param itemName  The item to remove
        ///
        /// In case the names are not unique, only the first item with that name will be removed.
        ///
        /// @return
        ///        - true when the item was removed
        ///        - false when the name did not match any item
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool removeItem(const sf::String& itemName);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Removes the item that were added with the given id.
        ///
        /// @param id  Id that was given to the addItem function.
        ///
        /// In case the id is not unique, only the first item with that id will be removed.
        ///
        /// @return
        ///        - true when the item was removed
        ///        - false when there was no item with the given id
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool removeItemById(const sf::String& id);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Removes the item from the list box.
        ///
        /// @param index  Index of the item in the list box
        ///
        /// @return
        ///        - true when the item was removed
        ///        - false when the index was too high
        ///
        /// @see removeItem
        /// @see removeItemById
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool removeItemByIndex(std::size_t index);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Removes all items from the list.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void removeAllItems();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the item name of the item with the given id.
        ///
        /// @param id  The id of the item that was given to it when it was added
        ///
        /// In case the id is not unique, the first item with that id will be returned.
        ///
        /// @return The requested item, or an empty string when no item matches the id
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        sf::String getItemById(const sf::String& id) const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the currently selected item.
        ///
        /// @return The selected item.
        ///         When no item was selected then this function will return an empty string.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        sf::String getSelectedItem() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Get the id of the selected item.
        ///
        /// @return The id of the selected item, which was the optional id passed to the addItem function.
        ///         When no item was selected then this function returns an empty string.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        sf::String getSelectedItemId() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Get the index of the selected item.
        ///
        /// @return The index of the selected item, or -1 when no item was selected
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        int getSelectedItemIndex() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes an item with name originalValue to newValue.
        ///
        /// @param originalValue The name of the item which you want to change
        /// @param newValue      The new name for that item
        ///
        /// In case the names are not unique, only the first item with that name will be changed.
        ///
        /// @return
        ///        - true when the item was changed
        ///        - false when none of the items had the given name
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool changeItem(const sf::String& originalValue, const sf::String& newValue);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the name of an item with the given id to newValue.
        ///
        /// @param id       The unique id of the item which you want to change
        /// @param newValue The new name for that item
        ///
        /// In case the id is not unique, only the first item with that id will be changed.
        ///
        /// @return
        ///        - true when the item was changed
        ///        - false when none of the items had the given id
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool changeItemById(const sf::String& id, const sf::String& newValue);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the name of an item at the given index to newValue.
        ///
        /// @param index    The index of the item which you want to change
        /// @param newValue The new name for that item
        ///
        /// @return
        ///        - true when the item was changed
        ///        - false when the index was too high
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool changeItemByIndex(std::size_t index, const sf::String& newValue);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the amount of items in the list box
        ///
        /// @return Number of items inside the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        std::size_t getItemCount()
        {
            return m_items.size();
        }

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Return a copy of the items in the list box
        ///
        /// @return items
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        std::vector<sf::String> getItems();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Return a copy of the item ids in the list box
        ///
        /// @return item ids
        ///
        /// Items that were not given an id simply have an empty string as id.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        const std::vector<sf::String>& getItemIds();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the scrollbar of the list box.
        ///
        /// @param scrollbar The new scrollbar to use in the list box
        ///
        /// Pass a nullptr to remove the scrollbar. Note that when removing the scrollbar while there are too many items
        /// to fit in the list box then the excess items will be removed.
        ///
        /// The scrollbar should have no parent and you should not change it yourself.
        /// The function is meant to be used like this:
        /// @code
        /// listBox->setScrollbar(theme->load("scrollbar"));
        /// @endcode
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setScrollbar(Scrollbar::Ptr scrollbar);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Access the scrollbar of the list box
        ///
        /// @return scrollbar in the list box
        ///
        /// You should not change the scrollbar yourself
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        Scrollbar::Ptr getScrollbar() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the height of the items in the list box.
        ///
        /// @param itemHeight  The size of a single item in the list
        ///
        /// @warning When there is no scrollbar then the items will be removed when they no longer fit inside the list box.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setItemHeight(unsigned int itemHeight);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the height of the items in the list box.
        ///
        /// @return The item height
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        unsigned int getItemHeight() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the text size of the items
        ///
        /// @param textSize  The size size of the text
        ///
        /// This will not change the height that each item has. By default (or when passing 0 to this function) the text will
        /// be auto-sized to nicely fit inside this item height.
        ///
        /// @see setItemHeight
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setTextSize(unsigned int textSize);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the text size of the items
        ///
        /// @return The text size
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        unsigned int getTextSize() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the maximum items that the list box can contain.
        ///
        /// @param maximumItems  The maximum items inside the list box.
        ///                      When the maximum is set to 0 then the limit will be disabled.
        ///
        /// If no scrollbar was loaded then there is always a limitation because there will be a limited space for the items.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setMaximumItems(std::size_t maximumItems = 0);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the maximum items that the list box can contain.
        ///
        /// @return The maximum items inside the list box.
        ///         If the function returns 0 then there is no limit.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        std::size_t getMaximumItems() const
        {
            return m_maxItems;
        }

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes whether the list box scrolls to the bottom when a new item is added
        ///
        /// @param autoScroll  Should list box scroll to the bottom when new items are added?
        ///
        /// Auto scrolling is enabled by default.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setAutoScroll(bool autoScroll);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the maximum items that the list box can contain.
        ///
        /// @return The maximum items inside the list box.
        ///         If the function returns 0 then there is no limit.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        bool getAutoScroll() const
        {
            return m_autoScroll;
        }

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the opacity of the widget.
        ///
        /// @param opacity  The opacity of the widget. 0 means completely transparent, while 1 (default) means fully opaque.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setOpacity(float opacity) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Returns the distance between the position where the widget is drawn and where the widget is placed
        ///
        /// This is basically the width and height of the optional borders drawn around widgets.
        ///
        /// @return Offset of the widget
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual sf::Vector2f getWidgetOffset() const override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual bool mouseOnWidget(float x, float y) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void leftMousePressed(float x, float y) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void leftMouseReleased(float x, float y) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void mouseMoved(float x, float y) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void mouseWheelMoved(int delta, int x, int y) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void mouseNotOnWidget() override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @internal
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void mouseNoLongerDown() override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    protected:

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Update the color of the items
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void updateItemColors();

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Reload the widget
        ///
        /// @param primary    Primary parameter for the loader
        /// @param secondary  Secondary parameter for the loader
        /// @param force      Try to only change the looks of the widget and not alter the widget itself when false
        ///
        /// @throw Exception when the connected theme could not create the widget
        ///
        /// When primary is an empty string the built-in white theme will be used.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void reload(const std::string& primary = "", const std::string& secondary = "", bool force = false) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Makes a copy of the widget
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual Widget::Ptr clone() override
        {
            return std::make_shared<ListBox>(*this);
        }

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // This function is called every frame with the time passed since the last frame.
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void update(sf::Time elapsedTime) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Draws the widget on the render target.
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    protected:

        // This contains the different items in the list box
        std::vector<Label>      m_items;
        std::vector<sf::String> m_itemIds;

        // What is the index of the selected item?
        // This is also used by combo box, so it can't just be changed to a pointer!
        int m_selectedItem = -1;

        int m_hoveringItem = -1;

        // The size must be stored
        unsigned int m_itemHeight = 22;
        unsigned int m_requestedTextSize = 0;
        unsigned int m_textSize = 18;

        // This will store the maximum number of items in the list box (zero by default, meaning that there is no limit)
        std::size_t m_maxItems = 0;

        // When there are too many items a scrollbar will be shown
        Scrollbar::Ptr m_scroll = std::make_shared<Scrollbar>();

        // Will be set to true after the first click, but gets reset to false when the second click does not occur soon after
        bool m_possibleDoubleClick = false;

        bool m_autoScroll = true;

        // ComboBox contains a list box internally and it should be able to adjust it.
        friend class ComboBox;
        friend class ListBoxRenderer;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    };

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    class TGUI_API ListBoxRenderer : public WidgetRenderer, public WidgetBorders, public WidgetPadding
    {
    public:

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Constructor
        ///
        /// @param listBox  The list box that is connected to the renderer
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ListBoxRenderer(ListBox* listBox) : m_listBox{listBox} {}

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Change a property of the renderer
        ///
        /// @param property  The property that you would like to change
        /// @param value     The new serialized value that you like to assign to the property
        ///
        /// @throw Exception when deserialization fails or when the widget does not have this property.
        /// @throw Exception when loading scrollbar fails with the theme connected to the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setProperty(std::string property, const std::string& value) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Change a property of the renderer
        ///
        /// @param property  The property that you would like to change
        /// @param value     The new value that you like to assign to the property.
        ///                  The ObjectConverter is implicitly constructed from the possible value types.
        ///
        /// @throw Exception for unknown properties or when value was of a wrong type.
        /// @throw Exception when loading scrollbar fails with the theme connected to the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setProperty(std::string property, ObjectConverter&& value) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Retrieve the value of a certain property
        ///
        /// @param property  The property that you would like to retrieve
        ///
        /// @return The value inside a ObjectConverter object which you can extract with the correct get function or
        ///         an ObjectConverter object with type ObjectConverter::Type::None when the property did not exist.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual ObjectConverter getProperty(std::string property) const override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Get a map with all properties and their values
        ///
        /// @return Property-value pairs of the renderer
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual std::map<std::string, ObjectConverter> getPropertyValuePairs() const override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the background color that will be used inside the list box.
        ///
        /// @param backgroundColor  The color of the background of the list box
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setBackgroundColor(const sf::Color& backgroundColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the text color that will be used inside the list box.
        ///
        /// @param textColor  The color of the text
        ///
        /// This color will overwrite the color for both the normal and hover state.
        ///
        /// @see setTextColorNormal
        /// @see setTextColorHover
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setTextColor(const sf::Color& textColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the color of the text in the normal state (mouse not on top of the item).
        ///
        /// @param color  New text color
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setTextColorNormal(const sf::Color& color);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the color of the text in the hover state (mouse is standing on top of the item).
        ///
        /// @param color  New text color
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setTextColorHover(const sf::Color& color);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the background color of the unselected item on which the mouse is standing.
        ///
        /// @param hoverBackgroundColor  The color of the background of unselected item below the mouse
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setHoverBackgroundColor(const sf::Color& hoverBackgroundColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the background color of the selected text that will be used inside the list box.
        ///
        /// @param selectedBackgroundColor  The color of the background of the selected item
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setSelectedBackgroundColor(const sf::Color& selectedBackgroundColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the text color of the selected text that will be used inside the list box.
        ///
        /// @param selectedTextColor  The color of the text when it is selected
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setSelectedTextColor(const sf::Color& selectedTextColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Set the border color text that will be used inside the list box.
        ///
        /// @param borderColor  The color of the borders
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setBorderColor(const sf::Color& borderColor);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the background image
        ///
        /// @param texture  New background texture
        ///
        /// When this image is set, the background color property will be ignored.
        /// Pass an empty string to unset the image, in this case the background color property will be used again.
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void setBackgroundTexture(const Texture& texture);

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// @brief Changes the padding of the list box.
        ///
        /// This padding will be scaled together with the background image.
        /// If there is no background image, or when 9-slice scaling is used, the padding will be exactly what you pass here.
        ///
        /// @param padding  The padding width and height
        ///
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual void setPadding(const Padding& padding) override;
        using WidgetPadding::setPadding;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Draws the widget on the render target.
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        void draw(sf::RenderTarget& target, sf::RenderStates states) const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    private:

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Returns the padding, which is possibly scaled with the background image.
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        Padding getScaledPadding() const;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // Makes a copy of the renderer
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        virtual std::shared_ptr<WidgetRenderer> clone(Widget* widget) override;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        ListBoxRenderer(const ListBoxRenderer&) = default;
        ListBoxRenderer& operator=(const ListBoxRenderer&) = delete;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    protected:

        ListBox*  m_listBox;

        Texture   m_backgroundTexture;

        sf::Color m_backgroundColor;
        sf::Color m_textColor;
        sf::Color m_hoverBackgroundColor;
        sf::Color m_hoverTextColor;
        sf::Color m_selectedBackgroundColor;
        sf::Color m_selectedTextColor;
        sf::Color m_borderColor;

        friend class ListBox;
        friend class ComboBox;
        friend class ComboBoxRenderer;

        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    };

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#endif // TGUI_LIST_BOX_HPP

redpajama_set_name: RedPajamaGithub


text:
Stonehenge: Decoded! ; or, What's so Secret about the Past?
by Mary Kate Hurley
[fig. 1: Aliens over Stonehenge, pilfered from the National Geographic site here]
If one searches ITM for "Stonehenge", a number of results come up, many associated with JJC's Weight of the Past project. I have not seen the special on the National Geographic Channel to which the title of this post refers to, though I'm hoping to catch it on a rebroadcast at some point. However, when I ran across Robin McKie's article on the Guardian entitled "Leave these stones their eternal secrets".
The article didn't really provoke much comment (or at least anything that was really productive), but I thought it might be of interest to ITM, particularly because of this part of McKie's process, which is in the ending of her article:
And that, of course, is the wonderful thing about Stonehenge: there are more theories about its meaning and purpose than there are stones inside it, a trend that goes right back to the idea, popular in the Middle Ages, that its monoliths had been assembled on Salisbury Plain by Merlin, though exactly why he bothered to do so remains a mystery.
In fact, Stonehenge took at least 1,000 years to build, starting from rings of wooden poles to its current complex status and its use clearly changed over the millenniums. Recent studies suggest it may have been 'Christianised' in the first millennium AD and at one point was used as a place of execution by the Anglo-Saxons to judge from the 7th-century gallows found there. This multiplicity of use increases opportunities for archaeologists to pin their pet theories to the great stone monument.
The crucial point is that every age gets the Stonehenge it deserves, as archaeologist Jacquetta Hawkes once remarked. Hence in medieval times, it was built by giants, while in the 1960s, at the dawn of the computing era, researchers said you could have used it as a giant calculating machine, while in more mystical New Age times, it was clearly a spaceport for aliens. 'In fact, you can come up with just about any idea to explain a structure like Stonehenge if you stare at it for long enough,' says archaeologist David Miles.
Just what that the latest patch of Stonehenge theories says about the 21st century is less clear. I would argue that the World Heritage site is probably best viewed today as a monument to government prevarication and deceit. Having promised a decade ago that it would bury and realign the roads that surround and disfigure Britain's most important ancient monument, ministers now seem to have abandoned any attempt to protect the monument and restore the site to its ancient glory, for the simple reason they are too mean-spirited and short-sighted to see its value.
What interests me here is the assertion, made clearer by the end of that final paragraph, that "every age gets the Stonehenge it deserves," commonly attributed to Jacquetta Hawkes. McKie makes an interesting point, though she doesn't really flesh it out. She seems to be arguing, if I read between her lines correctly, that every age dreams the Stonehenge it deserves -- or more likely, the Stonehenge that can speak to it, in that time, in that place.
Of course, "Stonehenge" is not really the monument it was at its building (whether by Merlin or under the influence of Aliens or as a burial ground), much less in its "original" usage -- rather, "Stonehenge" is a kind of shorthand, by which we mean all the things which intervened, the multiplicities of usages and all the "theories" about its origins that exist in the intervening time. The question McKie doesn't really ask, and the one which I think may be necessary to ask, is whether Stonehenge, World Heritage site, is important in and of itself, or only important in so far as "modernity" recognizes something in it.
It raises a question that I'm addressing in my current dissertation chapter, on time in the Old English Orosius. I'm planning another post on this, when I've figured out what it is I'm trying to do with Bakhtin, but there's this part of The Dialogic Imagination, in "Discourse in the Novel" that keeps obsessing me:
every word is directed toward an answer and cannot escape the profound influence of the answering word it anticipates…The word in living conversation is directly, blatantly, oriented toward a future answer-word: it provokes an answer, anticipates it and structures itself in the answer's direction. Forming itself in an atmosphere of the already spoken, the word is at the same time determined by that which has not yet been said but which is needed and in fact anticipated by the answering word. Such is the situation in any living dialogue. (280)
However, in his "Epic and Novel" (which I should really reread at some point, Bakhtin makes the point that "The dead are loved in a different way. They are removed from the sphere of contact, one can and indeed must speak of them in a different style. Language about the dead is stylistically quite distinct from language about the living."
It all returns to a question that for me is not really answerable: can there really be a conversation between the living and the dead -- the past and the present? Or is the past destined to be a kind of straw man, whose script is always written by the living?
Or is there a way in which past words -- or past monuments -- are, in an odd Bakhtinian* way still actively responding to a kind of "answering word its future" -- our present -- will provide? Can we expand a notion of a "living dialogue" so far?
M. M. Bakhtin, The Dialogic Imagination : Four Essays, University of Texas Press Slavic Series ; (Austin: University of Texas Press, 2004).
Cross posted at OENY.
Posted by Mary Kate Hurley at 8:14 PM
Labels: prehistory, stonehenge, time
I am hoping it will work if I post a link here to a neat-o video of the many phases of Stonehenge from the 'Time Watch' crew, at BBC:
http://www.bbc.co.uk/history/programmes/stonehenge/video.shtml?video=cgi
There are other interesting Stonehenge links on that page, too. This must be part of the current fantasy of Stonehenge: wanting to understand not just what it 'originally' was, but everything it ever was. Built in a day by Merlin, indeed! We much prefer the narrative of a millenium-long building project, whose aims no doubt changed considerably during that time. We positively revel in its many mutations and transformations, not to mention its many avatars in different cultural moments throughout its history.
Steve Muhlberger said...
Certainly the "dead past" can be treated as a straw man, but haven't you been surprised by evidence of the past?
If you have, doesn't that answer your question?
Mary Kate, thanks for this post on a topic near to my heart. I like how you brought Bakhtin into it, as well as your sensitivity towards the temporal orientation of the monument. It is interesting how every age makes it own Stonehenge, and I am going to agree with Sylvia that "our" Stonehenge is multitemporal/multicultural -- that is, stresses the cohabitations of peoples and times that cluster around the stone. Those kinds of cohabitations are precisely the ones, in our most utopian moments, we imagine for our nations.
Sylvia, great link. I have just finished reading an article in National Geographic that is rather skeptical of the "prehistoric Lourdes" hypothesis, mainly for the absence of disabled bodies ... but who knows. The essay (which is quite good) also looks at the source of the bluestones on the Preseli Mountains in Wales, where Stonehenge-like standing rocks occur naturally and where springs have from time out of memory been associated with healing. I like the idea that nature made the first standing stones, and that Stonehenge is just the human version of this art.
...can there really be a conversation between the living and the dead -- the past and the present? Or is the past destined to be a kind of straw man, whose script is always written by the living?
What a wonderful way to phrase this question. It is certainly a mystery that confounds and inspires both intellect and spirit.
I enjoyed your post very much - thanks!
Inapposite Art
Repatriate the Bayeux Tapestry!
3 Leeds IMC Announcements
A Not-So-Brief History of Time: Daniel Smail on De...
The World Without Us: Kid Version. Medieval Version?
The price of scholarly publishing
Albert Camus, Amy Winehouse, Baudelaire, destructi...
Woofing and Weeping with Animals in Ava's Das Jüng...
Gender Trouble [Again]: If It's July, I Must be in...
4 postcards from Orlando, Florida
Saving Beowulf, or, Stories of Love and/or Loss?
The Tiny Shriner-palooza, or, What's Bothering Me ...
Beware the Zybo, Victorious 'Wulfers
Chillout Tuesdays: What is Your Oasis?
The Map of Love: Let Us Now Speak of Fathers
ITMBC4DSoMA 2 Victor + New Poll
Blogging is more than its own reward
ITMBC4DSoMA 2: vote now
Cinesexuality
And the Votes are In!
"a desperate wishing that I might somehow live ins...
False Victims, Inwardly Ravening Rulers
Eileen scolded us for not reading enough poetry
Stonehenge: Decoded! ; or, What's so Secret about ...
Of Hospitals, Waiting Rooms, and Singular Unable B...
ITMBC4DSoMA 2: You decide
DC snapshot
Pleasure reading
Start Voting for Me or the Tiny Shriner Dies
Look to your right ...

redpajama_set_name: RedPajamaCommonCrawl


LOS ANGELES (July 23, 2008) – The record-setting Amgen Tour of California professional cycling road race will be expanded in 2009, race presenter AEG announced today through a series of press conferences throughout the state. The 2009 race will include stops in 16 host cities over the course of nine days from February 14-22. Already considered cycling's most important and successful road race in the United States, the event's fourth running will be expanded to cover more than 800 miles over the nine days. Traveling almost the entire length of California, the race will begin in the state's capital, Sacramento, and end in San Diego County (a new addition to the race) with a finish in Escondido on February 22. Also for the first time, the riders will cross the Golden Gate Bridge at the beginning of Stage 3.
The 16 official stage start and finish cities that have been selected for the 2009 race include eight new locales – Davis, Santa Cruz, Merced, Clovis, Visalia, Paso Robles, Rancho Bernardo and Escondido – that will join Sacramento, Santa Rosa, Sausalito, San Jose, Modesto, Solvang, Santa Clarita and Pasadena as host cities along the route.
Stage Two of the race will start in Davis and end in Santa Rosa on Sunday, February 15. "Since the Amgen Tour of California's inception - when it was still just being floated as an idea - Santa Rosa has embraced this race as a wonderful opportunity. This race is an opportunity to showcase California in all its beauty, to highlight the benefits of cycling on the environment and for personal well being, and an opportunity to elevate the Breakaway from Cancer cause supported by this event," said Santa Rosa Mayor John Sawyer. "In our fourth year of participation we have seen this race steadily capture the hearts and minds of the community, becoming a rally cry for all the event symbolizes. Spirit, courage, health, integrity, passion... the ATOC symbolizes all of Santa Rosa's most important values."
In its first three years, the Amgen Tour of California has become the most successful race in the United States with regards to attendance, economic benefits to the state, global recognition and the caliber of the cyclists participating. In 2008, the race drew 1.6 million spectators, continuing to set records for a single sporting event in the state of California, as well as any cycling event ever held on U.S. soil. Each year the race has generated $100 million in economic growth for the state.
The Amgen Tour of California kicks off the professional road cycling season each year and continues to draw some of the world's most renowned and respected riders, such as top Tour de France competitors, World Champions and Olympic medalists that include Tom Boonen, Paolo Bettini, Fabian Cancellara, George Hincapie, Oscar Freire and Bobby Julich. Winner of the 2007 and 2008 Amgen Tour of California, Santa Rosa resident Levi Leipheimer of the Astana team has had a strong season since his Amgen Tour of California victory earlier in the year and will next be representing the United States in the Olympic Games.
Last month AEG, presenter of the race, formed a multi-dimensional marketing partnership with the Amaury Sport Organisation (ASO), owner of the Tour de France, to grow and develop each other's events. Beginning with the 2008 Tour de France and 2009 Amgen Tour of California, the multi-year agreement calls for the organizations to develop and initiate comprehensive cross-promotional platforms for the world's most prestigious cycling event and America's most successful cycling race, as well as provide assistance with media and sponsorship sales for the races in their respective regions.
Returning for the fourth consecutive year as the title sponsor of the Amgen Tour of California, Amgen, a leading global biotechnology company with headquarters in Thousand Oaks, Calif., will continue to leverage the race to raise awareness and support for people affected by cancer through the Breakaway from CancerTM initiative. Amgen's invaluable support of the Amgen Tour of California has helped to ensure the race's continued success and impact beyond the sporting arena.
"Sponsorship of the Amgen Tour of California has given Amgen the opportunity to educate people about the great advances in medicine made possible by biotechnology, and to strengthen our relationships with local communities, cancer support organizations and cancer survivors through our Breakaway from Cancer initiative," said George Morrow, Amgen's executive vice president, Global Commercial Operations. "We look forward to another great race in 2009 and the opportunity to again lead the Breakaway from Cancer initiative to increase awareness of the support and educational resources available to help people living with cancer."
Having been sanctioned by the UCI (Union Cycliste International) and USA Cycling, the Amgen Tour of California has drawn the attention of both cycling enthusiasts and first-time spectators, making it one of the most anticipated events on the international cycling calendar.
Since its 2006 inaugural, the Amgen Tour of California has become one of the pre-eminent professional cycling events in the world with over 100 international cyclists traversing over 700 miles of scenic state highways, back roads and coastline from northern to southern California. An extra day and more varied terrain have been added to the route for 2009 which now starts in Sacramento.
Riding for Team Astana, legendary cyclist and 7-time winner of the Tour de France, Lance Armstrong will be in the peloton, as will ATOC defending champion Levi Leipheimer of Santa Rosa. It will be Armstrong's first race on U.S. soil since coming out of retirement.
The 2008 event drew 1.8 million spectators – the record for a single sporting event in the State of California, as well as for any cycling event ever held in the U.S. Tour officials estimated that the 2008 race generated $100 million in economic growth for the state. Local merchants in Sausalito also benefited from the influx of visitors over the race weekend.
With stunning bay vistas and waterfront views, and now the Golden Gate Bridge, Sausalito will once again provide a dramatic backdrop for the Amgen Tour of California. The city is again planning a week of race-related activities for locals and visitors alike including the popular Tour de Cuisine.
Amgen discovers, develops and delivers innovative human therapeutics. A biotechnology pioneer since 1980, Amgen was one of the first companies to realize the new science's promise by bringing safe and effective medicines from lab, to manufacturing plant, to patient. Amgen therapeutics have changed the practice of medicine, helping millions of people around the world in the fight against cancer, kidney disease, rheumatoid arthritis, and other serious illnesses. With a broad and deep pipeline of potential new medicines, Amgen remains committed to advancing science to dramatically improve people's lives. To learn more about Amgen's pioneering science and vital medicines, visit www.amgen.com.


text:
Q: Waiting for Hazelcast cache to complete rebalancing during a blue/green deploy In my setup I have two instances of an application that are both up and processing requests at the same time, using Hazelcast to share state and locking. The setup is default in that all the data is on both nodes with 50% being live, 50% being a backup for the other node.
I wish to add blue/green deployment to my setup such that, I can deploy a new version with no interruptions in processing requests and without loosing any data/processing requests erroneously.
During a deploy, I would bring down one instance of the application, meaning the remaining instance will now have 100% of the live data and process requests with that. If anything were to go wrong with that instance, I'd loose all my data (I have no backup setup) - I'm happy accepting this risk.
Once I bring up the new version instance of the application, Hazelcast should start to rebalance the cache, such that its 50% live and 50% backup on each instance again. It is at this point I want to block and wait until the rebalance is fully complete before I advertise the new instance as live. When complete, the new instance has 50% of the live data and 50% as backup.
When rebalancing is complete, I can then bring down the second version, bring up the new version, Hazelcast would initialize a rebalance, I'd block, wait for the rebalance to complete, then advertise the second instance as live.
My blue/green deployment would now be complete.
The question: how do I block the new instance until the rebalance in complete (it's received all the data)?

A: Hazelcast automatically rebalances and creates backups as needed as you add/remove members, you don't need to do any additional configuration. Important point is to do graceful shutdowns to avoid data loss during rollover of members.
Ways to shut down a member gracefully:

*

*You can call the method HazelcastInstance.shutdown() programatically.

*You can use JMX API's shutdown method. You can do this by implementing a JMX client application or using a JMX monitoring tool (like JConsole).

*You can set the property hazelcast.shutdownhook.policy to GRACEFUL and then shutdown by using kill -15 . Your member will be gracefully shutdown.

*You can use the "Shutdown Member" button in the member view of Hazelcast Management Center if you're using it.

OTOH, Hazelcast wise you don't need to block a member during this process. Is this an application specific requirement?

redpajama_set_name: RedPajamaStackExchange


Queen Size Sleeper - TOP 10 Results for Price Compare - Queen Size Sleeper Information for April 23, 2019.
Luxurious Finish 500 Thread Count Comfortable Sleeper Sofa Bed Sheets Set, Egyptian Cotton - Solid Light Blue ( Queen Size 60"x74"x 5"
Package Contains 1-Piece Fitted Sheet, 1-Piece Flat sheet and 2-Piece Pillowcases only. 500 Thread count Cotton !! Modify your home decor with this beautifully designed bed linen set. Enhance the ambience of your home with this brightly hued marvel. Crafted with exquisite fabrics, this bed linen will define your fashion choices !!
Don't satisfied with search results? Try to more related search from users who also looking for Queen Size Sleeper: Worx Intake Grate, Prestige Combination, Strawberry Blueberry Muffins, Shot Glass Blank, Wool Table Runner.
Queen Size Sleeper - Video Review.


text:
CROSSTASTEmovies absolutely needs Javascript to be enabled!
Please don't disable it if you want to use this site properly.
Search	 movie user
Quiz >
High-Scores
Movie images
Four trailers
Latest movie rates
Most recent users
Random users
One random user
Movies with "Anne Hathaway" (15)
''Serenity'' (2019)
Thriller, Mystery, Drama
Directed by Steven Knight
With Matthew McConaughey and Anne Hathaway The quiet life of Baker Dill, a fishing boat captain who lives on the isolated Plymouth Island, where he spends his days obsessed with capturing an...[+]
''The Intern'' (2015)
Directed by Nancy Meyers
With Anne Hathaway, Robert De Niro and Nat Wolff 70-year-old widower Ben Whittaker has discovered that retirement isn't all it's cracked up to be. Seizing an opportunity to get back in the game,...[+]
''Song One'' (2014)
Drama, Music
Directed by Kate Barker-Froyland
With Anne Hathaway, Mary Steenburgen and Lola Kirke A young woman strikes up a relationship with her ailing brother's favorite musician.
''Interstellar'' (2014)
Adventure, Sci-Fi
Directed by Christopher Nolan
With Matthew McConaughey and Anne Hathaway In the near future Earth has been devastated by drought and famine, causing a scarcity in food and extreme changes in climate. When humanity is...[+]
''Les Misérables'' (2013)
Drama, Music, Romance
Directed by Tom Hooper
With Anne Hathaway and Helena Bonham Carter An adaptation of the successful stage musical based on Victor Hugo's classic novel set in 19th-century France, in which a paroled prisoner named...[+]
''Rio'' (2011)
Directed by Carlos Saldanha
With Jesse Eisenberg and Anne Hathaway When Blu, a domesticated macaw from small-town Minnesota, meets the fiercely independent Jewel, he takes off on an adventure to Rio de Janeiro with...[+]


text:
Home > Nature and biodiversity > Dolphins
[NB10] Dolphins
Estimated density of the population of bottlenose dolphins (Tursiops truncatus) in Slovenian territorial waters has been relatively stable since 2004, with an annual density estimate of 0.068-0.07 specimen per square km or around 70 dolphins per year on average.
Slovenian territorial waters regularly host the local dolphin population throughout the entire year. Due to their mobile lifestyle, however, dolphins can also be seen beyond Slovenian maritime borders, in Italian and Croatian waters.
The parameter indicates the status of the population of bottlenose dolphins (Tursiops truncatus) in Slovenia and, indirectly, the conservation status of their natural habitat.
The estimates regarding the status of the population of bottlenose dolphins are based on the number of specimen and the density of the population, and the overall trends of these two indicators. For example, a low number of specimen in the population or the decrease in its number indicates poor conditions of the marine environment. On the contrary, a population large and stable enough (or increasing even) bears prof of sufficiently beneficial environment for its living.
The size and status of the dolphin population in Slovenia may be affected by the following factors:
1.	Natural (food provision, mating season)
2.	Human (see below)
The following human factors may potentially affect the dolphin population in Slovenian waters:
1.	Excessive fishing (leading to lack of food)
2.	By-catch (unintended catch) and direct injury and death to dolphins which get entangled in fishing nets
3.	Pollution (higher disease rate, higher mortality rate, lower reproductive capability)
4.	Marine traffic (noise, stress, change in behavior, higher energy consumption, disruption of normal vital functions, loss of habitat).
Definition of favourable conservation status
The EU Directive on habitats defines a favourable conservation status to be such that population dynamics data on the species concerned indicate that it is maintaining itself on a long-term basis as a viable component of its natural habitats, and the natural range of the species is neither being reduced nor is likely to be reduced for the foreseeable future, and there is, and will probably continue to be, a sufficiently large habitat to maintain its populations on a long-term basis.
The problem occurs where the criteria to determine the conservation status of a population are limited to recent trends and development (covering the last 6 years or less), as this can somewhat distort the real situation in certain cases; if a population decreased slowly, yet persistently, in size in the past only to reach a certain low, although stable, number in the past years, this should not be deemed to constitute a favourable conservation status.
Given the fact that data on the status of the population of bottlenose dolphins in Slovenian waters (and the Adriatic as a whole) has only become available recently (Genov et al. 2008), whereas the number of dolphins in the Adriatic sea has spiked in the past 30 years (Bearzi et al., 2004), this data does not provide sufficient basis in determining the initial status, which would probably be assessed as favourable to the species or population in this area.
It is thus important to focus on the best available data and prevent further deterioration, until further research allows a more detailed definition of a favourable conservation status of the aforementioned population to be devised and helps us pinpoint the actual negative impacts on the population.
Research during 2002 through 2008 show that the population of bottlenose dolphins more or less regularly present in Slovenian waters includes at least 69 specimen, with the density of the population reaching above 0.069 (specimen per suqare km).
Figure NB10-1: Eastimated density of the dolphin population
Morigenos – Marine mammal research and conservation society, 2009
density number/km2 0.069 0.068 0.09 0.049 0.069
annual estimate of animals number 38 68 108 68 69
study area km2 550 1000 1200 1400 1000
- One of the main objectives defined in the Resolution on National Environmental Action Plan 2005-2012 (NPVO) is the protection and preservation of natural systems, habitats, of wild flora and fauna, to prevent the loss of biodiversity and genetic diversity. The Resolution also aims to »preserve or attain favourable conservation status of endangered species and habitat types.«
-All types of cetaceans (including bottlenose dolphins - Tursiops truncatus) are included in Appendix I to the Decree on protected wild animal species, which is the executive act under the Nature Conservation Act, and are thereby protected. Pursuant to the aforementioned Decree, the status of species from Appendix I must be monitored, especially as regards the natural range of the animal species, the size and density of the population, and any activities, actions, interventions or phenomena, which have an adverse effect on the status of conservation of the species, including unintentional capture or killing of the animal.
- The Republic of Slovenia is a party to the international Agreement on the Conservation of Cetaceans of the Black Sea, the Mediterranean Sea and the Contigeous Atlantic Area (ACCOBAMS), and is thereunder engaged in monitoring of species of cetaceans and dolphins so as to ensure favourable conservation status.
- The red list of endangered species in the Republic of Slovenia lists bottlenose dolphins as endangered (E). Conservation measures are primarily focused on presumably extinct, endangered, vulnerable and rare species of flora and fauna.
- Bottlenose dolphins are also listed in Appendix II to the EU Directive on habitats, meaning its conservation is in the interest of the Community and special areas should be designated for their conservation.
The main objective to attain in this area is therefore to preserve and guarantee favourable conservation status for the population of bottlenose dolphins in Slovenian territorial waters so as to mitigate negative impact on the population.
This could also contribute to ensuring favourable conservation status for other species within the same ecosystem, thereby preserving biodiversity.
Data available thusfar on the population of bottlenose dolphins (Tursiops truncatus) in Slovenian waters are presented in Genov et al. (2008) and are summarised below.
Bottlenose dolphins use Slovenian waters in all seasons and can be seen during nearly every month of the year. Due to Slovenian geographical and political attachment to Croatia and Italy, the animals also enter Italian and Croatian waters daily, meaning that a common approach is necessary to protect these animals populating a common area.
Natural marks on dorsal fins allowed for the identification of 101 specimen, and data show that approximately 75% of the population can be identified in this manner. Gender was determined for 18 females and 2 males, whereas it remains unknown for 81 specimen of the population. Some specimen rarely use the area, while others have been spotted every year and are therefore defined as residents.
The estimated size of the population for individual years is presented in NB10-1 Diagram and Table. 2005 and 2008 have been assessed as the most robust, making the estimates therein the most reliable (68 specimen in 2005 and 69 specimen in 2008). The density of the population was 0.068 specimen per square km in 2005, and 0.069 in 2008. Density and use of the area vary in time, which is normally the case with bottlenose dolphins. Nevertheless, the density in individual years was more or less stable (except in 2006, where a far wider area was included in the sample, and in 2007, where the density was lower because a lower number of specimen was spotted). A detailed explanation of the estimated density of the population in individual years is provided for in Genov et al. (2008). The aforementioned variations make it more difficult to project the future development of the phenomenon.
The size of groups ranges between 1 to 43 specimen, with 8 specimen in a group on average. Most (88.9%) of the groups include 15 specimen or less. Although groups constantly mix and change, some specimen can be traced to relatively stable groups. Offspring has been noticed in 53.3% of groups. Some newborn dolphins are reported of every year, and records show two instances of offspring mortality.
Dolphins use the area to feed, play, rest, and also to breed and raise calves.
Interactions between dolphins and the fishing sector are common, but by-catch of dolphins in fishing nets is a rare phenomenon in Slovenia.
The only other known and documented resident population of bottlenose dolphins in the Adriatic Sea is the one in the Lošinj–Cres archipelago (Croatia); it is estimated to include 100-130 specimen (Bearzi et al., 1997; Fortuna, 2006). Other areas in the Adriatic Sea have not yet been explored in this regard.
There are several populations of bottlenose dolphins documented in EU area but comparison is difficult because of different geographical features.
Data for Slovenia
Source database or source: Morigenos – marine mammal research and conservation society
Data administrator: Morigenos – marine mammal research and conservation society, Jarška cesta 36/a, SI-1000 Ljubljana; contact: Tilen Genov
Data acquisition date for this indicator: 18 July 2009
Methodology and frequency of data collection for the indicator (Genov et al., 2008): Land-based (between 67 and 82 times since 2004) and boat-based (between 24 and 63 times since 2004) surveys were carried out. Further information on the frequency of data collection are available in Genov et al. (2008).
Due to weather and logistic considerations, most observations were carried out during the summer. Boat-based surveying was carried out from boats at a constant speed (25 to 30 km/h). Land-based surveys were carried out at high coastal points with binoculars. The position of the boat and of the dolphins were established by GPS. "Sighting" was defined as an uninterrupted continuous observation of a dolphin focal group.
Survey conditions were considered good if a) the sea state of Beaufort scale was 2 or less; b) at least one experienced observer searched for dolphins (usually 2–5 other observers could participate in the search); c) visibility was not reduced by heavy fog or precipitation. If survey conditions did not match these criteria, no systematic search for dolphins was carried out. During each survey, navigation and environmental data (time, position, sea state, etc.) were collected every 15 minutes or whenever the direction or conditions of the search changed. When dolphins were found, the tracking of the group begins. The boat had to approach the group slowly and remain parallel to the group, and the steering of the craft must be in accordance with protocol, without upsetting the animals.
Standard photo identification was carried out upon each sighting (Würsig, Jefferson, 1990). Natural marks on the dorsal fin (nicks, notches and scars) were used to identify individual specimen. Photos of each animal record the presence of specimen.
Data on position, time, size of group, offspring, behaviour, breathing patterns, and interactions with fishing activities and marine traffic were recorded upon each observation. The size of groups was assessed on the spot and later supported by photo identification.
Data processing methodology (Genov et al., 2008): Over 10,000 photographies were taken, analysed, marked and sorted during the research phase. New photos were optically scanned and compared to earlier photos. Two catalogues arose from this, one including all photographies in chronological order, and the other containing the best photos of each individual specimen. To avoid any bias in analysing the size and density of the population, only the well marked specimen on high-quality photographies were taken into account. Every specimen was given a name for further reference. Data on spotting identified specimen were used in the mark-recapture method on a closed population (Otis et al., 1978) to establish the size and density of the population. MARK 4.3 computer software was used in the process. Photo identification data in individual observations were catalogued in two groups of observations' history: one for 15 days, and the other 30 days. These two time frames were set as a good compromise between the need for sufficient data and the need to allow animals to mix during sampling. The most suitable model was chosen based on χ2 test (chi-square goodness-of-fit test), which is implemented within the framework of the MARK programme. The annual estimated size of the population, includng offspring, were calculated based on the assessed number of marked animals and the share of non-marked specimen within the population.
- Advantages of the indicator: the estimated annual size of the population is a suitable indicator, as it relies on unified methodology and reflects relatively well the real situation, provided field work is carried out regularly.
- Disadvantages of the indicator: natural variability in density and use of any given area (due to the species's social nature and tendency to adapt to the presence and accessibility of the prey) by the bottlenose dolphine can lead to some variations, which must be accounted for in the interpretation of the results.
- Overall assessment (1 = no major comments, 3 = data to be considered with reservation):
Monitoring and guaranteeing a favourable conservation status of the bottlenose dolphins population is required by the secondary acts issued on the basis of the Nature Conservation Act, in Directive on habitats, the Resolution on National Environmental Action Plan 2005-2012 (NPVO) and the international Agreement on the Conservation of Cetaceans of the Black Sea, the Mediterranean Sea and the Contigeous Atlantic Area (ACCOBAMS).
Data collection and analysis are carried out through internationally accepted standard methodology.
Each data string is 6 years long; each additional year of research will contribute to higher comparability of data.
As Slovenian territorial waters cover but a small geographic area, while bottlenose dolphins often cross national borders, the population of the entire area (thus beyond Slovenian waters) must be considered as a whole.
• Bearzi, G., D. Holcer & G. Notarbartolo di Sciara (2004): The role of historical dolphin takes and habitat degradation in shaping the present status of northern Adriatic cetaceans. Aquatic Conservation: Marine and Freshwater Ecosystems, 14, 363–379.
• Bearzi, G., G. Notarbartolo di Sciara, & E. Politi (1997): Social ecology of bottlenose dolphins in the Kvarneric (northern Adriatic Sea). Marine Mammal Science, 13, 650–668.
• Fortuna, C. M. (2006): Ecology and conservation of bottlenose dolphins (Tursiops truncatus) in the north-eastern Adriatic Sea. PhD thesis, University of St. Andrews, Scotland. 256 pp.
• Genov, T., Kotnjek, P., Lesjak, J., Hace, A. & C. M. Fortuna (2008). Bottlenose dolphins (Tursiops truncatus) in Slovenian and adjacent waters (northern Adriatic Sea). Annales, Series Historia Naturalis, 18(2), 227-244. (1,12 MB)
• Otis, D. L., K. P. Burnham, G. C. White & D. R. Anderson (1978): Statistical inference from capture data on closed animal populations. Wildlife Monographs 62. 137 pp.
• Würsig B. & T. A. Jefferson (1990): Methods of photo-identification for small cetaceans. Report of the International Whaling Commission, Special Issue, 12, 43–52.
• Council Directive 92/43/EEC of 21 May 1992 on the conservation of natural habitats and of wild fauna and flora
• Pravilnik o uvrstitvi ogroženih rastlinskih in živalskih vrst v rdeči seznam. Uradni list RS, št. 82/2002 (Rules on the inclusion of endangered plant and animal species in the Red List. Official Journal of the Republic of Slovenia, 82/02)
• Resolucija o Nacionalnem programu varstva okolja 2005-2012 (ReNPVO). Uradni list RS, št. 2/2006 (Resolution on National Environmental Action Plan 2005-2012 (ReNPVO. Official Journal of the Republic of Slovenia, 2/06)
• Uredba o zavarovanih prosto živečih živalskih vrstah. Uradni list RS, št. 46/04 (Decree on protected wild animal species. Official Journal of the Republic of Slovenia, 46/04)
• Zakon o ratifikaciji Sporazuma o ohranjanju kitov in delfinov Črnega morja, Sredozemskega morja in atlantskega območja ob njem (MSOKD). Uradni list. RS-MP, št. 16/06 (Act ratifying the Agreement on the Conservation of Cetaceans of the Black Sea, Mediterranean Sea and Contiguous Atlantic Area (ACCOBAMS). Official Journal of the Republic of Slovenia RS-MP, 16/06)
[NB02] Threatened species
Author(s): Tilen Genov, Morigenos – Marine mammal research and conservation society


text:
The Prediction: Washington Huskies vs. Oregon State Beavers Football
Will Oregon State become Washington's latest victims of a demoralizing blowout defeat?
By Ryan Priest, Chris Landon, John Sayler, and Gabey Lucas Sep 29, 2017, 1:02pm PDT
Share All sharing options for: The Prediction: Washington Huskies vs. Oregon State Beavers Football
Photo by Otto Greule Jr/Getty Images
The Washington Huskies travel this week to Corvallis, Ore., where they will take on arguably the Pac-12's most woeful team in the Oregon State Beavers. In what is something of a recurring theme with regard to Washington's opponents so far this year, few expect this game to be much of a contest, as ESPN's Football Power Index gives the Dawgs a 97.1 percent chance to win while Vegas has the Huskies as 26.5-point favorites over their Pac-12 North opponent. Do the UW Dawg Pound writers see a competitive game in store?
Ryan Priest
I'm not going to bury the lede here: Washington is going to win this game, and they're going to win it decisively.
At the start of this season, Oregon State fans had more than a few reasons to think that their program was ready to take the next step. Head coach Gary Andersen's rebuilding project was entering into its third year; stud running back Ryan Nall seemed poised to build upon his 15-touchdown sophomore season; and the program snapped a five-game losing skid last November by rattling off two consecutive wins over Arizona and Oregon.
Fast forward to the present day, and just one of those circumstances seems well positioned to pay dividends. Nall is averaging a shade over six yards per carry and has found the end zone four times in as many games, but the Beavers are just 1-3 after losing to Colorado State, Minnesota and Washington State by a combined score of 158-64.
As you might imagine, the lion's share of Oregon State's problems this year fall on the defensive side of the ball. With four games down, the Beavers have yielded 6.39 yards per play (ranked 113th nationally among 130 FBS teams), 47.5 points per game (127th), and possess a turnover margin of negative-six (120th). In Jake Browning, they'll face a quarterback who is 2-0 against them with a career stat line of 32 completions on 48 attempts (67 percent) for 502 yards, seven touchdowns and zero interceptions.
Even if Washington's passing game doesn't live up to its billing, there is little reason to think that Myles Gaskin shouldn't potentially have another career day. The Beavs so far this season have surrendered 4.65 yards per carry and 11 rushing touchdowns, figures that rank 97th and 117th nationally, respectively.
In other words, this is a name-your-score type of game, which Chris Petersen always manages to keep from turning into an utter embarrassment for the opposing program. (Well, almost always.) I'd be shocked if Oregon State leads for a second of this contest, but I also think they cover the point spread due to nothing else than Petersen taking his foot off the gas somewhere around halftime. Washington 41, Oregon State 17.
Chris Landon
One truism in college football is that your opponent is never quite as good ... or as bad ... as the fan base perceives them to be.
I'm not sure that this principle applies to the 2017 Oregon State Beavers.
For whatever reason, the Beavers have not been able to capitalize on the momentum they claimed at the end of last season. Maybe it is because of the insertion of a new QB in the now-injured Jake Luton. Maybe it is because of the injuries. Maybe it is all the new players they've worked in on D.
What I do know is that I have a certain discomfort with this matchup. Let's count the reasons: Darrell Garretson is back at QB which almost certainly means that OSU will retrench around the rushing attack. They still have man-child Ryan "Wrecking" Nall. Noah Togiai has emerged as a legit weapon at TE (posing the first true TE test UW has seen all year). The weather is going to suck.
Notice that I mentioned nothing about the OSU defense because, well, there is no hope for them on that side of the ball.
And that, my friends, is why UW wins no matter what progress OSU's offense makes on Saturday.
Gekko's Pick: UW 45, OSU 17
John Sayler
For the fourth time in five games so far this season, the Huskies play a team they should demolish.The weather forecast for Saturday evening in Corvallis calls for 65 degrees and cloudy. The football forecast calls for UW domination from the opening snap. The Beavers are going to be ready and will treating this game like their Rose Bowl.
I think the Beavs play well in this game and it won't be over in the first quarter, but it will be getting closer to that by halftime. Ryan Nall is a legit running back and between him and Darell Garretson OSU will get a little bit of a running game going early. If Oregon State can avoid giving up the big play and possibly generate one or two of their own, they will be able to keep things interesting for a half.
Second half, UW unleashes the running game, Garretson makes a few mistakes, and K.J. Carta-Samuels is snapping his chinstrap in the 3rd quarter.
UW 45, OSU 13
Gabey Lucas
A lot to very little. I feel like I tend to predict things as closer than they end up so it's nice being 100% confident in this one.
I can't imagine the Oregon State offense is gonna be able to do much -- although Ryan Nall will probably have a couple annoyingly beautiful runs -- and I imagine their defense will subsequently get pretty tired out relatively early on. Then the Washington offense should have little trouble being mega-efficient, the run blocking should destroy, and Gaskin and Ahmed (and Coleman if he's back) will probably rack up some yardage. Looking forward to see what non-Dante receivers make noise too and if the pass rush can improve upon last week's performance at Colorado.
Final: Washington 49 - 16 Oregon State
What result do you expect from the Washington vs. Oregon State game?
Washington wins a blowout
Washington wins a close one
Oregon State wins a close one
Oregon State wins a blowout


Easy access to all buttons, headphone jack and charging port with cut-out for Apple Logo.
No need to remove your phone from the case to use or charge your phone.
Protects from scratches, fingerprints, scuffs and dust.
This case is made from high quality materials for robust protection to your device.
The case is durable, scratch resistant and easy to fit & remove.


This harrowing and inspiring doc follows the highly organized activists that demanded medical and social progress for AIDS sufferers during the height of the epidemic in the '80s and '90s — a lesson in complacency, compassion and the power of a dedicated group of people.
Whether you know everything or nothing about hip-hop culture and the history of rap, Ice-T's exploration into one of America's most successful folk traditions — with the likes of Dr. Dre, Run DMC and Eminem — is eye-opening and, often times, hilarious.
I don't think a documentary has ever made me laugh this much. This fashion retrospective makes the Anna Wintour-centric The September Issue feel dull and prudish. Diana Vreeland is a plucky, sartorially minded tour de force, playing the roll of innovator, muse and industry leader.
Did you know there are more black Americans in prison today then there were slaves at the height of pre- Emancipation America? This drug documentary is full of shocking realizations like that, making the War on Drugs seem like the most ineffective, misguided and brutal war that the U.S. has ever fought.
Sugar Man has the kind of premise that no longer seems possible in our über-connected information age. If you haven't seen this music detective story, I won't ruin it for you, but I will say that is spans the globe seeking a silver-tongued troubadour that gives Dylan a run for his money.