Torque3D/Templates/BaseGame/game/tools/assetBrowser/scripts/assetBrowser.tscript

//AssetBrowser.addToolbarButton
function AssetBrowser::addToolbarButton(%this)
{
	%button = new GuiBitmapButtonCtrl() {
		canSaveDynamicFields = "0";
		internalName = AssetBrowserBtn;
		Enabled = "1";
		isContainer = "0";
		Profile = "ToolsGuiButtonProfile";
		HorizSizing = "right";
		VertSizing = "bottom";
		position = "180 0";
		Extent = "25 19";
		MinExtent = "8 2";
		canSave = "1";
		Visible = "1";
		Command = "AssetBrowser.ShowDialog();";
		tooltipprofile = "ToolsGuiToolTipProfile";
		ToolTip = "Asset Browser";
		hovertime = "750";
		bitmapAsset = "ToolsModule:assetBrowser_n_image";
		bitmapMode = "Stretched";
		buttonType = "ToggleButton";
		groupNum = "0";
		useMouseEvents = "0";
	};
	ToolsToolbarArray.add(%button);
	EWToolsToolbar.setExtent((29 + 4) * (ToolsToolbarArray.getCount()) + 4 SPC "32");
}
//

//
function AssetBrowser::registerAssetType(%assetTypeName, %humanReadableName, %assetClassNamesList, %showInFilters)
{
   if(%showInFilters $= "")
      %showInFilters = true;
      
   ABAssetTypesList.add("Asset", %assetTypeName TAB %humanReadableName TAB %assetClassNamesList TAB %showInFilters);
}

function AssetBrowser::registerFileType(%fileTypeName, %humanReadableName, %fileExtensionsList, %showInFilters)
{
   if(%showInFilters $= "")
      %showInFilters = true;
      
   ABAssetTypesList.add("File", %fileTypeName TAB %humanReadableName TAB %fileExtensionsList TAB %showInFilters);
}

function AssetBrowser::registerObjectType(%objectTypeName, %humanReadableName, %objectClassNames, %showInFilters)
{
   if(%showInFilters $= "")
      %showInFilters = true;
      
   ABAssetTypesList.add("Object", %objectTypeName TAB %humanReadableName TAB %objectClassNames TAB %showInFilters);
}

function AssetBrowser::callAssetTypeFunc(%this, %type, %function, %param0, %param1, %param2, %param3, %param4)
{
   //echo("AssetBrowser::callAssetTypeFunc() - deets: " @ %type @ ", " @ %function @ ", " @ %param0 @ ", " @ %param1 @ ", " @ %param2 @ ", " @ %param3 @ ", " @ %param4);
   $paramCache0 = %param0;
   $paramCache1 = %param1;
   $paramCache2 = %param2;
   $paramCache3 = %param3;
   $paramCache4 = %param4;
   
   $CurrentAssetBrowser = %this;
   
   //look up the type group
   %typeGroup = "";
   %typeData = "";
   for(%i=0; %i < ABAssetTypesList.count(); %i++)
   {
      %group = ABAssetTypesList.getKey(%i);
      %typeData = ABAssetTypesList.getValue(%i);

      if(getField(%typeData, 0) $= %type)
      {
         %typeGroup = %group;
         %typeData = %typeData;
         break;
      }
   }
   
   %paramOffset = 0;
   %isStaticCall = false;
   %command = "";
   if(%typeGroup $= "Asset")
   {
      //check to see if the first param is an asset definition
      if(isObject(%param0) && %param0.isInNamespaceHierarchy("AssetBase"))
      {
         if(%param0.isMethod(%function))
         {
            %command = %param0 @ "." @ %function @ "(";
            %paramOffset = 1;
         }
         else
         {
            %command = "GenericAsset::" @ %function @ "(" @ %param0;
            %paramOffset = 1;
            %isStaticCall = true;
         }
      }
      else
      {
         if(AssetDatabase.isDeclaredAsset(%param0))
         {
            %assetDef = AssetDatabase.acquireAsset(%param0);
            if(%assetDef.isMethod(%function))
            {
               %command = %assetDef @ "." @ %function @ "(";
               %paramOffset = 1;
            }
            else
            {
               %command = "GenericAsset::" @ %function @ "(" @ %assetDef;
               %paramOffset = 1;
               %isStaticCall = true;
            }
         }
         else
         {
            //we may have to build the assetID
            %assetId = %param0 @ ":" @ %param1;
            if(AssetDatabase.isDeclaredAsset(%assetId))
            {
               %assetDef = AssetDatabase.acquireAsset(%assetId);
               
               if(%assetDef.isMethod(%function))
               {
                  %command = %assetDef @ "." @ %function @ "(";
                  %paramOffset = 2;
               }
               else
               {
                  %command = "GenericAsset::" @ %function @ "(" @ %assetDef;
                  %paramOffset = 2;
                  %isStaticCall = true;
               }
            }
         }
      }
   }
   else if(%typeGroup $= "File")
   {
      %compoundPath = %param0 @ "/" @ %param1;
      if(isFile(%compoundPath) || isDirectory(%compoundPath))
      {
         if(isMethod(%type, %function))
         {
            %command = %type @ "::" @ %function @ "(\"" @ %compoundPath @ "\"";
            %paramOffset = 2;
            %isStaticCall = true;
         }
         else
         {
            %command = "GenericAsset::" @ %function @ "(\"" @ %compoundPath @ "\"";
            %paramOffset = 2;
            %isStaticCall = true;
         }
      }
      else if(isFile(%param0) || isDirectory(%param0))
      {
         if(isMethod(%type, %function))
         {
            %command = %type @ "::" @ %function @ "(\"" @ %param0 @ "\"";
            %paramOffset = 1;
            %isStaticCall = true;
         }
         else
         {
            %command = "GenericAsset::" @ %function @ "(\"" @ %param0 @ "\"";
            %paramOffset = 1;
            %isStaticCall = true;
         }
      }
   }
   else if(%typeGroup $= "Object")
   {
      if(isObject(%param0) && %param0.isMethod(%function))
      {
         %command = %param0 @ "." @ %function @ "(";
         %paramOffset = 1;
      }
      else
      {
         if(isMethod(%type, %function))
         {
            %command = %type @ "::" @ %function @ "(";
            %isStaticCall = true;
         }
      }
   }
   
   if(%command $= "")
   {
      //check in case it's a purely static type call with no usual incoming vars. 
      //Usually only relevent for create functions
      if($paramCache0 $= "" && $paramCache1 $= "" && isMethod(%type, %function))
      {
         %command = %type @ "::" @ %function @ "(";
         %isStaticCall = true;
      }
      else if(isMethod("GenericAsset", %function))
      {
         %command = "GenericAsset::" @ %function @ "(";
         %isStaticCall = true;
      }
      else
      {
         error("AssetBrowser::callAssetTypeFunc() - unable to find a valid type: " @ %type @ " with function: " @ %function);
         return;
      }
   }
   
   for(%i=%paramOffset; %i < 5; %i++)
   {
      %paramVar = getVariable("$paramCache" @ %i);
      if(%paramVar !$= "")
      {
         if(%paramOffset != 0 && %i==%paramOffset && %isStaticCall)
            %command = %command @ ",";
            
         if(getWordCount(%paramVar) > 1 || strPos(%paramVar, "/") != 0 || stePos(%paramVar, "\\") != 0)
            %command = %command @ "\"" @ %paramVar @ "\"";
         else
            %command = %command @ %paramVar;
      }
      %nextParamVar = getVariable("$paramCache" @ %i+1);
      if(%nextParamVar !$= "")
      {
         %command = %command @ ",";
      }
   }
   
   %command = %command @ ");";
   
   //echo("AssetBrowser::callAssetTypeFunc() - executing command: " @ %command);
      
   %return = "";
   if(%command !$= "")
      %return = eval(%command);
      
   $CurrentAssetBrowser = "";
   
   return %return;
}

function AssetBrowser::getAssetTypeGroup(%typeName)
{
   %typeGroup = "";
   %typeData = "";
   for(%i=0; %i < ABAssetTypesList.count(); %i++)
   {
      %group = ABAssetTypesList.getKey(%i);
      %typeData = ABAssetTypesList.getValue(%i);

      if(getField(%typeData, 0) $= %typeName)
      {
         %typeGroup = %group;
         %typeData = %typeData;
         break;
      }
   }
   
   return %typeGroup;
}

//
function AssetBrowser::initialize(%this)
{
   // manage preview array
   if(!isObject(AssetPreviewArray))
      new ArrayObject(AssetPreviewArray);
      
   if(!isObject(ObjectCreator))
      new ScriptObject(ObjectCreator);
      
   if(!isObject(%this.dirHandler))
   {
      %this.dirHandler = makedirectoryHandler(%this-->filterTree, "cache,shaderCache,previewCache", ""); 
      %this.dirHandler.currentAddress = "data/";
   }
      
   %this-->filterTree.buildIconTable( ":tools/classIcons/Prefab:tools/classIcons/Prefab" @
                                             ":tools/classIcons/SimSet:tools/classIcons/SimSet");
      
   %this.isReImportingAsset = false;
   
   %this.coreModulesFilter = false;
   %this.toolsModulesFilter = false;
   %this.onlyShowModulesWithAssets = false;
   
   %this.folderPanelState = true;
   %this.folderPanelSplit = 0;
   
   %this.templateFilesPath = "tools/assetBrowser/scripts/templateFiles/";
   
   //First, build our our list of active modules
   %modulesList = ModuleDatabase.findModules(true);
   
   %this-->previewSlider.setValue(EditorSettings.value("Assets/Browser/previewTileSize", "1.0"));
   
   %this-->filterAssetsButton.setActive(true); 
   
   %this.toggleAssetTypeFilter(0);
}

function AssetBrowser::onAdd(%this)
{
}

function AssetBrowser::onWake(%this)
{
   %this.initialize();
   
   // Make the window fit next to the side panel
   // We do a simple resize so that we don't have to redo the whole GUI layout
   %newWidth = getWord($pref::Video::mode, 0) - 360;
   %vertPos = getWord($pref::Video::mode, 1) - 360 - 35;
   AssetBrowserWindow.resize("0", %vertPos, %newWidth, "360");
   AssetBrowserWindow.dockPanel();
}

function AssetBrowser::onDialogPop(%this)
{
   $AssetBrowser::Open = false;
   %lastPosExt = AssetBrowserWindow.position SPC AssetBrowserWindow.extent;
   EditorSettings.setValue("Assets/Browser/LastPosExt", %lastPosExt);
}

function AssetBrowser::onDialogPush(%this)
{
   $AssetBrowser::Open = true;
   EditorGui.updateSideBar();
}

function AssetBrowser::setTab(%this, %tab, %text, %command)
{
   if(isObject(%tab))
   {
      %tab.setActive(true);
      %tab.setHidden(false);
      %tab.setText(%text);
      %tab.command = %command;
   }
}

function AssetBrowser::putToFront(%this)
{
   // Close the object
   %this.hideDialog();
   // Create the object again so it will render on top
   %this.ShowDialog();
   // Put the focus on this window
   %this.restoreLastPosExt();
   AssetBrowserWindow.selectWindow();
}

function AssetBrowser::restoreLastPosExt(%this)
{
   %lastPosExt = EditorSettings.value("Assets/Browser/LastPosExt", ""); 
   if(%lastPosExt !$= "")
   {
      AssetBrowserWindow.resize(getWord(%lastPosExt, 0), getWord(%lastPosExt, 1), getWord(%lastPosExt, 2), getWord(%lastPosExt, 3));
   }    
   EditorGui.updateSideBar();
}

function contentTreeTabBook::onTabSelected(%this, %tabText, %tabIndex)
{
   if(%tabText $= "Content")
   {
      //Force it to navigate to current active directory, which also rebuilds the
      //tree
      AssetBrowser.dirHandler.navigateTo(AssetBrowser.dirHandler.currentAddress);
   }
   else
   {
      AssetBrowser-->filterTree.clear();
      AssetBrowser-->filterTree.buildVisibleTree(true);
   }
}

//Filters
function AssetBrowser::showFilterPopup(%this)
{
   BrowserVisibilityPopup.showPopup(Canvas);
}

function AssetBrowser::viewCoreModulesFilter(%this)
{
   %oldVal = EditorSettings.value("Assets/Browser/showCoreModule", false);
   %newVal = !%oldVal;
   
   %this.coreModulesFilter = %newVal;
   
   BrowserVisibilityPopup.checkItem(0,%newVal);
   
   EditorSettings.setValue("Assets/Browser/showCoreModule", %newVal);
    
   AssetBrowser.loadDirectories();
}

function AssetBrowser::viewToolsModulesFilter(%this)
{
   %oldVal = EditorSettings.value("Assets/Browser/showToolsModule", false);
   %newVal = !%oldVal;
   
   %this.toolsModulesFilter = %newVal;
   
   BrowserVisibilityPopup.checkItem(1,%newVal);
   
   EditorSettings.setValue("Assets/Browser/showToolsModule", %newVal);
    
   %this.loadDirectories();
}

function AssetBrowser::viewPopulatedModulesFilter(%this)
{
   %oldVal = EditorSettings.value("Assets/Browser/showOnlyPopulatedModule", false);
   %newVal = !%oldVal;
   
   BrowserVisibilityPopup.checkItem(2,%newVal);
   
   EditorSettings.setValue("Assets/Browser/showOnlyPopulatedModule", %newVal);
    
   %this.loadDirectories();
}

function AssetBrowser::toggleShowingFolders(%this)
{
   %oldVal = EditorSettings.value("Assets/Browser/showFolders", false);
   %newVal = !%oldVal;
   
   BrowserVisibilityPopup.checkItem(4,%newVal);
   
   EditorSettings.setValue("Assets/Browser/showFolders", %newVal);
    
   %this.loadDirectories();
}

function AssetBrowser::toggleShowingEmptyFolders(%this)
{
   %oldVal = EditorSettings.value("Assets/Browser/showEmptyFolders", false);
   %newVal = !%oldVal;
   
   BrowserVisibilityPopup.checkItem(5,%newVal);
   
   EditorSettings.setValue("Assets/Browser/showEmptyFolders", %newVal);
    
   %this.refresh();
}

function AssetBrowser::toggleAssetTypeFilter(%this, %assetTypeIdx)
{
   %isChecked = AssetTypeListPopup.isItemChecked(%assetTypeIdx);
   
   //Clear existing filters
   if(%assetTypeIdx == 0)
   {
      for(%i=0; %i < ABAssetTypesList.Count(); %i++)
      {
         AssetTypeListPopup.checkItem(%i+2, false);  
      }
      
      AssetTypeListPopup.checkItem(0, true);
   }
   else if(%assetTypeIdx > 1) //slot 1 is the divider so ignore it
   {
      if(%isChecked)
      {
         %anyOtherFilters = false;
         for(%i=0; %i < ABAssetTypesList.Count(); %i++)
         {
            if(%assetTypeIdx == %i+2)
               continue;
               
            if(AssetTypeListPopup.isItemChecked(%i+1))
            {
               %anyOtherFilters = true;
               break;  
            }
         }
      }
      
      if(%isChecked && !%anyOtherFilters)
      {
         for(%i=0; %i < ABAssetTypesList.Count(); %i++)
         {
            AssetTypeListPopup.checkItem(%i+2, false);  
         }
      
         AssetTypeListPopup.checkItem(0, true);
      }
      else
      {
         AssetTypeListPopup.checkItem(0, false);
         AssetTypeListPopup.checkItem(%assetTypeIdx, !%isChecked);
      }
   }
   
   //Update the displayed search text!
   //First, clear out the old type search term
   for(%i=0; %i < AssetSearchTerms.count(); %i++)
   {
      %action = AssetSearchTerms.getKey(%i);

      if(%action $= "type")
      {
         AssetSearchTerms.erase(%i);
         %i--;
      }
   }

   for(%i=2; %i < AssetTypeListPopup.getItemCount(); %i++)
   {
      %isChecked = AssetTypeListPopup.isItemChecked(%i);
      if(!%isChecked)
         continue;
         
      %typeListText = AssetTypeListPopup.getItemText(%i);
         
      for(%t=0; %t < ABAssetTypesList.Count(); %t++)
      {
         %typeData = ABAssetTypesList.getValue(%t);
         %typeName = getField(%typeData, 1);
         
         if(%typeListText $= %typeName)
         {
            AssetSearchTerms.add("type", getField(%typeData, 0));
            break;
         }
      }
   }
   
   %this.updateSearchTextFromFilter();
   
   %this.rebuildAssetArray();
}

//
function AssetBrowser::selectAsset( %this, %asset )
{
   if(%this.selectCallback !$= "")
   {
      // The callback function should be ready to intake the returned material
      //eval("materialEd_previewMaterial." @ %propertyField @ " = " @ %value @ ";");
      if( %this.returnType $= "name" )
      {
         // TODO!
         %name = "";
         eval( "" @ %this.selectCallback @ "(" @ %name  @ ");");
      }
      else
      {
         %command = "" @ %this.selectCallback @ "(\"" @ %asset  @ "\");";
         eval(%command);
      }
   }
   else
   {
      //try just setting the asset
      %this.changeAsset();
   }
   
   if(isObject(Inspector))
   Inspector.refresh();
   
   %this.hideDialog();
}

function AssetBrowser::showDialog( %this, %AssetTypeFilter, %selectCallback, %targetObj, %fieldName, %returnType)
{
   // Set the select callback
   %this.selectCallback = %selectCallback;
   %this.returnType = %returnType;
   %this.assetTypeFilter = %AssetTypeFilter;
   %this.fieldTargetObject = %targetObj;
   %this.fieldTargetName = %fieldName;

   Canvas.popDialog(%this);
   Canvas.pushDialog(%this);
   
   %this.setVisible(1);
   AssetBrowserWindow.setVisible(1);
   AssetBrowserWindow.selectWindow();
   
   if(AssetBrowserWindow.docked)
      AssetBrowserWindow.dockPanel();
   else
      AssetBrowserWindow.releasePanel();
   
   //If we're special-case filtering(like for selecting a given type), then ignore our normal
   //visibility filter
   if(%AssetTypeFilter !$= "")
   {
      %this-->filterAssetsButton.setActive(false);
   }
   else
   {
      %this-->filterAssetsButton.setActive(true);  
   }
   
   if(%selectCallback $= "")
   {
      //we're not in selection mode, so just hide the select button
      %this-->SelectButton.setHidden(true);  
      %this.selectMode = 0;
   }
   else
   {
      %this-->SelectButton.setHidden(false); 
      %this.selectMode = 1;
   }

   %this.loadDirectories();
   
   %this.restoreLastPosExt();
}

function AssetBrowser::hideDialog( %this )
{
   %this.setVisible(1);
   AssetBrowserWindow.setVisible(1);
   Canvas.popDialog(AssetBrowser_addModule);
   Canvas.popDialog(ImportAssetWindow);
   
   Canvas.popDialog(%this);
}

function AssetBrowser::toggleDialog( %this )
{
   if(%this.isAwake())
   {
      %this.hideDialog();
   }
   else
   {
      %this.showDialog();
   }
}

function AssetBrowser::buildAssetPreview( %this, %asset, %moduleName )
{
   if(!isObject(%this.previewData))
   {
      %this.previewData = new ScriptObject();      
   }
   else
   {
      %this.previewData.tooltip = "";
      %this.previewData.assetName = "";
      %this.previewData.previewImage = "";
      %this.previewData.doubleClickCommand = "";
   }
   
   %previewImage = "core/art/warnmat";
   
   if(/*%moduleName !$= "" && */ModuleDatabase.findModule(%moduleName, 1) !$= "")
   {
      %assetDesc = AssetDatabase.acquireAsset(%asset);
      %assetName = AssetDatabase.getAssetName(%asset);
      %assetType = AssetDatabase.getAssetType(%asset);
   }
   else
   {
      //special-case entry
      if(getFieldCount(%asset) > 1)
      {
         %assetType = getField(%asset,0);
         %assetName = getField(%asset, 1);
         
         if(%assetType $= "Creator")
         {
            %assetDesc = %assetName;
            %assetDesc.assetType = %assetType;
            %moduleName = %assetDesc;
         }
      }
   }

   %previewSize = 100 SPC 100;
   %previewBounds = 20;
   
   %tooltip = %assetName;
   
   %textBottomPad = 20;

   %previewScaleSize = %this-->previewSlider.getValue();
   
   if(%previewScaleSize $= "")
   {
      %previewScaleSize = 1;
      %this-->previewSlider.setValue(1);
   }
   
   if(%this.selectMode)
   {
      %doubleClickCommand = %this @ ".selectAsset( "@ %this @ ".selectedAsset );";
   }
   else
   {
      %doubleClickCommand = %this @ ".callAssetTypeFunc(" @ %assetType @ ", \"onEdit\", \"" @ %moduleName @ "\", \"" @ %assetName @ "\" );";
   }
   
   %this.previewData.previewLoaded = true;
   
   //echo("AssetBrowser::buildAssetPreview() - building preview of asset type: " @ %assetType);
   %this.callAssetTypeFunc(%assetType, "buildBrowserElement", %moduleName, %assetName, %this.previewData);
   
   //debug dump
   %tooltip = %this.previewData.tooltip;
   %assetName = %this.previewData.assetName;
   %previewImage = %this.previewData.previewImage;
   
   if(%this.previewData.doubleClickCommand !$= "")
      %doubleClickCommand = %this.previewData.doubleClickCommand;
      
   %previewButton = new GuiIconButtonCtrl()
   {
      class = "AssetBrowserPreviewButton";
      useMouseEvents = true;
      iconLocation = "Center";
      sizeIconToButton = true;
      makeIconSquare = true;
      textLocation = "Bottom";
      extent = %previewSize.x SPC %previewSize.y + %textBottomPad;
      buttonType = "RadioButton";
      buttonMargin = "0 -10";
      profile = ToolsGuiDefaultIconBtnProfile;
      tooltip =  %this.previewData.tooltip;
      assetBrowser = %this;
      assetName = %assetName;
      moduleName = %moduleName;
      assetType = %assetType;
      bitmapAsset = %this.previewData.previewImage;
      Command = %this @ ".updateSelection( $ThisControl.assetName, $ThisControl.moduleName );";
      altCommand = %doubleClickCommand;
      text = %this.previewData.assetName;
      originalAssetName = %this.previewData.assetName;
   };
   
   if(%previewScaleSize == 0 || startsWith(%this.dirHandler.currentAddress, "Creator"))
   {
      %previewButton.iconLocation = "Left";
      %previewButton.textLocation = "Right";
      %previewButton.setextent(160,34);
      %previewButton.buttonMargin = "8 8";
      %previewButton.textMargin = "6";
      
      %this.previewListMode = true;
   }
   else
   {
      %size = %previewSize.x * %previewScaleSize;
      %previewButton.setextent(%size,%size + %textBottomPad);
      
      %this.previewListMode = false;
   }
   
   // add to the gui control array
   %this-->assetList.add(%previewButton);
   
   // add to the array object for reference later
   if(%this.previewData.previewLoaded == false)
      AssetPreviewArray.add( %previewButton );
}

function AssetBrowser::refresh(%this, %regenPreviews)
{
   if(%regenPreviews $= "")
      %regenPreviews = true;
      
   if(!%this.dirty && %regenPreviews)
   {
      %this.dirty = true;
      
      %this.schedule(1, "doRefresh");
   }
}

function AssetBrowser::doRefresh(%this)
{
   if(%this.dirty)
   {
      %this.navigateTo(%this.dirHandler.currentAddress);  
      
      //Forces a clean collapse of the tree for any not-really-exposed items
      %dataItem = %this-->filterTree.findItemByName("data");

      if(%dataItem != 0)
      {
         %this-->filterTree.expandItem(%dataItem, false);
         %this-->filterTree.expandItem(%dataItem);
      }
      
      %this.dirty = false;
   }
}

function AssetBrowser::populatePreviewImages(%this)
{
   for(%i=0; %i < AssetPreviewArray.count(); %i++)
   {
      %previewButton = AssetPreviewArray.getKey(%i);
      %assetType = %previewButton.assetType;
      
      %this.callAssetTypeFunc(%assetType, "generatePreviewImage", %previewButton.moduleName, %previewButton.assetName, %previewButton);
      
      AssetPreviewArray.erase(%i);

      %this.schedule(32, "populatePreviewImages");
      return;
   }
}
//
//
/*function AssetPreviewButton::onClick(%this)
{
   echo("CLICKED AN ASSET PREVIEW BUTTON");
}

function AssetPreviewButton::onDoubleClick(%this)
{
   echo("DOUBLE CLICKED AN ASSET PREVIEW BUTTON");
}*/
//
//

function assetBrowserPreviewSlider::onMouseDragged(%this)
{
   EditorSettings.setValue("Assets/Browser/previewTileSize", %this.getValue());
   AssetBrowser.refresh(false);  
}

function AssetBrowser::loadDirectories( %this )
{
   %this-->filterTree.clear();
   
   %dataItem = AssetBrowser-->filterTree.insertItem(0, "Content");
   %this-->filterTree.collectionsIdx = %this-->filterTree.insertItem(1, "Collections");
   
   %this-->filterTree.modulesIdx = %this-->filterTree.insertItem(1, "Modules");
   
   %dataItem = AssetBrowser-->filterTree.insertItem(AssetBrowser-->filterTree.modulesIdx, "data");
   %this-->filterTree.tagsIdx = %this-->filterTree.insertItem(1, "Tags");
   
   %this-->filterTree.creatorIdx = %this-->filterTree.insertItem(1, "Creator");
   
   %this-->filterTree.clearSelection();
      
   if(%this.selectMode)
   {
      //Due to a fluke in how this tracks, it overrides the current addres, so we'll
      //store it real fast
      %curAdd = %this.dirHandler.currentAddress;
      
      //Disable these for this go
      %this-->filterTree.addSelection(%this-->filterTree.collectionsIdx);
      %this-->filterTree.addSelection(%this-->filterTree.creatorIdx);
      %this-->filterTree.hideSelection();
      %this-->filterTree.clearSelection();
      
      %this.dirHandler.currentAddress = %curAdd;
   }
   
   %this.dirHandler.loadFolders("data", %dataItem);
   
   %this.loadCollectionSets();
   
   %this.loadTags();
   
   if (!%this.selectMode)
      %this.loadCreatorClasses();
   
   //If set to, show core
   if(EditorSettings.value("Assets/Browser/showCoreModule", false) == 1)
   {
      %coreItem = %this-->filterTree.insertItem(%this-->filterTree.modulesIdx, "core");
      %this.dirHandler.loadFolders("core", %coreItem);
   }
   
   //If set to, show tools
   if(EditorSettings.value("Assets/Browser/showToolsModule", false) == 1)
   {
      %toolsItem = %this-->filterTree.insertItem(%this-->filterTree.modulesIdx, "tools");
      %this.dirHandler.loadFolders("tools", %toolsItem);
   }
   
   %this-->filterTree.buildVisibleTree(true);
   
   //Remove any modules that have no assets if we have that filter on
   if(%this.onlyShowModulesWithAssets)
   {
      %modulesList = ModuleDatabase.findModules();
      for(%i=0; %i < getWordCount(%modulesList); %i++)
      {
         %moduleName = getWord(%modulesList, %i).ModuleId;
         
         %moduleItemId = %this-->filterTree.findItemByName(%moduleName);
         
         if(%this-->filterTree.isParentItem(%moduleItemId) == false)
            %this-->filterTree.removeItem(%moduleItemId);
      }
   }
  
   //special handling for selections
   if(%this.newModuleId !$= "")
   {
      %this-->filterTree.clearSelection();
      %newModuleItem = %this-->filterTree.findItemByName(%this.newModuleId);
      %this-->filterTree.selectItem(%newModuleItem);
      %this.newModuleId = ""; 
   }
   
   %this.dirHandler.expandTreeToAddress(%this.dirHandler.currentAddress);
   
   %selectedItem = %this.dirHandler.getFolderTreeItemFromAddress(%this.dirHandler.currentAddress);
   %this-->filterTree.scrollVisibleByObjectId(%selectedItem);
   
   %this-->filterTree.buildVisibleTree(true); 
   
   %this.refresh();
}

function AssetBrowser::updateSelection( %this, %asset, %moduleName )
{
   //If we had an existing selected assetDef, clear the reference
   if(isObject(AssetBrowser.selectedAssetDef))
      AssetDatabase.releaseAsset(AssetBrowser.selectedAssetDef.getAssetId());
   
   //AssetBrowser.selectedMaterial = %asset;
   AssetBrowser.selectedAsset = %moduleName@":"@%asset;
   
   //If it's got slashes, it's a path so it's actually a folder item, not an asset
   if(strstr(%moduleName, "/") != -1)
      return;
      
   //Check if this is an actual assetId, or if it's just a programmatic reference
   //like what we use for the creator entries
   if(AssetDatabase.isDeclaredAsset(AssetBrowser.selectedAsset))
   {
      //Looks good, it's an asset so we'll select the definition while we're at it
   AssetBrowser.selectedAssetDef = AssetDatabase.acquireAsset(AssetBrowser.selectedAsset);
   }
}

function AssetBrowser::loadCollectionSets(%this)
{
   //Process any datablocks and populate their lists categories as tags as well
   %collectionsItem = AssetBrowser-->filterTree.collectionsIdx;
   
   %collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
   
   for ( %i = 0; %i < %collectionsCount; %i++ )
   {
      %collection = AssetBrowserCollectionSets.value("Collection"@%i, "");
      %collectionName = getField(%collection, 0);
      %collectionTerm = getField(%collection, 1);
      
      AssetBrowser-->filterTree.insertItem(%collectionsItem, %collectionName, %collectionTerm);
   }
}

function AssetBrowser::setCollectionSetActive(%this, %collectionSet)
{
   AssetBrowserSearchFilter.setText(%collectionSet);
   AssetBrowserSearchFilter.onReturn();
}

function AssetBrowser::loadTags(%this)
{
   //Process any datablocks and populate their lists categories as tags as well
   %dataGroup = "DataBlockGroup";
   %tagItem = AssetBrowser-->filterTree.tagsIdx;
   
   for ( %i = 0; %i < %dataGroup.getCount(); %i++ )
   {
      %obj = %dataGroup.getObject(%i);
      // echo ("Obj: " @ %obj.getName() @ " - " @ %obj.category );
      
      if ( %obj.category $= "" && %obj.category == 0 )
         continue;
         
      %tagChildItem = AssetBrowser-->filterTree.findChildItemByName(%tagItem, %obj.category);
      if(%tagChildItem == 0)
      {
         //Didn't already exist, so register it in
         AssetBrowser-->filterTree.insertItem(%tagItem, %obj.category);
      }
   }
}

function AssetBrowser::setTagActive(%this, %tag)
{
   %found = false;
   
   for(%i=0; %i < AssetSearchTerms.count(); %i++)
   {
      %action = AssetSearchTerms.getKey(%i);
      %word = AssetSearchTerms.getValue(%i);
      
      if(%action $= "tag" && %word $= %tag)
      {
         //If we found it, we just remove it from our list, toggling it off
         AssetSearchTerms.erase(%i);
         %found = true;
      }
   }
   
   //If we didn't find it, we're going to add it into our list
   if(!%found)
   {
      AssetSearchTerms.add("tag", %tag);
   }
   
   %this.updateSearchTextFromFilter();
   
   %this.rebuildAssetArray();
}

//
//needs to be deleted with the persistence manager and needs to be blanked out of the matmanager
//also need to update instances... i guess which is the tricky part....
function AssetBrowser::showDeleteDialog( %this )
{
   %material = AssetBrowser.selectedAsset;
   %secondFilter = "MaterialFilterMappedArray";
   %secondFilterName = "Mapped";
   
   for( %i = 0; %i < MaterialFilterUnmappedArray.count(); %i++ )
   {
      if( MaterialFilterUnmappedArray.getValue(%i) $= %material )
      {
         %secondFilter = "MaterialFilterUnmappedArray";
         %secondFilterName = "Unmapped";
         break;
      }
   }
   
   if( isObject( %material ) )
   {
      toolsMessageBoxYesNoCancel("Delete Material?", 
         "Are you sure you want to delete<br><br>" @ %material.getName() @ "<br><br> Material deletion won't take affect until the engine is quit.", 
         "AssetBrowser.deleteMaterial( " @ %material @ ", " @ %secondFilter @ ", " @ %secondFilterName @" );", 
         "", 
         "" );
   }
}

function AssetBrowser::deleteMaterial( %this, %materialName, %secondFilter, %secondFilterName )
{
   if( !isObject( %materialName ) )
      return;
   
   for( %i = 0; %i <= MaterialFilterAllArray.countValue( %materialName ); %i++)
   {
      %index = MaterialFilterAllArray.getIndexFromValue( %materialName );
      MaterialFilterAllArray.erase( %index );
   }
   MaterialFilterAllArrayCheckbox.setText("All ( " @ MaterialFilterAllArray.count() - 1 @ " ) ");
   
   %checkbox = %secondFilter @ "Checkbox";
   for( %k = 0; %k <= %secondFilter.countValue( %materialName ); %k++)
   {
      %index = %secondFilter.getIndexFromValue( %materialName );
      %secondFilter.erase( %index );
   }
   %checkbox.setText( %secondFilterName @ " ( " @ %secondFilter.count() - 1 @ " ) ");
   
   for( %i = 0; %materialName.getFieldValue("materialTag" @ %i) !$= ""; %i++ )
   {
      %materialTag = %materialName.getFieldValue("materialTag" @ %i);
         
         for( %j = AssetBrowser.staticFilterObjects; %j < AssetBrowser-->filterArray.getCount() ; %j++ )
         {
            if( %materialTag $= AssetBrowser-->filterArray.getObject(%j).getObject(0).filter )
            {
               %count = getWord( AssetBrowser-->filterArray.getObject(%j).getObject(0).getText(), 2 );
               %count--;
               AssetBrowser-->filterArray.getObject(%j).getObject(0).setText( %materialTag @ " ( "@ %count @ " )");
            }
         }
      
   }
   
   UnlistedMaterials.add( "unlistedMaterials", %materialName );
   
   if( %materialName.getFilename() !$= "" && 
         %materialName.getFilename() !$= "tools/gui/AssetBrowser.ed.gui" &&
         %materialName.getFilename() !$= "tools/materialEditor/scripts/materialEditor.ed." @ $TorqueScriptFileExtension )
   {
      AssetBrowserPerMan.removeObjectFromFile(%materialName);
      AssetBrowserPerMan.saveDirty();
   }
      
   AssetBrowser.refresh();
}

function AssetBrowser::toggleTagFilterPopup(%this)
{
	if(TagFilterWindow.visible)
		TagFilterWindow.visible = false;
	else
		TagFilterWindow.visible = true;
		
	return;
   %assetQuery = new AssetQuery();
   %numAssetsFound = AssetDatabase.findAllAssets(%assetQuery);
   
   for( %i=0; %i < %numAssetsFound; %i++)
   {
	    %assetId = %assetQuery.getAsset(%i);
		
		//first, get the asset's module, as our major categories
		%module = AssetDatabase.getAssetModule(%assetId);
		
		%moduleName = %module.moduleId;
		
		//check that we don't re-add it
		%moduleItemId = AssetBrowser-->filterTree.findItemByName(%moduleName);
		
		if(%moduleItemId == -1 || %moduleItemId == 0)
			%moduleItemId = AssetBrowser-->filterTree.insertItem(1, %module.moduleId, "", "", 1, 2);
			
		//now, add the asset's category
		%assetType = AssetDatabase.getAssetCategory(%assetId);
		
      // TODO?
      %text = "";
      %var = "";
      %cmd = "";
      %textLength = strlen(%text);
      // end todo

		%checkBox = new GuiCheckBoxCtrl()
		{
			canSaveDynamicFields = "0";
			isContainer = "0";
			Profile = "ToolsGuiCheckBoxListProfile";
			HorizSizing = "right";
			VertSizing = "bottom";
			Position = "0 0";
			Extent = (%textLength * 4) @ " 18";
			MinExtent = "8 2";
			canSave = "1";
			Visible = "1";
			Variable = %var;
			tooltipprofile = "ToolsGuiToolTipProfile";
			hovertime = "1000";
			text = %text;
			groupNum = "-1";
			buttonType = "ToggleButton";
			useMouseEvents = "0";
			useInactiveState = "0";
			Command = %cmd;
		};
		
		TagFilterList.add(%checkBox);
   }	
}

function AssetBrowser::changeAsset(%this)
{
   %targetObject = %this.fieldTargetObject;
   %inspectorObject = "";
   
   if(isObject(%this.fieldTargetObject) && %this.fieldTargetObject.isInNamespaceHierarchy("GuiInspector"))
   {
      %inspectorObject = %this.fieldTargetObject;
      if(%inspectorObject.getNumInspectObjects() != 0)
      {
         %targetObject = %inspectorObject.getInspectObject();
         %cmd = %targetObject @ "." @ %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
      }
      else if(startsWith(%this.fieldTargetName, "$"))
      {
         //we're targeting a variable directly, so deal with that then
         %cmd = %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
      }
   }
   else if(isObject(%this.fieldTargetObject))
   {
      //alright, we've selectd an asset for a field, so time to set it!
      if(%this.fieldTargetName $= "")
         %cmd = %targetObject @ ".apply(\""@ %this.selectedAsset @ "\");";
      else
         %cmd = %targetObject @ "." @ %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
      //echo("Changing asset via the " @ %cmd @ " command");
   }
   else if(startsWith(%this.fieldTargetName, "$"))
   {
      //we're targeting a variable directly, so deal with that then
      %cmd = %this.fieldTargetName @ "=\"" @ %this.selectedAsset @ "\";";
   }
   
   eval(%cmd);
   
   //Force update our object with the field change
   if(isObject(%targetObject))
   {
      if(%this.fieldTargetObject.isInNamespaceHierarchy("GuiInspector"))
         %this.fieldTargetObject.refresh();
      else
         %targetObject.inspectPostApply();
   }
   
   //Flag us as dirty for editing purposes
   EWorldEditor.setSceneAsDirty();
}

function AssetBrowser::reImportAsset(%this)
{
   //Find out what type it is
   %assetDef = AssetDatabase.acquireAsset(EditAssetPopup.assetId);
   %assetType = AssetDatabase.getAssetType(EditAssetPopup.assetId);
      
   if(%assetType $= "ShapeAsset" || %assetType $= "ImageAsset" || %assetType $= "SoundAsset")
   {
      AssetBrowser.isAssetReImport = true;
      AssetBrowser.reImportingAssetId = EditAssetPopup.assetId;
      
      %reimportingPath = %assetDef.originalFilePath;
      
      if(%reimportingPath $= "" || !isFile(%reimportingPath))
      {
         //if we have no defined original file path, attempt to re-import the 
         //current loosefile
         if(%assetType $= "ShapeAsset")
            %reimportingPath = %assetDef.getShapePath();
         else if(%assetType $= "ImageAsset")
            %reimportingPath = %assetDef.getImagePath();
         else if(%assetType $= "SoundAsset")
            %reimportingPath = %assetDef.getSoundPath();
      }
      
      //first, double-check we have an originating file. if we don't then we need to basically go out looking for it
      if(!isFile(%reimportingPath))
      {
         //if(%assetType $= "ImageAsset")
         //   %filters = "";
            
         //TODO
         %currentFile = "";

         %dlg = new OpenFileDialog()
         {
            Filters = "(All Files (*.*)|*.*|";
            DefaultFile = %currentFile;
            ChangePath = false;
            MustExist = true;
            MultipleFiles = false;
            forceRelativePath = false;
         };
            
         if ( %dlg.Execute() )
         {
            %reimportingPath = %dlg.FileName;
         }
         
         %dlg.delete();
      }
      
      AssetBrowser.onBeginDropFiles();
      AssetBrowser.onDropFile(%reimportingPath);
      AssetBrowser.onEndDropFiles();
      
      %module = AssetDatabase.getAssetModule(EditAssetPopup.assetId);
      
      //get the selected module data
      ImportAssetModuleList.setText(%module.ModuleId);
   }
}

//
//
// RMB context popups
function AssetBrowserPreviewButton::onRightClick(%this)
{
   %this.assetBrowser.selectedAssetPreview = %this;
   %this.assetBrowser.callAssetTypeFunc(%this.assetType, "onShowActionMenu", %this.moduleName, %this.assetName);
}

//function AssetListPanel::onRightMouseDown(%this)
function AssetListPanelInputs::onRightMouseDown(%this)
{
   AddNewAssetPopup.showPopup(Canvas);
}

function AssetBrowserFilterTree::onRightMouseDown(%this, %itemId)
{
   %count = %this.getSelectedItemsCount();
   
   %itemText = %this.getItemText(%itemId);
   %parentItem = %this.getParentItem(%itemId);
   if(%parentItem == %this.tagsIdx)
   {
   }
   else if(%parentItem == %this.collectionsIdx)
   {
      EditCollectionSets.showPopup(Canvas); 
      AssetBrowser.selectedCollectionSet = %itemText;
   }
   else if(%parentItem == %this.creatorIdx)
   {
   }
   else
   {
      if( %this.getSelectedItemsCount() > 0 && (%itemText !$= "data" && %itemText !$="core" && %itemText !$= "tools"))
      {
         //AddNewAssetPopup.showPopup(Canvas);  
         
         //We have something clicked, so figure out if it's a sub-filter or a module filter, then push the correct
         //popup menu
         %parentItem = %this.getParentItem(%itemId);
         if(%this.getItemText(%parentItem) $= "data") //if it's a data module, continue
         {
            //find out if it's a folder or a module!
            if(ModuleDatabase.findModule(%itemText))
            {
               //yep, module, push the all-inclusive popup  
               EditModulePopup.showPopup(Canvas); 
               //also set the module value for creation info
               AssetBrowser.selectedModule = %itemText;
            }
            else
            {
               EditNonModulePopup.showPopup(Canvas);
               EditNonModulePopup.targetFolder = %itemText;
            }
         }
         else
         {
            EditFolderPopup.showPopup(Canvas);
            EditFolderPopup.assetType = "Folder";  
         }
      }
      else if(%itemText $= "data")
      {
         AddNewModulePopup.showPopup(Canvas);
      }
      else if(%itemText $= "tools")
      {
         AddNewToolPopup.showPopup(Canvas);
      }
   }
}

//
//
//
function AssetBrowser::openAssetSettings(%this)
{
   ESettingsWindow.toggleEditorSettings();
   %assetEditIndex = ESettingsWindowList.findTextIndex("Asset Editing");
   ESettingsWindowList.setSelectedRow( %assetEditIndex );
}

function ESettingsWindow::getAssetManagementSettings(%this)
{
   SettingsInspector.startGroup("Modules");
   SettingsInspector.addSettingsField("AssetManagement/Modules/coreModulePath", "Core Module Path", "string", "");
   SettingsInspector.addSettingsField("AssetManagement/Modules/gameDataModulePath", "Game Data Module Path", "string", "");
   SettingsInspector.addSettingsField("AssetManagement/Modules/moduleExtension", "Module Extension", "string", "");
   
   %moduleList = ModuleDatabase.findModules(true);
   %moduleList = strreplace(%moduleList, " ", ",");
   
   SettingsInspector.addSettingsField("AssetManagement/Modules/DefaultModule", "Default Module", "list", %moduleList);
   SettingsInspector.endGroup();
   
   SettingsInspector.startGroup("Assets");
   SettingsInspector.addSettingsField("AssetManagement/Assets/assetExtension", "Asset Extension", "string", "");
   SettingsInspector.addSettingsField("AssetManagement/Assets/datablockCaching", "Cache Datablocks", "bool", "");
   //SettingsInspector.addSettingsField("AssetManagement/Assets/moduleExtension", "Module Extension", "string", "");
   
   SettingsInspector.endGroup();
} 

function ESettingsWindow::getAssetEditingSettings(%this)
{
   ImportAssetWindow::reloadImportOptionConfigs();
   
   //First, get our list of modules
   %moduleList = ModuleDatabase.findModules();
   %formattedModuleList = "";
   
   %count = getWordCount(%moduleList);
   for(%i=0; %i < %count; %i++)
   {
      %module = getWord(%moduleList, %i);
      if(%module.group !$= "Tools" && %module.group !$= "Core")
      {
         if(%formattedModuleList $= "")
            %formattedModuleList = %module.moduleId;
         else
            %formattedModuleList = %formattedModuleList @ "," @ %module.moduleId;  
      }
   }
   
   SettingsInspector.startGroup("Asset Creation");
   SettingsInspector.addSettingsField("Assets/New/defaultModule", "Default Module", "list", "Default Module for new assets to be created into", %formattedModuleList); 
   SettingsInspector.addSettingsField("Assets/New/alwaysPromptModuleTarget", "Always Prompt Target Module", "bool", "If off, use the default module"); 
   SettingsInspector.endGroup();
   
   %formattedConfigList = "";
   for(%i=0; %i < ImportAssetWindow.importConfigsList.Count(); %i++)
   {
      %configName = ImportAssetWindow.importConfigsList.getKey(%i);
      %formattedConfigList = %i == 0 ? %configName : %formattedConfigList @ "," @ %configName;
   }
   
   SettingsInspector.startGroup("Assets Importing");
   SettingsInspector.addField("Edit Import Configs", "Edit Asset Import Configs", "button", "Open Asset Import Config Editor", "", "Canvas.pushDialog(AssetImportConfigEditor);");
   SettingsInspector.addSettingsField("Assets/AssetImporDefaultConfig", "Default Asset Import Config", "list", "", %formattedConfigList); 
   SettingsInspector.addSettingsField("Assets/AutoImport", "Automatically Import using default config", "bool", "If on, the asset importing process" @
                                                                                                                        "will attempt to automatically import any inbound assets"@
                                                                                                                        "using the default config, without prompting the import window."@
                                                                                                                        "The window will still display if any issues are detected", ""); 
   SettingsInspector.addSettingsField("Assets/AutoImportLooseFiles", "Automatically Import Loose Files", "bool", "If on, will automatically import unassociated loose files in assets when navigating the Asset Browser.", ""); 
   SettingsInspector.endGroup();
   
   SettingsInspector.startGroup("Asset Browser");
   SettingsInspector.addSettingsField("Assets/Browser/showCoreModule", "Show Core Module in Asset Browser", "bool", ""); 
   SettingsInspector.addSettingsField("Assets/Browser/showToolsModule", "Show Tools Module in Asset Browser", "bool", ""); 
   SettingsInspector.addSettingsField("Assets/Browser/showOnlyPopulatedModule", "Show Only Modules with Assets in Asset Browser", "bool", "");
   SettingsInspector.addSettingsField("Assets/Browser/showFolders", "Show Folders in Tiles view in Asset Browser", "bool", "");
   SettingsInspector.addSettingsField("Assets/Browser/showEmptyFolders", "Show Empty Folders in Tiles view in Asset Browser", "bool", "");
   SettingsInspector.addSettingsField("Assets/Browser/showLooseFiles", "Show Loose Files when viewing in Asset Browser", "bool", "");
   SettingsInspector.addSettingsField("AssetManagement/Assets/promptOnRename", "Prompt on Rename", "bool", "");
   SettingsInspector.addSettingsField("Assets/Browser/doubleClickAction", "Double Click Action", "list", "Dictates what sort of action double clicking on an asset in the Browser will invoke", "Edit Asset,Spawn Asset");
   SettingsInspector.addSettingsField("AssetManagement/Assets/closeBrowserOnDragAction", "Close Browser on Drag Action", "bool", "If on, the Asset Browser will automatically close after dragging an asset from it to the editor interface.");
   SettingsInspector.endGroup();
}
//
//
//

function AssetBrowser::showVisibiltyOptions(%this)
{
   BrowserVisibilityPopup.showPopup(Canvas);
}

function AssetBrowser::saveCurrentFiltersAsCollection(%this)
{
   %colSetName = CreateNewCollectionSetCtrl-->collectionSetName.getText();
   
   if(%colSetName $= "")
   {
      error("Collection Sets require a name!");  
   }
   
   %collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
   %collectionsCount += 1;
   
   AssetBrowserCollectionSets.setValue("CollectionSetCount", %collectionsCount);
   
   %collection = %colSetName TAB AssetBrowserSearchFilter.getText();
   
   AssetBrowserCollectionSets.setValue("Collection"@%collectionsCount-1, %collection);
   
   %success = AssetBrowserCollectionSets.write();
   
   AssetBrowser.loadDirectories();
}

function AssetBrowser::deleteCollectionSet(%this)
{
   %collectionsCount = AssetBrowserCollectionSets.value("CollectionSetCount", 0);
   %tempCollectionListCount = 0;
   
   %found = false;
   for ( %i = 0; %i < %collectionsCount; %i++ )
   {
      %collection = AssetBrowserCollectionSets.value("Collection"@%i, "");
      %collectionName = getField(%collection, 0);
      %collectionTerm = getField(%collection, 1);
      
      if(AssetBrowser.selectedCollectionSet !$= %collectionName)
      {
         %tempCollectionList[%tempCollectionListCount] = %collection;
         %tempCollectionListCount++;
      }
   }
   
   AssetBrowserCollectionSets.setValue("CollectionSetCount", %tempCollectionListCount);
   for(%i=0; %i < %collectionsCount; %i++)
   {
      if(%i < %tempCollectionListCount)
         AssetBrowserCollectionSets.setValue("Collection"@%i, %tempCollectionList[%i]);  
      else
         AssetBrowserCollectionSets.remove("Collection"@%i);  
   }
   
   AssetBrowserCollectionSets.write();
   
   %this.loadDirectories();
}

function AssetBrowser::refreshPreviews(%this)
{
   AssetBrowserFilterTree.onSelect(AssetBrowser.selectedItem);
}

function AssetBrowserFilterTree::onSelect(%this, %itemId)
{
	if(%itemId == 1)
		//can't select root
		return;
		
   %scrollCtrl = %this.getParent();
   %scrollPos = %scrollCtrl.getScrollPosition();
   
   //process special cases
   %parentItem = %this.getParentItem(%itemId);
   if(%parentItem == %this.tagsIdx)
   {
      //we selected a tag, so deal with that 
      AssetBrowser.setTagActive(%this.getItemText(%itemId));
   }
   else if(%parentItem == %this.collectionsIdx)
   {
      //A collection set was selected
      AssetBrowser.setCollectionSetActive(%this.getItemValue(%itemId));
   }
   else if(%parentItem == %this.creatorIdx)
   {
      %name = %this.getItemText(%itemId);
      AssetBrowser.dirHandler.currentAddress = "Creator/" @ %name;
      AssetBrowser.rebuildAssetArray();
      AssetBrowser.refresh();
   }
   else
   {
      //Make sure we have an actual module selected!
      %parentId = %this.getParentItem(%itemId);
      
      %name = %this.getItemText(%itemId);
      
      %breadcrumbPath = %this.getItemValue(%itemId);
      if(%breadcrumbPath !$= "")
         %breadcrumbPath = %breadcrumbPath @ "/" @ %this.getItemText(%itemId);
      else
         %breadcrumbPath = %this.getItemText(%itemId);
         
      if(%breadcrumbPath $= "")
         %breadcrumbPath = AssetBrowser.dirHandler.currentAddress;
         
      AssetBrowser.navigateTo(%breadcrumbPath);
   }
   
   //restore the scroll position
   %scrollCtrl.schedule(1, "setScrollPosition", %scrollPos.x, %scrollPos.y);
}

function AssetBrowserFilterTree::hasAsParent(%this, %itemId, %text)
{
   %parentId = %this.getParentItem(%itemId);
   
   while(%parentId != 0)
   {
      %parentText =  %this.getItemText(%parentId);
      if(%parentText $= %text)
         return true;
         
      %parentId = %this.getParentItem(%parentId);
   }
   
   
   return false;
}

function AssetBrowser::rebuildAssetArray(%this)
{
   if(!%this.previewArrayDirty)
   {
      %this.previewArrayDirty = true;
      cancel(%this.pendingRebuild);
      %this.pendingRebuild = %this.schedule(16, "doRebuildAssetArray");
   }
}

function AssetBrowser::doRebuildAssetArray(%this)
{
   if(!%this.previewArrayDirty)
      return;
   
   %breadcrumbPath = AssetBrowser.dirHandler.currentAddress;
   
   // we have to empty out the list; so when we create new guicontrols, these dont linger
   AssetBrowser-->assetList.deleteAllObjects();
   AssetPreviewArray.empty();

   if(isObject($AssetBrowser::AssetArray))
      $AssetBrowser::AssetArray.delete();
      
   $AssetBrowser::AssetArray = new ArrayObject();
   
   //First, Query for our assets
   %assetQuery = new AssetQuery();
   %numAssetsFound = AssetDatabase.findAllAssets(%assetQuery);

   %finalAssetCount = 0;
   
   if(!startsWith(%breadcrumbPath, "Creator"))
   {
      //Add folders
      if(EditorSettings.value("Assets/Browser/showFolders", true) == true)
      {
         %folders = getDirectoryList(%breadcrumbPath);
         for(%f=0; %f < getFieldCount(%folders); %f++)
         {
            %folderName = getField(%folders, %f);
            
            %searchActive = AssetSearchTerms.count() != 0;
            if(%searchActive)
            {
               if(matchesSearch(%folderName, "Folder", ""))
               {
                  $AssetBrowser::AssetArray.add( %breadcrumbPath, "FolderObjectType" TAB %folderName );
                  continue;
               }
            }
            else
            {
               //got it.	
               if(%folderName $= "shaderCache" || %folderName $= "cache" || %folderName $= ".git" || %folderName $= "previewCache")
                  continue;
                  
               if(!%this.coreModulesFilter && %folderName $= "core" && %breadcrumbPath $= "")
                  continue;
                  
               if(!%this.toolsModulesFilter && %folderName $= "tools" && %breadcrumbPath $= "")
                  continue;
                  
               $AssetBrowser::AssetArray.add( %breadcrumbPath, "FolderObjectType" TAB %folderName );
            }
         }
      }
      
       //now, we'll iterate through, and find the assets that are in this module, and this category
       for( %i=0; %i < %numAssetsFound; %i++)
       {
          %assetId = %assetQuery.getAsset(%i);
          
          %assetPath = makeRelativePath(AssetDatabase.getAssetFilePath(%assetId));
          %assetBasePath = filePath(%assetPath);
          
          //clean up the path
          %assetBasePath = strreplace(%assetBasePath, "//", "/");
          
          %searchActive = AssetSearchTerms.count() != 0;
          if(%assetBasePath $= %breadcrumbPath || (%searchActive && startsWith(%assetBasePath,%breadcrumbPath)))
          {
             //first, get the asset's module, as our major categories
             %module = AssetDatabase.getAssetModule(%assetId);
             %moduleName = %module.moduleId;
             
             //it's good, so test that the category is right!
            %assetType = AssetDatabase.getAssetCategory(%assetId);
            if(%assetType $= "")
            {
               %assetType = AssetDatabase.getAssetType(%assetId);
            }
            
            //stop adding after previewsPerPage is hit
            %assetName = AssetDatabase.getAssetName(%assetId);

            if(%searchActive)
            {
               if(matchesSearch(%assetName, %assetType))
               {
                  $AssetBrowser::AssetArray.add( %moduleName, %assetId);
                     
                  if(%assetType !$= "Folder")
                     %finalAssetCount++;
                     
                  continue;
               }
            }
            else
            {
               if(AssetBrowser.assetTypeFilter !$= "")
               {
                  %filtersCount = getWordCount(AssetBrowser.assetTypeFilter);
                  for(%fltrIdx = 0; %fltrIdx < %filtersCount; %fltrIdx++)
                  {
                     %fltr = getWord(AssetBrowser.assetTypeFilter, %fltrIdx);
                     if(%fltr $= %assetType)
                     {
                        $AssetBrowser::AssetArray.add( %moduleName, %assetId );
                        
                        if(%assetType !$= "FolderObjectType")
                           %finalAssetCount++;
                     }
                  }
               }
               else
               {
                  //got it.	
                  $AssetBrowser::AssetArray.add( %moduleName, %assetId );
                  
                  if(%assetType !$= "FolderObjectType")
                     %finalAssetCount++;
               }
            }
         }
      }
      
      if(!isObject(ABLooseFileArray))
         new ArrayObject(ABLooseFileArray){};
         
      %nonAssetFileCount = getNonAssetFilesInDir(%this.dirHandler.currentAddress, ABLooseFileArray);
      
      %looseFiles = ABLooseFileArray.count();
      for( %i=0; %i < %looseFiles; %i++)
      {
         %looseFileFullPath = ABLooseFileArray.getKey(%i);
         %looseFilePath = filePath(%looseFileFullPath);
         %looseFileName = fileName(%looseFileFullPath);
         %looseFileExt = fileExt(%looseFileFullPath);
         
         //iterate over the registered types to filter out types we special handle
         for(%t=0; %t < ABAssetTypesList.count(); %t++)
         {
            %typeGroup = ABAssetTypesList.getKey(%t);

            %typeEntryName = getField(ABAssetTypesList.getValue(%t), 0);
            %filterDataList = getField(ABAssetTypesList.getValue(%t), 2);
            
            if(%typeGroup $= "Asset")
            {
               %classNameCount = getTokenCount(%filterDataList, ";");
               
               for(%e=0; %e < %classNameCount; %e++)
               {
                  %className = getToken(%filterDataList, ";", %e);
                  
                  if(%className $= %looseFileExt)
                  {
                     if(matchesSearch(%looseFileName, %typeEntryName))
                        $AssetBrowser::AssetArray.add( %looseFilePath, %typeEntryName TAB %looseFileName );
                  }
               }
            }
            else if(%typeGroup $= "File")
            {
               %extensionsCount = getTokenCount(%filterDataList, ";");
               
               for(%e=0; %e < %extensionsCount; %e++)
               {
                  %extension = getToken(%filterDataList, ";", %e);
                  
                  if(%extension $= %looseFileExt)
                  {
                     if(matchesSearch(%looseFileName, %typeEntryName))
                        $AssetBrowser::AssetArray.add( %looseFilePath, %typeEntryName TAB %looseFileName );
                  }
               }
            }
            else if(%typeGroup $= "Object")
            {
               %classNameCount = getTokenCount(%filterDataList, ";");
               
               //now we iterate over the root group to find any and all objects that match to class
               for(%rgo = 0; %rgo < RootGroup.getCount(); %rgo++)
               {
                  %rootGroupObj = RootGroup.getObject(%rgo);
                  %rootGroupObjPath = filePath(%rootGroupObj.getFileName());
                  if(%rootGroupObjPath !$= %this.dirHandler.currentAddress)
                     continue;
                  
                  for(%c=0; %c < %classNameCount; %c++)
                  {
                     %className = getToken(%filterDataList, ";", %c);

                     if(%rootGroupObj.isMemberOfClass(%className))
                     {
                        if(matchesSearch(%className, %typeEntryName))
                           $AssetBrowser::AssetArray.add( %rootGroupObj, %typeEntryName TAB %className );
                     }
                  }
               }
               
               //check the datablocks group for certainty as well`
               for(%rgo = 0; %rgo < DatablockGroup.getCount(); %rgo++)
               {
                  %dbGroupObject = DatablockGroup.getObject(%rgo);
                  %dbGroupObjPath = filePath(%dbGroupObject.getFileName());
                  if(%dbGroupObjPath !$= %this.dirHandler.currentAddress)
                     continue;
                  
                  for(%c=0; %c < %classNameCount; %c++)
                  {
                     %className = getToken(%filterDataList, ";", %c);

                     if(%dbGroupObject.isMemberOfClass(%className))
                     {
                        if(matchesSearch(%className, %typeEntryName))
                           $AssetBrowser::AssetArray.add( %dbGroupObject, %typeEntryName TAB %className );
                     }
                  }
               }
            }
         }
      }
   }
	else  //If we've selected into the Creator section, we have special handling for that
	{
      //One of the creator folders was selected
      %creatorGroup = AssetBrowserFilterTree.getItemText(AssetBrowserFilterTree.getSelectedItem(0));
            
      if(%creatorGroup $= "Creator")
      {
         //add folders for the groups
         %placeholderVar = "";
      }
      else
      {
         for ( %i = 0; %i < %this.creatorClassArray.count(); %i++ )
         {
            %group = %this.creatorClassArray.getKey( %i );

            //Do some filter logic do skip out of groups if we're in the wrong editor mode for it
            %creatorEditorFilter = "WorldEditor";
            if(GuiEditorIsActive())
            {
               %creatorEditorFilter = "GuiEditor";
            }
            
            %creatorGroupIndex = AssetBrowserCreatorGroupsList.getIndexFromValue(%group);
            %creatorGroupKey = AssetBrowserCreatorGroupsList.getKey(%creatorGroupIndex);
            
            if ( %group $= %creatorGroup && %creatorGroupKey $= %creatorEditorFilter )
            {
               %creatorObj = %this.creatorClassArray.getValue( %i );
               %class = %creatorObj.val[0];
               %name = %creatorObj.val[1];
               %func = %creatorObj.val[2];
               
               %searchActive = AssetSearchTerms.count() != 0;
               if(%searchActive && !matchesSearch(%name, "Creator"))
                  continue;

               $AssetBrowser::AssetArray.add( %name, "Creator" TAB %creatorObj );
            }               
         }   
      }
	}
	
   for(%i=0; %i < $AssetBrowser::AssetArray.count(); %i++)
		%this.buildAssetPreview( $AssetBrowser::AssetArray.getValue(%i), $AssetBrowser::AssetArray.getKey(%i) );  
		
   //Queue population of any non-Type Card preview images
   %this.schedule(32, "populatePreviewImages");
		
   AssetBrowser_FooterText.text = %finalAssetCount @ " Assets";
   
   %activeTypeFilterList = "";
   if(AssetBrowser.assetTypeFilter $= "")
   {
      if(!AssetTypeListPopup.isItemChecked(0))
      {
         for(%f=0; %f < ABAssetTypesList.Count(); %f++)
         {
            %isChecked = AssetTypeListPopup.isItemChecked(%f+2);  
            
            if(%isChecked)
            {
               %filterTypeData = ABAssetTypesList.getKey(%f);
               %filterTypeName = getField(%filterTypeData, 0);
               
               if(%activeTypeFilterList $= "")
                  %activeTypeFilterList = %filterTypeName;
               else
                  %activeTypeFilterList = %activeTypeFilterList @ ", " @ %filterTypeName;
            }
         }
      }
   }
   else
   {
      %activeTypeFilterList = AssetBrowser.assetTypeFilter;
   }
   
   if(%activeTypeFilterList !$= "")
      AssetBrowser_FooterText.text = AssetBrowser_FooterText.text @ " | Active Type Filters: " @ %activeTypeFilterList;
      
   %this.previewArrayDirty = false;
}

//
//
// Search
function AssetBrowser::updateSearchTextFromFilter(%this)
{
   AssetSearchTerms.sortk();
   
   //Update the displayed search text!
   %newSearchPhrase = "";
   %currentAction = "";
   %actionCount = 0;
   for(%i=0; %i < AssetSearchTerms.count(); %i++)
   {
      %action = AssetSearchTerms.getKey(%i);
      %word = AssetSearchTerms.getValue(%i);
      
      if(%action !$= %currentAction)
      {
         if(%actionCount != 0)
         {
            if(%action !$= "")
               %newSearchPhrase = %newSearchPhrase @ ";" @ %action @ ":" @ %word;
            else
               %newSearchPhrase = %newSearchPhrase @ ";" @ %word;
         }
         else
         {
            if(%action !$= "")
               %newSearchPhrase = %action @ ":" @ %word;
            else
               %newSearchPhrase = %word;
         }
            
         %actionCount++;
      }
      else
      {
         %newSearchPhrase = %newSearchPhrase @ "," @ %word;
      }
      
      %currentAction = %action;
   }
   
   AssetBrowserSearchFilter.setText(%newSearchPhrase);
}

function AssetBrowser::processSearchFilter(%this)
{
   AssetSearchTerms.empty();
      
   %searchText = AssetBrowserSearchFilter.getText();
   
   %termCount = getTokenCount(%searchText, ";");
   for(%s=0; %s < %termCount; %s++)
   {
      %term = getToken(%searchText, ";", %s);
      
      %phraseCount = getTokenCount(%term, ":");
      
      if(%phraseCount == 2)
      {
         //action/words split
         %action = getToken(%term, ":", 0);  
         %words = getToken(%term, ":", 1);  
      }
      else
      {
         %action = "";
         %words = getToken(%term, ":", 0);
      }
      
      %wordCount = getTokenCount(%words, ",");
      for(%w=0; %w < %wordCount; %w++)
      {
         %word = getToken(%words, ",", %w);
         AssetSearchTerms.add(%action, %word);
      }
   }
}

//Takes an item and compares it against the parsed search language
//This is written to be inclusive, rather than exclusive
function matchesSearch(%assetName, %assetType)
{
   if(AssetSearchTerms.count() == 0)
      return true;
      
   %matchTags = false;
   %matchType = false;
   %matchName = false;
   
   %needsTag = false;
   %needsType = false;
   %needsName = false;
   for(%i=0; %i < AssetSearchTerms.count(); %i++)
   {
      %action = AssetSearchTerms.getKey(%i);
      %word = AssetSearchTerms.getValue(%i);
      
      if(%action $= "tag" && %matchTags == false)
      {
         %needsTag = true;
         if(%assetType $= "Datablock")
         {
            if(%assetName.category $= %word)
               %matchTags = true;
         }
         else
         {
            if(strstr(strlwr(%assetName.tags), strlwr(%word)) != -1)
               %matchTags = true;
         }
      }
      else if(%action $= "type" && %matchType == false)
      {
         %needsType = true;
         if(%assetType $= %word)
            %matchType = true;
      }
      else if(%action $= "" && %matchName == false)
      {
         %needsName = true;
         if(strstr(strlwr(%assetName), strlwr(%word)) != -1)
            %matchName = true;  
      }
   }
   
   if(((%needsTag && %matchTags) || !%needsTag) && 
      ((%needsType && %matchType) || !%needsType) && 
      ((%needsName && %matchName) || !%needsName))
      return true;
   else
      return false;  
}

//
//
// Search Filters
function AssetBrowserSearchFilterTxt::onWake( %this )
{
   /*%filter = %this.treeView.getFilterText();
   if( %filter $= "" )
      %this.setText( "\c2Filter..." );
   else
      %this.setText( %filter );*/
}

function AssetBrowserSearchFilterTxt::onGainFirstResponder( %this )
{
   %this.selectAllText();
}

// When Enter is pressed in the filter text control, pass along the text of the control
// as the treeview's filter.
function AssetBrowserFolderSearchFilter::onReturn( %this )
{
   %text = %this.getText();
   if( %text $= "" )
      %this.reset();
   
   AssetBrowser.refresh();
}

function AssetBrowserFolderSearchFilter::onEdited(%this)
{
   if(AssetBrowserFolderSearchFilter.getText() $= "")
   {
      AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
   }
   else
   {
      AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/cross.png");
   }
}

function AssetBrowserSearchFilter::onEdited(%this)
{
   AssetBrowserSearchFilter.updateButton();
}

function AssetBrowserSearchFilter::onReturn( %this )
{
   %text = %this.getText();
   if( %text $= "" )
      %this.reset();
      
   AssetBrowserSearchFilter.updateButton();
      
   AssetBrowser.processSearchFilter();
   
   AssetBrowser.rebuildAssetArray();
}

function AssetBrowserSearchFilter::updateButton(%this)
{
   if(%this.getText() $= "")
   {
      AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
   }
   else
   {
      AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/cross.png");
   }
}

function AssetBrowserFolderSearchFilter::reset( %this )
{
   %this.setText( "" );
   AssetBrowser-->folderSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
   //AssetBrowser.refresh();
}

function AssetBrowserSearchFilter::reset( %this )
{
   %this.setText( "" );
   AssetBrowser-->assetSearchBtn.setBitmap("tools/gui/images/stencilIcons/zoom.png");
   //AssetBrowser.rebuildAssetArray();
}

function AssetBrowserFolderSearchBtn::onClick( %this )
{
   AssetBrowserFolderSearchFilter.reset();
   AssetBrowser.refresh();
}

function AssetBrowserAssetSearchBtn::onClick( %this )
{
   AssetBrowserSearchFilter.reset();
   AssetBrowser.processSearchFilter();
   
   AssetBrowser.rebuildAssetArray();
}

//
//
// Navigation
function AssetBrowser::navigateTo(%this, %address, %historyNav)
{
   //Sanitize
   if(startsWith(%address, "/"))
      %address = strreplace(%address, "/", "");
      
   // Safety
   %address = strreplace(%address, "//", "/");
      
   //Don't bother navigating if it's to the place we already are
   if(%this.dirHandler.currentAddress !$= %address)
   {
      %this.dirHandler.navigateTo(%address, %historyNav);
         
      //%this.updateNavigationBreadcrumb(%address);
      
      %this.lastValidNavPath = %address;
      %this-->navPath.setText(%address);
      
      %module = %this.dirHandler.getModuleFromAddress(%address);
      if(%module !$= "")
      {
         //legit module, so set it as current target
         %this.SelectedModule = %module.moduleId;
      }
      
      if(%this.hasLooseFilesInDir())
      {
         if(EditorSettings.value("Assets/AutoImportLooseFiles", false) && EditorSettings.value("Assets/AutoImport", false))
         {
            AssetBrowser.autoImportSimpleLooseFiles();
         }
         else
         {
         %this-->AutoImportAssetButton.visible = true;
         }
      }
      else
      {
          %this-->AutoImportAssetButton.visible = false; 
      }
   }
   
   %this.rebuildAssetArray();
   %this.refresh();
}

function AssetBrowser::navigateHistoryForward(%this)
{
   %this.dirHandler.navigateHistoryForward();
   
   %this.updateNavigationBreadcrumb();
   
   %address = %this.dirHandler.currentAddress;
   
   %module = AssetBrowser.dirHandler.getModuleFromAddress(%address);
   if(%module !$= "")
   {
      //legit module, so set it as current target
      %this.SelectedModule = %module.moduleId;
   }
   
   %this.lastValidNavPath = %address;
   %this-->navPath.setText(%address);
   
   %this.rebuildAssetArray();
}

function AssetBrowser::navigateHistoryBack(%this)
{
   %this.dirHandler.navigateHistoryBack();
      
   %this.updateNavigationBreadcrumb();
   
   %address = %this.dirHandler.currentAddress;
   
   %module = %this.dirHandler.getModuleFromAddress(%address);
   if(%module !$= "")
   {
      //legit module, so set it as current target
      %this.SelectedModule = %module.moduleId;
   }
   
   %this.lastValidNavPath = %address;
   %this-->navPath.setText(%address);
   
   %this.rebuildAssetArray();
}

function AssetBrowser::updateNavigationBreadcrumb(%this, %address)
{
   //clear the breadcrumb bar
   AssetBrowser_BreadcrumbBar.clear();
   
   //break down the address
   %folderCount = getTokenCount(%address, "/");
      
   %rebuiltPath = "";
   for(%f=0; %f < %folderCount; %f++)
   {
      %folderName = getToken(%address, "/", %f);
      
      %rebuiltPath = %f == 0 ? %folderName : %rebuiltPath @ "/" @ %folderName;
      
      %folderNavButton = new GuiButtonCtrl()
      {
         profile = ToolsGuiButtonProfile;
         text = %folderName;
         command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
         extent = "100" SPC AssetBrowser_BreadcrumbBar.extent.y;
      };
      
      AssetBrowser_BreadcrumbBar.add(%folderNavButton);
      
      if(%f != %folderCount-1)
      {
         %folderSpacerButton = new GuiBitmapButtonCtrl()
         {
            profile = ToolsGuiButtonProfile;
            bitmapAsset = "ToolsModule:rightArrowWhite_image";
            bitmapMode = "Centered";
            extent = "25" SPC AssetBrowser_BreadcrumbBar.extent.y;
            //command = "AssetBrowser.navigateTo(\"" @ %rebuiltPath @ "\");";
         };
         
         AssetBrowser_BreadcrumbBar.add(%folderSpacerButton);
      }
   }

   //refresh the nav buttons to display the history
   %backButtonHistory = "";
   for(%i=0; %i < AssetBrowser.dirHandler.prevHistoryList.Count(); %i++)
   {
      %prevAddress = AssetBrowser.dirHandler.prevHistoryList.getKey(%i);
      %backButtonHistory = %i==0 ? %prevAddress @ "\n" : %backButtonHistory @ %prevAddress @ "\n";
   }
   
   AssetBrowser_NavigateBackBtn.tooltip = %backButtonHistory;
   
   %foreButtonHistory = "";
   for(%i=0; %i < AssetBrowser.dirHandler.foreHistoryList.Count(); %i++)
   {
      %prevAddress = AssetBrowser.dirHandler.foreHistoryList.getKey(%i);
      %foreButtonHistory = %i==0 ? %prevAddress @ "\n" : %foreButtonHistory @ %prevAddress @ "\n";
   }
   
   AssetBrowser_NavigateForwardBtn.tooltip = %foreButtonHistory;
}

function assetBrowserNavPath::onReturn(%this)
{
   %newPath = %this.getText();
   if(isDirectory(%newPath))
   {
      AssetBrowser.lastValidNavPath =  %newPath;
      AssetBrowser.navigateTo(%newPath); 
   }
   else
   {
      %this.setText(AssetBrowser.lastValidNavPath);
      AssetBrowser.navigateTo(AssetBrowser.lastValidNavPath);
   }
}
//
//
//
function AssetBrowser::reloadModules(%this)
{
   ModuleDatabase.unloadGroup("Game");
   
   %modulesList = ModuleDatabase.findModules();
   
   %count = getWordCount(%modulesList);
   
   for(%i=0; %i < %count; %i++)
   {
      %moduleId = getWord(%modulesList, %i).ModuleId;
      ModuleDatabase.unloadExplicit(%moduleId);
   }

   ModuleDatabase.scanModules();
   
   %modulesList = ModuleDatabase.findModules();
   
   %count = getWordCount(%modulesList);
   
   for(%i=0; %i < %count; %i++)
   {
      %moduleId = getWord(%modulesList, %i).ModuleId;
      ModuleDatabase.loadExplicit(%moduleId);
   }
   
   //ModuleDatabase.loadGroup("Game");
}

//
//
//
function AssetBrowser::toggleFolderCollapseButton(%this)
{
   %this.folderPanelState = !%this.folderPanelState;
   
   //If we're collapsing
   if(!%this.folderPanelState)
   {
      //Store the original
      %this.folderPanelSplit = AssetBrowser_MainSplit.splitPoint.x;
      
      //collapse it
      AssetBrowser_MainSplit.setSplitPoint(AssetBrowser_MainSplit.splitterSize SPC AssetBrowser_MainSplit.splitPoint.y);
   }
   else
   {
      //restore the original
      AssetBrowser_MainSplit.setSplitPoint(%this.folderPanelSplit SPC AssetBrowser_MainSplit.splitPoint.y);
   }  
}
//
//
// Drag n drop
function AssetBrowserPreviewButton::onMouseDragged(%this)
{
   %payload = %this.clone();
   %payload.position = "0 0";
   //%payload.class = "AssetPreviewControl";
   
   %xOffset = getWord( %payload.extent, 0 ) / 2;
   %yOffset = getWord( %payload.extent, 1 ) / 2;
   
   // Compute the initial position of the GuiDragAndDrop control on the cavas based on the current
   // mouse cursor position.
   
   %cursorpos = Canvas.getCursorPos();
   %xPos = getWord( %cursorpos, 0 ) - %xOffset;
   %yPos = getWord( %cursorpos, 1 ) - %yOffset;
   
   if(!isObject(EditorDragAndDropLayer))
   {
      new GuiControl(EditorDragAndDropLayer)
      {
         position = "0 0";
         extent = Canvas.extent;
      };
   }
   
   // Create the drag control.
   %ctrl = new GuiDragAndDropControl()
   {
      canSaveDynamicFields    = "0";
      Profile                 = "ToolsGuiSolidDefaultProfile";
      HorizSizing             = "right";
      VertSizing              = "bottom";
      Position                = %xPos SPC %yPos;
      extent                  = %payload.extent;
      MinExtent               = "4 4";
      canSave                 = "1";
      Visible                 = "1";
      hovertime               = "1000";

      // Let the GuiDragAndDropControl delete itself on mouse-up.  When the drag is aborted,
      // this not only deletes the drag control but also our payload.
      deleteOnMouseUp         = true;
      
      useWholeCanvas = true;

      // To differentiate drags, use the namespace hierarchy to classify them.
      // This will allow a color swatch drag to tell itself apart from a file drag, for example.
      class                   = "AssetPreviewControlType_AssetDrop";
   };
   
   // Add the temporary color swatch to the drag control as the payload.
   %ctrl.add( %payload );
   
   // Start drag by adding the drag control to the canvas and then calling startDragging().
   //Canvas.getContent().add( %ctrl );
   EditorDragAndDropLayer.add(%ctrl);
   Canvas.pushDialog(EditorDragAndDropLayer);
   
   %ctrl.startDragging( %xOffset, %yOffset );
   
   Canvas.repaint();
}

function AssetPreviewControlType_AssetDrop::onControlDragCancelled(%this)
{
   Canvas.popDialog(EditorDragAndDropLayer);
}

function AssetBrowserPreviewButton::onControlDropped( %this, %payload, %position )
{
   Canvas.popDialog(EditorDragAndDropLayer);
   
   if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
      return;

   // If dropped on same button whence we came from,
   // do nothing.

   if( %payload.dragSourceControl == %this )
      return;
      
   %assetType = %payload.assetType;
   %assetName = %payload.assetName;
   %moduleName = %payload.moduleName;
   
   %targetAssetName = %this.assetName;
   %targetAssetType = %this.assetType;
   %targetModuleName = %this.moduleName;

   if( %payload.dragSourceControl.class $= "AssetPreviewButton" && %targetAssetType $= "Folder")
   {
      %destination = %targetModuleName @ "/" @ %targetAssetName;
      
      if(%assetType $= "Folder")
      {
         %originFolder = %moduleName @ "/" @ %assetName;
         %destination = %destination @ "/" @ %assetName;
         
         //Do any cleanup required given the type
         if(AssetBrowser.isMethod("moveFolder"))
            eval(AssetBrowser @ ".moveFolder(\""@%originFolder@"\",\""@%destination@"\");");
      }
      else
      {
         %assetId = %moduleName @ ":" @ %assetName;
         %assetDef = AssetDatabase.acquireAsset(%assetId);
         %assetType = AssetDatabase.getAssetType(%assetId);
         
         //Do any cleanup required given the type
         if(AssetBrowser.isMethod("move"@%assetType))
         {
            %command = AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %destination @ "\");";
            eval(AssetBrowser @ ".move" @ %assetType @ "(" @ %assetDef @ ",\"" @ %destination @ "\");");
         }
      }
      
      AssetBrowser.refresh();
   }
}

function EWorldEditor::onControlDropped( %this, %payload, %position )
{
   Canvas.popDialog(EditorDragAndDropLayer);
   
   // Make sure this is a color swatch drag operation.
   if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
      return;

   // If dropped on same button whence we came from,
   // do nothing.

   if( %payload.dragSourceControl == %this )
      return;

   %assetType = %payload.assetType;
   
   %createPosition = ObjectCreator.getCreateObjectPosition(); //LocalClientConnection.camera.position; 
   %targetPosition = EWorldEditor.unproject(%createPosition SPC 1);
   %camPos = LocalClientConnection.camera.getPosition();
   %rayResult = containerRayCast(%camPos, %targetPosition, -1);
   
   %pos = ObjectCreator.getCreateObjectPosition();

   if(%rayResult != 0)
   {
      %pos = getWords(%rayResult, 1, 3);
   }
   else
   {
      %pos = "0 0 0";  
   }
   
   AssetBrowser.callAssetTypeFunc(%assetType, "onWorldEditorDropped", %payload.moduleName, %payload.assetName, %pos);
   
   if(EditorSettings.value("AssetManagement/Assets/closeBrowserOnDragAction", false))
   {
      AssetBrowser.hideDialog();  
   }
   
   EWorldEditor.isDirty = true;
}

function GuiEditor::onControlDropped(%this, %payload, %position)
{  
   Canvas.popDialog(EditorDragAndDropLayer);
   // Make sure we have the right kind of D&D.
   
   if( !%payload.parentGroup.isInNamespaceHierarchy( "GuiDragAndDropControlType_GuiControl" ) &&
         !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ))
      return;
      
   if( %payload.dragSourceControl == %this )
      return;

   %pos = %payload.getGlobalPosition();
   %x = getWord(%pos, 0);
   %y = getWord(%pos, 1);
   
   if(%payload.assetType !$= "Creator")
   {
      //dealing with an actual asset, so build the assetName
      %assetId = %payload.moduleName @ ":" @ %payload.assetName;
      %assetType = AssetDatabase.getAssetType(%assetId);
      
      %ctrl = AssetBrowser.callAssetTypeFunc(%assetType, "onGUIEditorDropped", %payload.moduleName, %payload.assetName, %pos);
   }
   else
   {
      %className = %payload.assetName;
      if(%payload.altCommand !$= "")
      {
         %cmd = %payload.altCommand;
      }
      else
      {
      %cmd = "return new " @ %className @ "();";
      }
      %ctrl = eval( %cmd );
   }

   %this.addNewCtrl(%ctrl);
   
   %ctrl.setPositionGlobal(%x, %y);
   %this.setFirstResponder();
   
   if(EditorSettings.value("AssetManagement/Assets/closeBrowserOnDragAction", false))
   {
      AssetBrowser.hideDialog();  
   }
}

function AssetBrowserFilterTree::onControlDropped( %this, %payload, %position )
{
   Canvas.popDialog(EditorDragAndDropLayer);
   
   if( !%payload.parentGroup.isInNamespaceHierarchy( "AssetPreviewControlType_AssetDrop" ) )
      return;
      
   %assetType = %payload.assetType;
   %assetName = %payload.assetName;
   %moduleName = %payload.moduleName;
   
   %item = %this.getItemAtPosition(%position);
   
   %parent = %this.getParentItem(%item);
   
   if(%item != 1)
   {
      //we're a folder entry, cool
      %path = %this.getItemValue(%item) @ "/" @ %this.getItemText(%item);
      
      if(%path !$= AssetBrowser.dirHandler.CurrentAddress)
      {
         if(getModuleFromAddress(%path) !$= getModuleFromAddress(AssetBrowser.dirHandler.CurrentAddress))
         {
            AssetBrowser.callAssetTypeFunc(%this.assetType, "onMoveModule", %this.moduleName, %this.assetName, %path);
         }
         else
         {
            AssetBrowser.callAssetTypeFunc(%this.assetType, "onMovePath", %this.moduleName, %this.assetName, %path);
         }
   
         //we're trying to move the asset to a different module!
         //toolsMessageBoxYesNo( "Move Asset", "Do you wish to move asset " @ %assetName @ " to " @ %path @ "?", 
         //      "AssetBrowser.moveAsset(\""@ %moduleName @ ":" @ %assetName @"\", \""@%path@"\");", ""); 
      }
   }
}

function AssetBrowserFilterTree::onDragDropped( %this )
{
}

function AssetBrowser::hasLooseFilesInDir(%this)
{
   if(!isDirectory(%this.dirHandler.currentAddress))
      return false;
   
   //First, wipe out any files inside the folder first
   %file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
   
   %aq = new AssetQuery();

   while( %file !$= "" )
   {      
      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
      {
         %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
         
         if(%assetsFound == 0)
         {
            %ext = fileExt(%file);
            if(isShapeFormat(%ext) || isImageFormat(%ext) || isSoundFormat(%ext))
            {
               %aq.delete();
               return true; 
            }
         }
      }
      
      %file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
   }
   
   %aq.delete();
   return false;
}

function AssetBrowser::autoImportSimpleLooseFiles(%this)
{
   %importer = new AssetImporter();
   
   //First, wipe out any files inside the folder first
   %file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
   
   %aq = new AssetQuery();

   while( %file !$= "" )
   {      
      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file) 
         && !strIsMatchExpr("*.cs", %file) && !strIsMatchExpr("*.tscript", %file) && !strIsMatchExpr("*.module", %file))
      {
         %aq.clear();
         %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
         
         if(%assetsFound == 0)
         {
            %ext = fileExt(%file);
            if(isShapeFormat(%ext) || isImageFormat(%ext) || isSoundFormat(%ext))
            {
               %assetId = %importer.autoImportFile(%file);  
            }
         }
      }
      
      %file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
   }
   
   %aq.delete();
   %importer.delete(); 
   
   %this.refresh();
}

function AssetBrowser::getLooseFilesInDir(%this)
{
   if(!isObject(ABLooseFileArray))
      new ArrayObject(ABLooseFileArray);
      
   ABLooseFileArray.empty();
   
   %showLooseFiles = EditorSettings.value("Assets/Browser/showLooseFiles", false);
   if(%showLooseFiles == false)
      return;
      
   //First, wipe out any files inside the folder first
   %file = findFirstFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*", false);
   
   %aq = new AssetQuery();

   while( %file !$= "" )
   {      
      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
      {
         %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
         
         if(%assetsFound == 0)
         {
            ABLooseFileArray.add(%file);
         }
      }
      
      %file = findNextFileMultiExpr( %this.dirHandler.currentAddress @ "/*.*" );
   }
   
   %aq.delete();
   return false;
}

function getNonAssetFilesInDir(%path, %arrayObj)
{
   //echo("getNonAssetFilesInDir() - path: " @ %path);
   
   if(!isObject(%arrayObj))
   {
      error("getNonAssetFilesInDir() - requires a valid arrayObject to place found non-Asset files into!");
      return 0;
   }
   
   %arrayObj.empty();
   
   //First, wipe out any files inside the folder first
   %file = findFirstFileMultiExpr( %path @ "/*.*", false);
   
   %aq = new AssetQuery();

   while( %file !$= "" )
   {      
      if(!strIsMatchExpr("*.asset.taml", %file) && !strIsMatchExpr("*.taml", %file) && !strIsMatchExpr("*.cached.dts", %file))
      {
         %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %file);
         
         if(%assetsFound == 0)
         {
            %arrayObj.add(%file);
         }
      }
      
      %file = findNextFileMultiExpr( %path @ "/*.*" );
   }
   
   %aq.delete();
   
   return %arrayObj.count();
}

//
//
function AssetBrowser::importLooseFiles(%this)
{
   echo("Adding loose files at directory " @ %this.dirHandler.currentAddress);
   LooseFileAuditWindow.showDialog(%this.dirHandler.currentAddress);  
}

// -----------------------------------------------------------------------------

function getAssetPreviewImage(%asset)
{
   if(isFile(%asset))
   {
      %aq = new AssetQuery();
      %assetsFound = AssetDatabase.findAssetLooseFile(%aq, %asset);
      if(%assetsFound != 0)
      {
         %asset = %aq.getAsset(0);
      }
      else
      {
         %previewPath = %asset;
      }
      
      %aq.delete();
   }
   
   if(AssetDatabase.isDeclaredAsset(%asset))
   {
      %moduleName = AssetDatabase.getAssetModule(%asset).ModuleId;
      %assetName = AssetDatabase.getAssetName(%asset);
      
      %previewPath = "tools/resources/previewCache/" @ %moduleName @ "/";
      %previewFilePath = %previewPath @ %assetName @ ".png";

      if(isFile(%previewFilePath))
      {
         %previewPath = %previewFilePath;
      }
      else
      {
         %previewPath = %asset;  
      }
   }
   else
   {
      %previewPath = %asset;
   }
   
   if(%previewPath $= "")
      %previewPath = "ToolsModule:unknownImage_image";

   return %previewPath;
}

// -----------------------------------------------------------------------------

function AssetBrowserWindow::dockPanel(%this)
{
   if(%this.docked == true)
      return;
   
   %this.resizing = true;
      
   %this.docked = true;

   %this.canCollapse = "0";
   %this.canMove = "0";
   %this.resizeWidth = "0";
   
   AssetBrowserWindow_UnDockBtn.Visible = "1";
   AssetBrowserWindow_DockBtn.Visible = "0";
   
   EditorGui.updateSideBar();
}

function AssetBrowserWindow::releasePanel(%this)
{
   if(%this.docked == false)
      return;

   %this.canCollapse = "1";
   %this.canMove = "1";
   %this.resizeWidth = "1";
   
   AssetBrowserWindow_UnDockBtn.Visible = "0";
   AssetBrowserWindow_DockBtn.Visible = "1";
   
   // Let's do a small resize so it's visually clear we're "undocking"
   %position = %this.position.x + 6 SPC %this.position.y - 6;
   %extent = %this.extent.x SPC %this.extent.y;
   %this.resize(%position.x, %position.y, %extent.x, %extent.y);
   
   %this.docked = false;
   %this.resizing = false;
   
   EditorGui.updateSideBar();
}

function AssetBrowserWindow::onResize(%this, %posX, %posY, %width, %height)
{
    if (%width>%height)
    {
        AssetBrowser-->assetList.fillRowFirst = true;
        AssetBrowser-->assetList.extent.x = AssetListPanel.extent.x;
    }
    else
    {
        AssetBrowser-->assetList.fillRowFirst = false;
        AssetBrowser-->assetList.extent.y = AssetListPanel.extent.y;
    }
        
    //AssetBrowser.rebuildAssetArray();
}