Merge branch master (DRTVWR-571) into DRTVWR-559

# Conflicts:
#	indra/newview/llpanelface.cpp
#	indra/newview/llpanelface.h

1 files changed, 858 insertions, 34 deletions

diff --git a/indra/newview/llpanelface.cpp b/indra/newview/llpanelface.cpp
index 28b8a64131..7b7fcd4585 100644
--- a/indra/newview/llpanelface.cpp
+++ b/indra/newview/llpanelface.cpp
@@ -49,11 +49,15 @@
 #include "llinventoryfunctions.h"
 #include "llinventorymodel.h" // gInventory
 #include "llinventorymodelbackgroundfetch.h"
+#include "llfloatermediasettings.h"
+#include "llfloaterreg.h"
 #include "lllineeditor.h"
 #include "llmaterialmgr.h"
+#include "llmediactrl.h"
 #include "llmediaentry.h"
 #include "llmenubutton.h"
 #include "llnotificationsutil.h"
+#include "llpanelcontents.h"
 #include "llradiogroup.h"
 #include "llresmgr.h"
 #include "llselectmgr.h"
@@ -115,10 +119,9 @@ std::string USE_TEXTURE;
 
 LLRender::eTexIndex LLPanelFace::getTextureChannelToEdit()
 {
-	LLComboBox* combobox_matmedia = getChild<LLComboBox>("combobox matmedia");
 	LLRadioGroup* radio_mat_type = getChild<LLRadioGroup>("radio_material_type");
 
-	LLRender::eTexIndex channel_to_edit = (combobox_matmedia && combobox_matmedia->getCurrentIndex() == MATMEDIA_MATERIAL) ?
+	LLRender::eTexIndex channel_to_edit = (mComboMatMedia && mComboMatMedia->getCurrentIndex() == MATMEDIA_MATERIAL) ?
 	                                                    (radio_mat_type ? (LLRender::eTexIndex)radio_mat_type->getSelectedIndex() : LLRender::DIFFUSE_MAP) : LLRender::DIFFUSE_MAP;
 
 	channel_to_edit = (channel_to_edit == LLRender::NORMAL_MAP)		? (getCurrentNormalMap().isNull()		? LLRender::DIFFUSE_MAP : channel_to_edit) : channel_to_edit;
@@ -177,6 +180,8 @@ BOOL	LLPanelFace::postBuild()
 	childSetCommitCallback("glossiness",&LLPanelFace::onCommitMaterialGloss, this);
 	childSetCommitCallback("environment",&LLPanelFace::onCommitMaterialEnv, this);
 	childSetCommitCallback("maskcutoff",&LLPanelFace::onCommitMaterialMaskCutoff, this);
+    childSetCommitCallback("add_media", &LLPanelFace::onClickBtnAddMedia, this);
+    childSetCommitCallback("delete_media", &LLPanelFace::onClickBtnDeleteMedia, this);
 
 	childSetAction("button align",&LLPanelFace::onClickAutoFix,this);
 	childSetAction("button align textures", &LLPanelFace::onAlignTexture, this);
@@ -350,6 +355,9 @@ BOOL	LLPanelFace::postBuild()
 
     mMenuClipboardColor = getChild<LLMenuButton>("clipboard_color_params_btn");
     mMenuClipboardTexture = getChild<LLMenuButton>("clipboard_texture_params_btn");
+    
+    mTitleMedia = getChild<LLMediaCtrl>("title_media");
+    mTitleMediaText = getChild<LLTextBox>("media_info");
 
 	clearCtrls();
 
@@ -358,24 +366,31 @@ BOOL	LLPanelFace::postBuild()
 
 LLPanelFace::LLPanelFace()
 :	LLPanel(),
-	mIsAlpha(false)
+    mIsAlpha(false),
+    mComboMatMedia(NULL),
+    mTitleMedia(NULL),
+    mTitleMediaText(NULL),
+    mNeedMediaTitle(true)
 {
     USE_TEXTURE = LLTrans::getString("use_texture");
     mCommitCallbackRegistrar.add("PanelFace.menuDoToSelected", boost::bind(&LLPanelFace::menuDoToSelected, this, _2));
     mEnableCallbackRegistrar.add("PanelFace.menuEnable", boost::bind(&LLPanelFace::menuEnableItem, this, _2));
 }
 
-
 LLPanelFace::~LLPanelFace()
 {
-	// Children all cleaned up by default view destructor.
+    unloadMedia();
 }
 
-
 void LLPanelFace::draw()
 {
     updateCopyTexButton();
 
+    // grab media name/title and update the UI widget
+    // Todo: move it, it's preferable not to update
+    // labels inside draw
+    updateMediaTitle();
+
     LLPanel::draw();
 }
 
@@ -866,7 +881,7 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
 		BOOL editable = objectp->permModify() && !objectp->isPermanentEnforced();
 
 		// only turn on auto-adjust button if there is a media renderer and the media is loaded
-		getChildView("button align")->setEnabled(editable);
+        childSetEnabled("button align", editable);
 		
 		LLComboBox* combobox_matmedia = getChild<LLComboBox>("combobox matmedia");
         if (combobox_matmedia->getCurrentIndex() < MATMEDIA_MATERIAL)
@@ -926,22 +941,22 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
 		{
 			getChildView("color label")->setEnabled(editable && !has_pbr_material);
 		}
-		LLColorSwatchCtrl*	mColorSwatch = findChild<LLColorSwatchCtrl>("colorswatch");
+		LLColorSwatchCtrl*	color_swatch = findChild<LLColorSwatchCtrl>("colorswatch");
 
 		LLColor4 color					= LLColor4::white;
 		bool		identical_color	= false;
 
-		if(mColorSwatch)
+		if(color_swatch)
 		{
 			LLSelectedTE::getColor(color, identical_color);
-			LLColor4 prev_color = mColorSwatch->get();
+			LLColor4 prev_color = color_swatch->get();
 
-			mColorSwatch->setOriginal(color);
-			mColorSwatch->set(color, force_set_values || (prev_color != color) || !editable);
+            color_swatch->setOriginal(color);
+            color_swatch->set(color, force_set_values || (prev_color != color) || !editable);
 
-			mColorSwatch->setValid(editable && !has_pbr_material);
-			mColorSwatch->setEnabled(editable && !has_pbr_material);
-			mColorSwatch->setCanApplyImmediately( editable );
+            color_swatch->setValid(editable);
+            color_swatch->setEnabled( editable );
+            color_swatch->setCanApplyImmediately( editable );
 		}
 
 		// Color transparency
@@ -1726,6 +1741,755 @@ void LLPanelFace::refresh()
 	getState();
 }
 
+void LLPanelFace::refreshMedia()
+{
+    LLObjectSelectionHandle selected_objects = LLSelectMgr::getInstance()->getSelection();
+    LLViewerObject* first_object = selected_objects->getFirstObject();
+
+    if (!(first_object
+        && first_object->getPCode() == LL_PCODE_VOLUME
+        && first_object->permModify()
+        ))
+    {
+        getChildView("add_media")->setEnabled(FALSE);
+        mTitleMediaText->clear();
+        clearMediaSettings();
+        return;
+    }
+
+    std::string url = first_object->getRegion()->getCapability("ObjectMedia");
+    bool has_media_capability = (!url.empty());
+
+    if (!has_media_capability)
+    {
+        getChildView("add_media")->setEnabled(FALSE);
+        LL_WARNS("LLFloaterToolsMedia") << "Media not enabled (no capability) in this region!" << LL_ENDL;
+        clearMediaSettings();
+        return;
+    }
+
+    BOOL is_nonpermanent_enforced = (LLSelectMgr::getInstance()->getSelection()->getFirstRootNode()
+        && LLSelectMgr::getInstance()->selectGetRootsNonPermanentEnforced())
+        || LLSelectMgr::getInstance()->selectGetNonPermanentEnforced();
+    bool editable = is_nonpermanent_enforced && (first_object->permModify() || selectedMediaEditable());
+
+    // Check modify permissions and whether any selected objects are in
+    // the process of being fetched.  If they are, then we're not editable
+    if (editable)
+    {
+        LLObjectSelection::iterator iter = selected_objects->begin();
+        LLObjectSelection::iterator end = selected_objects->end();
+        for (; iter != end; ++iter)
+        {
+            LLSelectNode* node = *iter;
+            LLVOVolume* object = dynamic_cast<LLVOVolume*>(node->getObject());
+            if (NULL != object)
+            {
+                if (!object->permModify())
+                {
+                    LL_INFOS("LLFloaterToolsMedia")
+                        << "Selection not editable due to lack of modify permissions on object id "
+                        << object->getID() << LL_ENDL;
+
+                    editable = false;
+                    break;
+                }
+            }
+        }
+    }
+
+    // Media settings
+    bool bool_has_media = false;
+    struct media_functor : public LLSelectedTEGetFunctor<bool>
+    {
+        bool get(LLViewerObject* object, S32 face)
+        {
+            LLTextureEntry *te = object->getTE(face);
+            if (te)
+            {
+                return te->hasMedia();
+            }
+            return false;
+        }
+    } func;
+
+
+    // check if all faces have media(or, all dont have media)
+    LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo = selected_objects->getSelectedTEValue(&func, bool_has_media);
+
+    const LLMediaEntry default_media_data;
+
+    struct functor_getter_media_data : public LLSelectedTEGetFunctor< LLMediaEntry>
+    {
+        functor_getter_media_data(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        LLMediaEntry get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return *(object->getTE(face)->getMediaData());
+            return mMediaEntry;
+        };
+
+        const LLMediaEntry& mMediaEntry;
+
+    } func_media_data(default_media_data);
+
+    LLMediaEntry media_data_get;
+    LLFloaterMediaSettings::getInstance()->mMultipleMedia = !(selected_objects->getSelectedTEValue(&func_media_data, media_data_get));
+
+    std::string multi_media_info_str = LLTrans::getString("Multiple Media");
+    std::string media_title = "";
+    // update UI depending on whether "object" (prim or face) has media
+    // and whether or not you are allowed to edit it.
+
+    getChildView("add_media")->setEnabled(editable);
+    // IF all the faces have media (or all dont have media)
+    if (LLFloaterMediaSettings::getInstance()->mIdenticalHasMediaInfo)
+    {
+        // TODO: get media title and set it.
+        mTitleMediaText->clear();
+        // if identical is set, all faces are same (whether all empty or has the same media)
+        if (!(LLFloaterMediaSettings::getInstance()->mMultipleMedia))
+        {
+            // Media data is valid
+            if (media_data_get != default_media_data)
+            {
+                // initial media title is the media URL (until we get the name)
+                media_title = media_data_get.getHomeURL();
+            }
+            // else all faces might be empty. 
+        }
+        else // there' re Different Medias' been set on on the faces.
+        {
+            media_title = multi_media_info_str;
+        }
+
+        getChildView("delete_media")->setEnabled(bool_has_media && editable);
+        // TODO: display a list of all media on the face - use 'identical' flag
+    }
+    else // not all face has media but at least one does.
+    {
+        // seleted faces have not identical value
+        LLFloaterMediaSettings::getInstance()->mMultipleValidMedia = selected_objects->isMultipleTEValue(&func_media_data, default_media_data);
+
+        if (LLFloaterMediaSettings::getInstance()->mMultipleValidMedia)
+        {
+            media_title = multi_media_info_str;
+        }
+        else
+        {
+            // Media data is valid
+            if (media_data_get != default_media_data)
+            {
+                // initial media title is the media URL (until we get the name)
+                media_title = media_data_get.getHomeURL();
+            }
+        }
+
+        getChildView("delete_media")->setEnabled(TRUE);
+    }
+
+    U32 materials_media = mComboMatMedia->getCurrentIndex();
+    if (materials_media == MATMEDIA_MEDIA)
+    {
+        // currently displaying media info, navigateTo and update title
+        navigateToTitleMedia(media_title);
+    }
+    else
+    {
+        // Media can be heavy, don't keep it around
+        // MAC specific: MAC doesn't support setVolume(0) so if  not
+        // unloaded, it might keep playing audio until user closes editor
+        unloadMedia();
+        mNeedMediaTitle = false;
+    }
+
+    mTitleMediaText->setText(media_title);
+
+    // load values for media settings
+    updateMediaSettings();
+
+    LLFloaterMediaSettings::initValues(mMediaSettings, editable);
+}
+
+void LLPanelFace::unloadMedia()
+{
+    // destroy media source used to grab media title
+    if (mTitleMedia)
+        mTitleMedia->unloadMediaSource();
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+void LLPanelFace::navigateToTitleMedia( const std::string url )
+{
+	std::string multi_media_info_str = LLTrans::getString("Multiple Media");
+	if (url.empty() || multi_media_info_str == url)
+	{
+		// nothing to show
+		mNeedMediaTitle = false;
+	}
+	else if (mTitleMedia)
+	{
+		LLPluginClassMedia* media_plugin = mTitleMedia->getMediaPlugin();
+		// check if url changed or if we need a new media source
+		if (mTitleMedia->getCurrentNavUrl() != url || media_plugin == NULL)
+		{
+			mTitleMedia->navigateTo( url );
+
+            LLViewerMediaImpl* impl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mTitleMedia->getTextureID());
+            if (impl)
+            {
+                // if it's a page with a movie, we don't want to hear it
+                impl->setVolume(0);
+            };
+		}
+
+		// flag that we need to update the title (even if no request were made)
+		mNeedMediaTitle = true;
+	}
+}
+
+bool LLPanelFace::selectedMediaEditable()
+{
+    U32 owner_mask_on;
+    U32 owner_mask_off;
+    U32 valid_owner_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER,
+        &owner_mask_on, &owner_mask_off);
+    U32 group_mask_on;
+    U32 group_mask_off;
+    U32 valid_group_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP,
+        &group_mask_on, &group_mask_off);
+    U32 everyone_mask_on;
+    U32 everyone_mask_off;
+    S32 valid_everyone_perms = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE,
+        &everyone_mask_on, &everyone_mask_off);
+
+    bool selected_Media_editable = false;
+
+    // if perms we got back are valid
+    if (valid_owner_perms &&
+        valid_group_perms &&
+        valid_everyone_perms)
+    {
+
+        if ((owner_mask_on & PERM_MODIFY) ||
+            (group_mask_on & PERM_MODIFY) ||
+            (everyone_mask_on & PERM_MODIFY))
+        {
+            selected_Media_editable = true;
+        }
+        else
+            // user is NOT allowed to press the RESET button
+        {
+            selected_Media_editable = false;
+        };
+    };
+
+    return selected_Media_editable;
+}
+
+void LLPanelFace::clearMediaSettings()
+{
+    LLFloaterMediaSettings::clearValues(false);
+}
+
+void LLPanelFace::updateMediaSettings()
+{
+    bool identical(false);
+    std::string base_key("");
+    std::string value_str("");
+    int value_int = 0;
+    bool value_bool = false;
+    LLObjectSelectionHandle selected_objects = LLSelectMgr::getInstance()->getSelection();
+    // TODO: (CP) refactor this using something clever or boost or both !!
+
+    const LLMediaEntry default_media_data;
+
+    // controls 
+    U8 value_u8 = default_media_data.getControls();
+    struct functor_getter_controls : public LLSelectedTEGetFunctor< U8 >
+    {
+        functor_getter_controls(const LLMediaEntry &entry) : mMediaEntry(entry) {}
+
+        U8 get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getControls();
+            return mMediaEntry.getControls();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_controls(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_controls, value_u8);
+    base_key = std::string(LLMediaEntry::CONTROLS_KEY);
+    mMediaSettings[base_key] = value_u8;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // First click (formerly left click)
+    value_bool = default_media_data.getFirstClickInteract();
+    struct functor_getter_first_click : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_first_click(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getFirstClickInteract();
+            return mMediaEntry.getFirstClickInteract();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_first_click(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_first_click, value_bool);
+    base_key = std::string(LLMediaEntry::FIRST_CLICK_INTERACT_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Home URL
+    value_str = default_media_data.getHomeURL();
+    struct functor_getter_home_url : public LLSelectedTEGetFunctor< std::string >
+    {
+        functor_getter_home_url(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        std::string get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getHomeURL();
+            return mMediaEntry.getHomeURL();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_home_url(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_home_url, value_str);
+    base_key = std::string(LLMediaEntry::HOME_URL_KEY);
+    mMediaSettings[base_key] = value_str;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Current URL
+    value_str = default_media_data.getCurrentURL();
+    struct functor_getter_current_url : public LLSelectedTEGetFunctor< std::string >
+    {
+        functor_getter_current_url(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        std::string get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getCurrentURL();
+            return mMediaEntry.getCurrentURL();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_current_url(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_current_url, value_str);
+    base_key = std::string(LLMediaEntry::CURRENT_URL_KEY);
+    mMediaSettings[base_key] = value_str;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Auto zoom
+    value_bool = default_media_data.getAutoZoom();
+    struct functor_getter_auto_zoom : public LLSelectedTEGetFunctor< bool >
+    {
+
+        functor_getter_auto_zoom(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getAutoZoom();
+            return mMediaEntry.getAutoZoom();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_auto_zoom(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_auto_zoom, value_bool);
+    base_key = std::string(LLMediaEntry::AUTO_ZOOM_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Auto play
+    //value_bool = default_media_data.getAutoPlay();
+    // set default to auto play TRUE -- angela  EXT-5172
+    value_bool = true;
+    struct functor_getter_auto_play : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_auto_play(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getAutoPlay();
+            //return mMediaEntry.getAutoPlay(); set default to auto play TRUE -- angela  EXT-5172
+            return true;
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_auto_play(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_auto_play, value_bool);
+    base_key = std::string(LLMediaEntry::AUTO_PLAY_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+
+    // Auto scale
+    // set default to auto scale TRUE -- angela  EXT-5172
+    //value_bool = default_media_data.getAutoScale();
+    value_bool = true;
+    struct functor_getter_auto_scale : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_auto_scale(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getAutoScale();
+            // return mMediaEntry.getAutoScale();  set default to auto scale TRUE -- angela  EXT-5172
+            return true;
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_auto_scale(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_auto_scale, value_bool);
+    base_key = std::string(LLMediaEntry::AUTO_SCALE_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Auto loop
+    value_bool = default_media_data.getAutoLoop();
+    struct functor_getter_auto_loop : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_auto_loop(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getAutoLoop();
+            return mMediaEntry.getAutoLoop();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_auto_loop(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_auto_loop, value_bool);
+    base_key = std::string(LLMediaEntry::AUTO_LOOP_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // width pixels (if not auto scaled)
+    value_int = default_media_data.getWidthPixels();
+    struct functor_getter_width_pixels : public LLSelectedTEGetFunctor< int >
+    {
+        functor_getter_width_pixels(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        int get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getWidthPixels();
+            return mMediaEntry.getWidthPixels();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_width_pixels(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_width_pixels, value_int);
+    base_key = std::string(LLMediaEntry::WIDTH_PIXELS_KEY);
+    mMediaSettings[base_key] = value_int;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // height pixels (if not auto scaled)
+    value_int = default_media_data.getHeightPixels();
+    struct functor_getter_height_pixels : public LLSelectedTEGetFunctor< int >
+    {
+        functor_getter_height_pixels(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        int get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getHeightPixels();
+            return mMediaEntry.getHeightPixels();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_height_pixels(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_height_pixels, value_int);
+    base_key = std::string(LLMediaEntry::HEIGHT_PIXELS_KEY);
+    mMediaSettings[base_key] = value_int;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Enable Alt image
+    value_bool = default_media_data.getAltImageEnable();
+    struct functor_getter_enable_alt_image : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_enable_alt_image(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getAltImageEnable();
+            return mMediaEntry.getAltImageEnable();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_enable_alt_image(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_enable_alt_image, value_bool);
+    base_key = std::string(LLMediaEntry::ALT_IMAGE_ENABLE_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - owner interact
+    value_bool = 0 != (default_media_data.getPermsInteract() & LLMediaEntry::PERM_OWNER);
+    struct functor_getter_perms_owner_interact : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_owner_interact(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_OWNER));
+            return 0 != (mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_OWNER);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_owner_interact(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_perms_owner_interact, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_OWNER_INTERACT_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - owner control
+    value_bool = 0 != (default_media_data.getPermsControl() & LLMediaEntry::PERM_OWNER);
+    struct functor_getter_perms_owner_control : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_owner_control(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_OWNER));
+            return 0 != (mMediaEntry.getPermsControl() & LLMediaEntry::PERM_OWNER);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_owner_control(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_perms_owner_control, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_OWNER_CONTROL_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - group interact
+    value_bool = 0 != (default_media_data.getPermsInteract() & LLMediaEntry::PERM_GROUP);
+    struct functor_getter_perms_group_interact : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_group_interact(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_GROUP));
+            return 0 != (mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_GROUP);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_group_interact(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_perms_group_interact, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_GROUP_INTERACT_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - group control
+    value_bool = 0 != (default_media_data.getPermsControl() & LLMediaEntry::PERM_GROUP);
+    struct functor_getter_perms_group_control : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_group_control(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_GROUP));
+            return 0 != (mMediaEntry.getPermsControl() & LLMediaEntry::PERM_GROUP);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_group_control(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_perms_group_control, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_GROUP_CONTROL_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - anyone interact
+    value_bool = 0 != (default_media_data.getPermsInteract() & LLMediaEntry::PERM_ANYONE);
+    struct functor_getter_perms_anyone_interact : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_anyone_interact(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsInteract() & LLMediaEntry::PERM_ANYONE));
+            return 0 != (mMediaEntry.getPermsInteract() & LLMediaEntry::PERM_ANYONE);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_anyone_interact(default_media_data);
+    identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&func_perms_anyone_interact, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_ANYONE_INTERACT_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // Perms - anyone control
+    value_bool = 0 != (default_media_data.getPermsControl() & LLMediaEntry::PERM_ANYONE);
+    struct functor_getter_perms_anyone_control : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_perms_anyone_control(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return (0 != (object->getTE(face)->getMediaData()->getPermsControl() & LLMediaEntry::PERM_ANYONE));
+            return 0 != (mMediaEntry.getPermsControl() & LLMediaEntry::PERM_ANYONE);
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_perms_anyone_control(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_perms_anyone_control, value_bool);
+    base_key = std::string(LLPanelContents::PERMS_ANYONE_CONTROL_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // security - whitelist enable
+    value_bool = default_media_data.getWhiteListEnable();
+    struct functor_getter_whitelist_enable : public LLSelectedTEGetFunctor< bool >
+    {
+        functor_getter_whitelist_enable(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        bool get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getWhiteListEnable();
+            return mMediaEntry.getWhiteListEnable();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_whitelist_enable(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_whitelist_enable, value_bool);
+    base_key = std::string(LLMediaEntry::WHITELIST_ENABLE_KEY);
+    mMediaSettings[base_key] = value_bool;
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+
+    // security - whitelist URLs
+    std::vector<std::string> value_vector_str = default_media_data.getWhiteList();
+    struct functor_getter_whitelist_urls : public LLSelectedTEGetFunctor< std::vector<std::string> >
+    {
+        functor_getter_whitelist_urls(const LLMediaEntry& entry) : mMediaEntry(entry) {}
+
+        std::vector<std::string> get(LLViewerObject* object, S32 face)
+        {
+            if (object)
+                if (object->getTE(face))
+                    if (object->getTE(face)->getMediaData())
+                        return object->getTE(face)->getMediaData()->getWhiteList();
+            return mMediaEntry.getWhiteList();
+        };
+
+        const LLMediaEntry &mMediaEntry;
+
+    } func_whitelist_urls(default_media_data);
+    identical = selected_objects->getSelectedTEValue(&func_whitelist_urls, value_vector_str);
+    base_key = std::string(LLMediaEntry::WHITELIST_KEY);
+    mMediaSettings[base_key].clear();
+    std::vector< std::string >::iterator iter = value_vector_str.begin();
+    while (iter != value_vector_str.end())
+    {
+        std::string white_list_url = *iter;
+        mMediaSettings[base_key].append(white_list_url);
+        ++iter;
+    };
+
+    mMediaSettings[base_key + std::string(LLPanelContents::TENTATIVE_SUFFIX)] = !identical;
+}
+
+void LLPanelFace::updateMediaTitle()
+{
+    // only get the media name if we need it
+    if (!mNeedMediaTitle)
+        return;
+
+    // get plugin impl
+    LLPluginClassMedia* media_plugin = mTitleMedia->getMediaPlugin();
+    if (media_plugin && mTitleMedia->getCurrentNavUrl() == media_plugin->getNavigateURI())
+    {
+        // get the media name (asynchronous - must call repeatedly)
+        std::string media_title = media_plugin->getMediaName();
+
+        // only replace the title if what we get contains something
+        if (!media_title.empty())
+        {
+            // update the UI widget
+            if (mTitleMediaText)
+            {
+                mTitleMediaText->setText(media_title);
+
+                // stop looking for a title when we get one
+                mNeedMediaTitle = false;
+            };
+        };
+    };
+}
+
 //
 // Static functions
 //
@@ -1784,9 +2548,9 @@ void LLPanelFace::onCommitMaterialsMedia(LLUICtrl* ctrl, void* userdata)
 	self->updateShinyControls(false,true);
 	self->updateBumpyControls(false,true);
 	self->updateUI();
+	self->refreshMedia();
 }
 
-// static
 void LLPanelFace::updateVisibility()
 {
     LLComboBox* combo_matmedia = findChild<LLComboBox>("combobox matmedia");
@@ -1799,7 +2563,7 @@ void LLPanelFace::updateVisibility()
 		LL_WARNS("Materials") << "Combo box not found...exiting." << LL_ENDL;
 		return;
 	}
-	U32 materials_media = combo_matmedia->getCurrentIndex();
+	U32 materials_media = mComboMatMedia->getCurrentIndex();
 	U32 material_type = radio_mat_type->getSelectedIndex();
     U32 pbr_type = radio_pbr_type->getSelectedIndex();
 	bool show_media = (materials_media == MATMEDIA_MEDIA) && combo_matmedia->getEnabled();
@@ -1816,7 +2580,7 @@ void LLPanelFace::updateVisibility()
     radio_pbr_type->setVisible(show_pbr);
 
 	// Media controls
-	getChildView("media_info")->setVisible(show_media);
+    mTitleMediaText->setVisible(show_media);
 	getChildView("add_media")->setVisible(show_media);
 	getChildView("delete_media")->setVisible(show_media);
 	getChildView("button align")->setVisible(show_media);
@@ -1960,12 +2724,11 @@ void LLPanelFace::updateShinyControls(bool is_setting_texture, bool mess_with_sh
 	}
 
 
-	LLComboBox* combo_matmedia = getChild<LLComboBox>("combobox matmedia");
 	LLRadioGroup* radio_mat_type = getChild<LLRadioGroup>("radio_material_type");
-	U32 materials_media = combo_matmedia->getCurrentIndex();
+	U32 materials_media = mComboMatMedia->getCurrentIndex();
 	U32 material_type = radio_mat_type->getSelectedIndex();
 	bool show_material = (materials_media == MATMEDIA_MATERIAL);
-	bool show_shininess = show_material && (material_type == MATTYPE_SPECULAR) && combo_matmedia->getEnabled();
+	bool show_shininess = show_material && (material_type == MATTYPE_SPECULAR) && mComboMatMedia->getEnabled();
 	U32 shiny_value = comboShiny->getCurrentIndex();
 	bool show_shinyctrls = (shiny_value == SHINY_TEXTURE) && show_shininess; // Use texture
 	getChildView("label glossiness")->setVisible(show_shinyctrls);
@@ -2039,11 +2802,10 @@ void LLPanelFace::updateAlphaControls()
 	U32 alpha_value = comboAlphaMode->getCurrentIndex();
 	bool show_alphactrls = (alpha_value == ALPHAMODE_MASK); // Alpha masking
     
-    LLComboBox* combobox_matmedia = getChild<LLComboBox>("combobox matmedia");
     U32 mat_media = MATMEDIA_MATERIAL;
-    if (combobox_matmedia)
+    if (mComboMatMedia)
     {
-        mat_media = combobox_matmedia->getCurrentIndex();
+        mat_media = mComboMatMedia->getCurrentIndex();
     }
     
     U32 mat_type = MATTYPE_DIFFUSE;
@@ -2260,6 +3022,77 @@ void LLPanelFace::onSelectNormalTexture(const LLSD& data)
 	sendBump(nmap_id.isNull() ? 0 : BUMPY_TEXTURE);
 }
 
+//////////////////////////////////////////////////////////////////////////////
+// called when a user wants to edit existing media settings on a prim or prim face
+// TODO: test if there is media on the item and only allow editing if present
+void LLPanelFace::onClickBtnEditMedia(LLUICtrl* ctrl, void* userdata)
+{
+    LLPanelFace* self = (LLPanelFace*)userdata;
+    self->refreshMedia();
+    LLFloaterReg::showInstance("media_settings");
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// called when a user wants to delete media from a prim or prim face
+void LLPanelFace::onClickBtnDeleteMedia(LLUICtrl* ctrl, void* userdata)
+{
+    LLNotificationsUtil::add("DeleteMedia", LLSD(), LLSD(), deleteMediaConfirm);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// called when a user wants to add media to a prim or prim face
+void LLPanelFace::onClickBtnAddMedia(LLUICtrl* ctrl, void* userdata)
+{
+    // check if multiple faces are selected
+    if (LLSelectMgr::getInstance()->getSelection()->isMultipleTESelected())
+    {
+        LLPanelFace* self = (LLPanelFace*)userdata;
+        self->refreshMedia();
+        LLNotificationsUtil::add("MultipleFacesSelected", LLSD(), LLSD(), multipleFacesSelectedConfirm);
+    }
+    else
+    {
+        onClickBtnEditMedia(ctrl, userdata);
+    }
+}
+
+// static
+bool LLPanelFace::deleteMediaConfirm(const LLSD& notification, const LLSD& response)
+{
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    switch (option)
+    {
+    case 0:  // "Yes"
+        LLSelectMgr::getInstance()->selectionSetMedia(0, LLSD());
+        if (LLFloaterReg::instanceVisible("media_settings"))
+        {
+            LLFloaterReg::hideInstance("media_settings");
+        }
+        break;
+
+    case 1:  // "No"
+    default:
+        break;
+    }
+    return false;
+}
+
+// static
+bool LLPanelFace::multipleFacesSelectedConfirm(const LLSD& notification, const LLSD& response)
+{
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    switch (option)
+    {
+    case 0:  // "Yes"
+        LLFloaterReg::showInstance("media_settings");
+        break;
+    case 1:  // "No"
+    default:
+        break;
+    }
+    return false;
+}
+
 //static
 void LLPanelFace::syncOffsetX(LLPanelFace* self, F32 offsetU)
 {
@@ -2637,10 +3470,9 @@ void LLPanelFace::onCommitRepeatsPerMeter(LLUICtrl* ctrl, void* userdata)
 	LLPanelFace* self = (LLPanelFace*) userdata;
 	
 	LLUICtrl*	repeats_ctrl	= self->getChild<LLUICtrl>("rptctrl");
-	LLComboBox* combo_matmedia = self->getChild<LLComboBox>("combobox matmedia");
 	LLRadioGroup* radio_mat_type = self->getChild<LLRadioGroup>("radio_material_type");
 	
-	U32 materials_media = combo_matmedia->getCurrentIndex();
+	U32 materials_media = self->mComboMatMedia->getCurrentIndex();
 
 	U32 material_type           = (materials_media == MATMEDIA_MATERIAL) ? radio_mat_type->getSelectedIndex() : 0;
 	F32 repeats_per_meter	= repeats_ctrl->getValue().asReal();
@@ -3576,14 +4408,6 @@ bool LLPanelFace::menuEnableItem(const LLSD& userdata)
 }
 
 
-// TODO: I don't know who put these in or what these are for???
-void LLPanelFace::setMediaURL(const std::string& url)
-{
-}
-void LLPanelFace::setMediaType(const std::string& mime_type)
-{
-}
-
 // static
 void LLPanelFace::onCommitPlanarAlign(LLUICtrl* ctrl, void* userdata)
 {