llfloaterimport.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llfloaterimport.h"

#include "llapr.h"

#include "llimagebmp.h"
#include "llimagetga.h"
#include "llimagejpeg.h"

#include "llagent.h"
#include "llbutton.h"
#include "llcombobox.h"
#include "lldrawable.h"
#include "lldrawpoolavatar.h"
#include "llface.h"
#include "llinventorymodel.h"
#include "lllineeditor.h"
#include "llresourcedata.h"
#include "lltextbox.h"
#include "lltoolmgr.h"
#include "llui.h"
#include "lluploaddialog.h"
#include "llviewercamera.h"
#include "llviewermenufile.h"   // upload_new_resource()
#include "llviewerwindow.h"
#include "llvoavatar.h"
#include "pipeline.h"
#include "viewer.h"
#include "llvieweruictrlfactory.h"
#include "llmd5.h"

extern LLInventoryModel gInventory;

//statics
//LLUploadDialog *LLFloaterImport::sImportDialog = NULL;
LLUUID LLFloaterImport::sImportRequestID;
LLString        LLFloaterImport::sOKText = LLString();

const S32 PREVIEW_BORDER_WIDTH = 2;
const S32 PREVIEW_RESIZE_HANDLE_SIZE = S32(RESIZE_HANDLE_WIDTH * OO_SQRT2) + PREVIEW_BORDER_WIDTH;
const S32 PREVIEW_HPAD = PREVIEW_RESIZE_HANDLE_SIZE;
const S32 PREF_BUTTON_HEIGHT = 16;
const S32 PREVIEW_TEXTURE_HEIGHT = 300;

//-----------------------------------------------------------------------------
// LLFloaterImport()
//-----------------------------------------------------------------------------
LLFloaterImport::LLFloaterImport(const std::string filename)
        : LLFloater("Import")
{
        mFilenameAndPath = filename;

        char file_path[256];    /*Flawfinder: ignore*/
        strncpy(file_path, mFilenameAndPath.c_str(), sizeof(file_path) -1);             /*Flawfinder: ignore*/
        file_path[sizeof(file_path) -1] = '\0';
        char *file_name = strrchr( file_path, gDirUtilp->getDirDelimiter()[0]);
        file_name[0] = 0;

        mFilename.assign(file_name + 1);
        mFilePath.assign(file_path);

        //LLString::toLower(mFilename);
        
        LLXMLNode::parseFile(filename, mObjectFile, NULL);
}

//-----------------------------------------------------------------------------
// postBuild()
//-----------------------------------------------------------------------------
BOOL LLFloaterImport::postBuild()
{
        LLString asset_name = mFilename;
        LLString::replaceNonstandardASCII( asset_name, '?' );
        LLString::replaceChar(asset_name, '|', '?');
        LLString::stripNonprintable(asset_name);
        LLString::trim(asset_name);

        char* asset_name_str = (char*)asset_name.c_str();
        char* end_p = strrchr(asset_name_str, '.');              // strip extension if exists
        if( !end_p )
        {
                end_p = asset_name_str + strlen( asset_name_str );                      /*Flawfinder: ignore*/
        }
                
        S32 len = llmin( (S32) (DB_INV_ITEM_NAME_STR_LEN), (S32) (end_p - asset_name_str) );

        asset_name = asset_name.substr( 0, len );

        setTitle(mFilename);

        {
                // Center the window
                LLRect window_rect = gViewerWindow->getRootView()->getRect();

                S32 dialog_left = window_rect.mLeft + (window_rect.getWidth() - mRect.getWidth()) / 2;
                S32 dialog_bottom = window_rect.mBottom + (window_rect.getHeight() - mRect.getHeight()) / 2;

                translate( dialog_left - mRect.mLeft, dialog_bottom - mRect.mBottom );
        }

        mNameEditor = LLViewerUICtrlFactory::getLineEditorByName(this, "name_form");
        mNameEditor->setMaxTextLength(DB_INV_ITEM_NAME_STR_LEN);
        //mNameEditor->setCommitCallback(onCommit);
        mNameEditor->setPrevalidate(&LLLineEditor::prevalidatePrintableNotPipe);

        mNameEditor->setText(asset_name);

        mDescEditor = LLViewerUICtrlFactory::getLineEditorByName(this, "description_form");
        mDescEditor->setMaxTextLength(DB_INV_ITEM_DESC_STR_LEN);
        //mDescEditor->setCommitCallback(onCommit);
        mDescEditor->setPrevalidate(&LLLineEditor::prevalidatePrintableNotPipe);

        // Cancel button
        mCancelBtn = LLViewerUICtrlFactory::getButtonByName(this, "cancel_btn");
        mCancelBtn->setClickedCallback(onBtnCancel);
        mCancelBtn->setCallbackUserData(this);

        // OK button
        mOKBtn = LLViewerUICtrlFactory::getButtonByName(this, "ok_btn");
        mOKBtn->setClickedCallback(onBtnOK);
        mOKBtn->setCallbackUserData(this);
        setDefaultBtn(mOKBtn);

        mImageLabel = LLViewerUICtrlFactory::getTextBoxByName(this, "preview_label");
        mImportList = LLViewerUICtrlFactory::getScrollListByName(this, "upload_list");

        bool object_file_read = false;
        int object_count = 0, image_count = 0;
        if (mObjectFile)
        {
                LLXMLNodeList object_list;
                mObjectFile->findName("object", object_list);
                LLXMLNodeList::iterator itor;
                LLXMLNodeList::iterator itor2;
                for (itor = object_list.begin(); itor != object_list.end(); ++itor)
                {
                        LLXMLNode *object = itor->second;
                        LLXMLNodeList tasks_list;
                        object->getChildren("task", tasks_list, FALSE);
                        for (itor2 = tasks_list.begin(); itor2 != tasks_list.end(); ++itor2)
                        {
                                LLXMLNode *task = itor2->second;
                                LLXMLNodePtr temp_node;
                                if (!task->getChild("root", temp_node, FALSE))
                                {
                                        // This task is a root
                                        LLString task_name = "(unnamed object)";
                                        LLXMLNodePtr task_name_node;
                                        if (task->getChild("name", task_name_node, FALSE))
                                        {
                                                task_name_node->getStringValue(1, &task_name);
                                        }
                                        {
                                                LLString output_line;
                                                char buffer[20];                /*Flawfinder: ignore*/
                                                snprintf(buffer, sizeof(buffer), "%d", (S32)tasks_list.size()); /* Flawfinder: ignore */
                                                output_line.append(buffer);
                                                output_line.append(" prims");

                                                LLSD row;
                                                row["columns"][0]["value"] = "OBJECT";
                                                row["columns"][0]["width"] = 60;
                                                row["columns"][1]["value"] = output_line;
                                                row["columns"][1]["width"] = 80;
                                                row["columns"][2]["value"] = task_name;
                                                row["enabled"] = false;
                                                mImportList->addElement(row);
                                        }
                                        mImportList->setCanSelect(TRUE);
                                        mImportList->setAllowMultipleSelection(TRUE);
                                        object_file_read = true;
                                        object_count++;
                                        break;
                                }
                        }
                }

                if (object_count > 0)
                {
                        std::string::size_type pos = mFilenameAndPath.rfind(".");
                        if (pos != mFilenameAndPath.npos)
                        {
                                mInventoryPath = mFilenameAndPath.substr(0, pos);
                        }
                        else
                        {
                                mInventoryPath = mFilenameAndPath;
                        }
                        mInventoryPath.append("_inventory");

                        LLXMLNodeList image_list;
                        mObjectFile->findName("sl:image", image_list);
                        std::vector<LLString> unique_images;
                        std::vector<LLUUID> unique_ids;
                        std::vector<bool> image_changed;
                        for (itor = image_list.begin(); itor != image_list.end(); ++itor)
                        {
                                LLXMLNode *image_node = itor->second;
                                LLString image_id = image_node->getID();

                                LLUUID image_uuid;
                                image_node->getUUIDValue(1, &image_uuid);

                                bool found_image = false;
                                for (U32 image_num=0; image_num<unique_images.size(); ++image_num)
                                {
                                        if (unique_images[image_num] == image_id)
                                        {
                                                found_image = true;
                                                continue;
                                        }
                                }
                                if (!found_image)
                                {
                                        unique_images.push_back(image_id);
                                        unique_ids.push_back(image_uuid);

                                        LLString node_hash = "00000000000000000000000000000000";
                                        LLXMLNodePtr image_hash_node;
                                        if (image_node->getChild("checksum", image_hash_node))
                                        {
                                                image_hash_node->getStringValue(1, &node_hash);
                                        }

                                        llinfos << "Node hash: " << node_hash << llendl;

                                        // Try to find image and get checksum
                                        LLString image_path = mInventoryPath;
                                        image_path.append(gDirUtilp->getDirDelimiter());
                                        image_path.append(image_id);
                                        image_path.append(".tga");

                                        llinfos << "Getting hash for " << image_path << llendl;

                                        char md5_hash_string[33];       /*Flawfinder: ignore*/
                                        strcpy(md5_hash_string, "00000000000000000000000000000000");                    /*Flawfinder: ignore*/
                                        FILE* fCheck = LLFile::fopen(image_path.c_str(), "rb"); /*Flawfinder: ignore*/
                                        if (fCheck)
                                        {
                                                LLMD5 my_md5_hash(fCheck); // this fclose()s fCheck too
                                                my_md5_hash.hex_digest(md5_hash_string);

                                                llinfos << "hash: " << md5_hash_string << llendl;
                                        }

                                        LoadPreviewImage(image_path, image_uuid);

                                        if (memcmp(md5_hash_string, node_hash.c_str(), 32) == 0)
                                        {
                                                // Image has not changed
                                                image_changed.push_back(false);
                                        }
                                        else
                                        {
                                                // Image has changed
                                                image_changed.push_back(true);
                                        }
                                }
                        }
                        for (U32 image_num=0; image_num<unique_images.size(); ++image_num)
                        {
                                LLSD row;
                                row["columns"][0]["value"] = "IMAGE";
                                row["columns"][0]["width"] = 60;
                                row["columns"][1]["value"] = image_changed[image_num]?"NEW":"NOT NEW";
                                row["columns"][1]["width"] = 80;
                                row["columns"][2]["value"] = unique_images[image_num];
                                mImportList->addElement(row);
                                mImportList->setCanSelect(TRUE);
                                image_count++;
                        }
                }
        }

        if (!object_file_read)
        {
                mImportList->addSimpleItem("Error: Invalid object file.", ADD_BOTTOM, FALSE);
                mImportList->setCanSelect(FALSE);
                mOKBtn->setEnabled(FALSE);
        }
        else
        {
                recalcCost();
        }

        return TRUE;
}

void LLFloaterImport::LoadPreviewImage(LLString image_path, LLUUID image_uuid)
{
        LLPointer<LLImageRaw> raw_image = new LLImageRaw;
        LLPointer<LLImageTGA> tga_image = new LLImageTGA;

        if (!tga_image->load(image_path))
        {
                return;
        }
        
        if (!tga_image->decode(raw_image))
        {
                return;
        }

        if(     (tga_image->getComponents() != 3) &&
                (tga_image->getComponents() != 4) )
        {
                tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
                return;
        }

        raw_image->biasedScaleToPowerOfTwo(256);

        mPreviewImages[image_uuid] = raw_image;
}

//-----------------------------------------------------------------------------
// LLFloaterImport()
//-----------------------------------------------------------------------------
LLFloaterImport::~LLFloaterImport()
{
        if (mGLName)
        {
                glDeleteTextures(1, &mGLName );
        }
}

//-----------------------------------------------------------------------------
// recalcCost()
//-----------------------------------------------------------------------------
void LLFloaterImport::recalcCost()
{
        /*S32 cost = 0;
        LLScrollListItem *item = mImportList->getFirstData();
        while (item)
        {
                LLString item_type = item->getColumn(0)->getText();

                if (item_type == "IMAGE" && item->getSelected())
                {
                        cost += 10; // hypothetical image cost
                }
                if (item_type == "OBJECT")
                {
                        cost += 10; // hypothetical object cost
                }
                item = mImportList->getNextData();
        }

        char buffer[20];
        sOKText = "Upload (L$";
        sprintf(buffer, "%d", cost);
        sOKText.append(buffer);
        sOKText.append(")");
        mOKBtn->setLabelSelected(sOKText.c_str());
        mOKBtn->setLabelUnselected(sOKText.c_str());
        mOKBtn->setEnabled(TRUE);*/
}

//-----------------------------------------------------------------------------
// draw()
//-----------------------------------------------------------------------------
void LLFloaterImport::draw()
{
        LLFloater::draw();

        LLRect PreviewImageRect;
        BOOL has_rect = childGetRect("dummy_preview", PreviewImageRect);
        
        if (mCurrentPreviewImage.notNull() && has_rect)
        {
                gl_rect_2d_checkerboard(PreviewImageRect);

                GLenum format_options[4] = { GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
                GLenum format = format_options[mCurrentPreviewImage->getComponents()-1];

                GLenum internal_format_options[4] = { GL_LUMINANCE8, GL_LUMINANCE8_ALPHA8, GL_RGB8, GL_RGBA8 };
                GLenum internal_format = internal_format_options[mCurrentPreviewImage->getComponents()-1];
        
                if (mGLName)
                {
                        LLImageGL::bindExternalTexture( mGLName, 0, GL_TEXTURE_2D ); 
                }
                else
                {
                        glGenTextures(1, &mGLName );
                        stop_glerror();

                        LLImageGL::bindExternalTexture( mGLName, 0, GL_TEXTURE_2D ); 
                        stop_glerror();

                        glTexImage2D(
                                GL_TEXTURE_2D, 0, internal_format, 
                                mCurrentPreviewImage->getWidth(), mCurrentPreviewImage->getHeight(),
                                0, format, GL_UNSIGNED_BYTE, mCurrentPreviewImage->getData());
                        stop_glerror();

                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                        
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                }

                glColor3f(1.f, 1.f, 1.f);
                glBegin( GL_QUADS );
                {
                        glTexCoord2f(0, 1);
                        glVertex2i(PreviewImageRect.mLeft, PreviewImageRect.mTop);
                        glTexCoord2f(0, 0);
                        glVertex2i(PreviewImageRect.mLeft, PreviewImageRect.mBottom);
                        glTexCoord2f(1, 0);
                        glVertex2i(PreviewImageRect.mRight, PreviewImageRect.mBottom);
                        glTexCoord2f(1, 1);
                        glVertex2i(PreviewImageRect.mRight, PreviewImageRect.mTop);
                }
                glEnd();

                LLImageGL::unbindTexture(0, GL_TEXTURE_2D);

                stop_glerror();
        }
}

// static
void LLFloaterImport::finishImport(ImportAssetInfo *info)
{
        // Commenting this code out and removing 
        // ObjectImport message from the message template
        /*
        llinfos << "Uploading object " << info->FilenameAndPath << "..." << llendl;

        LLUUID new_file_id;
        new_file_id.generate();
        bool generated_file = false;

        {
                // Copy file into a local directory
                LLString new_file = "TEMP";
                new_file.append(new_file_id.asString());
                new_file.append(".slobject");

                S32 length;
                apr_file_t* fIn = ll_apr_file_open(info->FilenameAndPath.c_str(), LL_APR_RB, &length);
                if (fIn)
                {
                        apr_file_t* fOut = ll_apr_file_open(new_file, LL_APR_WB);
                        if (fOut)
                        {
                                char  *buffer = new char[length];
                                ll_apr_file_read(fIn, buffer, length);
                                ll_apr_file_write(fOut, buffer, length);
                                delete[] buffer;
                                generated_file = true;
                                apr_file_close(fOut);
                        }
                        apr_file_close(fIn);
                }
        }

        if (generated_file)
        {
                LLMessageSystem *msg = gMessageSystem;
                msg->newMessageFast(_PREHASH_ObjectImport);
                msg->nextBlockFast(_PREHASH_AgentData);
                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
                msg->addUUIDFast(_PREHASH_FolderID, gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT));
                msg->nextBlockFast(_PREHASH_AssetData);
                msg->addUUIDFast(_PREHASH_FileID, new_file_id);
                msg->addStringFast(_PREHASH_ObjectName, info->Name);
                msg->addStringFast(_PREHASH_Description, info->Desc);
                msg->sendReliable(gAgent.getRegionHost());

                LLUploadDialog::modalUploadDialog("Importing geometry...");

                sImportRequestID = new_file_id;
        }
        else
        {
                llinfos << "Failed to copy file." << llendl;
        }*/
}

// static
void LLFloaterImport::asset_uploaded_callback(const LLUUID& uuid, void* user_data, S32 result, LLExtStat ext_status)
{
        llinfos << "LLFloaterImport: Finished uploading image." << llendl;
        LLResourceData *resource_data = (LLResourceData*)user_data;
        ImportAssetInfo *info = (ImportAssetInfo*)resource_data->mUserData;

        info->NewImageIDList.push_back(resource_data->mAssetInfo.mUuid.asString());

        LLUploadDialog::modalUploadFinished();
        if (info->ImageFileQueue.size() == 0)
        {
                finishImport(info);
        }
        else
        {
                // Start the next download
                LLString current_image = info->ImageFileQueue[0].c_str();
                info->ImageFileQueue.erase(info->ImageFileQueue.begin());

                upload_new_resource(current_image, info->Name, // file
                        info->Desc, 0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE, 
                        PERM_NONE, LLString::null, asset_uploaded_callback, info);
        }
}

//-----------------------------------------------------------------------------
// static onBtnOK()
//-----------------------------------------------------------------------------
void LLFloaterImport::onBtnOK(void*userdata)
{
        LLFloaterImport *fp =(LLFloaterImport*)userdata;

        ImportAssetInfo *asset_info = new ImportAssetInfo();
        asset_info->Name = fp->mNameEditor->getText();
        asset_info->Desc = fp->mDescEditor->getText();
        asset_info->FilenameAndPath = fp->mFilenameAndPath;
        asset_info->SourcePath = fp->mInventoryPath;

        std::vector<LLScrollListItem*> items = fp->mImportList->getAllSelected();
        std::vector<LLScrollListItem*>::iterator itor;
        if (items.size() > 0)
        {
                for (itor = items.begin(); itor != items.end(); ++itor)
                {
                        LLUUID id = (*itor)->getUUID();

                        //if (!id->isNull())
                        LLString *image_id = (LLString *)(*itor)->getUserdata();
                        if (image_id)
                        {
                                asset_info->OldImageIDList.push_back(id.asString());
                                LLString image_file = fp->mInventoryPath;
                                image_file.append(gDirUtilp->getDirDelimiter());
                                image_file.append(*image_id);
                                image_file.append(".tga");
                                llinfos << "Uploading image " << image_file << "..." << llendl;
                                asset_info->ImageFileQueue.push_back(image_file);
                        }
                }
                if (asset_info->ImageFileQueue.size() == 0)
                {
                        finishImport(asset_info);
                }
                else
                {
                        // Start the first download
                        LLString current_image = asset_info->ImageFileQueue[0].c_str();
                        asset_info->ImageFileQueue.erase(asset_info->ImageFileQueue.begin());

                        upload_new_resource(current_image, asset_info->Name, // file
                                asset_info->Desc, 0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE, 
                                PERM_NONE, LLString::null, asset_uploaded_callback, asset_info);
                }
        }
        else
        {
                finishImport(asset_info);
        }

        fp->close(false);
}

//-----------------------------------------------------------------------------
// static onBtnCancel()
//-----------------------------------------------------------------------------
void LLFloaterImport::onBtnCancel(void*userdata)
{
        LLFloaterImport *fp =(LLFloaterImport*)userdata;
        fp->close(false);
}


//-----------------------------------------------------------------------------
// virtual handleMouseDown()
//-----------------------------------------------------------------------------
BOOL LLFloaterImport::handleMouseDown(S32 x, S32 y, MASK mask)
{
        BOOL ret = LLFloater::handleMouseDown(x, y, mask);
        recalcCost();

        LLUUID current_preview_uuid;
        LLString current_preview_name = "none";

        LLScrollListItem *item;
        
        // Did we just select something?
        item = mImportList->getLastSelectedItem();
        if (item)
        {
                current_preview_uuid = item->getUUID();
                current_preview_name = item->getColumn(2)->getText();
        }
        else
        {
                // If not, see if exactly one object is selected
                std::vector<LLScrollListItem*> items = mImportList->getAllSelected();
                std::vector<LLScrollListItem*>::iterator itor;
                for (itor = items.begin(); itor != items.end(); ++itor)
                {
                        if (current_preview_uuid.isNull())
                        {
                                current_preview_uuid = (*itor)->getUUID();
                                current_preview_name = (*itor)->getColumn(2)->getText();
                        }
                        else
                        {
                                // More than one item is selected. Turn off preview
                                current_preview_uuid.setNull();
                                current_preview_name = "none";
                                break;
                        }
                }
        }

        mCurrentPreviewImage = NULL;
        if (current_preview_uuid.notNull())
        {
                image_map_t::iterator itor;
                itor = mPreviewImages.find(current_preview_uuid);
                if (itor != mPreviewImages.end())
                {
                        mCurrentPreviewImage = itor->second;
                        if (mGLName)
                        {
                                glDeleteTextures(1, &mGLName );
                        }
                        mGLName = 0;
                }
        }
        LLString label_text = "Image Preview: ";
        label_text.append(current_preview_name);
        mImageLabel->setText(label_text);

        return ret;
}

---