include/GUI/components/BrowserBar.hpp

Go to the documentation of this file.

#ifndef hpp_CPP_BrowserBar_CPP_hpp
#define hpp_CPP_BrowserBar_CPP_hpp

// We need our declaration
#include "../UZIBase.hpp"
// We need icons
#include "Resources/Icons.hpp"
// We need URL change updater
#include "../URLChangeUpdater.hpp"

namespace juce
{
    class BrowserBar : public Component, ComboBoxListener
    {
        // Members
    private:
        Toolbar* toolbar;
        URLChangeUpdate * urlUpdater;

        // Construction / Destruction
    public:
        BrowserBar (ApplicationCommandManager* commandManager, const String & homeURL) : urlUpdater(0)
        {
            // Create and add the toolbar...
            addAndMakeVisible (toolbar = new Toolbar());

            factory.setComboBoxListener(this);
            factory.setHomeURL(homeURL);
            // And use our item factory to add a set of default icons to it...
            toolbar->addDefaultItems (factory);
        }
        ~BrowserBar()    { deleteAllChildren(); }

        // Juce interface
    public:
        void resized()
        {
            toolbar->setBounds (0, 0, getWidth(), getHeight());
        }

        virtual void comboBoxChanged (ComboBox* comboBoxThatHasChanged)
        {
            if (comboBoxThatHasChanged && urlUpdater)
                urlUpdater->UpdateURL(comboBoxThatHasChanged->getText());
        }

        void setUpdater(URLChangeUpdate * _urlUpdater) { urlUpdater = _urlUpdater; }


        // Inner factory
    public:
        //==============================================================================
        class BrowserItemFactory : public ToolbarItemFactory
        {
            // Construction / Destruction
        public:
            BrowserItemFactory() : listener(0) {}
            ~BrowserItemFactory() {}

            // Enumerations
        public:
            enum BrowserItemIds
            {
                Previous         = 1,   
                Next             = 2,   
                URLBar           = 3,   
                Go               = 4,   
            };

            // ToolbarItemFactory interface
        public:
            void getAllToolbarItemIds (Array <int>& ids)
            {
                // This returns the complete list of all item IDs that are allowed to
                // go in our toolbar. Any items you might want to add must be listed here. The
                // order in which they are listed will be used by the toolbar customisation panel.
                ids.add (Previous);
                ids.add (Next);
                ids.add (URLBar);
                ids.add (Go);
                // If you're going to use separators, then they must also be added explicitly
                // to the list.
                ids.add (separatorBarId);
                ids.add (spacerId);
                ids.add (flexibleSpacerId);
            }

            void getDefaultItemSet (Array <int>& ids)
            {
                // This returns an ordered list of the set of items that make up a
                // toolbar's default set. Not all items need to be on this list, and
                // items can appear multiple times (e.g. the separators used here).
                ids.add (Previous);
                ids.add (Next);
                ids.add (separatorBarId);
                ids.add (URLBar);
                ids.add (spacerId);
                ids.add (separatorBarId);
                ids.add (Go);
            }

            ToolbarItemComponent* createItem (const int itemId)
            {
                switch (itemId)
                {
                case Previous:
                    return createButton (itemId, JUCE_T("Previous"));

                case Next:
                    return createButton (itemId, JUCE_T("Next"));

                case URLBar:
                    return new URLBarComboBox  (itemId, listener, homeURL);

                case Go:
                    return createButton (itemId, JUCE_T("Go"));

                default:
                    break;
                }

                return 0;
            }

            void setComboBoxListener(ComboBoxListener * _listener) { listener = _listener; }
            void setHomeURL(const String & url) { homeURL = url; }

        private:
            OwnedArray <Drawable> icons;

            // This is a little utility to create a button with one of the SVG images in
            // our embedded ZIP file "icons.zip"
            ToolbarButton* createButton (const int itemId, const String& text)
            {
                if (!icons.size())
                {
                    icons.add(Drawable::createFromImageData(ScalableIcons::previous_svg, ScalableIcons::previous_svgSize));
                    icons.add(Drawable::createFromImageData(ScalableIcons::next_svg, ScalableIcons::next_svgSize));
                    icons.add(Drawable::createFromImageData(ScalableIcons::go_svg, ScalableIcons::go_svgSize));
                }
                switch (itemId)
                {
                case Previous:
                    {
                        Drawable * image = icons[0]->createCopy();
                        return new ToolbarButton(itemId, text, image, 0);
                    }
                case Next:
                    {
                        Drawable * image = icons[1]->createCopy();
                        return new ToolbarButton(itemId, text, image, 0);
                    }
                case Go:
                    {
                        Drawable * image = icons[2]->createCopy();
                        return new ToolbarButton(itemId, text, image, 0);
                    }
                default:
                    return 0;
                }
            }

            // Demonstrates how to put a custom component into a toolbar - this one contains
            // a ComboBox.
            class URLBarComboBox : public ToolbarItemComponent
            {
            public:
                URLBarComboBox (const int toolbarItemId, ComboBoxListener * listener = 0, const String & homeURL = String::empty)
                    : ToolbarItemComponent (toolbarItemId, JUCE_T("Enter URL here"), false)
                {
                    addAndMakeVisible (comboBox = new ComboBox (JUCE_T("Enter URL here")));


                    comboBox->setTextWhenNothingSelected(JUCE_T("Enter URL here"));
                    if (homeURL.isNotEmpty()) comboBox->setText(homeURL);
                    comboBox->setEditableText (true);

                    if (listener) comboBox->addListener(listener);
                }

                ~URLBarComboBox()
                {
                    delete comboBox;
                }

                bool getToolbarItemSizes (int toolbarDepth,
                                          bool isToolbarVertical,
                                          int& preferredSize, int& minSize, int& maxSize)
                {
                    if (isToolbarVertical)
                        return false;

                    preferredSize = 600;
                    minSize = 80;
                    maxSize = 600;
                    return true;
                }

                void paintButtonArea (Graphics&, int, int, bool, bool)
                {
                }

                void contentAreaChanged (const Rectangle& contentArea)
                {
                    comboBox->setSize (contentArea.getWidth() - 2,
                                       jmin (contentArea.getHeight() - 2, 22));

                    comboBox->setCentrePosition (contentArea.getCentreX(), contentArea.getCentreY());
                }

            private:
                ComboBox* comboBox;
            };

            ComboBoxListener * listener;
            String             homeURL;
        };

        BrowserItemFactory factory;
    };

}

#endif

(C) An X-Ryl669 project 2007

This document describes Unlimited Zooming Interface source code. UZI stands for Unlimited Zooming Interface, and source code license is