Ported local textures from Emerald (requires boost filesystem and system libs to work)

11 files changed, 1799 insertions, 18 deletions

diff --git a/linden/indra/newview/CMakeLists.txt b/linden/indra/newview/CMakeLists.txt
index 7dfe3d2..13c972a 100644
--- a/linden/indra/newview/CMakeLists.txt
+++ b/linden/indra/newview/CMakeLists.txt
@@ -71,6 +71,7 @@ set(viewer_SOURCE_FILES
     floaterbusy.cpp
     floatergriddefault.cpp
     floatergridmanager.cpp
+    floaterlocalassetbrowse.cpp
     floatervoicelicense.cpp
     hbfloatergrouptitles.cpp
     hippoGridManager.cpp
@@ -504,6 +505,7 @@ set(viewer_HEADER_FILES
     floaterbusy.h
     floatergriddefault.h
     floatergridmanager.h
+    floaterlocalassetbrowse.h
     floatervoicelicense.h
     hbfloatergrouptitles.h
     hippoGridManager.h
diff --git a/linden/indra/newview/app_settings/settings.xml b/linden/indra/newview/app_settings/settings.xml
index 53a708e..b01544a 100644
--- a/linden/indra/newview/app_settings/settings.xml
+++ b/linden/indra/newview/app_settings/settings.xml
@@ -239,6 +239,22 @@
         <integer>0</integer>
     </array>
   </map>
+  <key>FloaterLocalbitmapbrowserRect</key>
+  <map>
+    <key>Comment</key>
+    <string>LOLRectangle</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Rect</string>
+    <key>Value</key>
+    <array>
+      <integer>0</integer>
+      <integer>400</integer>
+      <integer>400</integer>
+      <integer>0</integer>
+    </array>
+  </map>
   <key>FloaterPrimImport</key>
   <map>
     <key>Comment</key>
diff --git a/linden/indra/newview/floaterlocalassetbrowse.H b/linden/indra/newview/floaterlocalassetbrowse.H
new file mode 100644
index 0000000..6ee1c75
--- /dev/null
+++ b/linden/indra/newview/floaterlocalassetbrowse.H
@@ -0,0 +1,305 @@
+/**
+* @file floaterlocalassetbrowse.h
+* @brief Local texture support
+*
+* $LicenseInfo:firstyear=2009&license=viewergpl$
+*
+* Copyright (c) 2010, author unknown
+*
+* Imprudence Viewer Source Code
+* The source code in this file ("Source Code") is provided to you
+* under the terms of the GNU General Public License, version 2.0
+* ("GPL"). Terms of the GPL can be found in doc/GPL-license.txt in
+* this distribution, or online at
+* http://secondlifegrid.net/programs/open_source/licensing/gplv2
+*
+* There are special exceptions to the terms and conditions of the GPL as
+* it is applied to this Source Code. View the full text of the exception
+* in the file doc/FLOSS-exception.txt in this software distribution, or
+* online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+*
+* By copying, modifying or distributing this software, you acknowledge
+* that you have read and understood your obligations described above,
+* and agree to abide by those obligations.
+*
+* ALL SOURCE CODE IS PROVIDED "AS IS." THE AUTHOR MAKES NO
+* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+* COMPLETENESS OR PERFORMANCE.
+* $/LicenseInfo$
+*/
+
+/* Local Asset Browser: header 
+
+tag: vaa emerald local_asset_browser
+
+*/
+
+
+#ifndef VAA_LOCALBROWSER
+#define VAA_LOCALBROWSER
+
+#include "llfloater.h"
+#include "llscrolllistctrl.h"
+#include "lltexturectrl.h"
+#include "lldrawable.h"
+
+
+/*=======================================*/
+/*  Global structs / enums / defines     */
+/*=======================================*/ 
+
+#define LF_FLOATER_EXPAND_WIDTH 735
+#define LF_FLOATER_CONTRACT_WIDTH 415
+#define LF_FLOATER_HEIGHT 260
+
+#define LOCAL_USE_MIPMAPS true
+#define LOCAL_DISCARD_LEVEL 0
+#define NO_IMAGE LLUUID::null
+
+#define TIMER_HEARTBEAT 3.0
+
+#define SLAM_FOR_DEBUG true
+
+enum bitmaplist_cols
+{
+        BITMAPLIST_COL_NAME,
+        BITMAPLIST_COL_ID
+};
+
+/* upload & sculpt update related */
+struct affected_object
+{
+        LLViewerObject* object;
+        std::vector<LLFace*> face_list;
+        bool local_sculptmap;
+
+};
+
+/* texture picker defines */
+
+#define LOCAL_TEXTURE_PICKER_NAME "texture picker"
+#define LOCAL_TEXTURE_PICKER_LIST_NAME "local_name_list"
+#define LOCAL_TEXTURE_PICKER_RECURSE true
+#define LOCAL_TEXTURE_PICKER_CREATEIFMISSING true
+
+
+/*=======================================*/
+/*  LocalBitmap: unit class              */
+/*=======================================*/ 
+/*
+        The basic unit class responsible for
+        containing one loaded local texture.
+*/
+
+class LocalBitmap
+{
+        public:
+                LocalBitmap(std::string filename);
+                virtual ~LocalBitmap(void);
+                friend class LocalAssetBrowser;
+
+        public: /* [enums, typedefs, etc] */
+                enum link_status
+                {
+                        LINK_UNKNOWN, /* default fallback */
+                        LINK_ON,
+                        LINK_OFF,
+                        LINK_BROKEN,
+                        LINK_UPDATING /* currently redundant, but left in case necessary later. */
+                };
+
+                enum extension_type
+                {
+                        IMG_EXTEN_BMP,
+                        IMG_EXTEN_TGA,
+                        IMG_EXTEN_JPG,
+                        IMG_EXTEN_PNG
+                };
+
+                enum bitmap_type
+                {
+                        TYPE_TEXTURE = 0,
+                        TYPE_SCULPT = 1,
+                        TYPE_LAYER = 2
+                };
+
+        public: /* [information query functions] */
+                std::string getShortName(void);
+                std::string getFileName(void);
+                LLUUID      getID(void);
+                LLSD        getLastModified(void);
+                std::string getLinkStatus(void);
+                bool        getUpdateBool(void);
+                void        setType( S32 );
+                bool        getIfValidBool(void);
+                S32                 getType(void);
+                void            getDebugInfo(void);
+
+        private: /* [maintenence functions] */
+                void updateSelf(void);
+                bool decodeSelf(LLImageRaw* rawimg);
+                void setUpdateBool(void);
+
+                LocalBitmap*                             getThis(void);
+                std::vector<LLFace*>             getFaceUsesThis(LLDrawable*);
+                std::vector<affected_object> getUsingObjects(bool seek_by_type = true,
+                                                                                                     bool seek_textures = false, bool seek_sculptmaps = false);
+
+        protected: /* [basic properties] */
+                std::string    shortname;
+                std::string    filename;
+                extension_type extension;
+                LLUUID         id;
+                LLSD           last_modified;
+                link_status    linkstatus;
+                bool           keep_updating;
+                bool           valid;
+                S32                    bitmap_type;
+                bool           sculpt_dirty;
+                bool           volume_dirty;
+};
+
+/*=======================================*/
+/*  LocalAssetBrowser: main class        */
+/*=======================================*/ 
+/*
+        Responsible for internal workings.
+        Instantiated at the top of the source file.
+        Sits in memory until the viewer is closed.
+
+*/
+
+
+class LocalAssetBrowser
+{
+        public:
+                LocalAssetBrowser();
+                virtual ~LocalAssetBrowser();
+                friend class FloaterLocalAssetBrowser;
+                friend class LocalAssetBrowserTimer;
+                static void UpdateTextureCtrlList(LLScrollListCtrl*);
+                static void setLayerUpdated(bool toggle) { mLayerUpdated = toggle; }
+                static void setSculptUpdated(bool toggle) { mSculptUpdated = toggle; }
+                static void AddBitmap(void);
+                static void DelBitmap( std::vector<LLScrollListItem*>, S32 column = BITMAPLIST_COL_ID );
+
+                /* UpdateTextureCtrlList was made public cause texturectrl requests it once on spawn 
+                   ( added: when it's own add/remove funcs are used. )
+                   i've made it update on spawn instead of on pressing 'local' because the former does it once, 
+                   the latter - each time the button's pressed. */
+
+        private:
+                static void onChangeHappened(void);
+                static void onUpdateBool(LLUUID);
+                static void onSetType(LLUUID, S32);
+                static LocalBitmap* GetBitmapUnit(LLUUID);
+                static bool IsDoingUpdates(void);
+                static void PingTimer(void);
+                static void PerformTimedActions(void);
+                static void PerformSculptUpdates(LocalBitmap*);
+
+        protected:
+                static  std::vector<LocalBitmap*> loaded_bitmaps;
+                typedef std::vector<LocalBitmap*>::iterator local_list_iter;
+                static  bool    mLayerUpdated;
+                static  bool    mSculptUpdated; 
+};
+
+/*==================================================*/
+/*  FloaterLocalAssetBrowser : interface class      */
+/*==================================================*/ 
+/*
+        Responsible for talking to the user.
+        Instantiated by user request.
+        Destroyed when the floater is closed.
+
+*/
+class FloaterLocalAssetBrowser : public LLFloater
+{
+public:
+    FloaterLocalAssetBrowser();
+    virtual ~FloaterLocalAssetBrowser();
+    static void show(void*);
+
+
+ 
+private: 
+        /* Widget related callbacks */
+    // Button callback declarations
+    static void onClickAdd(void* userdata);
+        static void onClickDel(void* userdata);
+        static void onClickMore(void* userdata);
+        static void onClickLess(void* userdata);
+        static void onClickUpload(void* userdata);
+
+        // ScrollList callback declarations
+        static void onChooseBitmapList(LLUICtrl* ctrl, void* userdata);
+
+        // Checkbox callback declarations
+        static void onClickUpdateChkbox(LLUICtrl* ctrl, void* userdata);
+
+        // Combobox type select
+        static void onCommitTypeCombo(LLUICtrl* ctrl, void* userdata);
+
+        // Widgets
+        LLButton* mAddBtn;
+        LLButton* mDelBtn;
+        LLButton* mMoreBtn;
+        LLButton* mLessBtn;
+        LLButton* mUploadBtn;
+
+        LLScrollListCtrl* mBitmapList;
+        LLScrollListCtrl* mUsedList;
+        LLTextureCtrl*    mTextureView;
+        LLCheckBoxCtrl*   mUpdateChkBox;
+
+        LLLineEditor* mPathTxt;
+        LLLineEditor* mUUIDTxt;
+        LLLineEditor* mNameTxt;
+
+        LLTextBox*  mLinkTxt;
+        LLTextBox*  mTimeTxt;
+        LLComboBox* mTypeComboBox;
+
+        LLTextBox* mCaptionPathTxt;
+        LLTextBox* mCaptionUUIDTxt;
+        LLTextBox* mCaptionLinkTxt;
+        LLTextBox* mCaptionNameTxt;
+        LLTextBox* mCaptionTimeTxt;
+
+        /* static pointer to self, wai? oh well. */
+    static FloaterLocalAssetBrowser* sLFInstance;
+
+        // non-widget functions
+        static void FloaterResize(bool expand);
+        static void UpdateRightSide(void);
+
+public:
+        static void UpdateBitmapScrollList(void);
+
+
+};
+
+/*==================================================*/
+/*     LocalAssetBrowserTimer : timer class         */
+/*==================================================*/ 
+/*
+        A small, simple timer class inheriting from
+        LLEventTimer, responsible for pinging the
+        LocalAssetBrowser class to perform it's
+        updates / checks / etc.
+
+*/
+class LocalAssetBrowserTimer : public LLEventTimer
+{
+        public:
+                LocalAssetBrowserTimer();
+                ~LocalAssetBrowserTimer();
+                virtual BOOL tick();
+                void             start();
+                void             stop();
+                bool         isRunning();
+};
+
+#endif
+
diff --git a/linden/indra/newview/floaterlocalassetbrowse.cpp b/linden/indra/newview/floaterlocalassetbrowse.cpp
new file mode 100644
index 0000000..bf1bcad
--- /dev/null
+++ b/linden/indra/newview/floaterlocalassetbrowse.cpp
@@ -0,0 +1,1028 @@
+/**
+* @file floaterlocalassetbrowse.cpp
+* @brief Local texture support
+*
+* $LicenseInfo:firstyear=2009&license=viewergpl$
+*
+* Copyright (c) 2010, author unknown
+*
+* Imprudence Viewer Source Code
+* The source code in this file ("Source Code") is provided to you
+* under the terms of the GNU General Public License, version 2.0
+* ("GPL"). Terms of the GPL can be found in doc/GPL-license.txt in
+* this distribution, or online at
+* http://secondlifegrid.net/programs/open_source/licensing/gplv2
+*
+* There are special exceptions to the terms and conditions of the GPL as
+* it is applied to this Source Code. View the full text of the exception
+* in the file doc/FLOSS-exception.txt in this software distribution, or
+* online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+*
+* By copying, modifying or distributing this software, you acknowledge
+* that you have read and understood your obligations described above,
+* and agree to abide by those obligations.
+*
+* ALL SOURCE CODE IS PROVIDED "AS IS." THE AUTHOR MAKES NO
+* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+* COMPLETENESS OR PERFORMANCE.
+* $/LicenseInfo$
+*/
+
+/*
+
+tag: vaa emerald local_asset_browser
+
+this feature is still a work in progress.
+
+*/
+
+/* basic headers */
+#include "llviewerprecompiledheaders.h"
+#include "lluictrlfactory.h"
+
+/* boost madness from hell */
+#ifdef equivalent
+        #undef equivalent
+#endif
+#include <boost/filesystem.hpp>
+
+/* own class header && upload floater header */
+#include "floaterlocalassetbrowse.h"
+//#include "floaterlocaluploader.h" <- in development.
+
+/* image compression headers. */
+#include "llimagebmp.h"
+#include "llimagetga.h"
+#include "llimagejpeg.h"
+#include "llimagepng.h"
+
+/* misc headers */
+#include <time.h>
+#include <ctime>
+#include "llviewerimagelist.h"
+#include "llviewerobjectlist.h"
+#include "llfilepicker.h"
+#include "llviewermenufile.h"
+#include "llfloaterimagepreview.h"
+
+/* repeated in header */
+#include "lltexturectrl.h"   
+#include "llscrolllistctrl.h"
+#include "llviewercontrol.h"
+
+/* including to force rebakes when needed */
+#include "llagent.h"
+#include "llvoavatar.h"
+
+/* sculpt refresh */
+#include "llvovolume.h"
+#include "llface.h"
+
+
+/*=======================================*/
+/*     Instantiating manager class       */
+/*    and formally declaring it's list   */
+/*=======================================*/ 
+LocalAssetBrowser* gLocalBrowser;
+LocalAssetBrowserTimer* gLocalBrowserTimer;
+std::vector<LocalBitmap*> LocalAssetBrowser::loaded_bitmaps;
+bool    LocalAssetBrowser::mLayerUpdated;
+bool    LocalAssetBrowser::mSculptUpdated;
+
+/*=======================================*/
+/*  LocalBitmap: unit class              */
+/*=======================================*/ 
+/*
+        The basic unit class responsible for
+        containing one loaded local texture.
+*/
+
+LocalBitmap::LocalBitmap(std::string fullpath)
+{
+        this->valid = false;
+        if ( gDirUtilp->fileExists(fullpath) )
+        {
+                /* taking care of basic properties */
+                this->id.generate();
+                this->filename      = fullpath;
+                this->linkstatus    = LINK_OFF;
+                this->keep_updating = false;
+                this->shortname     = gDirUtilp->getBaseFileName(this->filename, true);
+                this->bitmap_type   = TYPE_TEXTURE;
+                this->sculpt_dirty  = false;
+                this->volume_dirty  = false;
+                this->valid         = false;
+
+                /* taking care of extension type now to avoid switch madness */
+                std::string temp_exten = gDirUtilp->getExtension(this->filename);
+
+                if (temp_exten == "bmp") { this->extension = IMG_EXTEN_BMP; }
+                else if (temp_exten == "tga") { this->extension = IMG_EXTEN_TGA; }
+                else if (temp_exten == "jpg" || temp_exten == "jpeg") { this->extension = IMG_EXTEN_JPG; }
+                else if (temp_exten == "png") { this->extension = IMG_EXTEN_PNG; }
+                else { return; } // no valid extension.
+                
+                /* getting file's last modified */
+                const std::time_t time = boost::filesystem::last_write_time( boost::filesystem::path( this->filename ) );
+                this->last_modified = asctime( localtime(&time) );
+                
+                /* checking if the bitmap is valid && decoding if it is */
+                LLImageRaw* raw_image = new LLImageRaw();
+                if ( this->decodeSelf(raw_image) )
+                {
+                        /* creating a shell LLViewerImage and fusing raw image into it */
+                        LLViewerImage* viewer_image = new LLViewerImage( "file://"+this->filename, this->id, LOCAL_USE_MIPMAPS );
+                        viewer_image->createGLTexture( LOCAL_DISCARD_LEVEL, raw_image );
+                        viewer_image->mCachedRawImage = raw_image;
+
+                        /* making damn sure gImageList will not delete it prematurely */
+                        viewer_image->ref(); 
+
+                        /* finalizing by adding LLViewerImage instance into gImageList */
+                        gImageList.addImage(viewer_image);
+
+                        /* filename is valid, bitmap is decoded and valid, i can haz liftoff! */
+                        this->valid = true;
+                }
+        }
+}
+
+LocalBitmap::~LocalBitmap()
+{
+}
+
+/* [maintenence functions] */
+void LocalBitmap::updateSelf()
+{
+        if ( this->linkstatus == LINK_ON || this->linkstatus == LINK_UPDATING )
+        {
+                /* making sure file still exists */
+                if ( !gDirUtilp->fileExists(this->filename) ) { this->linkstatus = LINK_BROKEN; return; }
+
+                /* exists, let's check if it's lastmod has changed */
+                const std::time_t temp_time = boost::filesystem::last_write_time( boost::filesystem::path( this->filename ) );
+                LLSD new_last_modified = asctime( localtime(&temp_time) );
+                if ( this->last_modified.asString() == new_last_modified.asString() ) { return; }
+
+                /* here we update the image */
+                LLImageRaw* new_imgraw = new LLImageRaw();
+                
+                if ( !decodeSelf(new_imgraw) ) { this->linkstatus = LINK_UPDATING; return; }
+                else { this->linkstatus = LINK_ON; }
+
+                LLViewerImage* image = gImageList.hasImage(this->id);
+                
+                if (!image->mForSculpt) 
+                    { image->createGLTexture( LOCAL_DISCARD_LEVEL, new_imgraw ); }
+                else
+                    { image->mCachedRawImage = new_imgraw; }
+
+                /* finalizing by updating lastmod to current */
+                this->last_modified = new_last_modified;
+
+                /* setting unit property to reflect that it has been changed */
+                switch (this->bitmap_type)
+                {
+                        case TYPE_TEXTURE:
+                                  { break; }
+
+                        case TYPE_SCULPT:
+                                  {
+                                          /* sets a bool to run through all visible sculpts in one go, and update the ones necessary. */
+                                          this->sculpt_dirty = true;
+                                          this->volume_dirty = true;
+                                          gLocalBrowser->setSculptUpdated( true );
+                                          break;
+                                  }
+
+                        case TYPE_LAYER:
+                                  {
+                                          /* sets a bool to rebake layers after the iteration is done with */
+                                          gLocalBrowser->setLayerUpdated( true );
+                                          break;
+                                  }
+
+                        default:
+                                  { break; }
+
+                }
+        }
+
+}
+
+bool LocalBitmap::decodeSelf(LLImageRaw* rawimg)
+{
+        switch (this->extension)
+        {
+                case IMG_EXTEN_BMP:
+                        {
+                                LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
+                                if ( !bmp_image->load(filename) ) { break; }
+                                if ( !bmp_image->decode(rawimg, 0.0f) ) { break; }
+
+                                rawimg->biasedScaleToPowerOfTwo( LLViewerImage::MAX_IMAGE_SIZE_DEFAULT );
+                                return true;
+                        }
+
+                case IMG_EXTEN_TGA:
+                        {
+                                LLPointer<LLImageTGA> tga_image = new LLImageTGA;
+                                if ( !tga_image->load(filename) ) { break; }
+                                if ( !tga_image->decode(rawimg) ) { break; }
+
+                                if(     ( tga_image->getComponents() != 3) &&
+                                        ( tga_image->getComponents() != 4) ) { break; }
+
+                                rawimg->biasedScaleToPowerOfTwo( LLViewerImage::MAX_IMAGE_SIZE_DEFAULT );
+                                return true;
+                        }
+
+                case IMG_EXTEN_JPG:
+                        {
+                                LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
+                                if ( !jpeg_image->load(filename) ) { break; }
+                                if ( !jpeg_image->decode(rawimg, 0.0f) ) { break; }
+
+                                rawimg->biasedScaleToPowerOfTwo( LLViewerImage::MAX_IMAGE_SIZE_DEFAULT );
+                                return true;
+                        }
+
+                case IMG_EXTEN_PNG:
+                        {
+                                LLPointer<LLImagePNG> png_image = new LLImagePNG;
+                                if ( !png_image->load(filename) ) { break; }
+                                if ( !png_image->decode(rawimg, 0.0f) ) { break; }
+
+                                rawimg->biasedScaleToPowerOfTwo( LLViewerImage::MAX_IMAGE_SIZE_DEFAULT );
+                                return true;
+                        }
+
+                default:
+                        break;
+        }
+        return false;
+}
+
+void LocalBitmap::setUpdateBool()
+{
+        if ( this->linkstatus != LINK_BROKEN )
+        {
+                if ( !this->keep_updating )
+                {
+                        this->linkstatus = LINK_ON;
+                        this->keep_updating = true;
+                }
+                else
+                {
+                        this->linkstatus = LINK_OFF;
+                        this->keep_updating = false;
+                }
+        }
+        else
+        {
+                this->keep_updating = false;
+        }
+}
+
+void LocalBitmap::setType( S32 type )
+{
+        this->bitmap_type = type;
+}
+
+/* [information query functions] */
+std::string LocalBitmap::getShortName()
+{
+        return this->shortname;
+}
+
+std::string LocalBitmap::getFileName()
+{
+        return this->filename;
+}
+
+LLUUID LocalBitmap::getID()
+{
+        return this->id;
+}
+
+LLSD LocalBitmap::getLastModified()
+{
+        return this->last_modified;
+}
+
+std::string LocalBitmap::getLinkStatus()
+{
+        switch(this->linkstatus)
+        {
+                case LINK_ON:
+                        return "On";
+
+                case LINK_OFF:
+                        return "Off";
+
+                case LINK_BROKEN:
+                        return "Broken";
+
+                case LINK_UPDATING:
+                        return "Updating";
+
+                default:
+                        return "Unknown";
+        }
+}
+
+bool LocalBitmap::getUpdateBool()
+{
+        return this->keep_updating;
+}
+
+bool LocalBitmap::getIfValidBool()
+{
+        return this->valid;
+}
+
+LocalBitmap* LocalBitmap::getThis()
+{
+        return this;
+}
+
+S32 LocalBitmap::getType()
+{
+        return this->bitmap_type;
+}
+
+std::vector<LLFace*> LocalBitmap::getFaceUsesThis(LLDrawable* drawable)
+{
+        std::vector<LLFace*> matching_faces;
+
+        for ( S32 face_iter = 0; face_iter <= drawable->getNumFaces(); face_iter++ )
+        {
+                LLFace* newface = drawable->getFace(face_iter);
+
+                if ( this->id == newface->getTexture()->getID() )
+                { matching_faces.push_back(newface); }
+        }
+
+        return matching_faces;
+}
+
+std::vector<affected_object> LocalBitmap::getUsingObjects(bool seek_by_type, bool seek_textures, bool seek_sculptmaps)
+{
+        std::vector<affected_object> affected_vector;
+        
+        for( LLDynamicArrayPtr< LLPointer<LLViewerObject>, 256 >::iterator  iter = gObjectList.mObjects.begin();
+                 iter != gObjectList.mObjects.end(); iter++ )
+        {
+                LLViewerObject* obj = *iter;
+                affected_object shell;
+                shell.object = obj;
+                shell.local_sculptmap = false;
+                bool obj_relevant = false;
+
+                if ( obj && obj->mDrawable )
+                {
+                        /* looking for textures */
+                        if ( seek_textures || ( seek_by_type && this->bitmap_type == TYPE_TEXTURE ) )
+                        {
+                                std::vector<LLFace*> affected_faces = this->getFaceUsesThis( obj->mDrawable );
+                                if ( !affected_faces.empty() )
+                                {
+                                        shell.face_list = affected_faces;
+                                        obj_relevant = true;
+                                }
+                        }
+
+                        /* looking for sculptmaps */
+                        if ( ( seek_sculptmaps || ( seek_by_type && this->bitmap_type == TYPE_SCULPT ) )
+                                   && obj->isSculpted() && obj->getVolume() 
+                                   && this->id == obj->getVolume()->getParams().getSculptID() 
+                           )    
+                        { 
+                                shell.local_sculptmap = true;
+                                obj_relevant = true;
+                        }
+                }
+
+                if (obj_relevant)
+                { affected_vector.push_back(shell); }
+        }
+
+
+
+        return affected_vector;
+}
+
+void LocalBitmap::getDebugInfo()
+{
+        /* debug function: dumps everything human readable into llinfos */
+        llinfos << "===[local bitmap debug]==="               << "\n"
+                        << "path: "          << this->filename        << "\n"
+                        << "name: "          << this->shortname       << "\n"
+                        << "extension: "     << this->extension       << "\n"
+                        << "uuid: "          << this->id              << "\n"
+                        << "last modified: " << this->last_modified   << "\n"
+                        << "link status: "   << this->getLinkStatus() << "\n"
+                        << "keep updated: "  << this->keep_updating   << "\n"
+                        << "type: "          << this->bitmap_type     << "\n"
+                        << "is valid: "      << this->valid           << "\n"
+                        << "=========================="               << llendl;
+        
+}
+
+/*=======================================*/
+/*  LocalAssetBrowser: internal class  */
+/*=======================================*/ 
+/*
+        Responsible for internal workings.
+        Instantiated at the top of the source file.
+        Sits in memory until the viewer is closed.
+*/
+
+LocalAssetBrowser::LocalAssetBrowser()
+{
+        this->mLayerUpdated = false;
+        this->mSculptUpdated = false;
+}
+
+LocalAssetBrowser::~LocalAssetBrowser()
+{
+
+}
+
+void LocalAssetBrowser::AddBitmap()
+{
+        LLFilePicker& picker = LLFilePicker::instance();
+        if ( !picker.getMultipleOpenFiles(LLFilePicker::FFLOAD_IMAGE) ) 
+           { return; }
+
+        bool change_happened = false;
+        std::string filename = picker.getFirstFile();   
+        while( !filename.empty() )
+        {
+                LocalBitmap* unit = new LocalBitmap( filename );
+
+                if      ( unit->getIfValidBool() )
+                { 
+                        loaded_bitmaps.push_back( unit ); 
+                        change_happened = true;
+                }
+        
+                filename = picker.getNextFile();
+        }
+
+        if ( change_happened )
+        { onChangeHappened(); }
+}
+
+void LocalAssetBrowser::DelBitmap( std::vector<LLScrollListItem*> delete_vector, S32 column )
+{
+        bool change_happened = false;
+        for( std::vector<LLScrollListItem*>::iterator list_iter = delete_vector.begin();
+                 list_iter != delete_vector.end(); list_iter++ )
+        {
+                LLScrollListItem* list_item = *list_iter; 
+                if ( list_item )
+                {
+                        LLUUID id = list_item->getColumn(column)->getValue().asUUID();
+                        for (local_list_iter iter = loaded_bitmaps.begin();
+                                 iter != loaded_bitmaps.end();)
+                        {
+                                LocalBitmap* unit = (*iter)->getThis();
+
+                                if ( unit->getID() == id )
+                                {       
+                                        LLViewerImage* image = gImageList.hasImage(id);
+                                        gImageList.deleteImage( image );
+                                        image->unref();
+
+                                        iter = loaded_bitmaps.erase(iter);
+                                        delete unit;
+                                        unit = NULL;
+
+                                        change_happened = true;
+                                }
+                                else
+                                { iter++; }
+                        }
+                }
+        }
+
+        if ( change_happened )
+        { onChangeHappened(); }
+}
+
+void LocalAssetBrowser::onUpdateBool(LLUUID id)
+{
+        LocalBitmap* unit = GetBitmapUnit( id );
+        if ( unit ) 
+        { 
+                unit->setUpdateBool(); 
+                PingTimer();
+        }
+}
+
+void LocalAssetBrowser::onSetType(LLUUID id, S32 type)
+{
+        LocalBitmap* unit = GetBitmapUnit( id );
+        if ( unit ) 
+        { unit->setType(type); }
+}
+
+LocalBitmap* LocalAssetBrowser::GetBitmapUnit(LLUUID id)
+{
+        local_list_iter iter = loaded_bitmaps.begin();
+        for (; iter != loaded_bitmaps.end(); iter++)
+        { 
+                if ( (*iter)->getID() == id ) 
+                {
+                        return (*iter)->getThis();
+                } 
+        }
+        
+        return NULL;
+}
+
+bool LocalAssetBrowser::IsDoingUpdates()
+{
+        local_list_iter iter = loaded_bitmaps.begin();
+        for (; iter != loaded_bitmaps.end(); iter++)
+        { 
+                if ( (*iter)->getUpdateBool() ) 
+                { return true; } /* if at least one unit in the list needs updates - we need a timer. */
+        }
+
+        return false;
+}
+
+
+/* Reaction to a change in bitmaplist, this function finds a texture picker floater's appropriate scrolllist
+   and passes this scrolllist's pointer to UpdateTextureCtrlList for processing.
+   it also processes timer start/stops as needed */
+void LocalAssetBrowser::onChangeHappened()
+{
+        /* own floater update */
+        FloaterLocalAssetBrowser::UpdateBitmapScrollList();
+
+        /* texturepicker related */
+        const LLView::child_list_t* child_list = gFloaterView->getChildList();
+        LLView::child_list_const_iter_t child_list_iter = child_list->begin();
+
+        for (; child_list_iter != child_list->end(); child_list_iter++)
+        {
+                LLView* view = *child_list_iter;
+                if ( view->getName() == LOCAL_TEXTURE_PICKER_NAME )
+                {
+                        LLScrollListCtrl* ctrl = view->getChild<LLScrollListCtrl>
+                                                                        ( LOCAL_TEXTURE_PICKER_LIST_NAME, 
+                                                                          LOCAL_TEXTURE_PICKER_RECURSE, 
+                                                                          LOCAL_TEXTURE_PICKER_CREATEIFMISSING );
+
+                        if ( ctrl ) { UpdateTextureCtrlList(ctrl); }
+                }
+        }
+
+        /* poking timer to see if it's still needed/still not needed */
+        PingTimer();
+
+}
+
+void LocalAssetBrowser::PingTimer()
+{
+        if ( !loaded_bitmaps.empty() && IsDoingUpdates() )
+        {
+                if (!gLocalBrowserTimer) 
+                { gLocalBrowserTimer = new LocalAssetBrowserTimer(); }
+                
+                if ( !gLocalBrowserTimer->isRunning() )
+                { gLocalBrowserTimer->start(); }
+        }
+
+        else
+        {
+                if (gLocalBrowserTimer)
+                {
+                        if ( gLocalBrowserTimer->isRunning() ) 
+                        { gLocalBrowserTimer->stop(); } 
+                }
+        }
+}
+
+/* This function refills the texture picker floater's scrolllist with the updated contents of bitmaplist */
+void LocalAssetBrowser::UpdateTextureCtrlList(LLScrollListCtrl* ctrl)
+{
+        if ( ctrl ) // checking again in case called externally for some silly reason.
+        {
+                ctrl->clearRows(); 
+                if ( !loaded_bitmaps.empty() )
+                {
+                        local_list_iter iter = loaded_bitmaps.begin();
+                        for ( ; iter != loaded_bitmaps.end(); iter++ )
+                        {
+                                LLSD element;
+                                element["columns"][0]["column"] = "unit_name";
+                                element["columns"][0]["type"] = "text";
+                                element["columns"][0]["value"] = (*iter)->shortname;
+
+                                element["columns"][1]["column"] = "unit_id_HIDDEN";
+                                element["columns"][1]["type"] = "text";
+                                element["columns"][1]["value"] = (*iter)->id;
+
+                                ctrl->addElement(element);
+                        }
+                }
+        }
+}
+
+void LocalAssetBrowser::PerformTimedActions(void)
+{
+        // perform checking if updates are needed && update if so.
+        local_list_iter iter;
+        for (iter = loaded_bitmaps.begin(); iter != loaded_bitmaps.end(); iter++)
+        { (*iter)->updateSelf(); }
+
+        // one or more sculpts have been updated, refreshing them.
+        if ( mSculptUpdated )
+        {
+                LocalAssetBrowser::local_list_iter iter;
+                for(iter = loaded_bitmaps.begin(); iter != loaded_bitmaps.end(); iter++)
+                {
+                        if ( (*iter)->sculpt_dirty )
+                        {
+                                PerformSculptUpdates( (*iter)->getThis() );
+                                (*iter)->sculpt_dirty = false;
+                        }
+                }
+                mSculptUpdated = false;
+        }
+
+        // one of the layer bitmaps has been updated, we need to rebake.
+        if ( mLayerUpdated )
+        {
+            LLVOAvatar* avatar = gAgent.getAvatarObject();
+            if (avatar) { avatar->forceBakeAllTextures(SLAM_FOR_DEBUG); }
+                
+                mLayerUpdated = false;
+        }
+}
+
+void LocalAssetBrowser::PerformSculptUpdates(LocalBitmap* unit)
+{
+
+        /* looking for sculptmap using objects only */
+        std::vector<affected_object> object_list = unit->getUsingObjects(false, false, true);
+        if (object_list.empty()) { return; }
+
+        for( std::vector<affected_object>::iterator iter = object_list.begin();
+                 iter != object_list.end(); iter++ )
+        {
+                affected_object aobj = *iter;
+                if ( aobj.object )
+                {
+                        if ( !aobj.local_sculptmap ) { continue; } // should never get here. only in case of misuse.
+                        
+                        // update code [begin]
+                        if ( unit->volume_dirty )
+                        {
+                                LLImageRaw* rawimage = gImageList.hasImage( unit->getID() )->getCachedRawImage();
+
+                                aobj.object->getVolume()->sculpt(rawimage->getWidth(), rawimage->getHeight(), 
+                                                                                                  rawimage->getComponents(), rawimage->getData(), 0);   
+                                unit->volume_dirty = false;
+                        }
+
+                                // tell affected drawable it's got updated
+                                aobj.object->mDrawable->getVOVolume()->setSculptChanged( true );
+                                aobj.object->mDrawable->getVOVolume()->markForUpdate( true );
+                        // update code [end]
+                }
+                        
+        }
+
+}
+
+/*==================================================*/
+/*  FloaterLocalAssetBrowser : floater class      */
+/*==================================================*/ 
+/*
+        Responsible for talking to the user.
+        Instantiated by user request.
+        Destroyed when the floater is closed.
+
+*/
+
+// Floater Globals
+FloaterLocalAssetBrowser* FloaterLocalAssetBrowser::sLFInstance = NULL;
+
+// widgets:
+        LLButton* mAddBtn;
+        LLButton* mDelBtn;
+        LLButton* mMoreBtn;
+        LLButton* mLessBtn;
+        LLButton* mUploadBtn;
+
+        
+        LLScrollListCtrl* mBitmapList;
+        LLTextureCtrl*    mTextureView;
+        LLCheckBoxCtrl*   mUpdateChkBox;
+
+        LLLineEditor* mPathTxt;
+        LLLineEditor* mUUIDTxt;
+        LLLineEditor* mNameTxt;
+
+        LLTextBox* mLinkTxt;
+        LLTextBox* mTimeTxt;
+        LLComboBox* mTypeComboBox;
+
+        LLTextBox* mCaptionPathTxt;
+        LLTextBox* mCaptionUUIDTxt;
+        LLTextBox* mCaptionLinkTxt;
+        LLTextBox* mCaptionNameTxt;
+        LLTextBox* mCaptionTimeTxt;
+
+FloaterLocalAssetBrowser::FloaterLocalAssetBrowser()
+:   LLFloater(std::string("local_bitmap_browser_floater"))
+{
+        // xui creation:
+    LLUICtrlFactory::getInstance()->buildFloater(this, "floater_local_asset_browse.xml");
+        
+        // setting element/xui children:
+        mAddBtn         = getChild<LLButton>("add_btn");
+        mDelBtn         = getChild<LLButton>("del_btn");
+        mMoreBtn        = getChild<LLButton>("more_btn");
+        mLessBtn        = getChild<LLButton>("less_btn");
+        mUploadBtn      = getChild<LLButton>("upload_btn");
+
+        mBitmapList     = getChild<LLScrollListCtrl>("bitmap_list");
+        mTextureView    = getChild<LLTextureCtrl>("texture_view");
+        mUpdateChkBox   = getChild<LLCheckBoxCtrl>("keep_updating_checkbox");
+
+        mPathTxt            = getChild<LLLineEditor>("path_text");
+        mUUIDTxt            = getChild<LLLineEditor>("uuid_text");
+        mNameTxt            = getChild<LLLineEditor>("name_text");
+
+        mLinkTxt                    = getChild<LLTextBox>("link_text");
+        mTimeTxt                    = getChild<LLTextBox>("time_text");
+        mTypeComboBox       = getChild<LLComboBox>("type_combobox");
+
+        mCaptionPathTxt     = getChild<LLTextBox>("path_caption_text");
+        mCaptionUUIDTxt     = getChild<LLTextBox>("uuid_caption_text");
+        mCaptionLinkTxt     = getChild<LLTextBox>("link_caption_text");
+        mCaptionNameTxt     = getChild<LLTextBox>("name_caption_text");
+        mCaptionTimeTxt     = getChild<LLTextBox>("time_caption_text");
+
+        // pre-disabling line editors, they're for view only and buttons that shouldn't be on on-spawn.
+        mPathTxt->setEnabled( false );
+        mUUIDTxt->setEnabled( false );
+        mNameTxt->setEnabled( false );
+
+        mDelBtn->setEnabled( false );
+        mUploadBtn->setEnabled( false );
+
+        // setting button callbacks:
+        mAddBtn->setClickedCallback(         onClickAdd,         this);
+        mDelBtn->setClickedCallback(         onClickDel,         this);
+        mMoreBtn->setClickedCallback(        onClickMore,        this);
+        mLessBtn->setClickedCallback(        onClickLess,        this);
+        mUploadBtn->setClickedCallback(      onClickUpload,      this);
+        
+        // combo callback
+        mTypeComboBox->setCommitCallback(onCommitTypeCombo);
+
+        // scrolllist callbacks
+        mBitmapList->setCommitCallback(onChooseBitmapList);
+
+        // checkbox callbacks
+        mUpdateChkBox->setCommitCallback(onClickUpdateChkbox);
+
+}
+
+void FloaterLocalAssetBrowser::show(void*)
+{
+    if (!sLFInstance)
+        sLFInstance = new FloaterLocalAssetBrowser();
+    sLFInstance->open();
+        sLFInstance->UpdateBitmapScrollList();
+}
+
+FloaterLocalAssetBrowser::~FloaterLocalAssetBrowser()
+{
+    sLFInstance=NULL;
+}
+
+void FloaterLocalAssetBrowser::onClickAdd(void* userdata)
+{       
+        gLocalBrowser->AddBitmap();
+}
+
+void FloaterLocalAssetBrowser::onClickDel(void* userdata)
+{
+        gLocalBrowser->DelBitmap( sLFInstance->mBitmapList->getAllSelected() );
+}
+
+/* what stopped me from using a single button and simply changing it's label
+   is the fact that i'd need to hardcode the button labels here, and that is griff. */
+void FloaterLocalAssetBrowser::onClickMore(void* userdata)
+{
+        FloaterResize(true);
+}
+
+void FloaterLocalAssetBrowser::onClickLess(void* userdata)
+{
+        FloaterResize(false);
+}
+
+void FloaterLocalAssetBrowser::onClickUpload(void* userdata)
+{
+        std::string filename = gLocalBrowser->GetBitmapUnit( 
+                (LLUUID)sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID) )->getFileName();
+
+        if ( !filename.empty() )
+        {
+                LLFloaterImagePreview* floaterp = new LLFloaterImagePreview(filename);
+                LLUICtrlFactory::getInstance()->buildFloater(floaterp, "floater_image_preview.xml");
+        }
+}
+
+void FloaterLocalAssetBrowser::onChooseBitmapList(LLUICtrl* ctrl, void *userdata)
+{
+        bool button_status = sLFInstance->mBitmapList->isEmpty();
+        sLFInstance->mDelBtn->setEnabled(!button_status);
+        sLFInstance->mUploadBtn->setEnabled(!button_status);
+
+        sLFInstance->UpdateRightSide();
+}
+
+void FloaterLocalAssetBrowser::onClickUpdateChkbox(LLUICtrl *ctrl, void *userdata)
+{
+        std::string temp_str = sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
+        if ( !temp_str.empty() )
+        {
+                gLocalBrowser->onUpdateBool( (LLUUID)temp_str );
+                sLFInstance->UpdateRightSide();
+        }
+}
+
+void FloaterLocalAssetBrowser::onCommitTypeCombo(LLUICtrl* ctrl, void *userdata)
+{
+        std::string temp_str = sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID);
+
+        if ( !temp_str.empty() )
+        {
+                S32 selection = sLFInstance->mTypeComboBox->getCurrentIndex();
+                gLocalBrowser->onSetType( (LLUUID)temp_str, selection ); 
+
+        }
+}
+
+void FloaterLocalAssetBrowser::FloaterResize(bool expand)
+{
+        sLFInstance->mMoreBtn->setVisible(!expand);
+        sLFInstance->mLessBtn->setVisible(expand);
+        sLFInstance->mTextureView->setVisible(expand);
+        sLFInstance->mUpdateChkBox->setVisible(expand);
+        sLFInstance->mCaptionPathTxt->setVisible(expand);
+        sLFInstance->mCaptionUUIDTxt->setVisible(expand);
+        sLFInstance->mCaptionLinkTxt->setVisible(expand);
+        sLFInstance->mCaptionNameTxt->setVisible(expand);
+        sLFInstance->mCaptionTimeTxt->setVisible(expand);
+        sLFInstance->mTypeComboBox->setVisible(expand);
+
+        sLFInstance->mTimeTxt->setVisible(expand);
+        sLFInstance->mPathTxt->setVisible(expand);
+        sLFInstance->mUUIDTxt->setVisible(expand);
+        sLFInstance->mLinkTxt->setVisible(expand);
+        sLFInstance->mNameTxt->setVisible(expand);
+
+        if(expand)
+        { 
+                sLFInstance->reshape(LF_FLOATER_EXPAND_WIDTH, LF_FLOATER_HEIGHT); 
+                sLFInstance->setResizeLimits(LF_FLOATER_EXPAND_WIDTH, LF_FLOATER_HEIGHT);
+                sLFInstance->UpdateRightSide();
+        }
+        else
+        { 
+                sLFInstance->reshape(LF_FLOATER_CONTRACT_WIDTH, LF_FLOATER_HEIGHT);
+                sLFInstance->setResizeLimits(LF_FLOATER_CONTRACT_WIDTH, LF_FLOATER_HEIGHT);
+        }
+
+}
+
+void FloaterLocalAssetBrowser::UpdateBitmapScrollList()
+{
+        if ( !sLFInstance ) { return; }
+
+        sLFInstance->mBitmapList->clearRows();
+        if (!gLocalBrowser->loaded_bitmaps.empty())
+        {
+                
+                LocalAssetBrowser::local_list_iter iter;
+                for(iter = gLocalBrowser->loaded_bitmaps.begin(); iter != gLocalBrowser->loaded_bitmaps.end(); iter++)
+                {
+                        LLSD element;
+                        element["columns"][BITMAPLIST_COL_NAME]["column"] = "bitmap_name";
+                        element["columns"][BITMAPLIST_COL_NAME]["type"]   = "text";
+                        element["columns"][BITMAPLIST_COL_NAME]["value"]  = (*iter)->getShortName();
+
+                        element["columns"][BITMAPLIST_COL_ID]["column"] = "bitmap_uuid";
+                        element["columns"][BITMAPLIST_COL_ID]["type"]   = "text";
+                        element["columns"][BITMAPLIST_COL_ID]["value"]  = (*iter)->getID();
+
+                        sLFInstance->mBitmapList->addElement(element);
+                }
+
+        }
+        sLFInstance->UpdateRightSide();
+}
+
+void FloaterLocalAssetBrowser::UpdateRightSide()
+{
+        /*
+        Since i'm not keeping a bool on if the floater is expanded or not, i'll
+        just check if one of the widgets that shows when the floater is expanded is visible.
+
+        Also obviously before updating - checking if something IS actually selected :o
+        */
+
+        if ( !sLFInstance->mTextureView->getVisible() ) { return; }
+
+        if ( !sLFInstance->mBitmapList->getAllSelected().empty() )
+        { 
+                LocalBitmap* unit = gLocalBrowser->GetBitmapUnit( LLUUID(sLFInstance->mBitmapList->getSelectedItemLabel(BITMAPLIST_COL_ID)) );
+                
+                if ( unit )
+                {
+                        sLFInstance->mTextureView->setImageAssetID( unit->getID() );
+                        sLFInstance->mUpdateChkBox->set( unit->getUpdateBool() );
+                        sLFInstance->mPathTxt->setText( unit->getFileName() );
+                        sLFInstance->mUUIDTxt->setText( unit->getID().asString() );
+                        sLFInstance->mNameTxt->setText( unit->getShortName() );
+                        sLFInstance->mTimeTxt->setText( unit->getLastModified().asString() );
+                        sLFInstance->mLinkTxt->setText( unit->getLinkStatus() );
+                        sLFInstance->mTypeComboBox->selectNthItem( unit->getType() );
+
+                        sLFInstance->mTextureView->setEnabled(true);
+                        sLFInstance->mUpdateChkBox->setEnabled(true);
+                        sLFInstance->mTypeComboBox->setEnabled(true);
+                }
+        }
+        else
+        {
+                sLFInstance->mTextureView->setImageAssetID( NO_IMAGE );
+                sLFInstance->mTextureView->setEnabled( false );
+                sLFInstance->mUpdateChkBox->set( false );
+                sLFInstance->mUpdateChkBox->setEnabled( false );
+
+                sLFInstance->mTypeComboBox->selectFirstItem();
+                sLFInstance->mTypeComboBox->setEnabled( false );
+                
+                sLFInstance->mPathTxt->setText( LLStringExplicit("None") );
+                sLFInstance->mUUIDTxt->setText( LLStringExplicit("None") );
+                sLFInstance->mNameTxt->setText( LLStringExplicit("None") );
+                sLFInstance->mLinkTxt->setText( LLStringExplicit("None") );
+                sLFInstance->mTimeTxt->setText( LLStringExplicit("None") );
+        }
+}
+
+
+/*==================================================*/
+/*     LocalAssetBrowserTimer: timer class          */
+/*==================================================*/ 
+/*
+        A small, simple timer class inheriting from
+        LLEventTimer, responsible for pinging the
+        LocalAssetBrowser class to perform it's
+        updates / checks / etc.
+
+*/
+
+LocalAssetBrowserTimer::LocalAssetBrowserTimer() : LLEventTimer( (F32)TIMER_HEARTBEAT )
+{
+
+}
+
+LocalAssetBrowserTimer::~LocalAssetBrowserTimer()
+{
+
+}
+
+BOOL LocalAssetBrowserTimer::tick()
+{
+        gLocalBrowser->PerformTimedActions();
+        return FALSE;
+}
+
+void LocalAssetBrowserTimer::start()
+{
+        mEventTimer.start();
+}
+
+void LocalAssetBrowserTimer::stop()
+{
+        mEventTimer.stop();
+}
+
+bool LocalAssetBrowserTimer::isRunning()
+{
+        return mEventTimer.getStarted();
+}
+
diff --git a/linden/indra/newview/lltexturectrl.cpp b/linden/indra/newview/lltexturectrl.cpp
index 7946604..38849f9 100644
--- a/linden/indra/newview/lltexturectrl.cpp
+++ b/linden/indra/newview/lltexturectrl.cpp
@@ -68,6 +68,12 @@
 #include "lluictrlfactory.h"
 #include "lltrans.h"
 
+// tag: vaa emerald local_asset_browser [begin]
+#include "floaterlocalassetbrowse.h"
+#include "llscrolllistctrl.h"
+#include "llfilepicker.h"
+#define LOCALLIST_COL_ID 1
+// tag: vaa emerald local_asset_browser [end]
 
 static const S32 CLOSE_BTN_WIDTH = 100;
 const S32 PIPETTE_BTN_WIDTH = 32;
@@ -163,6 +169,18 @@ public:
         static void             onSearchEdit(const std::string& search_string, void* user_data );
         static void             onTextureSelect( const LLTextureEntry& te, void *data );
 
+        // tag: vaa emerald local_asset_browser [begin]
+//      static void     onBtnLocal( void* userdata );
+//      static void     onBtnServer( void* userdata );
+//      static void     switchModes( bool localmode, void* userdata );
+
+        static void     onBtnAdd( void* userdata );
+        static void     onBtnRemove( void* userdata );
+        static void     onBtnBrowser( void* userdata );
+
+        static void     onLocalScrollCommit ( LLUICtrl* ctrl, void *userdata );
+        // tag: vaa emerald local_asset_browser [end]
+
 protected:
         LLPointer<LLViewerImage> mTexturep;
         LLTextureCtrl*          mOwner;
@@ -192,6 +210,7 @@ protected:
         BOOL                            mNoCopyTextureSelected;
         F32                                     mContextConeOpacity;
         LLSaveFolderState       mSavedFolderState;
+        LLScrollListCtrl*   mLocalScrollCtrl; // tag: vaa emerald local_asset_browser
 };
 
 LLFloaterTexturePicker::LLFloaterTexturePicker( 
@@ -236,6 +255,18 @@ LLFloaterTexturePicker::LLFloaterTexturePicker(
         childSetAction("Blank", LLFloaterTexturePicker::onBtnWhite,this);
         childSetAction("Invisible", LLFloaterTexturePicker::onBtnInvisible,this);
 
+        // tag: vaa emerald local_asset_browser [begin]
+//      childSetAction("Local", LLFloaterTexturePicker::onBtnLocal, this);  
+//      childSetAction("Server", LLFloaterTexturePicker::onBtnServer, this);
+        childSetAction("Add", LLFloaterTexturePicker::onBtnAdd, this);
+        childSetAction("Remove", LLFloaterTexturePicker::onBtnRemove, this);
+        childSetAction("Browser", LLFloaterTexturePicker::onBtnBrowser, this);
+
+        mLocalScrollCtrl = getChild<LLScrollListCtrl>("local_name_list");
+        mLocalScrollCtrl->setCallbackUserData(this);                            
+        mLocalScrollCtrl->setCommitCallback(onLocalScrollCommit);
+        LocalAssetBrowser::UpdateTextureCtrlList( mLocalScrollCtrl );
+        // tag: vaa emerald local_asset_browser [end]   
                 
         childSetCommitCallback("show_folders_check", onShowFolders, this);
         childSetVisible("show_folders_check", FALSE);
@@ -763,6 +794,70 @@ void LLFloaterTexturePicker::onBtnSelect(void* userdata)
         self->close();
 }
 
+// tag: vaa emerald local_asset_browser [begin]
+
+// static, switches between showing inventory instance for global bitmaps
+// to showing the scroll list for local ones and back.
+/*
+void LLFloaterTexturePicker::onBtnLocal(void *userdata)
+{
+        switchModes( true, userdata );
+}
+
+void LLFloaterTexturePicker::onBtnServer(void *userdata)
+{
+        switchModes( false, userdata );
+}
+
+void LLFloaterTexturePicker::switchModes(bool localmode, void *userdata)
+{
+        LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
+
+        // servermode widgets
+        self->childSetVisible("Local", !localmode);
+        self->childSetVisible("Default", !localmode);
+        self->childSetVisible("None", !localmode);
+        self->childSetVisible("Blank", !localmode);
+        self->mSearchEdit->setVisible(!localmode);
+        self->mInventoryPanel->setVisible(!localmode);
+        
+        // localmode widgets
+        self->childSetVisible("Server", localmode);
+        self->childSetVisible("Add", localmode);
+        self->childSetVisible("Remove", localmode);
+        self->childSetVisible("Browser", localmode);
+        self->mLocalScrollCtrl->setVisible(localmode);
+}
+*/
+void LLFloaterTexturePicker::onBtnAdd(void *userdata)
+{
+        LocalAssetBrowser::AddBitmap(); 
+}
+
+void LLFloaterTexturePicker::onBtnRemove(void *userdata)
+{
+        LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
+        LocalAssetBrowser::DelBitmap( self->mLocalScrollCtrl->getAllSelected(), LOCALLIST_COL_ID );
+}
+
+void LLFloaterTexturePicker::onBtnBrowser(void *userdata)
+{
+        FloaterLocalAssetBrowser::show(NULL);
+}
+
+// static, reacts to user clicking a valid field in the local scroll list.
+void LLFloaterTexturePicker::onLocalScrollCommit(LLUICtrl *ctrl, void *userdata)
+{
+        LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
+        LLUUID id = (LLUUID)self->mLocalScrollCtrl->getSelectedItemLabel( LOCALLIST_COL_ID ); 
+
+        self->mOwner->setImageAssetID( id );
+        if ( self->childGetValue("apply_immediate_check").asBoolean() )
+        { self->mOwner->onFloaterCommit(LLTextureCtrl::TEXTURE_CHANGE, id); } // calls an overridden function.
+}
+
+// tag: vaa emerald local_asset_browser [end]
+
 // static
 void LLFloaterTexturePicker::onBtnPipette( void* userdata )
 {
@@ -1272,6 +1367,40 @@ void LLTextureCtrl::onFloaterCommit(ETexturePickOp op)
         }
 }
 
+// tag: vaa emerald local_asset_browser [begin]
+
+/*
+   overriding onFloaterCommit to forcefeed it a uuid.
+   also, i still don't get the difference beween mImageItemID and mImageAssetID,
+   they seem to affect the same thing? using mImageAssetID.
+*/
+void LLTextureCtrl::onFloaterCommit(ETexturePickOp op, LLUUID id)
+{
+        LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
+
+        if( floaterp && getEnabled())
+        {
+                mImageItemID = id;
+                mImageAssetID = id; //floaterp->getAssetID(); // using same as on above func. 
+                                                                                                // seems to work anyway.
+
+                if (op == TEXTURE_SELECT && mOnSelectCallback)
+                {
+                        mOnSelectCallback(this, mCallbackUserData);
+                }
+                else if (op == TEXTURE_CANCEL && mOnCancelCallback)
+                {
+                        mOnCancelCallback(this, mCallbackUserData);
+                }
+                else
+                {
+                        onCommit();
+                }
+        }
+}
+
+// tag: vaa emerald local_asset_browser [end]
+
 void LLTextureCtrl::setImageAssetID( const LLUUID& asset_id )
 {
         if( mImageAssetID != asset_id )
diff --git a/linden/indra/newview/lltexturectrl.h b/linden/indra/newview/lltexturectrl.h
index dccdbc5..27ac1e1 100644
--- a/linden/indra/newview/lltexturectrl.h
+++ b/linden/indra/newview/lltexturectrl.h
@@ -140,6 +140,7 @@ public:
 
         void                    onFloaterClose();
         void                    onFloaterCommit(ETexturePickOp op);
+        void                    onFloaterCommit(ETexturePickOp op, LLUUID id); // tag: vaa emerald local_asset_browser
 
         // This call is returned when a drag is detected. Your callback
         // should return TRUE if the drag is acceptable.
diff --git a/linden/indra/newview/llviewerimage.h b/linden/indra/newview/llviewerimage.h
index fc27f17..c82b68b 100644
--- a/linden/indra/newview/llviewerimage.h
+++ b/linden/indra/newview/llviewerimage.h
@@ -313,6 +313,9 @@ public:
 
         void        addFace(LLFace* facep) ;
         void        removeFace(LLFace* facep) ;
+
+        friend class LocalBitmap; // tag: vaa emerald local_asset_browser
+
 private:
         /*virtual*/ void cleanup(); // Cleanup the LLViewerImage (so we can reinitialize it)
 
diff --git a/linden/indra/newview/llviewerobjectlist.h b/linden/indra/newview/llviewerobjectlist.h
index 721bab1..07920cb 100644
--- a/linden/indra/newview/llviewerobjectlist.h
+++ b/linden/indra/newview/llviewerobjectlist.h
@@ -65,6 +65,8 @@ public:
         ~LLViewerObjectList();
 
         void destroy();
+        
+        friend class LocalBitmap; // tag: vaa emerald local_asset_browser
 
         // For internal use only.  Does NOT take a local id, takes an index into
         // an internal dynamic array.
diff --git a/linden/indra/newview/llvovolume.h b/linden/indra/newview/llvovolume.h
index 960f6da..a78aa37 100644
--- a/linden/indra/newview/llvovolume.h
+++ b/linden/indra/newview/llvovolume.h
@@ -211,6 +211,9 @@ public:
         BOOL isVolumeGlobal() const;
         BOOL canBeFlexible() const;
         BOOL setIsFlexible(BOOL is_flexible);
+
+        // tag: vaa emerald local_asset_browser
+        void setSculptChanged(BOOL has_changed) { mSculptChanged = has_changed; }
                         
 protected:
         S32     computeLODDetail(F32    distance, F32 radius);
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_local_asset_browse.xml b/linden/indra/newview/skins/default/xui/en-us/floater_local_asset_browse.xml
new file mode 100644
index 0000000..3ea7ce4
--- /dev/null
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_local_asset_browse.xml
@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<!-- Local Asset Browser: xui -->
+<!-- floater definition start -->
+
+<floater
+        name="local_bitmap_browser_floater"
+        title="Local Bitmap Browser"
+        can_resize="true"
+        can_minimize="true"
+        can_close="true"
+        can_drag_on_left="false"
+        width="415"
+        height="260"
+        min_width="415"
+        min_height="260"
+  rect_control="FloaterLocalbitmapbrowserRect"
+        >
+
+  <!-- floater definition end, left side begin -->
+
+  <button
+                name="add_btn"
+                label="Add"
+                left="12.5"
+                bottom="10"
+                width="90"
+                height="20"
+                />
+  <button
+                name="del_btn"
+                label="Remove"
+                left_delta="100"
+          bottom_delta="0"
+                width="90"
+                height="20"
+                />
+  <button
+    name="upload_btn"
+    label="Upload"
+    left_delta="100"
+    bottom_delta="0"
+    width="90"
+    height="20"
+                />
+  <button
+                name="more_btn"
+                label="More"
+                left_delta="100"
+          bottom_delta="0"
+    width="90"
+                height="20"
+                />
+  <button
+                name="less_btn"
+                label="Less"
+    left_delta="0"
+    bottom_delta="0"
+    width="90"
+    height="20"
+    visible="false"
+    />
+  
+  <scroll_list
+    name="bitmap_list"
+    left="10"
+    bottom_delta="30"
+    width="395"
+    height="200"
+    column_padding="0"
+    can_resize="false"
+    draw_heading="true"
+    multi_select="true"
+    search_column="1"
+    follows="bottom|top"
+                >
+    <column name="bitmap_name" label="Name" dynamicwidth="true" />
+    <column name="bitmap_uuid" label="UUID" width="240" />
+  </scroll_list>
+
+  <!-- left side done, right side begin -->
+
+  <line_editor 
+    bevel_style="in" 
+    border_style="line" 
+    border_thickness="1"
+    mouse_opaque="true"
+                follows="top" 
+    height="16" 
+    bottom_delta="16"
+    left_delta="405"
+    name="path_text"
+          select_all_on_focus_received="true" 
+    width="305" 
+    visible="false"
+    />
+  
+  <text name="path_caption_text"
+    left_delta="0"
+    bottom_delta="20"
+    follows="top"
+    width="100"
+    height="16"
+    visible="false"
+          >
+    Local path:
+  </text>
+
+  <line_editor
+    bevel_style="in"
+    border_style="line"
+    border_thickness="1"
+    mouse_opaque="true"
+                follows="top"
+    height="16"
+    bottom_delta="20"
+    left_delta="0"
+    name="uuid_text"
+          select_all_on_focus_received="true"
+    width="305"
+    visible="false"
+    />
+
+  <text name="uuid_caption_text"
+    left_delta="0"
+    follows="top" 
+    bottom_delta="21"
+    width="260"
+    height="16"
+    visible="false"
+          >
+    Local UdddUID:
+  </text>
+
+  <texture_picker
+    allow_no_texture="false"
+    height="100"
+    width="80"
+    default_image_name="Default"
+    can_apply_immediately="true"
+    follows="left|top"
+    label="Texture"
+    bottom_delta="20"
+    left_delta="0"
+    mouse_opaque="true"
+    name="texture_view"
+    visible="false"
+    />
+
+  <check_box
+    bottom_delta="15"
+    left_delta="100"
+    follows="top"
+    height="16"
+    initial_value="true"
+    label="Keep updating"
+    mouse_opaque="true"
+    name="keep_updating_checkbox"
+    tool_tip="Enable or disable periodic checks if the source bitmap on your hard drive has been updated"
+    width="166"
+    visible="false"
+    enabled="true"
+    />
+
+  <combo_box 
+    visible="false"
+    allow_text_entry="false" 
+    bottom_delta="0" 
+    follows="top" 
+    height="18"       
+    left_delta="120" 
+    max_chars="20" 
+    mouse_opaque="true" 
+    name="type_combobox"
+    width="83"
+    >
+    
+    <combo_item name="type_texture" value="type_texture">
+      Texture
+    </combo_item>
+    
+    <combo_item name="type_sculptie" value="type_sculptie">
+      Sculptmap
+    </combo_item>
+    
+    <combo_item name="type_layer" value="type_layer">
+      Clothing
+    </combo_item>
+  
+  </combo_box>
+  
+  <text name="time_caption_text"
+    left_delta="-115"
+    bottom_delta="25"
+    follows="top" 
+    width="260"
+    height="16"
+    visible="false"
+          >
+    Time:
+  </text>
+  
+  <text name="time_text"
+    left_delta="50"
+    bottom_delta="0"
+    follows="top"
+    width="260"
+    height="16"
+          visible="false"
+    >
+    (date here)
+  </text>
+
+  <text name="link_caption_text"
+    left_delta="-50"
+    bottom_delta="20"
+    follows="top"
+    width="260"
+    height="16"
+    visible="false"
+          >
+    Link:
+  </text>
+  
+  <text name="link_text"
+    left_delta="50"
+    bottom_delta="0"
+    follows="top"
+    width="260"
+    height="16"
+    visible="false"
+    >
+    (link status)
+  </text>
+
+  <text name="name_caption_text"
+    left_delta="-50"
+    bottom_delta="20"
+    follows="top"
+    width="260"
+    height="16"
+    visible="false"
+        >
+    Name:
+  </text>
+
+  <line_editor
+    bevel_style="in"
+    border_style="line"
+    border_thickness="1"
+    mouse_opaque="true"
+                follows="top"
+    height="16"
+    bottom_delta="0"
+    left_delta="50"
+    name="name_text"
+          select_all_on_focus_received="true"
+    width="150"
+    visible="false"
+    />
+
+</floater>
diff --git a/linden/indra/newview/skins/default/xui/en-us/floater_texture_ctrl.xml b/linden/indra/newview/skins/default/xui/en-us/floater_texture_ctrl.xml
index 97b12e0..34cb851 100644
--- a/linden/indra/newview/skins/default/xui/en-us/floater_texture_ctrl.xml
+++ b/linden/indra/newview/skins/default/xui/en-us/floater_texture_ctrl.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 <floater bottom="-516" can_close="true" can_drag_on_left="false" can_minimize="false"
-     can_resize="true" can_tear_off="true" enabled="true" height="290"
-     left="478" min_height="290" min_width="410" mouse_opaque="true"
-     name="texture picker" title="Pick: Texture" width="410">
+     can_resize="true" can_tear_off="true" enabled="true" height="330"
+     left="478" min_height="330" min_width="460" mouse_opaque="true"
+     name="texture picker" title="Pick: Texture" width="460">
         <string name="choose_picture">
                 Click to choose a picture
         </string>
@@ -30,31 +30,62 @@
         <button bottom="-252" enabled="false" follows="left|bottom" font="SansSerifSmall"
              halign="center" height="20" label="Invisible" label_selected="Invisible" left="72"
              mouse_opaque="true" name="Invisible" scale_image="true" width="64" />
-        <check_box bottom="-44" enabled="true" follows="left|top" font="SansSerifSmall"
-             height="24" initial_value="true" label="Show Folders" left="175"
+
+        <check_box bottom="-305" enabled="true" follows="left|bottom" font="SansSerifSmall"
+             height="20" initial_value="true" label="Show Folders" left="4"
              mouse_opaque="true" name="show_folders_check" radio_style="false"
-             width="201" />
-        <search_editor bottom="-36" enabled="true" follows="left|top|right" height="16"
-             label="Type here to search" left="175" mouse_opaque="true"
-             name="inventory search editor" width="231" />
-        <inventory_panel allow_multi_select="false" border="true" bottom="-256" enabled="true"
-             follows="left|top|right|bottom" height="216" left="175" mouse_opaque="true"
-             name="inventory panel" sort_order="TexturePickerSortOrder" width="231" />
-        <check_box bottom="-282" enabled="true" follows="left|bottom" font="SansSerifSmall"
+             width="150" />
+
+        <check_box bottom="-322" enabled="true" follows="left|bottom" font="SansSerifSmall"
              height="20" initial_value="true" label="Apply Immediately" left="4"
              mouse_opaque="true" name="apply_immediate_check" radio_style="false"
              width="150" />
-        <button bottom="-282" enabled="true" follows="left|bottom" font="SansSerif"
+        <button bottom="-322" enabled="true" follows="left|bottom" font="SansSerif"
              halign="center" height="32" image_selected="eye_button_active.tga"
              image_unselected="eye_button_inactive.tga" label="" label_selected=""
              left="139" mouse_opaque="true" name="Pipette" scale_image="true" width="32" />
-        <button bottom="-282" enabled="true" follows="right|bottom" font="SansSerif"
+        <button bottom="-322" enabled="true" follows="right|bottom" font="SansSerif"
              halign="center" height="20" label="Cancel" label_selected="Cancel"
-             left="186" mouse_opaque="true" name="Cancel" scale_image="true" width="100" />
-        <button bottom="-282" enabled="true" follows="right|bottom" font="SansSerif"
+             left="176" mouse_opaque="true" name="Cancel" scale_image="true" width="100" />
+        <button bottom="-322" enabled="true" follows="right|bottom" font="SansSerif"
              halign="center" height="20" label="Select" label_selected="Select"
-             left="290" mouse_opaque="true" name="Select" scale_image="true" width="100" />
+             left="280" mouse_opaque="true" name="Select" scale_image="true" width="100" />
         <string name="pick title">
                 Pick:
         </string>
+
+        <tab_container border="false" bottom_delta="0" width="410" height="300" left="175" mouse_opaque="false" name="actions_tab_container" tab_position="top" follows="left|top|right|bottom">
+    <panel border="false" bottom_delta="0" follows="right|top" height="300" label="Inventory" left="0" mouse_opaque="false" name="server_tab" width="410">
+        <search_editor bottom_delta="-20" enabled="true" follows="left|top|right" height="16"
+                 label="Type here to search" left="0" mouse_opaque="true"
+                 name="inventory search editor" width="271" />
+        <inventory_panel allow_multi_select="false" border="true" bottom="-270" enabled="true"
+                 follows="left|top|right|bottom" height="245" left="0" mouse_opaque="true"
+                 name="inventory panel" sort_order="TexturePickerSortOrder" width="271" />
+    </panel>
+    <panel border="false" bottom_delta="0" follows="left|top" height="300" label="My Computer" left="175" mouse_opaque="false" name="local_tab" width="410">
+  <!-- tag: vaa emerald local_asset_browser [begin] -->
+      <button bottom_delta="-26" enabled="true" follows="left|top" font="SansSerifSmall" halign="center" height="20" label="Add" label_selected="Add" left="4" mouse_opaque="true" name="Add" scale_image="true" width="64" visible="true" />
+      <button bottom_delta="0" enabled="true" follows="left|top" font="SansSerifSmall" halign="center" height="20" label="Remove" label_selected="Remove" left="72" mouse_opaque="true" name="Remove" scale_image="true" width="64" visible="true" />
+      <button bottom_delta="0" enabled="true" follows="left|top" font="SansSerifSmall" halign="center" height="20" label="Browser" label_selected="Browser" left="140" mouse_opaque="true" name="Browser" scale_image="true" width="64" visible="true" />
+          <scroll_list
+                name="local_name_list"
+                    left="0"
+                    bottom="-255"
+                    width="271"
+                    height="225"
+                follows="left|top|right|bottom"
+                column_padding="0"
+                can_resize="false"
+                draw_heading="true"
+                multi_select="true"
+                search_column="1"
+                    visible="true"
+                          >
+            <column name="unit_name" label="Name" dynamicwidth="true" />
+            <column name="unit_id_HIDDEN" label="ID" width="0" />
+          </scroll_list>
+          <!-- tag: vaa emerald local_asset_browser [end] -->
+    </panel>
+  </tab_container>
 </floater>