public void Remove(GumpEntry g)
{
if (g == null || !Entries.Contains(g))
{
return;
}
Entries.Remove(g);
g.Parent = null;
}
public void Add(GumpEntry g)
{
if (g.Parent != this)
{
g.Parent = this;
}
else if (!Entries.Contains(g))
{
Entries.Add(g);
}
}
public void OnFontSmallRadioButtonUpdate(GumpEntry gumpComponent, object param)
{
var radio = gumpComponent as GumpRadio;
if (radio != null)
{
if (radio.InitialState)
{
FontSize = FontHandling.FontSize.Small;
}
}
}
public void OnBoldCheckboxUpdate(GumpEntry gumpComponent, object param)
{
var check = gumpComponent as GumpCheck;
if (check != null)
{
try
{
Bold = check.InitialState;
}
catch
{ }
}
}
public void OnTextEntryUpdate(GumpEntry gumpComponent, object param)
{
var entry = gumpComponent as GumpTextEntry;
if (entry != null)
{
try
{
Text = entry.InitialText;
}
catch
{ }
}
}
public void OnGumpIdTextEntryUpdate(GumpEntry gumpComponent, object param)
{
var entry = gumpComponent as GumpTextEntry;
if (entry != null)
{
try
{
GumpId = Convert.ToInt32(entry.InitialText);
}
catch
{ }
}
}
private void DisposeEntry(GumpEntry e)
{
if (e == null || e.Parent != this)
{
return;
}
if (e is IDisposable)
{
((IDisposable)e).Dispose();
}
else
{
e.Parent = null;
}
Entries.Remove(e);
}
public void OnScrollbarCheckboxUpdate(GumpEntry gumpComponent, object param)
{
var check = gumpComponent as GumpCheck;
if (check != null)
{
try
{
Scrollbar = check.InitialState;
}
catch
{ }
}
}
public void OnBackgroundCheckboxUpdate(GumpEntry gumpComponent, object param)
{
var check = gumpComponent as GumpCheck;
if (check != null)
{
try
{
Background = check.InitialState;
}
catch
{ }
}
}
public void OnGumpLinkEntryUpdate(GumpEntry gumpComponent, object param)
{
var entry = gumpComponent as GumpTextEntry;
if (entry != null)
{
try
{
GumpLink = entry.InitialText;
}
catch
{ }
}
}
public void OnFontSmallRadioButtonUpdate(GumpEntry gumpComponent, object param)
{
var radio = gumpComponent as GumpRadio;
if (radio != null)
{
if (radio.InitialState)
{
FontSize = FontHandling.FontSize.Small;
}
}
}
public static void AppendToByType(this GumpEntry e, IGumpWriter disp, List <string> strings)
{
switch (e)
{
case GumpAlphaRegion g:
{
g.AppendTo(disp, strings);
break;
}
case GumpBackground g:
{
g.AppendTo(disp, strings);
break;
}
case GumpButton g:
{
g.AppendTo(disp, strings);
break;
}
case GumpCheck g:
{
g.AppendTo(disp, strings);
break;
}
case GumpGroup g:
{
g.AppendTo(disp, strings);
break;
}
case GumpECHandleInput g:
{
g.AppendTo(disp, strings);
break;
}
case GumpHtml g:
{
g.AppendTo(disp, strings);
break;
}
case GumpHtmlLocalized g:
{
g.AppendTo(disp, strings);
break;
}
case GumpImage g:
{
g.AppendTo(disp, strings);
break;
}
case GumpImageTileButton g:
{
g.AppendTo(disp, strings);
break;
}
case GumpImageTiled g:
{
g.AppendTo(disp, strings);
break;
}
case GumpItem g:
{
g.AppendTo(disp, strings);
break;
}
case GumpItemProperty g:
{
g.AppendTo(disp, strings);
break;
}
case GumpLabel g:
{
g.AppendTo(disp, strings);
break;
}
case GumpLabelCropped g:
{
g.AppendTo(disp, strings);
break;
}
case GumpMasterGump g:
{
g.AppendTo(disp, strings);
break;
}
case GumpPage g:
{
g.AppendTo(disp, strings);
break;
}
case GumpRadio g:
{
g.AppendTo(disp, strings);
break;
}
case GumpSpriteImage g:
{
g.AppendTo(disp, strings);
break;
}
case GumpTextEntry g:
{
g.AppendTo(disp, strings);
break;
}
case GumpTextEntryLimited g:
{
g.AppendTo(disp, strings);
break;
}
case GumpTooltip g:
{
g.AppendTo(disp, strings);
break;
}
}
}
/// <summary>
/// Generates class and saves it to stream.
/// </summary>
/// <param name="stream">Stream to write to.</param>
/// <param name="gump">Gump to generate.</param>
public static void Generate(Stream stream, GenericGumpPacket gump)
{
UltimaStringCollection clilocs = Globals.Instance.Clilocs;
using (UltimaClassWriter writer = new UltimaClassWriter(stream))
{
writer.WriteUsing("System");
writer.WriteUsing("Server");
writer.WriteUsing("Server.Gumps");
writer.WriteUsing("Server.Network");
writer.WriteLine();
writer.BeginNamespace("Server.Gumps");
string className = "GenericGump";
writer.BeginClass(className, "Gump");
writer.BeginConstructor("public", className, null, String.Format("{0}, {1}", gump.X, gump.Y));
for (int i = 0; i < gump.Entries.Count; i++)
{
GumpEntry entry = gump.Entries[i];
bool space = entry is GumpPage;
if (space && i != 0)
{
writer.WriteLine();
}
writer.WriteWithIndent(entry.GetRunUOLine());
// Comment
int cliloc = 0;
if (entry is GumpHtmlLocalized)
{
cliloc = (int)((GumpHtmlLocalized)entry).Number;
}
else if (entry is GumpHtmlLocalizedColor)
{
cliloc = (int)((GumpHtmlLocalizedColor)entry).Number;
}
else if (entry is GumpHtmlLocalizedArgs)
{
cliloc = (int)((GumpHtmlLocalizedArgs)entry).Number;
}
if (cliloc > 0 && clilocs != null)
{
string clilocText = clilocs.GetString(cliloc);
if (!String.IsNullOrEmpty(clilocText))
{
writer.WriteLine(" // {0}", clilocText);
}
else
{
writer.WriteLine();
}
}
else
{
writer.WriteLine();
}
if (space && i < gump.Entries.Count)
{
writer.WriteLine();
}
}
writer.EndConstructor();
writer.WriteLine();
writer.BeginOverrideMethod("public", "void", "OnResponse", "NetState sender, RelayInfo info");
writer.EndMethod();
writer.EndClass();
writer.EndNamespace();
App.Window.ShowNotification(NotificationType.Info, "Gump generation complete");
}
}
public void OnHeightTextEntryUpdate(GumpEntry gumpComponent, object param)
{
var entry = gumpComponent as GumpTextEntry;
if (entry != null)
{
try
{
Height = Convert.ToUInt32(entry.InitialText);
}
catch
{ }
}
}
public void OnPressedIdTextEntryUpdate(GumpEntry gumpComponent, object param)
{
var entry = gumpComponent as GumpTextEntry;
if (entry != null)
{
try
{
PressedId = Convert.ToInt32(entry.InitialText);
}
catch
{ }
}
}
private void CreateElement(GumpEntry e)
{
_CurrentNode = _Document.CreateElement(e.GetType().Name);
}
public override void OnResponse(NetState state, RelayInfo info)
{
Mobile from = state.Mobile;
int craft = info.ButtonID - 1;
if (craft < 0)
{
return;
}
if (!SpellCraftConfig.CraftEnabled[craft])
{
from.SendMessage("This craft is currently not enabled.");
return;
}
if (!SpellCraft.SufficientSkillToCraft(from))
{
from.SendMessage("You must have at least {0} alchemy and {1} inscription to use this craft.",
SpellCraftConfig.MinimumAlchemy, SpellCraftConfig.MinimumInscription);
return;
}
from.SendMessage("Select the item to place this spellcraft on.");
switch (craft)
{
case 0: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusStr.Callback), new CraftState(m_Book, 0)); break;
case 1: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusDex.Callback), new CraftState(m_Book, 1)); break;
case 2: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusInt.Callback), new CraftState(m_Book, 2)); break;
case 3: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusHits.Callback), new CraftState(m_Book, 3)); break;
case 4: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusStam.Callback), new CraftState(m_Book, 4)); break;
case 5: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(BonusMana.Callback), new CraftState(m_Book, 5)); break;
case 6: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(PhysicalResist.Callback), new CraftState(m_Book, 6)); break;
case 7: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(FireResist.Callback), new CraftState(m_Book, 7)); break;
case 8: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(ColdResist.Callback), new CraftState(m_Book, 8)); break;
case 9: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(PoisonResist.Callback), new CraftState(m_Book, 9)); break;
case 10: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(EnergyResist.Callback), new CraftState(m_Book, 10)); break;
case 11: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(RegenHits.Callback), new CraftState(m_Book, 11)); break;
case 12: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(RegenMana.Callback), new CraftState(m_Book, 12)); break;
case 13: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(RegenStam.Callback), new CraftState(m_Book, 13)); break;
case 14: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(CastRecovery.Callback), new CraftState(m_Book, 14)); break;
case 15: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(CastSpeed.Callback), new CraftState(m_Book, 15)); break;
case 16: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(LowerManaCost.Callback), new CraftState(m_Book, 16)); break;
case 17: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(LowerRegCost.Callback), new CraftState(m_Book, 17)); break;
case 18: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(MageArmor.Callback), new CraftState(m_Book, 18)); break;
case 19: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(MageWeapon.Callback), new CraftState(m_Book, 19)); break;
case 20: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(SpellChanneling.Callback), new CraftState(m_Book, 20)); break;
case 21: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(SpellDamage.Callback), new CraftState(m_Book, 21)); break;
case 22: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitColdArea.Callback), new CraftState(m_Book, 22)); break;
case 23: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitEnergyArea.Callback), new CraftState(m_Book, 23)); break;
case 24: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitFireArea.Callback), new CraftState(m_Book, 24)); break;
case 25: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitPhysicalArea.Callback), new CraftState(m_Book, 25)); break;
case 26: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitPoisonArea.Callback), new CraftState(m_Book, 26)); break;
case 27: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitDispel.Callback), new CraftState(m_Book, 27)); break;
case 28: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitFireball.Callback), new CraftState(m_Book, 28)); break;
case 29: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitHarm.Callback), new CraftState(m_Book, 29)); break;
case 30: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLightning.Callback), new CraftState(m_Book, 30)); break;
case 31: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitMagicArrow.Callback), new CraftState(m_Book, 31)); break;
case 32: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLowerAttack.Callback), new CraftState(m_Book, 32)); break;
case 33: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLowerDefend.Callback), new CraftState(m_Book, 33)); break;
case 34: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLeechHits.Callback), new CraftState(m_Book, 34)); break;
case 35: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLeechMana.Callback), new CraftState(m_Book, 35)); break;
case 36: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(HitLeechStam.Callback), new CraftState(m_Book, 36)); break;
case 37: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(UseBestSkill.Callback), new CraftState(m_Book, 37)); break;
case 38: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(WeaponDamage.Callback), new CraftState(m_Book, 38)); break;
case 39: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(WeaponSpeed.Callback), new CraftState(m_Book, 39)); break;
case 40: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(AttackChance.Callback), new CraftState(m_Book, 40)); break;
case 41: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(DefendChance.Callback), new CraftState(m_Book, 41)); break;
case 42: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(EnhancePotions.Callback), new CraftState(m_Book, 42)); break;
case 43: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(LowerStatReq.Callback), new CraftState(m_Book, 43)); break;
case 44: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(Luck.Callback), new CraftState(m_Book, 44)); break;
case 45: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(ReflectPhysical.Callback), new CraftState(m_Book, 45)); break;
case 46: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(SelfRepair.Callback), new CraftState(m_Book, 46)); break;
case 47: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(NightSight.Callback), new CraftState(m_Book, 47)); break;
case 48: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(Slayer.Callback), new CraftState(m_Book, 48)); break;
case 49: from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(Durability.Callback), new CraftState(m_Book, 49)); break;
default: break;
}
// Retrieve the current page from the button that was used to get here, and reopen the book.
List <Server.Gumps.GumpEntry> entries = Entries;
int page = 1;
for (int i = entries.Count - 1; i >= 0; i--)
{
GumpEntry e = entries[i];
if (e is GumpButton && ((GumpButton)e).ButtonID == craft + 1)
{
page = ((GumpButton)e).Param;
break;
}
}
from.SendGump(new SpellCraftBook(from, m_Book, page));
}
