public MainForm()
{
try
{
Instance = this;
_pb = Professionbuddy.Instance;
InitializeComponent();
// assign the localized strings
toolStripOpen.Text = _pb.Strings["UI_FileOpen"];
toolStripSave.Text = _pb.Strings["UI_FileSave"];
toolStripHelp.Text = _pb.Strings["UI_Help"];
toolStripCopy.Text = _pb.Strings["UI_Copy"];
toolStripCut.Text = _pb.Strings["UI_Cut"];
toolStripPaste.Text = _pb.Strings["UI_Paste"];
toolStripDelete.Text = _pb.Strings["UI_Delete"];
toolStripBotConfigButton.Text = _pb.Strings["UI_Settings"];
ProfileTab.Text = _pb.Strings["UI_Profiles"];
ActionsColumn.HeaderText = ActionsTab.Text = _pb.Strings["UI_Actions"];
TradeSkillTab.Text = _pb.Strings["UI_Tradeskill"];
TabPageProfile.Text = _pb.Strings["UI_Profile"];
IngredientsColumn.HeaderText = _pb.Strings["UI_Ingredients"];
NeedColumn.HeaderText = _pb.Strings["UI_Need"];
BagsColumn.HeaderText = _pb.Strings["UI_Bags"];
BankColumn.HeaderText = _pb.Strings["UI_Bank"];
toolStripAddBtn.Text = _pb.Strings["UI_Add"];
toolStripReloadBtn.Text = _pb.Strings["UI_Reload"];
LoadProfileButton.Text = _pb.Strings["UI_LoadProfile"];
saveFileDialog.InitialDirectory = _pb.ProfilePath;
_profileWatcher = new FileSystemWatcher(_pb.ProfilePath)
{
NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName
};
_profileWatcher.Changed += ProfileWatcherChanged;
_profileWatcher.Created += ProfileWatcherChanged;
_profileWatcher.Deleted += ProfileWatcherChanged;
_profileWatcher.Renamed += ProfileWatcherChanged;
_profileWatcher.EnableRaisingEvents = true;
// used by the dev to display the 'Secret button', a button that dumps some debug info of the Task list.
if (Environment.UserName == "highvoltz")
{
toolStripSecretButton.Visible = true;
}
}
catch (Exception ex)
{
Professionbuddy.Err(ex.ToString());
}
}
public static void CheckForUpdate()
{
try
{
Professionbuddy.Log("Checking for new version");
{
Professionbuddy.Log("A new version was found.Downloading Update");
Professionbuddy.Log("Download complete :P");
Logging.Write(Color.DodgerBlue, "************* Change Log ****************");
Logging.Write(Color.DodgerBlue, "*****************************************");
}
}
catch (Exception ex)
{
Professionbuddy.Err(ex.ToString());
}
}
/// <summary>
/// Profile behavior.
/// </summary>
//public PrioritySelector Branch { get; protected set; }
public PbDecorator LoadFromFile(string path)
{
try
{
if (File.Exists(path))
{
ProfilePath = path;
string extension = Path.GetExtension(path);
if (extension != null && extension.Equals(".package", StringComparison.InvariantCultureIgnoreCase))
{
using (Package zipFile = Package.Open(path, FileMode.Open, FileAccess.Read))
{
PackageRelationship packageRelation = zipFile.GetRelationships().FirstOrDefault();
if (packageRelation == null)
{
Professionbuddy.Err("{0} contains no usable profiles", path);
return(null);
}
PackagePart pbProfilePart = zipFile.GetPart(packageRelation.TargetUri);
path = ExtractPart(pbProfilePart, DynamicCodeCompiler.TempFolder);
PackageRelationshipCollection pbProfileRelations = pbProfilePart.GetRelationships();
foreach (PackageRelationship rel in pbProfileRelations)
{
PackagePart hbProfilePart = zipFile.GetPart(rel.TargetUri);
ExtractPart(hbProfilePart, DynamicCodeCompiler.TempFolder);
}
}
}
XmlPath = path;
return((PbDecorator)Load(XElement.Load(path), new PbDecorator()));
}
Professionbuddy.Err("Profile: {0} does not exist", path);
return(null);
}
catch (Exception ex)
{
Professionbuddy.Err(ex.ToString());
return(null);
}
}
public void CreatePackage(string path, string profilePath)
{
try
{
Uri partUriProfile = PackUriHelper.CreatePartUri(
new Uri(Path.GetFileName(profilePath), UriKind.Relative));
var hbProfileUrls = new Dictionary <string, Uri>();
GetHbprofiles(profilePath, Professionbuddy.Instance.PbBehavior, hbProfileUrls);
using (Package package = Package.Open(path, FileMode.Create))
{
// Add the PB profile
PackagePart packagePartDocument =
package.CreatePart(partUriProfile, MediaTypeNames.Text.Xml, CompressionOption.Normal);
using (var fileStream = new FileStream(
profilePath, FileMode.Open, FileAccess.Read))
{
CopyStream(fileStream, packagePartDocument.GetStream());
}
package.CreateRelationship(packagePartDocument.Uri, TargetMode.Internal, PackageRelationshipType);
foreach (var kv in hbProfileUrls)
{
PackagePart packagePartHbProfile =
package.CreatePart(kv.Value, MediaTypeNames.Text.Xml, CompressionOption.Normal);
using (var fileStream = new FileStream(kv.Key, FileMode.Open, FileAccess.Read))
{
CopyStream(fileStream, packagePartHbProfile.GetStream());
}
packagePartDocument.CreateRelationship(kv.Value, TargetMode.Internal, ResourceRelationshipType);
}
}
}
catch (Exception ex)
{
Professionbuddy.Err(ex.ToString());
}
}
private GroupComposite Load(XElement xml, GroupComposite comp)
{
foreach (XNode node in xml.Nodes())
{
if (node.NodeType == XmlNodeType.Comment)
{
comp.AddChild(new Comment(((XComment)node).Value));
}
else if (node.NodeType == XmlNodeType.Element)
{
var element = (XElement)node;
Type type = Type.GetType("HighVoltz.Composites." + element.Name);
if (type == null)
{
IEnumerable <Type> pbTypes = from t in Assembly.GetExecutingAssembly().GetTypes()
where (typeof(IPBComposite)).IsAssignableFrom(t) && !t.IsAbstract
select t;
type =
pbTypes.FirstOrDefault(
t =>
t.GetCustomAttributes(typeof(XmlRootAttribute), true).Any(
a => ((XmlRootAttribute)a).ElementName == element.Name));
if (type == null)
{
throw new InvalidOperationException(
string.Format("Unable to bind XML Element: {0} to a Type", element.Name));
}
}
var pbComp = (IPBComposite)Activator.CreateInstance(type);
pbComp.OnProfileLoad(element);
var pbXmlAttrs = from pi in type.GetProperties()
from attr in
(PbXmlAttributeAttribute[])
pi.GetCustomAttributes(typeof(PbXmlAttributeAttribute), true)
where attr != null
let name = attr.AttributeName ?? pi.Name
select new { name, pi };
Dictionary <string, PropertyInfo> piDict = pbXmlAttrs.ToDictionary(kv => kv.name, kv => kv.pi);
Dictionary <string, string> attributes = element.Attributes().ToDictionary(k => k.Name.ToString(),
v => v.Value);
// use legacy X,Y,Z location for backwards compatability
if (attributes.ContainsKey("X"))
{
string location = string.Format("{0},{1},{2}", attributes["X"], attributes["Y"], attributes["Z"]);
piDict["Location"].SetValue(pbComp, location, null);
attributes.Remove("X");
attributes.Remove("Y");
attributes.Remove("Z");
}
foreach (var attr in attributes)
{
if (piDict.ContainsKey(attr.Key))
{
PropertyInfo pi = piDict[attr.Key];
// check if there is a type converter attached
var typeConverterAttr =
(TypeConverterAttribute)
pi.GetCustomAttributes(typeof(TypeConverterAttribute), true).FirstOrDefault();
if (typeConverterAttr != null)
{
try
{
var typeConverter =
(TypeConverter)
Activator.CreateInstance(Type.GetType(typeConverterAttr.ConverterTypeName));
if (typeConverter.CanConvertFrom(typeof(string)))
{
pi.SetValue(pbComp,
typeConverter.ConvertFrom(null, CultureInfo.CurrentCulture,
attr.Value), null);
}
else
{
Professionbuddy.Err("The TypeConvert {0} can not convert from string.",
typeConverterAttr.ConverterTypeName);
}
}
catch (Exception ex)
{
Professionbuddy.Err("Type conversion for {0} has failed.\n{1}", type.Name + attr.Key,
ex);
}
}
else
{
pi.SetValue(pbComp,
pi.PropertyType.IsEnum
? Enum.Parse(pi.PropertyType, attr.Value)
: Convert.ChangeType(attr.Value, pi.PropertyType), null);
}
}
else
{
Professionbuddy.Log("{0}->{1} appears to be unused", type, attr.Key);
}
}
if (pbComp is GroupComposite)
{
Load(element, pbComp as GroupComposite);
}
comp.AddChild((Composite)pbComp);
}
}
return(comp);
}
private XElement Save(XElement xml, GroupComposite comp)
{
foreach (IPBComposite pbComp in comp.Children)
{
if (pbComp is Comment)
{
xml.Add(new XComment(((Comment)pbComp).Text));
}
else
{
var newElement = new XElement(pbComp.GetType().Name);
var rootAttr =
(XmlRootAttribute)
pbComp.GetType().GetCustomAttributes(typeof(XmlRootAttribute), true).FirstOrDefault();
if (rootAttr != null)
{
newElement.Name = rootAttr.ElementName;
}
pbComp.OnProfileSave(newElement);
List <PropertyInfo> piList = pbComp.GetType().GetProperties().
Where(p => p.GetCustomAttributes(typeof(PbXmlAttributeAttribute), true).
Any()).ToList();
foreach (PropertyInfo pi in piList)
{
List <PbXmlAttributeAttribute> pList =
((PbXmlAttributeAttribute[])pi.GetCustomAttributes(typeof(PbXmlAttributeAttribute), true))
.ToList();
string name = pList.Any(a => a.AttributeName == null) ? pi.Name : pList[0].AttributeName;
string value = "";
var typeConverterAttr =
(TypeConverterAttribute)
pi.GetCustomAttributes(typeof(TypeConverterAttribute), true).FirstOrDefault();
if (typeConverterAttr != null)
{
try
{
var typeConverter =
(TypeConverter)
Activator.CreateInstance(Type.GetType(typeConverterAttr.ConverterTypeName));
if (typeConverter.CanConvertTo(typeof(string)))
{
value = (string)typeConverter.ConvertTo(pi.GetValue(pbComp, null), typeof(string));
}
else
{
Professionbuddy.Err("The TypeConvert {0} can not convert to string.",
typeConverterAttr.ConverterTypeName);
}
}
catch (Exception ex)
{
Professionbuddy.Err("Type conversion for {0}->{1} has failed.\n{2}", comp.GetType().Name,
pi.Name, ex);
}
}
else
{
value = pi.GetValue(pbComp, null).ToString();
}
newElement.Add(new XAttribute(name, value));
}
if (pbComp is GroupComposite)
{
Save(newElement, (GroupComposite)pbComp);
}
xml.Add(newElement);
}
}
return(xml);
}
public Type CompileAndLoad()
{
CompilerResults results = null;
using (CSharpCodeProvider provider = new CSharpCodeProvider(new Dictionary <string, string>()
{
{ "CompilerVersion", "v3.5" },
}))
{
CompilerParameters options = new CompilerParameters();
foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
{
if (!asm.GetName().Name.Contains(Name))
{
options.ReferencedAssemblies.Add(asm.Location);
}
}
options.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
// disabled due to a bug in 2.0.0.3956;
//options.GenerateInMemory = true;
options.GenerateExecutable = false;
options.TempFiles = new TempFileCollection(TempFolder, false);
options.IncludeDebugInformation = false;
options.OutputAssembly = string.Format("{0}\\CodeAssembly{1:N}.dll", TempFolder, Guid.NewGuid());
options.CompilerOptions = "/optimize";
CsharpStringBuilder = new StringBuilder();
CsharpStringBuilder.Append(prefix);
// Line numbers are used to identify actions that genorated compile errors.
int currentLine = CsharpStringBuilder.ToString().Count(c => c == '\n') + 1;
// genorate CanRun Methods
foreach (var met in CsharpCodeDict)
{
if (met.Value.CodeType == CsharpCodeType.BoolExpression)
{
CsharpStringBuilder.AppendFormat("public bool {0} (object context){{return {1};}}\n", met.Key, met.Value.Code);
}
else if (met.Value.CodeType == CsharpCodeType.Statements)
{
CsharpStringBuilder.AppendFormat("public void {0} (object context){{{1}}}\n", met.Key, met.Value.Code);
}
met.Value.CodeLineNumber = currentLine++;
}
CsharpStringBuilder.Append(postfix);
results = provider.CompileAssemblyFromSource(
options, CsharpStringBuilder.ToString());
}
if (results.Errors.HasErrors)
{
if (results.Errors.Count > 0)
{
foreach (CompilerError error in results.Errors)
{
ICSharpCode icsc = CsharpCodeDict.Values.FirstOrDefault(c => c.CodeLineNumber == error.Line);
if (icsc != null)
{
Professionbuddy.Err("{0}\nCompile Error : {1}\n", ((IPBComposite)icsc).Title, error.ErrorText);
icsc.CompileError = error.ErrorText;
}
else
{
Professionbuddy.Err("Unable to link action that produced Error: {0}", error.ErrorText);
}
}
MainForm.Instance.RefreshActionTree(typeof(ICSharpCode));
}
return(null);
}
else
{
CodeWasModified = false;
return(results.CompiledAssembly.GetType("CodeDriver"));
}
}
