llalertdialog.h

Go to the documentation of this file.

#ifndef LL_ALERTDIALOG_H
#define LL_ALERTDIALOG_H

#include "llpanel.h"
#include "llmodaldialog.h"
#include "llmemory.h"
#include "llui.h"

class LLButton;
class LLCheckBoxCtrl;
class LLAlertDialogTemplate;
class LLLineEditor;

// https://wiki.lindenlab.com/mediawiki/index.php?title=LLAlertDialog&oldid=81388
class LLAlertDialog : public LLModalDialog
{
public:
        typedef void (*alert_callback_t)(S32 option, void* user_data);
        typedef void (*alert_text_callback_t)(S32 option, const LLString& text, void* user_data);
        typedef bool (*display_callback_t)(S32 modal);
        enum { IGNORE_USE_DEFAULT=1, IGNORE_USE_SAVED=2, IGNORE_SHOW_AGAIN=3 };

        class URLLoader
        {
        public:
                virtual void load(const std::string& url) = 0;
        virtual ~URLLoader() {}
        };
        
        static void setURLLoader(URLLoader* loader)
        {
                sURLLoader = loader;
        }
        
public:
        // User's responsibility to call show() after creating these.
        LLAlertDialog( const LLAlertDialogTemplate* xml_template, const LLString::format_map_t& args,
                                   alert_callback_t callback = NULL, void *user_data = NULL);

        virtual BOOL    handleKeyHere(KEY key, MASK mask );

        virtual void    draw();
        virtual void    setVisible( BOOL visible );
        virtual void    onClose(bool app_quitting);

        bool                    setCheckBox( const LLString&, const LLString& );        
        void                    setOptionEnabled( S32 option, BOOL enable );
        void                    setCaution(BOOL val = TRUE) { mCaution = val; }
        // If mUnique==TRUE only one copy of this message should exist
        void                    setUnique(BOOL val = TRUE) { mUnique = val; }
        void                    setEditTextCallback(alert_text_callback_t callback, void *user_data);
        void                    setEditTextArgs(const LLString::format_map_t& edit_args);
        void                    setDrawAsterixes(BOOL enable);
        
        bool                    show(); // May instantly destroy the message if it is unique (returns false)
        
        //statics
        static void             onButtonPressed(void* userdata);

        static LLAlertDialog* createXml( const LLString& xml_desc,
                                                                         alert_callback_t callback = NULL, void *user_data = NULL);
        static LLAlertDialog* createXml( const LLString& xml_desc, const LLString::format_map_t& args,
                                                                         alert_callback_t callback = NULL, void *user_data = NULL);
        
        static LLAlertDialog*   showXml( const LLString& xml_desc,
                                                         alert_callback_t callback = NULL, void *user_data = NULL);
        static LLAlertDialog*   showXml( const LLString& xml_desc, const LLString::format_map_t& args,
                                                         alert_callback_t callback = NULL, void *user_data = NULL);

        static LLAlertDialog*   showCritical( const LLString& msg, alert_callback_t callback = NULL, void *user_data = NULL);
        
        static bool parseAlerts(const LLString& xml_filename, LLControlGroup* settings = NULL, BOOL settings_only = FALSE);
        static const LLString& getTemplateMessage(const LLString& xml_desc);

        static void setDisplayCallback(display_callback_t callback) { sDisplayCallback = callback; }

        void format(LLString& msg, const LLString::format_map_t& args);

        static LLControlGroup* sSettings;

        // use LLPointer so they delete themselves when sTemplates is destroyed
        typedef std::map<LLString, LLPointer<LLAlertDialogTemplate> > template_map_t;
        static template_map_t sAlertTemplates; // by mLabel
        static template_map_t sIgnorableTemplates; // by mIgnoreLabel


private:

        static std::map<LLString, LLAlertDialog*> sUniqueActiveMap;
        static display_callback_t sDisplayCallback;

        static LLString sStringSkipNextTime;
        static LLString sStringAlwaysChoose;

        void createDialog(const std::vector<LLString>* options, S32 default_option,
                                          const LLString& msg, const LLString::format_map_t& args,
                                          const LLString& edit_text);
        
        virtual ~LLAlertDialog();
        void handleCallbacks();
        // No you can't kill it.  It can only kill itself.

        // Does it have a readable title label, or minimize or close buttons?
        BOOL hasTitleBar() const;

        struct ButtonData
        {
                LLAlertDialog* mSelf;
                LLButton* mButton;
                S32 mOption;
        } * mButtonData;

        alert_callback_t mCallback;
        void*   mUserData;
        S32             mNumOptions;
        S32             mDefaultOption;
        BOOL    mOptionChosen;
        LLCheckBoxCtrl* mCheck;
        BOOL    mCaution;
        BOOL    mUnique;
        S32             mIgnorable;
        LLString mLabel;
        LLString mIgnoreLabel;
        LLFrameTimer mDefaultBtnTimer;
        // For Dialogs that take a line as text as input:
        LLLineEditor* mLineEditor;
        alert_text_callback_t mTextCallback;
        // For Dialogs linked to a URL
        LLString mURL;                          // Some alerts will direct the resident to a URL
        S32 mURLOption;

private:
        static URLLoader* sURLLoader;
};

//============================================================================

class LLAlertDialogTemplate : public LLRefCount
{
public:
        LLAlertDialogTemplate() : mTitle(), mURLOption(0), mModal(FALSE), mCaution(FALSE), mUnique(FALSE), mIgnorable(0), mDefaultOption(0) {}
        
        void addOption(const LLString& label, const LLString& ignore_text, BOOL is_default = FALSE)
        {
                if (is_default)
                {
                        mDefaultOption = mOptions.size();
                }
                mOptions.push_back(label);
                mOptionDefaultText.push_back(ignore_text);
        }

        S32 getIgnore()
        {
                if (mIgnorable)
                {
                        return LLAlertDialog::sSettings->getWarning(mIgnoreLabel) ? FALSE : mIgnorable;
                }
                else
                {
                        return FALSE;
                }
        }

        void setIgnore(bool state)
        {
                if (mIgnorable)
                {
                        LLAlertDialog::sSettings->setWarning(mIgnoreLabel, !state);
                }
        }

        
public:
        LLString mLabel;                        // Handle for access from code, etc
        LLString mTitle;                        // (optional) text to display in title bar
        LLString mMessage;                      // Message to display
        LLString mIgnoreListText;       // Text to display in enable/disable dialog (if mIgnorable == TRUE)
        LLString mIgnoreLabel;          // Handle for ignore variable (may be shared by multiple templates)
        LLString mURL;                          // Some alerts will direct the resident to a URL
        S32 mURLOption;
        BOOL mModal;
        BOOL mCaution;
        BOOL mUnique;
        S32 mIgnorable; // 0 = Never Ignore, 1 = Do default option, 2 = Do saved option
        std::vector<LLString> mOptions;
        std::vector<LLString> mOptionDefaultText;
        S32 mDefaultOption;
        LLString mEditLineText;
};

#endif  // LL_ALERTDIALOG_H

---