From f248ce248c8ac0f75fd0219542f4c329204d00f4 Mon Sep 17 00:00:00 2001 From: McCabe Maxsted Date: Wed, 25 Aug 2010 08:18:10 -0700 Subject: Ported local textures from Emerald (requires boost filesystem and system libs to work) --- linden/indra/newview/CMakeLists.txt | 2 + linden/indra/newview/app_settings/settings.xml | 16 + linden/indra/newview/floaterlocalassetbrowse.H | 305 ++++++ linden/indra/newview/floaterlocalassetbrowse.cpp | 1028 ++++++++++++++++++++ linden/indra/newview/lltexturectrl.cpp | 129 +++ linden/indra/newview/lltexturectrl.h | 1 + linden/indra/newview/llviewerimage.h | 3 + linden/indra/newview/llviewerobjectlist.h | 2 + linden/indra/newview/llvovolume.h | 3 + .../xui/en-us/floater_local_asset_browse.xml | 261 +++++ .../default/xui/en-us/floater_texture_ctrl.xml | 67 +- 11 files changed, 1799 insertions(+), 18 deletions(-) create mode 100644 linden/indra/newview/floaterlocalassetbrowse.H create mode 100644 linden/indra/newview/floaterlocalassetbrowse.cpp create mode 100644 linden/indra/newview/skins/default/xui/en-us/floater_local_asset_browse.xml (limited to 'linden/indra/newview') 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 @@ 0 + FloaterLocalbitmapbrowserRect + + Comment + LOLRectangle + Persist + 1 + Type + Rect + Value + + 0 + 400 + 400 + 0 + + FloaterPrimImport Comment 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 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 getFaceUsesThis(LLDrawable*); + std::vector 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, 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 loaded_bitmaps; + typedef std::vector::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 + +/* 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 +#include +#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 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 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 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 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 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 LocalBitmap::getFaceUsesThis(LLDrawable* drawable) +{ + std::vector 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 LocalBitmap::getUsingObjects(bool seek_by_type, bool seek_textures, bool seek_sculptmaps) +{ + std::vector affected_vector; + + for( LLDynamicArrayPtr< LLPointer, 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 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 delete_vector, S32 column ) +{ + bool change_happened = false; + for( std::vector::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 + ( 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 object_list = unit->getUsingObjects(false, false, true); + if (object_list.empty()) { return; } + + for( std::vector::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("add_btn"); + mDelBtn = getChild("del_btn"); + mMoreBtn = getChild("more_btn"); + mLessBtn = getChild("less_btn"); + mUploadBtn = getChild("upload_btn"); + + mBitmapList = getChild("bitmap_list"); + mTextureView = getChild("texture_view"); + mUpdateChkBox = getChild("keep_updating_checkbox"); + + mPathTxt = getChild("path_text"); + mUUIDTxt = getChild("uuid_text"); + mNameTxt = getChild("name_text"); + + mLinkTxt = getChild("link_text"); + mTimeTxt = getChild("time_text"); + mTypeComboBox = getChild("type_combobox"); + + mCaptionPathTxt = getChild("path_caption_text"); + mCaptionUUIDTxt = getChild("uuid_caption_text"); + mCaptionLinkTxt = getChild("link_caption_text"); + mCaptionNameTxt = getChild("name_caption_text"); + mCaptionTimeTxt = getChild("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 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("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 @@ + + + + + + + + +