public virtual IServiceContainer CreateServiceContainer(Type dataServiceType, IPrincipal principal)
{
var serviceContainer = new ServiceContainer();
var authorizer = new AuthorizerClass(dataServiceType, principal);
serviceContainer.AddService(typeof(IAuthorizer), authorizer);
var valueConverter = new ValueConverter(serviceContainer);
serviceContainer.AddService(typeof(IValueConverter), valueConverter);
var dataHelper = new DataHelper(serviceContainer);
serviceContainer.AddService(typeof(IDataHelper), dataHelper);
var validationHelper = new ValidationHelper(serviceContainer);
serviceContainer.AddService(typeof(IValidationHelper), validationHelper);
var queryHelper = new QueryHelper(serviceContainer);
serviceContainer.AddService(typeof(IQueryHelper), queryHelper);
return serviceContainer;
}
public Project()
{
Uid = Guid.NewGuid();
_services = new ServiceContainer();
Name = "Project";
_levels = new NamedResourceCollection<Level>();
_levels.Modified += (s, e) => OnModified(EventArgs.Empty);
_libraryManager = new LibraryManager();
_libraryManager.Libraries.Modified += (s, e) => OnModified(EventArgs.Empty);
Library defaultLibrary = new Library();
_libraryManager.Libraries.Add(defaultLibrary);
Extra = new List<XmlElement>();
_texturePool = new MetaTexturePool();
_texturePool.AddPool(defaultLibrary.Uid, defaultLibrary.TexturePool);
_tilePools = new MetaTilePoolManager(_texturePool);
_tilePools.AddManager(defaultLibrary.Uid, defaultLibrary.TilePoolManager);
_objectPools = new MetaObjectPoolManager(_texturePool);
_objectPools.AddManager(defaultLibrary.Uid, defaultLibrary.ObjectPoolManager);
_tileBrushes = new MetaTileBrushManager();
_tileBrushes.AddManager(defaultLibrary.Uid, defaultLibrary.TileBrushManager);
SetDefaultLibrary(defaultLibrary);
_services.AddService(typeof(TilePoolManager), _tilePools);
ResetModified();
}
public MoveCreatorForm()
{
//set up defaults
this.movelist = new Dictionary<String, Move>();
this.directoryHome = "../../../HeroesOfRock";
this.FormClosing += ContentList_FormClosing; ;
this.appClose = true;
//set up content manager
GraphicsDeviceService gds = GraphicsDeviceService.AddRef(this.Handle,
this.ClientSize.Width, this.ClientSize.Height);
ServiceContainer services = new ServiceContainer();
services.AddService<IGraphicsDeviceService>(gds);
this.content = new ContentManager(services, String.Concat(directoryHome, "/HeroesOfRock/bin/x86/Debug/Content"));
//Load and/or parse predefined objects
LoadMoveList(content.Load<Move[]>("Movelist"));
this.audioClips = Directory.GetFiles(String.Concat(content.RootDirectory, "/Audio")).ToList<string>();
this.particleFX = Directory.GetFiles(String.Concat(content.RootDirectory, "/ParticleFX")).ToList<string>();
//if null, will back up to the content default
BackUpMoveList(null);
InitializeComponent();
RefreshList();
}
public Workspace()
{
Services = new ServiceContainer();
Services.AddService<IIconReaderService>(new IconReaderService());
buildLogger = new BuildLogger(Tracer.TraceSource);
LoadPlugins();
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
}
public void GenerateBabylonFile(string file, string outputFile, bool skinned, bool rightToLeft)
{
if (OnImportProgressChanged != null)
OnImportProgressChanged(0);
var scene = new BabylonScene(Path.GetDirectoryName(outputFile));
var services = new ServiceContainer();
// Create a graphics device
var form = new Form();
services.AddService<IGraphicsDeviceService>(GraphicsDeviceService.AddRef(form.Handle, 1, 1));
var contentBuilder = new ContentBuilder(ExtraPipelineAssemblies);
var contentManager = new ContentManager(services, contentBuilder.OutputDirectory);
// Tell the ContentBuilder what to build.
contentBuilder.Clear();
contentBuilder.Add(Path.GetFullPath(file), "Model", Importer, skinned ? "SkinnedModelProcessor" : "ModelProcessor");
// Build this new model data.
string buildError = contentBuilder.Build();
if (string.IsNullOrEmpty(buildError))
{
var model = contentManager.Load<Model>("Model");
ParseModel(model, scene, rightToLeft);
}
else
{
throw new Exception(buildError);
}
// Output
scene.Prepare();
using (var outputStream = new FileStream(outputFile, FileMode.Create, FileAccess.Write))
{
var ser = new DataContractJsonSerializer(typeof(BabylonScene));
ser.WriteObject(outputStream, scene);
}
// Cleaning
foreach (var path in exportedTexturesFilename.Values)
{
File.Delete(path);
}
if (OnImportProgressChanged != null)
OnImportProgressChanged(100);
}
public void instance(string[] args)
{
try
{
Form form = new Form();
GraphicsDeviceService gds = GraphicsDeviceService.AddRef(form.Handle, form.ClientSize.Width, form.ClientSize.Height);
ServiceContainer services = new ServiceContainer();
services.AddService<IGraphicsDeviceService>(gds);
var content = new ContentManager(services);
foreach (string p in args)
{
Console.WriteLine(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name + " " + p);
if (File.Exists(p))
{
if (Path.GetExtension(p).Equals(".xnb"))
{
ConvertToPng(content, p);
}
}
else
{
Console.WriteLine("Invalid file path or file");
}
}
foreach (string f in filesToDelete)
{
File.Delete(f);
}
content.Unload();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void AdaptShouldReturnValidationContextAdapter()
{
// arrange
var instance = new object();
var service = new object();
var serviceProvider = new ServiceContainer();
var items = new Dictionary<object, object>() { { "Test", "Test" } };
var expected = new ValidationContext( instance, serviceProvider, items );
expected.MemberName = "Foo";
serviceProvider.AddService( typeof( object ), service );
// act
var actual = expected.Adapt();
// assert
Assert.Equal( expected.DisplayName, actual.DisplayName );
Assert.Same( expected.Items["Test"], actual.Items["Test"] );
Assert.Equal( expected.MemberName, actual.MemberName );
Assert.Same( expected.ObjectInstance, actual.ObjectInstance );
Assert.Equal( expected.ObjectType, actual.ObjectType );
Assert.Same( expected.GetService( typeof( object ) ), actual.GetService( typeof( object ) ) );
}
IServiceProvider CreateServiceProvider()
{
var container = new ServiceContainer(this.Application.RootServiceProvider);
container.AddService(typeof(ToolsUIWindow), this);
this.documentTracker = new WindowDocumentTracker(this, this.Application.RootServiceProvider);
container.AddService(typeof(IActiveDocumentTracker), this.documentTracker);
return container;
}
//private void Given_Platform(IPlatform platform)
//{
// this.oe = new Mock<OperatingEnvironment>();
// this.platform = platform;
// this.cfgSvc.Setup(c => c.GetEnvironment("testOS")).Returns(oe);
// oe.Setup(e => e.Load(sc, null)).IgnoreArguments().Returns(platform);
//}
private void Given_TypeLibraryLoaderService()
{
this.tlSvc = new Mock <ITypeLibraryLoaderService>();
sc.AddService <ITypeLibraryLoaderService>(this.tlSvc.Object);
}
public X86DisassemblerTests()
{
sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
}
public int Execute(string [] args)
{
TextReader input = Console.In;
Stream output = Console.OpenStandardOutput();
var sc = new ServiceContainer();
var rekoCfg = RekoConfigurationService.Load(sc);
sc.AddService <IConfigurationService>(rekoCfg);
var docopt = new Docopt();
IDictionary <string, ValueObject> options;
try {
options = docopt.Apply(usage, args);
} catch (Exception ex)
{
Console.Error.WriteLine(ex);
return(1);
}
var arch = rekoCfg.GetArchitecture(options["-a"].ToString());
if (arch == null)
{
Console.WriteLine(
"c2xml: unknown architecture '{0}'. Check the c2xml config file for supported architectures.",
options["-a"]);
return(-1);
}
var envElem = rekoCfg.GetEnvironment(options["-e"].ToString());
if (envElem == null)
{
Console.WriteLine(
"c2xml: unknown environment '{0}'. Check the c2xml config file for supported architectures.",
options["-e"]);
return(-1);
}
var platform = envElem.Load(sc, arch);
try
{
input = new StreamReader(options["<inputfile>"].ToString());
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: unable to open file {0} for reading. {1}", options["<inputfile>"], ex.Message);
return(1);
}
if (options.ContainsKey("<outputfile>") && options["<outputfile>"] != null)
{
try
{
output = new FileStream(options["<outputfile>"].ToString(), FileMode.Create, FileAccess.Write);
}
catch (Exception ex)
{
Console.Error.WriteLine("c2xml: unable to open file {0} for writing. {1}", options["<outputfile>"], ex.Message);
return(1);
}
}
string dialect = null;
if (options.TryGetValue("-d", out var optDialect))
{
dialect = (string)optDialect.Value;
}
var xWriter = new XmlTextWriter(output, new UTF8Encoding(false))
{
Formatting = Formatting.Indented
};
XmlConverter c = new XmlConverter(input, xWriter, platform, dialect);
c.Convert();
output.Flush();
output.Close();
return(0);
}
public void AddService(Type serviceType, object serviceInstance)
{
sc.AddService(serviceType, serviceInstance);
}
internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
{
if (!this.validateOnCreate)
{
return;
}
ValidationErrorCollection errors = new ValidationErrorCollection();
// For validation purposes, create a type provider in the type case if the
// host did not push one.
if (typeProvider == null)
{
typeProvider = WorkflowRuntime.CreateTypeProvider(root);
}
// Validate that we are purely XAML.
if (!isNewType)
{
if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, ErrorNumbers.Error_XomlWorkflowHasClassName));
}
Queue compositeActivities = new Queue();
compositeActivities.Enqueue(root);
while (compositeActivities.Count > 0)
{
Activity activity = compositeActivities.Dequeue() as Activity;
if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, ErrorNumbers.Error_XomlWorkflowHasCode));
}
CompositeActivity compositeActivity = activity as CompositeActivity;
if (compositeActivity != null)
{
foreach (Activity childActivity in compositeActivity.EnabledActivities)
{
compositeActivities.Enqueue(childActivity);
}
}
}
}
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(ITypeProvider), typeProvider);
ValidationManager validationManager = new ValidationManager(serviceContainer);
using (WorkflowCompilationContext.CreateScope(validationManager))
{
foreach (Validator validator in validationManager.GetValidators(root.GetType()))
{
foreach (ValidationError error in validator.Validate(validationManager, root))
{
if (!error.UserData.Contains(typeof(Activity)))
{
error.UserData[typeof(Activity)] = root;
}
errors.Add(error);
}
}
}
if (errors.HasErrors)
{
throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
}
}
public void Setup()
{
sc = new ServiceContainer();
cfgSvc = new Mock <IConfigurationService>();
sc.AddService <IConfigurationService>(cfgSvc.Object);
}
public void Setup()
{
this.sc = new ServiceContainer();
sc.AddService <DecompilerEventListener>(new FakeDecompilerEventListener());
}
/*
* ITemplate implementation
* This implementation of ITemplate is only used in the designer
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual void InstantiateIn(Control container)
{
IServiceProvider builderServiceProvider = null;
// Use the designer host to get one at designtime as the service provider
if (_designerHost != null)
{
builderServiceProvider = _designerHost;
}
else if (!IsNoCompile)
{
// Otherwise, create a ServiceContainer and try using the container as the service provider
ServiceContainer serviceContainer = new ServiceContainer();
if (container is IThemeResolutionService)
{
serviceContainer.AddService(typeof(IThemeResolutionService), (IThemeResolutionService)container);
}
if (container is IFilterResolutionService)
{
serviceContainer.AddService(typeof(IFilterResolutionService), (IFilterResolutionService)container);
}
builderServiceProvider = serviceContainer;
}
HttpContext context = null;
TemplateControl savedTemplateControl = null;
TemplateControl templateControl = container as TemplateControl;
if (templateControl != null)
{
context = HttpContext.Current;
if (context != null)
{
savedTemplateControl = context.TemplateControl;
}
}
try {
if (!IsNoCompile)
{
SetServiceProvider(builderServiceProvider);
}
if (context != null)
{
context.TemplateControl = templateControl;
}
BuildChildren(container);
}
finally {
if (!IsNoCompile)
{
SetServiceProvider(null);
}
// Restore the previous template control
if (context != null)
{
context.TemplateControl = savedTemplateControl;
}
}
}
public void SysV_TerminatingFunction()
{
var mr = new MockRepository();
var sc = new ServiceContainer();
var arch = mr.Stub <IProcessorArchitecture>();
var tlSvc = mr.Stub <ITypeLibraryLoaderService>();
var cfgSvc = mr.Stub <IConfigurationService>();
sc.AddService <IConfigurationService>(cfgSvc);
sc.AddService <ITypeLibraryLoaderService>(tlSvc);
cfgSvc.Stub(c => c.GetEnvironment(null))
.IgnoreArguments()
.Return(new OperatingEnvironmentElement
{
TypeLibraries =
{
new TypeLibraryElement
{
Name = "libc.xml"
}
},
CharacteristicsLibraries =
{
new TypeLibraryElement
{
Name = "libcharacteristics.xml",
}
}
});
tlSvc.Stub(t => t.LoadCharacteristics(null))
.IgnoreArguments()
.Return(new CharacteristicsLibrary
{
Entries =
{
{
"exit",
new ProcedureCharacteristics {
Terminates = true
}
}
}
});
tlSvc.Stub(t => t.LoadLibrary(null, null))
.IgnoreArguments()
.Return(new TypeLibrary
{
Signatures =
{
{
"exit",
new ProcedureSignature(null)
}
}
});
mr.ReplayAll();
var sysv = new SysVPlatform(sc, arch);
var proc = sysv.LookupProcedureByName(null, "exit");
Assert.IsTrue(proc.Characteristics.Terminates, "exit should have been marked as terminating.");
}
static void Main()
{
#if TRACE
System.Diagnostics.TextWriterTraceListener listener
= new System.Diagnostics.TextWriterTraceListener(System.Console.Out);
System.Diagnostics.Trace.Listeners.Add(listener);
#endif
Application.Init();
#region Packing and layout
Window window = new Window("AspNetEdit Host Sample");
window.SetDefaultSize(1000, 700);
window.DeleteEvent += new DeleteEventHandler(window_DeleteEvent);
VBox outerBox = new VBox();
window.Add(outerBox);
HPaned leftBox = new HPaned();
outerBox.PackEnd(leftBox, true, true, 0);
HPaned rightBox = new HPaned();
leftBox.Add2(rightBox);
geckoFrame = new Frame();
geckoFrame.Shadow = ShadowType.In;
rightBox.Pack1(geckoFrame, true, false);
#endregion
#region Toolbar
// * Save/Open
Toolbar buttons = new Toolbar();
outerBox.PackStart(buttons, false, false, 0);
ToolButton saveButton = new ToolButton(Stock.Save);
buttons.Add(saveButton);
saveButton.Clicked += new EventHandler(saveButton_Clicked);
ToolButton openButton = new ToolButton(Stock.Open);
buttons.Add(openButton);
openButton.Clicked += new EventHandler(openButton_Clicked);
buttons.Add(new SeparatorToolItem());
// * Clipboard
ToolButton undoButton = new ToolButton(Stock.Undo);
buttons.Add(undoButton);
undoButton.Clicked += new EventHandler(undoButton_Clicked);
ToolButton redoButton = new ToolButton(Stock.Redo);
buttons.Add(redoButton);
redoButton.Clicked += new EventHandler(redoButton_Clicked);
ToolButton cutButton = new ToolButton(Stock.Cut);
buttons.Add(cutButton);
cutButton.Clicked += new EventHandler(cutButton_Clicked);
ToolButton copyButton = new ToolButton(Stock.Copy);
buttons.Add(copyButton);
copyButton.Clicked += new EventHandler(copyButton_Clicked);
ToolButton pasteButton = new ToolButton(Stock.Paste);
buttons.Add(pasteButton);
pasteButton.Clicked += new EventHandler(pasteButton_Clicked);
buttons.Add(new SeparatorToolItem());
// * Text style
ToolButton boldButton = new ToolButton(Stock.Bold);
buttons.Add(boldButton);
boldButton.Clicked += new EventHandler(boldButton_Clicked);
ToolButton italicButton = new ToolButton(Stock.Italic);
buttons.Add(italicButton);
italicButton.Clicked += new EventHandler(italicButton_Clicked);
ToolButton underlineButton = new ToolButton(Stock.Underline);
buttons.Add(underlineButton);
underlineButton.Clicked += new EventHandler(underlineButton_Clicked);
ToolButton indentButton = new ToolButton(Stock.Indent);
buttons.Add(indentButton);
indentButton.Clicked += new EventHandler(indentButton_Clicked);
ToolButton unindentButton = new ToolButton(Stock.Unindent);
buttons.Add(unindentButton);
unindentButton.Clicked += new EventHandler(unindentButton_Clicked);
buttons.Add(new SeparatorToolItem());
// * Toolbox
ToolButton toolboxAddButton = new ToolButton(Stock.Add);
buttons.Add(toolboxAddButton);
toolboxAddButton.Clicked += new EventHandler(toolboxAddButton_Clicked);
#endregion
#region Designer services and host
//set up the services
ServiceContainer services = new ServiceContainer();
services.AddService(typeof(INameCreationService), new NameCreationService());
services.AddService(typeof(ISelectionService), new SelectionService());
services.AddService(typeof(IEventBindingService), new EventBindingService(window));
services.AddService(typeof(ITypeResolutionService), new TypeResolutionService());
ExtenderListService extListServ = new AspNetEdit.Editor.ComponentModel.ExtenderListService();
services.AddService(typeof(IExtenderListService), extListServ);
services.AddService(typeof(IExtenderProviderService), extListServ);
services.AddService(typeof(ITypeDescriptorFilterService), new TypeDescriptorFilterService());
toolboxService = new ToolboxService();
services.AddService(typeof(IToolboxService), toolboxService);
//create our host
host = new DesignerHost(services);
host.NewFile();
host.Activate();
#endregion
#region Designer UI and panels
IRootDesigner rootDesigner = (IRootDesigner)host.GetDesigner(host.RootComponent);
RootDesignerView designerView = (RootDesignerView)rootDesigner.GetView(ViewTechnology.Passthrough);
geckoFrame.Add(designerView);
PropertyGrid p = new PropertyGrid(services);
p.WidthRequest = 200;
rightBox.Pack2(p, false, false);
Toolbox toolbox = new Toolbox(services);
leftBox.Pack1(toolbox, false, false);
toolboxService.PopulateFromAssembly(System.Reflection.Assembly.GetAssembly(typeof(System.Web.UI.Control)));
toolboxService.AddToolboxItem(new TextToolboxItem("<table><tr><td></td><td></td></tr><tr><td></td><td></td></tr></table>", "Table"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<div style=\"width: 100px; height: 100px;\"></div>", "Div"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<hr />", "Horizontal Rule"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<select><option></option></select>", "Select"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<img src=\"\" />", "Image"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<textarea cols=\"20\" rows=\"2\"></textarea>", "Textarea"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"hidden\" />", "Input [Hidden]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"radio\" />", "Input [Radio]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"checkbox\" />", "Input [Checkbox]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"password\" />", "Input [Password]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"file\" />", "Input [File]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"text\" />", "Input [Text]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"submit\" value=\"submit\" />", "Input [Submit]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"reset\" value=\"reset\" />", "Input [Reset]"), "Html");
toolboxService.AddToolboxItem(new TextToolboxItem("<input type=\"button\" value=\"button\" />", "Input [Button]"), "Html");
toolbox.Refresh();
#endregion
window.ShowAll();
Application.Run();
}
public override void SetConfiguration(AspectConfiguration config)
{
_container.AddService("SnapAspectConfiguration", config);
Proxy.Configuration = config;
config.Container = this;
}
public void TestInitialize()
{
cmdService = new MockUIComandService();
services = new ServiceContainer();
services.AddService(typeof(IUICommandService), cmdService);
}
private static Control[] ParseControlsInternalHelper(DesignTimeParseData data, bool returnFirst)
{
TemplateParser parser = new PageParser();
parser.FInDesigner = true;
parser.DesignerHost = data.DesignerHost;
parser.DesignTimeDataBindHandler = data.DataBindingHandler;
parser.Text = data.ParseText;
parser.Parse();
ArrayList parsedControls = new ArrayList();
ArrayList subBuilders = parser.RootBuilder.SubBuilders;
if (subBuilders != null)
{
// Look for the first control builder
IEnumerator en = subBuilders.GetEnumerator();
for (int i = 0; en.MoveNext(); i++)
{
object cur = en.Current;
if ((cur is ControlBuilder) && !(cur is CodeBlockBuilder))
{
// Instantiate the control
ControlBuilder controlBuilder = (ControlBuilder)cur;
System.Diagnostics.Debug.Assert(controlBuilder.CurrentFilterResolutionService == null);
IServiceProvider builderServiceProvider = null;
// If there's a designer host, use it as the service provider
if (data.DesignerHost != null)
{
builderServiceProvider = data.DesignerHost;
}
// If it doesn't exist, use a default ---- filter resolution service
else
{
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(IFilterResolutionService), new SimpleDesignTimeFilterResolutionService(data.Filter));
builderServiceProvider = serviceContainer;
}
controlBuilder.SetServiceProvider(builderServiceProvider);
try {
Control control = (Control)controlBuilder.BuildObject(data.ShouldApplyTheme);
parsedControls.Add(control);
}
finally {
controlBuilder.SetServiceProvider(null);
}
if (returnFirst)
{
break;
}
}
// To preserve backwards compatibility, we don't add LiteralControls
// to the control collection when parsing for a single control
else if (!returnFirst && (cur is string))
{
LiteralControl literalControl = new LiteralControl(cur.ToString());
parsedControls.Add(literalControl);
}
}
}
data.SetUserControlRegisterEntries(parser.UserControlRegisterEntries, parser.TagRegisterEntries);
return((Control[])parsedControls.ToArray(typeof(Control)));
}
/// <summary>
/// Initializes the control.
/// </summary>
protected override void OnCreateControl()
{
// Don't initialize the graphics device if we are running in the designer.
if (!DesignMode)
{
Services = new ServiceContainer();
graphicsDeviceService = GraphicsDeviceService.AddRef(profile, Handle, ClientSize.Width, ClientSize.Height);
// Register the service, so components like ContentManager can find it.
Services.AddService<IGraphicsDeviceService>(graphicsDeviceService);
// Give derived classes a chance to initialize themselves.
Initialize();
}
base.OnCreateControl();
}
public void TestInitialize()
{
svcContainer.AddService(typeof(IBuilderConfigurator <BuilderStage>), new ILAnalyzerTestBuilderConfigurator());
svcContainer.AddService(typeof(CecilAnalyzerConfiguration), CecilAnalyzerConfiguration.CreateDefaultConfiguration(CreateFullPath("TestTarget.exe")));
svcContainer.AddService(typeof(ILanguageModelAccessor), new LanguageModelAccessorMock());
}
public void AddService(Type serviceType, object serviceInstance)
{
System.Console.WriteLine("DesignerLoaderHost.AddService: " + serviceType.Name + " IsNull: " + (serviceInstance == null));
serviceContainer.AddService(serviceType, serviceInstance);
}
public void AddService(Type serviceType, ServiceCreatorCallback callback, bool promote)
{
parentServices.AddService(serviceType, callback, promote);
}
public void TestInitialize()
{
cmdService = new MockUIComandService();
services = new ServiceContainer();
services.AddService(typeof(IUICommandService), cmdService);
}
private void ExtractTemplateValuesRecursive(ArrayList subBuilders, OrderedDictionary table, Control container)
{
foreach (object subBuilderObject in subBuilders)
{
ControlBuilder subBuilderControlBuilder = subBuilderObject as ControlBuilder;
if (subBuilderControlBuilder != null)
{
ICollection entries;
// filter out device filtered bound entries that don't apply to this device
if (!subBuilderControlBuilder.HasFilteredBoundEntries)
{
entries = subBuilderControlBuilder.BoundPropertyEntries;
}
else
{
Debug.Assert(subBuilderControlBuilder.ServiceProvider == null);
Debug.Assert(subBuilderControlBuilder.TemplateControl != null, "TemplateControl should not be null in no-compile pages. We need it for the FilterResolutionService.");
ServiceContainer serviceContainer = new ServiceContainer();
serviceContainer.AddService(typeof(IFilterResolutionService), subBuilderControlBuilder.TemplateControl);
try {
subBuilderControlBuilder.SetServiceProvider(serviceContainer);
entries = subBuilderControlBuilder.GetFilteredPropertyEntrySet(subBuilderControlBuilder.BoundPropertyEntries);
}
finally {
subBuilderControlBuilder.SetServiceProvider(null);
}
}
string previousControlName = null;
bool newControl = true;
Control control = null;
foreach (BoundPropertyEntry entry in entries)
{
// Skip all entries that are not two-way
if (!entry.TwoWayBound)
{
continue;
}
// Reset the "previous" Property Entry if we're not looking at the same control.
// If we don't do this, Two controls that have conditionals on the same named property will have
// their conditionals incorrectly merged.
if (String.Compare(previousControlName, entry.ControlID, StringComparison.Ordinal) != 0)
{
newControl = true;
}
else
{
newControl = false;
}
previousControlName = entry.ControlID;
if (newControl)
{
control = container.FindControl(entry.ControlID);
if (control == null || !entry.ControlType.IsInstanceOfType(control))
{
Debug.Assert(false, "BoundPropertyEntry is of wrong control type or couldn't be found. Expected " + entry.ControlType.Name);
continue;
}
}
string propertyName;
// map the property in case it's a complex property
object targetObject = PropertyMapper.LocatePropertyObject(control, entry.Name, out propertyName, InDesigner);
// FastPropertyAccessor uses ReflectEmit for lightning speed
table[entry.FieldName] = FastPropertyAccessor.GetProperty(targetObject, propertyName, InDesigner);
}
ExtractTemplateValuesRecursive(subBuilderControlBuilder.SubBuilders, table, container);
}
}
}
public void AddService(Type serviceType, ServiceCreatorCallback callback, bool promote)
{
_serviceContainer.AddService(serviceType, callback, promote);
}
public AnalysisTestBase()
{
//$TODO: this is a hard dependency on the file system.
sc = new ServiceContainer();
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
}
public TestContainer()
{
_services.AddService(typeof(TestService), new TestService());
}
private void Given_TypeLibraryLoaderService()
{
this.tlSvc = mr.Stub <ITypeLibraryLoaderService>();
sc.AddService <ITypeLibraryLoaderService>(this.tlSvc);
}
public void Setup()
{
form = new Mock <IMainForm>();
sc = new ServiceContainer();
loader = new Mock <ILoader>();
dec = new Mock <IDecompiler>();
sc = new ServiceContainer();
uiSvc = new Mock <IDecompilerShellUiService>();
host = new Mock <IDecompiledFileService>();
memSvc = new Mock <ILowLevelViewService>();
fsSvc = new Mock <IFileSystemService>();
abSvc = new Mock <IArchiveBrowserService>();
var mem = new ByteMemoryArea(Address.Ptr32(0x10000), new byte[1000]);
var imageMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var arch = new Mock <IProcessorArchitecture>();
arch.Setup(a => a.Name).Returns("FakeArch");
var platform = new Mock <IPlatform>();
program = new Program(imageMap, arch.Object, platform.Object);
project = new Project {
Programs = { program }
};
browserSvc = new Mock <IProjectBrowserService>();
sc.AddService <IDecompilerUIService>(uiSvc.Object);
sc.AddService <IDecompilerShellUiService>(new Mock <IDecompilerShellUiService>().Object);
sc.AddService <IDecompilerService>(new DecompilerService());
sc.AddService <IWorkerDialogService>(new FakeWorkerDialogService());
sc.AddService <DecompilerEventListener>(new FakeDecompilerEventListener());
sc.AddService <IProjectBrowserService>(browserSvc.Object);
sc.AddService <ILowLevelViewService>(memSvc.Object);
sc.AddService <ILoader>(loader.Object);
sc.AddService <IDecompiledFileService>(host.Object);
sc.AddService <IFileSystemService>(fsSvc.Object);
sc.AddService <IArchiveBrowserService>(abSvc.Object);
sc.AddService <IProcedureListService>(new Mock <IProcedureListService>().Object);
i = new TestInitialPageInteractor(sc, dec.Object);
}
public DisassemblerTests()
{
this.sc = new ServiceContainer();
sc.AddService <ITestGenerationService>(new UnitTestGenerationService(sc));
this.arch = new Z80ProcessorArchitecture(sc, "z80", new Dictionary <string, object>());
}
public async Task SetUp()
{
const string Original = @"original.config";
const string OriginalMono = @"original.mono.config";
if (Helper.IsRunningOnMono())
{
File.Copy("Website1/original.config", "Website1/web.config", true);
File.Copy(OriginalMono, Current, true);
}
else
{
File.Copy("Website1\\original.config", "Website1\\web.config", true);
File.Copy(Original, Current, true);
}
Environment.SetEnvironmentVariable(
"JEXUS_TEST_HOME",
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
_server = new IisExpressServerManager(Current);
var serviceContainer = new ServiceContainer();
serviceContainer.RemoveService(typeof(IConfigurationService));
serviceContainer.RemoveService(typeof(IControlPanel));
var scope = ManagementScope.Site;
serviceContainer.AddService(typeof(IControlPanel), new ControlPanel());
serviceContainer.AddService(
typeof(IConfigurationService),
new ConfigurationService(
null,
_server.Sites[0].GetWebConfiguration(),
scope,
null,
_server.Sites[0],
null,
null,
null, _server.Sites[0].Name));
serviceContainer.RemoveService(typeof(IManagementUIService));
var mock = new Mock <IManagementUIService>();
mock.Setup(
action =>
action.ShowMessage(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <MessageBoxButtons>(),
It.IsAny <MessageBoxIcon>(),
It.IsAny <MessageBoxDefaultButton>())).Returns(DialogResult.Yes);
serviceContainer.AddService(typeof(IManagementUIService), mock.Object);
var module = new HttpErrorsModule();
module.TestInitialize(serviceContainer, null);
_feature = new HttpErrorsFeature(module);
_feature.Load();
}
/// <summary>
/// Invoked after either control has created its graphics device.
/// </summary>
private void loadContent(object sender, GraphicsDeviceEventArgs e)
{
// Because this same event is hooked for both controls, we check if the Stopwatch
// is running to avoid loading our content twice.
if (!totalTime.IsRunning)
{
ServiceContainer = new ServiceContainer();
contentBuilder = new ContentBuilder();
ResourceBuilder.Instance.ContentBuilder = contentBuilder;
resourceContent.Activate();
errors = new List<Error>();
outputTextBlock = output;
EditorStatus = EditorStatus.STARTING;
EditMode = AridiaEditor.EditMode.STANDARD;
errorDataGrid.ItemsSource = errors;
Output.AddToOutput("WELCOME TO ARIDIA WORLD EDITOR ------------");
GameApplication.Instance.SetGraphicsDevice(e.GraphicsDevice);
MouseDevice.Instance.ResetMouseAfterUpdate = false;
ServiceContainer.AddService<IGraphicsDeviceService>(GraphicsDeviceService.AddRef(new IntPtr(), 100, 100));
ResourceManager.Instance.Content = new ContentManager(ServiceContainer, contentBuilder.OutputDirectory);
ResourceManager.Instance.Content.Unload();
sceneGraph = new SceneGraphManager();
sceneGraph.CullingActive = true;
sceneGraph.LightingActive = false; //deactivate lighting on beginning!
spriteBatch = new SpriteBatch(e.GraphicsDevice);
grid = new GridComponent(e.GraphicsDevice, 2);
e.GraphicsDevice.RasterizerState = RasterizerState.CullNone;
var versionAttribute = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
AssemblyBuild.Content = "Build: (Alpha) " + versionAttribute;
if (File.Exists(Settings.Default.LayoutFile))
dockManager.RestoreLayout(Settings.Default.LayoutFile);
// after we initialized everything we need start loading the content
// in a new thread!
StartContentBuilding();
// Start the watch now that we're going to be starting our draw loop
totalTime.Start();
}
}
public Toolbox(ServiceContainer parentServices)
{
this.parentServices = parentServices;
//we need this service, so create it if not present
toolboxService = parentServices.GetService(typeof(IToolboxService)) as ToolboxService;
if (toolboxService == null)
{
toolboxService = new ToolboxService();
parentServices.AddService(typeof(IToolboxService), toolboxService);
}
#region Toolbar
toolbar = new Toolbar();
toolbar.ToolbarStyle = ToolbarStyle.Icons;
toolbar.IconSize = IconSize.SmallToolbar;
base.PackStart(toolbar, false, false, 0);
filterToggleButton = new ToggleToolButton();
filterToggleButton.IconWidget = new Image(Stock.MissingImage, IconSize.SmallToolbar);
filterToggleButton.Toggled += new EventHandler(toggleFiltering);
toolbar.Insert(filterToggleButton, 0);
catToggleButton = new ToggleToolButton();
catToggleButton.IconWidget = new Image(Stock.MissingImage, IconSize.SmallToolbar);
catToggleButton.Toggled += new EventHandler(toggleCategorisation);
toolbar.Insert(catToggleButton, 1);
SeparatorToolItem sep = new SeparatorToolItem();
toolbar.Insert(sep, 2);
filterEntry = new Entry();
filterEntry.WidthRequest = 150;
filterEntry.Changed += new EventHandler(filterTextChanged);
#endregion
scrolledWindow = new ScrolledWindow();
base.PackEnd(scrolledWindow, true, true, 0);
//Initialise model
store = new ToolboxStore();
//initialise view
nodeView = new NodeView(store);
nodeView.Selection.Mode = SelectionMode.Single;
nodeView.HeadersVisible = false;
//cell renderers
CellRendererPixbuf pixbufRenderer = new CellRendererPixbuf();
CellRendererText textRenderer = new CellRendererText();
textRenderer.Ellipsize = Pango.EllipsizeMode.End;
//Main column with text, icons
TreeViewColumn col = new TreeViewColumn();
col.PackStart(pixbufRenderer, false);
col.SetAttributes(pixbufRenderer,
"pixbuf", ToolboxStore.Columns.Icon,
"visible", ToolboxStore.Columns.IconVisible,
"cell-background-gdk", ToolboxStore.Columns.BackgroundColour);
col.PackEnd(textRenderer, true);
col.SetAttributes(textRenderer,
"text", ToolboxStore.Columns.Label,
"weight", ToolboxStore.Columns.FontWeight,
"cell-background-gdk", ToolboxStore.Columns.BackgroundColour);
nodeView.AppendColumn(col);
//Initialise self
scrolledWindow.VscrollbarPolicy = PolicyType.Automatic;
scrolledWindow.HscrollbarPolicy = PolicyType.Never;
scrolledWindow.WidthRequest = 150;
scrolledWindow.AddWithViewport(nodeView);
//selection events
nodeView.NodeSelection.Changed += OnSelectionChanged;
nodeView.RowActivated += OnRowActivated;
//update view when toolbox service updated
toolboxService.ToolboxChanged += new EventHandler(tbsChanged);
Refresh();
//track expanded state of nodes
nodeView.RowCollapsed += new RowCollapsedHandler(whenRowCollapsed);
nodeView.RowExpanded += new RowExpandedHandler(whenRowExpanded);
//set initial state
filterToggleButton.Active = false;
catToggleButton.Active = true;
}
/// <summary>
/// Set SLForm State
/// </summary>
/// <param name="isshowcursor"></param>
/// <param name="isborder"></param>
/// <param name="issizable"></param>
public void SetSLForm(bool isshowcursor, bool isborder, bool issizable)
{
if (config == null)
{
config = new AssemblySettings(Assembly.GetAssembly(typeof(AssemblySettings)));
}
if (services == null)
{
services = new ServiceContainer();
// Register the service, so components like ContentManager can find it.
services.AddService<IGraphicsDeviceService>(this);
cm = new ContentManager(services, config["content"]);
// Hook the idle event to constantly redraw, getting a game style loop as default.
Application.Idle += delegate { Invalidate(); };
this.KeyDown += new KeyEventHandler(SLForm_KeyDown);
this.MouseDown += new MouseEventHandler(SLForm_MouseDown);
this.MouseMove += new MouseEventHandler(SLForm_MouseMove);
this.MouseWheel += new MouseEventHandler(SLForm_MouseWheel);
}
// Cursor State
if (!isshowcursor)
{
Cursor.Hide();
}
// Border and Sizable States
if (isborder)
{
if (issizable)
{
this.Resize += new EventHandler(SLForm_Resize);
}
else
{
this.MaximizeBox = false;
this.FormBorderStyle = FormBorderStyle.FixedSingle;
}
}
else
{
this.FormBorderStyle = FormBorderStyle.None;
}
}
public void AddService_should_throw_ArgumentNullException_on_serviceInstance_null()
{
ServiceContainer c = new ServiceContainer();
Assert.Throws <ArgumentNullException>(() => c.AddService((object)null));
}
protected override void OnCreateControl()
{
if(!DesignMode) {
services = new ServiceContainer();
graphicsDeviceService = GraphicsDeviceService.AddRef(Handle, Width, Height);
services.AddService<IGraphicsDeviceService>(graphicsDeviceService); // Register the service, so components like ContentManager can find it.
spriteBatch = new SpriteBatch(GraphicsDevice);
content = new ContentManager(services, "Content");
viewport = new Viewport();
surfaceRectangle = new XNARectangle(0, 0, Width, Height);
canUpdate = true;
Initialize();
}
base.OnCreateControl();
}
public ServiceContainer Build()
{
ServiceContainer container = new ServiceContainer();
NodeNameCreationService nodeNameCreationService = new NodeNameCreationService();
ConfigurationUIHierarchyService configurationUIHierarchy = new ConfigurationUIHierarchyService();
container.AddService(typeof(INodeNameCreationService), nodeNameCreationService);
container.AddService(typeof(IConfigurationUIHierarchyService), configurationUIHierarchy);
container.AddService(typeof(IUIService), this);
container.AddService(typeof(IErrorLogService), new ErrorLogService());
container.AddService(typeof(INodeCreationService), new NodeCreationService());
container.AddService(typeof(IUICommandService), new UICommandService(configurationUIHierarchy));
return container;
}
public void Setup()
{
this.sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
}
public MainForm()
{
InitializeComponent();
removeToolStripMenuItem.Image = DefaultTaskList.RemoveImage;
removeToolStripMenuItem1.Image = DefaultTaskList.RemoveImage;
btnRemoveFarmServer.Image = DefaultTaskList.RemoveImage;
toolStripMenuItem44.Image = DefaultTaskList.RemoveImage;
Icon = Resources.iis;
imageList1.Images.Add(Resources.iis_16);
imageList1.Images.Add(Resources.server_16);
imageList1.Images.Add(Resources.application_pools_16);
imageList1.Images.Add(Resources.sites_16);
imageList1.Images.Add(Resources.site_16);
imageList1.Images.Add(Resources.application_16);
imageList1.Images.Add(Resources.physical_directory_16);
imageList1.Images.Add(Resources.virtual_directory_16);
imageList1.Images.Add(Resources.farm_16);
imageList1.Images.Add(Resources.farm_server_16);
imageList1.Images.Add(Resources.servers_16);
btnAbout.Text = string.Format("About Jexus Manager {0}", Assembly.GetExecutingAssembly().GetName().Version);
treeView1.Nodes.Add(new HomePageTreeNode {
ContextMenuStrip = cmsIis
});
_providers = new List <ModuleProvider>
{
new AuthenticationModuleProvider(),
new AuthorizationModuleProvider(),
new CgiModuleProvider(),
new CompressionModuleProvider(),
new DefaultDocumentModuleProvider(),
new DirectoryBrowseModuleProvider(),
new FastCgiModuleProvider(),
new HttpErrorsModuleProvider(),
new HandlersModuleProvider(),
new HttpRedirectModuleProvider(),
new ResponseHeadersModuleProvider(),
new IpSecurityModuleProvider(),
new IsapiCgiRestrictionModuleProvider(),
new IsapiFiltersModuleProvider(),
new LoggingModuleProvider(),
new MimeMapModuleProvider(),
new ModulesModuleProvider(),
new CachingModuleProvider(),
new RequestFilteringModuleProvider(),
new AccessModuleProvider(),
new CertificatesModuleProvider(),
new RewriteModuleProvider(),
new HttpApiModuleProvider(),
new JexusModuleProvider()
};
_navigationService = new NavigationService(this);
_navigationService.NavigationPerformed += (sender, args) =>
{
var item = new ExplorerNavigationHistoryItem("");
item.Tag = args.NewItem;
eanLocation.Navigation.AddHistory(item);
};
this.UIService = new ManagementUIService(this);
_serviceContainer = new ServiceContainer();
_serviceContainer.AddService(typeof(INavigationService), _navigationService);
_serviceContainer.AddService(typeof(IManagementUIService), this.UIService);
LoadIisExpress();
this.LoadIis();
this.LoadJexus();
Text = NativeMethods.IsProcessElevated ? string.Format("{0} (Administrator)", this.Text) : Text;
}
//
//
//
private void menuItem_Click(object sender, System.EventArgs e)
{
// The IMenuCommandService makes doing common commands easy.
// It keeps track of what commands and verbs the designer supports
// and can invoke them given members of the MenuCommands enum (CommandID's).
IServiceContainer sc = host as IServiceContainer;
IMenuCommandService mcs = sc.GetService(typeof(IMenuCommandService)) as IMenuCommandService;
switch ((sender as MenuItem).Text)
{
case "Cu&t":
mcs.GlobalInvoke(StandardCommands.Cut);
break;
case "&Copy":
mcs.GlobalInvoke(StandardCommands.Copy);
break;
case "&Paste":
mcs.GlobalInvoke(StandardCommands.Paste);
break;
case "&Delete":
mcs.GlobalInvoke(StandardCommands.Delete);
break;
case "Select &All":
mcs.GlobalInvoke(StandardCommands.SelectAll);
break;
case "&Service Requests":
if (serviceRequests == null)
{
serviceRequests = new ServiceRequests();
serviceRequests.Closed += new EventHandler(OnServiceRequestsClosed);
// Our designer host looks for this service to announce the success / failure
// of service requests.
hostingServiceContainer.AddService(typeof(ServiceRequests), serviceRequests);
serviceRequests.Show();
}
serviceRequests.Activate();
break;
case "&Design":
tabControl.SelectedTab = tabDesign;
break;
case "&C# Source":
tabControl.SelectedTab = tabCS;
break;
case "&VB Source":
tabControl.SelectedTab = tabVB;
break;
case "&XML":
tabControl.SelectedTab = tabXML;
break;
case "&Properties":
mcs.GlobalInvoke(MenuCommands.Properties);
break;
case "Show &Grid":
mcs.GlobalInvoke(StandardCommands.ShowGrid);
menuItemShowGrid.Checked = !menuItemShowGrid.Checked;
break;
case "S&nap to Grid":
mcs.GlobalInvoke(StandardCommands.SnapToGrid);
menuItemSnapToGrid.Checked = !menuItemSnapToGrid.Checked;
break;
case "&Lefts":
mcs.GlobalInvoke(StandardCommands.AlignLeft);
break;
case "&Rights":
mcs.GlobalInvoke(StandardCommands.AlignRight);
break;
case "&Tops":
mcs.GlobalInvoke(StandardCommands.AlignTop);
break;
case "&Bottoms":
mcs.GlobalInvoke(StandardCommands.AlignBottom);
break;
case "&Middles":
mcs.GlobalInvoke(StandardCommands.AlignHorizontalCenters);
break;
case "&Centers":
mcs.GlobalInvoke(StandardCommands.AlignVerticalCenters);
break;
case "to &Grid":
mcs.GlobalInvoke(StandardCommands.AlignToGrid);
break;
case "&Horizontally":
mcs.GlobalInvoke(StandardCommands.CenterHorizontally);
break;
case "&Vertically":
mcs.GlobalInvoke(StandardCommands.CenterVertically);
break;
case "&Control":
mcs.GlobalInvoke(StandardCommands.SizeToControl);
break;
case "Control &Width":
mcs.GlobalInvoke(StandardCommands.SizeToControlWidth);
break;
case "Control &Height":
mcs.GlobalInvoke(StandardCommands.SizeToControlHeight);
break;
case "&Grid":
mcs.GlobalInvoke(StandardCommands.SizeToGrid);
break;
case "&Bring to Front":
mcs.GlobalInvoke(StandardCommands.BringToFront);
break;
case "&Send to Back":
mcs.GlobalInvoke(StandardCommands.SendToBack);
break;
case "&Tab Order":
mcs.GlobalInvoke(StandardCommands.TabOrder);
break;
}
}
public ValidatableObjectTest()
{
var container = new ServiceContainer();
container.AddService( typeof( IValidator ), new ValidatorAdapter() );
ServiceProvider.SetCurrent( container );
}
public void AddService(Type serviceType, object serviceInstance)
{
serviceContainer.AddService(serviceType, serviceInstance);
}
