コード例 #1
0
    public unsafe bool ApplyWorkshopData(WorkshopItemData data)
    {
        UGCUpdateHandle_t handle = SteamUGC.StartItemUpdate(SteamUtils.GetAppID(), _id);

        if (handle.m_UGCUpdateHandle == 0)
        {
            return(false);
        }
        this.data = data;
        if (data.name != null)
        {
            SteamUGC.SetItemTitle(handle, data.name);
            SteamUGC.SetItemVisibility(handle, (ERemoteStoragePublishedFileVisibility)data.visibility);
        }
        if (data.description != null)
        {
            SteamUGC.SetItemDescription(handle, data.description);
        }
        List <string> tags = data.tags;

        if (tags != null && tags.Count != 0)
        {
            SteamUGC.SetItemTags(handle, data.tags);
        }
        SteamUGC.SetItemPreview(handle, data.previewPath);
        SteamUGC.SetItemContent(handle, data.contentFolder);
        _currentUpdateHandle = handle;
        Steam.StartUpload(this);
        return(true);
    }
コード例 #2
0
 private unsafe static void OnSendQueryUGCRequest(SteamUGCQueryCompleted_t result, bool ioFailure)
 {
     if (!_initialized)
     {
         return;
     }
     for (uint i = 0; i < result.m_unNumResultsReturned; i++)
     {
         SteamUGCDetails_t details;
         if (SteamUGC.GetQueryUGCResult(result.m_handle, i, out details))
         {
             WorkshopItem item = WorkshopItem.GetItem(details.m_nPublishedFileId.m_PublishedFileId);
             if (item != null)
             {
                 WorkshopItemData workshopItemData = new WorkshopItemData();
                 SteamUGC.GetQueryUGCPreviewURL(result.m_handle, i, out workshopItemData.previewPath, 256);
                 workshopItemData.description = details.m_rgchDescription;
                 workshopItemData.votesUp     = (int)details.m_unVotesUp;
                 item.SetDetails(details.m_pchFileName, workshopItemData);
             }
         }
     }
     SteamUGC.ReleaseQueryUGCRequest(result.m_handle);
 }
コード例 #3
0
 public void SetDetails(string name, WorkshopItemData data)
 {
     this.name = name;
     this.data = data;
 }
コード例 #4
0
 public override void Update()
 {
     if (this._pressWait > 0)
     {
         --this._pressWait;
     }
     if (this._editModMenu.open)
     {
         if (!UIMenu.globalUILock && (Input.Pressed("QUACK") || Keyboard.Pressed(Keys.Escape)))
         {
             this._editModMenu.Close();
             this.Open();
             return;
         }
     }
     else if (this.open)
     {
         if (this._transferItem != null && !this._needsUpdateNotes)
         {
             if (!this._transferring)
             {
                 if (this._transferItem.result == SteamResult.OK)
                 {
                     WorkshopItemData dat = new WorkshopItemData();
                     if (this._selectedMod.configuration.workshopID == 0UL)
                     {
                         this._selectedMod.configuration.SetWorkshopID(this._transferItem.id);
                         dat.name        = this._selectedMod.configuration.displayName;
                         dat.description = this._selectedMod.configuration.description;
                         dat.visibility  = RemoteStoragePublishedFileVisibility.Private;
                         dat.tags        = new List <string>();
                         dat.tags.Add("Mod");
                     }
                     else
                     {
                         dat.changeNotes = this._updateTextBox.text;
                     }
                     string pathString = this._selectedMod.configuration.directory + "/content/";
                     DuckFile.CreatePath(pathString);
                     string path1 = pathString + "screenshot.png";
                     if (!File.Exists(path1))
                     {
                         File.Delete(path1);
                         Tex2D  screenshot = this._selectedMod.screenshot;
                         Stream stream     = (Stream)DuckFile.Create(path1);
                         ((Texture2D)screenshot.nativeObject).SaveAsPng(stream, screenshot.width, screenshot.height);
                         stream.Dispose();
                     }
                     dat.previewPath = path1;
                     string str = DuckFile.workshopDirectory + (object)this._transferItem.id + "/content";
                     if (Directory.Exists(str))
                     {
                         Directory.Delete(str, true);
                     }
                     DuckFile.CreatePath(str);
                     UIModManagement.DirectoryCopy(this._selectedMod.configuration.directory, str + "/" + this._selectedMod.configuration.name, true);
                     if (Directory.Exists(str + this._selectedMod.configuration.name + "/build"))
                     {
                         Directory.Delete(str + this._selectedMod.configuration.name + "/build", true);
                     }
                     if (Directory.Exists(str + this._selectedMod.configuration.name + "/.vs"))
                     {
                         Directory.Delete(str + this._selectedMod.configuration.name + "/.vs", true);
                     }
                     if (File.Exists(str + this._selectedMod.configuration.name + "/" + this._selectedMod.configuration.name + "_compiled.dll"))
                     {
                         string path2 = str + this._selectedMod.configuration.name + "/" + this._selectedMod.configuration.name + "_compiled.dll";
                         File.SetAttributes(path2, FileAttributes.Normal);
                         File.Delete(path2);
                     }
                     if (File.Exists(str + this._selectedMod.configuration.name + "/" + this._selectedMod.configuration.name + "_compiled.hash"))
                     {
                         string path2 = str + this._selectedMod.configuration.name + "/" + this._selectedMod.configuration.name + "_compiled.hash";
                         File.SetAttributes(path2, FileAttributes.Normal);
                         File.Delete(path2);
                     }
                     dat.contentFolder = str;
                     this._transferItem.ApplyWorkshopData(dat);
                     if (this._transferItem.needsLegal)
                     {
                         Steam.ShowWorkshopLegalAgreement("312530");
                     }
                     this._transferring = true;
                     this._transferItem.ResetProcessing();
                 }
             }
             else if (this._transferItem.finishedProcessing)
             {
                 Steam.OverlayOpenURL("http://steamcommunity.com/sharedfiles/filedetails/?id=" + (object)this._transferItem.id);
                 Directory.Delete(DuckFile.workshopDirectory + (object)this._transferItem.id + "/", true);
                 this._transferItem.ResetProcessing();
                 this._transferItem = (WorkshopItem)null;
                 this._transferring = false;
             }
             base.Update();
             return;
         }
         if (this._gamepadMode)
         {
             if (this._hoverIndex < 0)
             {
                 this._hoverIndex = 0;
             }
         }
         else
         {
             this._hoverIndex = -1;
             for (int index = 0; index < this._maxModsToShow && this._scrollItemOffset + index < this._mods.Count; ++index)
             {
                 if (new Rectangle((float)(int)(this._box.x - this._box.halfWidth), (float)(int)(this._box.y - this._box.halfHeight + (float)(36 * index)), (float)((int)this._box.width - 14), 36f).Contains(Mouse.position))
                 {
                     this._hoverIndex = this._scrollItemOffset + index;
                     break;
                 }
             }
         }
         if (this._transferItem != null)
         {
             if (this._updateTextBox != null)
             {
                 Editor.hoverTextBox           = false;
                 this._updateTextBox.position  = new Vec2((float)((double)this._box.x - (double)this._box.halfWidth + 16.0), (float)((double)this._box.y - (double)this._box.halfHeight + 48.0));
                 this._updateTextBox.size      = new Vec2(this._box.width - 32f, this._box.height - 80f);
                 this._updateTextBox._maxLines = (int)((double)this._updateTextBox.size.y / (double)this._fancyFont.characterHeight);
                 this._updateTextBox.Update();
                 float stringWidth = DuckGame.Graphics.GetStringWidth(this._updateButtonText, scale: 2f);
                 float height      = DuckGame.Graphics.GetStringHeight(this._updateButtonText) * 2f;
                 this._updateButton = new Rectangle(this._box.x - stringWidth / 2f, (float)((double)this._box.y + (double)this._box.halfHeight - 24.0), stringWidth, height);
                 if (this._updateButton.Contains(Mouse.position) && Mouse.left == InputState.Pressed)
                 {
                     this._needsUpdateNotes = false;
                     this._updateTextBox.LoseFocus();
                 }
                 else if (Keyboard.Pressed(Keys.Escape))
                 {
                     this._needsUpdateNotes = false;
                     this._transferItem     = (WorkshopItem)null;
                     this._updateTextBox.LoseFocus();
                     new UIMenuActionOpenMenu((UIComponent)this, (UIComponent)this._editModMenu).Activate();
                     return;
                 }
             }
         }
         else if (this._hoverIndex != -1)
         {
             this._selectedMod = this._mods[this._hoverIndex];
             if (Input.Pressed("SHOOT"))
             {
                 if (this._selectedMod != null && this._selectedMod.configuration != null)
                 {
                     if (this._selectedMod.configuration.disabled)
                     {
                         this._selectedMod.configuration.Enable();
                     }
                     else
                     {
                         this._selectedMod.configuration.Disable();
                     }
                     this.modsChanged = true;
                     SFX.Play("rockHitGround", 0.8f);
                 }
             }
             else if (Input.Pressed("SELECT") && this._pressWait == 0 && this._gamepadMode || !this._gamepadMode && Mouse.left == InputState.Pressed)
             {
                 if (this._selectedMod != null)
                 {
                     this._editModMenu.title = this._selectedMod.configuration.loaded ? "|YELLOW|" + this._selectedMod.configuration.displayName : "|YELLOW|" + this._selectedMod.configuration.name;
                     this._editModMenu.Remove((UIComponent)this._deleteOrUnsubItem);
                     this._editModMenu.Remove((UIComponent)this._uploadItem);
                     this._editModMenu.Remove((UIComponent)this._visitItem);
                     if (!this._selectedMod.configuration.isWorkshop && this._selectedMod.configuration.loaded)
                     {
                         this._uploadItem.text = this._selectedMod.configuration.workshopID == 0UL ? "UPLOAD" : "UPDATE";
                         this._editModMenu.Insert((UIComponent)this._uploadItem, 1, true);
                     }
                     if (!this._selectedMod.configuration.isWorkshop && !this._selectedMod.configuration.loaded)
                     {
                         this._deleteOrUnsubItem.text = "DELETE";
                         this._editModMenu.Insert((UIComponent)this._deleteOrUnsubItem, 1, true);
                     }
                     else if (this._selectedMod.configuration.isWorkshop)
                     {
                         this._deleteOrUnsubItem.text = "UNSUBSCRIBE";
                         this._editModMenu.Insert((UIComponent)this._deleteOrUnsubItem, 1, true);
                     }
                     if (this._selectedMod.configuration.isWorkshop)
                     {
                         this._editModMenu.Insert((UIComponent)this._visitItem, 1, true);
                     }
                     this._disableOrEnableItem.text = this._selectedMod.configuration.disabled ? "ENABLE" : "DISABLE";
                     this._editModMenu.dirty        = true;
                     SFX.Play("rockHitGround", 0.8f);
                     new UIMenuActionOpenMenu((UIComponent)this, (UIComponent)this._editModMenu).Activate();
                     return;
                 }
                 Steam.OverlayOpenURL("http://steamcommunity.com/workshop/browse/?appid=312530&searchtext=&childpublishedfileid=0&browsesort=trend&section=readytouseitems&requiredtags%5B%5D=Mod");
             }
         }
         else
         {
             this._selectedMod = (Mod)null;
         }
         if (this._gamepadMode)
         {
             this._draggingScrollbar = false;
             if (Input.Pressed("DOWN"))
             {
                 ++this._hoverIndex;
             }
             else if (Input.Pressed("UP"))
             {
                 --this._hoverIndex;
             }
             if (Input.Pressed("STRAFE"))
             {
                 this._hoverIndex -= 10;
             }
             else if (Input.Pressed("RAGDOLL"))
             {
                 this._hoverIndex += 10;
             }
             if (this._hoverIndex < 0)
             {
                 this._hoverIndex = 0;
             }
             if ((double)(this._oldPos - Mouse.positionScreen).lengthSq > 200.0)
             {
                 this._gamepadMode = false;
             }
         }
         else
         {
             if (!this._draggingScrollbar)
             {
                 if (Mouse.left == InputState.Pressed && this.ScrollBarBox().Contains(Mouse.position))
                 {
                     this._draggingScrollbar = true;
                     this._oldPos            = Mouse.position;
                 }
                 if ((double)Mouse.scroll > 0.0)
                 {
                     this._scrollItemOffset += 5;
                     this._hoverIndex       += 5;
                 }
                 else if ((double)Mouse.scroll < 0.0)
                 {
                     this._scrollItemOffset -= 5;
                     this._hoverIndex       -= 5;
                     if (this._hoverIndex < 0)
                     {
                         this._hoverIndex = 0;
                     }
                 }
             }
             else if (Mouse.left != InputState.Down)
             {
                 this._draggingScrollbar = false;
             }
             else
             {
                 Vec2 vec2 = Mouse.position - this._oldPos;
                 this._oldPos          = Mouse.position;
                 this.scrollBarOffset += (int)vec2.y;
                 if (this.scrollBarOffset > this.scrollBarScrollableHeight)
                 {
                     this.scrollBarOffset = this.scrollBarScrollableHeight;
                 }
                 else if (this.scrollBarOffset < 0)
                 {
                     this.scrollBarOffset = 0;
                 }
                 this._scrollItemOffset = (int)((double)(this._mods.Count - this._maxModsToShow) * (double)((float)this.scrollBarOffset / (float)this.scrollBarScrollableHeight));
             }
             if (Input.Pressed("ANY"))
             {
                 this._gamepadMode = true;
                 this._oldPos      = Mouse.positionScreen;
             }
         }
         if (this._scrollItemOffset < 0)
         {
             this._scrollItemOffset = 0;
         }
         else if (this._scrollItemOffset > Math.Max(0, this._mods.Count - this._maxModsToShow))
         {
             this._scrollItemOffset = Math.Max(0, this._mods.Count - this._maxModsToShow);
         }
         if (this._hoverIndex >= this._mods.Count)
         {
             this._hoverIndex = this._mods.Count - 1;
         }
         else if (this._hoverIndex >= this._scrollItemOffset + this._maxModsToShow)
         {
             this._scrollItemOffset += this._hoverIndex - (this._scrollItemOffset + this._maxModsToShow) + 1;
         }
         else if (this._hoverIndex >= 0 && this._hoverIndex < this._scrollItemOffset)
         {
             this._scrollItemOffset -= this._scrollItemOffset - this._hoverIndex;
         }
         this.scrollBarOffset = this._scrollItemOffset == 0 ? 0 : (int)Lerp.FloatSmooth(0.0f, (float)this.scrollBarScrollableHeight, (float)this._scrollItemOffset / (float)(this._mods.Count - this._maxModsToShow));
         if (!Editor.hoverTextBox && !UIMenu.globalUILock && (Input.Pressed("QUACK") || Keyboard.Pressed(Keys.Escape)))
         {
             if (this.modsChanged)
             {
                 this.Close();
                 MonoMain.pauseMenu = DuckNetwork.OpenModsRestartWindow(this._openOnClose);
             }
             else
             {
                 new UIMenuActionOpenMenu((UIComponent)this, (UIComponent)this._openOnClose).Activate();
             }
             this.modsChanged = false;
             return;
         }
     }
     if (this._showingMenu)
     {
         HUD.CloseAllCorners();
         this._showingMenu = false;
     }
     base.Update();
 }
コード例 #5
0
 public override void Update()
 {
     if (this._doingPublish && this._currentItem != null)
     {
         if (!this._currentItem.finishedProcessing)
         {
             return;
         }
         if (this._uploading)
         {
             this._uploading = false;
             if (this._currentItem.needsLegal)
             {
                 Steam.ShowWorkshopLegalAgreement("312530");
             }
             this._upload.Close();
             if (this._currentItem.result == SteamResult.OK)
             {
                 this._notify.Open("Item published!");
             }
             else
             {
                 this._notify.Open("Failed (" + this._currentItem.result.ToString() + ")");
             }
             this._doingPublish = false;
         }
         else if (this._currentItem.result == SteamResult.OK)
         {
             this._uploading = true;
             WorkshopItemData dat = new WorkshopItemData();
             dat.name        = this._nameBox.text;
             dat.description = this._descriptionBox.text;
             dat.visibility  = RemoteStoragePublishedFileVisibility.Public;
             dat.tags        = new List <string>();
             if (this._levelType == LevelType.ArcadeMachine)
             {
                 dat.tags.Add("Machine");
             }
             else
             {
                 dat.tags.Add("Map");
             }
             dat.tags.Add(this._levelSize.ToString());
             if (this._levelType != LevelType.Deathmatch)
             {
                 dat.tags.Add(this._levelType.ToString());
             }
             Editor.workshopName        = dat.name;
             Editor.workshopDescription = dat.description;
             Editor.workshopAuthor      = Steam.user.name;
             Editor.workshopID          = this._currentItem.id;
             if (this._addDeathmatchTag)
             {
                 dat.tags.Add("Deathmatch");
                 Editor.workshopLevelDeathmatchReady = true;
             }
             else if (this._addMachineTag)
             {
                 dat.tags.Add("Arcade Machine");
                 Editor.workshopLevelDeathmatchReady = true;
             }
             else if (this._levelType == LevelType.Deathmatch)
             {
                 dat.tags.Add("Strange");
             }
             dat.tags.AddRange((IEnumerable <string>)Editor.workshopTags);
             if (this._extraTags != null && ((IEnumerable <string>) this._extraTags).Count <string>() > 0)
             {
                 dat.tags.AddRange((IEnumerable <string>) this._extraTags);
             }
             (Level.current as Editor).Save();
             this._workshopID = this._currentItem.id;
             string pathString1 = DuckFile.workshopDirectory + (object)this._workshopID + "/";
             string pathString2 = DuckFile.workshopDirectory + (object)this._workshopID + "-preview/";
             DuckFile.CreatePath(pathString1);
             DuckFile.CreatePath(pathString2);
             string withoutExtension = Path.GetFileNameWithoutExtension(this._filePath);
             string str = pathString1 + Path.GetFileName(this._filePath);
             if (File.Exists(str))
             {
                 File.Delete(str);
             }
             File.Copy(this._filePath, str);
             File.SetAttributes(this._filePath, FileAttributes.Normal);
             dat.contentFolder = pathString1;
             string path = pathString2 + withoutExtension + ".png";
             if (File.Exists(path))
             {
                 File.Delete(path);
             }
             Stream stream = (Stream)DuckFile.Create(path);
             ((Texture2D)this._previewTarget.texture.nativeObject).SaveAsPng(stream, this._previewTarget.width, this._previewTarget.height);
             stream.Dispose();
             dat.previewPath = path;
             this._currentItem.ApplyWorkshopData(dat);
             if (this._currentItem.needsLegal)
             {
                 Steam.ShowWorkshopLegalAgreement("312530");
             }
             this._upload.Open("Uploading...", this._currentItem);
         }
         else
         {
             this._notify.Open("Failed (" + this._currentItem.result.ToString() + ")");
             this._doingPublish = false;
         }
         this._currentItem.ResetProcessing();
     }
     else if (!this.opened || this._opening || (this._confirm.opened || this._upload.opened) || (this._deathmatchTest.opened || this._arcadeTest.opened || this._testSuccess.opened))
     {
         if (this.opened)
         {
             Keyboard.keyString = "";
         }
         this._opening = false;
         foreach (ContextMenu contextMenu in this._items)
         {
             contextMenu.disabled = true;
         }
     }
     else if (this._confirm.result)
     {
         if (this._levelType == LevelType.ArcadeMachine)
         {
             this._arcadeTest.Open("This machine can automatically show up in generated arcades, if you pass this validity test. You need to get the Developer trophy on all 3 challenges (oh boy)!");
         }
         else
         {
             this._deathmatchTest.Open("In order to upload this map as a deathmatch level, all ducks need to be able to be eliminated. Do you want to launch the map and show that the map is functional? You don't have to do this, but the map won't show up with the DEATHMATCH tag without completing this test. If this is a challenge map, then don't worry about it!");
         }
         this._confirm.result = false;
     }
     else if (this._testing)
     {
         Keyboard.keyString = "";
         if (DeathmatchTestDialogue.success)
         {
             this._testSuccess.Open("Test success! The level can now be published as a deathmatch level!");
             this._addDeathmatchTag = true;
         }
         else if (ArcadeTestDialogue.success)
         {
             if (this._arcadeTestIndex != 2)
             {
                 ++this._arcadeTestIndex;
                 ArcadeTestDialogue.success       = false;
                 ArcadeTestDialogue.currentEditor = Level.current as Editor;
                 Level.current = this._arcadeTestIndex != 0 ? (this._arcadeTestIndex != 1 ? (Level) new ChallengeLevel(((Level.current as Editor).levelThings[0] as ArcadeMachine).challenge03Data, true) : (Level) new ChallengeLevel(((Level.current as Editor).levelThings[0] as ArcadeMachine).challenge02Data, true)) : (Level) new ChallengeLevel(((Level.current as Editor).levelThings[0] as ArcadeMachine).challenge01Data, true);
                 this._testing = true;
                 return;
             }
             this._testSuccess.Open("Test success! The arcade machine can now be published to the workshop!");
             this._addMachineTag = true;
         }
         else if (DeathmatchTestDialogue.tooSlow)
         {
             this._notify.Open("Framerate too low!");
         }
         else
         {
             this._notify.Open("Testing failed.");
             this._arcadeTestIndex = 0;
         }
         DeathmatchTestDialogue.success = false;
         ArcadeTestDialogue.success     = false;
         this._testing = false;
     }
     else if (this._testSuccess.result)
     {
         this._doingPublish = true;
         if (this._currentItem == null)
         {
             this._currentItem = Steam.CreateItem();
         }
         else
         {
             this._currentItem.SkipProcessing();
         }
         this._testSuccess.result = false;
     }
     else if (this._deathmatchTest.result != -1)
     {
         if (this._deathmatchTest.result == 1)
         {
             this._doingPublish = true;
             if (this._currentItem == null)
             {
                 this._currentItem = Steam.CreateItem();
             }
             else
             {
                 this._currentItem.SkipProcessing();
             }
         }
         else if (this._deathmatchTest.result == 0)
         {
             DeathmatchTestDialogue.success       = false;
             DeathmatchTestDialogue.currentEditor = Level.current as Editor;
             Level.current = (Level) new GameLevel(this._filePath, validityTest: true);
             this._testing = true;
         }
         this._deathmatchTest.result = -1;
     }
     else if (this._arcadeTest.result != -1)
     {
         if (this._arcadeTest.result == 1)
         {
             this._doingPublish = true;
             if (this._currentItem == null)
             {
                 this._currentItem = Steam.CreateItem();
             }
             else
             {
                 this._currentItem.SkipProcessing();
             }
         }
         else if (this._arcadeTest.result == 0)
         {
             ArcadeTestDialogue.success       = false;
             ArcadeTestDialogue.currentEditor = Level.current as Editor;
             Level.current = (Level) new ChallengeLevel(((Level.current as Editor).levelThings[0] as ArcadeMachine).challenge01Data, true);
             this._testing = true;
         }
         this._arcadeTest.result = -1;
     }
     else
     {
         if (this._tagMenu != null)
         {
             return;
         }
         Vec2 vec2 = new Vec2((float)((double)this.layer.width / 2.0 - (double)this.width / 2.0) + this.hOffset, (float)((double)this.layer.height / 2.0 - (double)this.height / 2.0 - 15.0)) + new Vec2(7f, 276f);
         foreach (KeyValuePair <string, Vec2> tagPosition in this.tagPositions)
         {
             if ((double)Mouse.x > (double)tagPosition.Value.x && (double)Mouse.x < (double)tagPosition.Value.x + 8.0 && ((double)Mouse.y > (double)tagPosition.Value.y && (double)Mouse.y < (double)tagPosition.Value.y + 8.0) && Mouse.left == InputState.Pressed)
             {
                 Editor.workshopTags.Remove(tagPosition.Key);
                 return;
             }
         }
         if (this.tagPositions.Count != this._possibleTags.Count)
         {
             bool flag = false;
             if ((double)Mouse.x > (double)this._plusPosition.x && (double)Mouse.x < (double)this._plusPosition.x + 8.0 && ((double)Mouse.y > (double)this._plusPosition.y && (double)Mouse.y < (double)this._plusPosition.y + 8.0))
             {
                 flag = true;
             }
             if (flag && Mouse.left == InputState.Pressed)
             {
                 ContextMenu contextMenu = new ContextMenu((IContextListener)this);
                 contextMenu.x     = this._plusPosition.x;
                 contextMenu.y     = this._plusPosition.y;
                 contextMenu.root  = true;
                 contextMenu.depth = this.depth + 20;
                 int num = 0;
                 foreach (string possibleTag in this._possibleTags)
                 {
                     if (!Editor.workshopTags.Contains(possibleTag))
                     {
                         contextMenu.AddItem(new ContextMenu((IContextListener)this)
                         {
                             itemSize =
                             {
                                 x = 40f
                             },
                             text = possibleTag
                         });
                         ++num;
                     }
                 }
                 contextMenu.y -= (float)(num * 16 + 10);
                 Level.Add((Thing)contextMenu);
                 contextMenu.opened       = true;
                 contextMenu.closeOnRight = true;
                 this._tagMenu            = contextMenu;
                 return;
             }
         }
         Editor.lockInput = (ContextMenu)this;
         this._descriptionBox.Update();
         this._nameBox.Update();
         this._acceptHover = false;
         this._cancelHover = false;
         if ((double)Mouse.x > (double)this._acceptPos.x && (double)Mouse.x < (double)this._acceptPos.x + (double)this._acceptSize.x && ((double)Mouse.y > (double)this._acceptPos.y && (double)Mouse.y < (double)this._acceptPos.y + (double)this._acceptSize.y))
         {
             this._acceptHover = true;
         }
         if ((double)Mouse.x > (double)this._cancelPos.x && (double)Mouse.x < (double)this._cancelPos.x + (double)this._cancelSize.x && ((double)Mouse.y > (double)this._cancelPos.y && (double)Mouse.y < (double)this._cancelPos.y + (double)this._cancelSize.y))
         {
             this._cancelHover = true;
         }
         if (this._acceptHover && Mouse.left == InputState.Pressed)
         {
             if (this._nameBox.text == "")
             {
                 this._notify.Open("Please enter a name :(");
             }
             else
             {
                 this._confirm.Open("Upload to workshop?");
             }
         }
         if (this._cancelHover && Mouse.left == InputState.Pressed)
         {
             this.Close();
         }
         base.Update();
     }
 }