private void StartAsyncUploading(IModule uploader, String name, byte[] bytes)
 {
     var backgroundWorker = new BackgroundWorker();
     backgroundWorker.DoWork += (s, e) => e.Result = uploader.Upload(name, bytes);
     backgroundWorker.RunWorkerCompleted += (s, e) => Clipboard.SetText((String) e.Result);
     backgroundWorker.RunWorkerAsync();
 }

        public override void SetModuleSettings(IModule module)
        {
            SvrTexture texture = (SvrTexture)module;

            // Set the pixel format
            switch (pixelFormatBox.SelectedIndex)
            {
                case 0: texture.PixelFormat = SvrPixelFormat.Rgb5a3; break;
                case 1: texture.PixelFormat = SvrPixelFormat.Argb8888; break;
            }

            // Set the data format
            switch (dataFormatBox.SelectedIndex)
            {
                case 0: texture.DataFormat = SvrDataFormat.Rectangle; break;
                case 1: texture.DataFormat = SvrDataFormat.Index4ExternalPalette; break;
                case 2: texture.DataFormat = SvrDataFormat.Index8ExternalPalette; break;
                case 3: texture.DataFormat = SvrDataFormat.Index4; break;
                case 4: texture.DataFormat = SvrDataFormat.Index8; break;
            }

            // Set the global index stuff
            texture.HasGlobalIndex = hasGlobalIndexCheckBox.Checked;
            if (texture.HasGlobalIndex)
            {
                uint globalIndex = 0;
                if (!uint.TryParse(globalIndexTextBox.Text, out globalIndex))
                {
                    globalIndex = 0;
                }
                texture.GlobalIndex = globalIndex;
            }
        }

 private void GenerateResponse(IModule module, HttpListenerContext context)
 {
     // Process the request then close the stream. All logic is delegated
     // to the supplied IModule implementer.
     module.Process(context.Response.OutputStream, context);
     context.Response.Close();
 }

 public ModuleLayout(IModule module)
 {
     this.InitializeComponent();
     this.module = module;
     this.module.setFrame(Window.Current.Content as Frame);
     this.moduleName.Text = module.getName();
 }

        public ClampOutput(IModule sourceModule)
        {
            SourceModule = sourceModule;

            LowerBound = -1;
            UpperBound = 1;
        }

        /// <summary>
        /// Creates an <see cref="IntegerType"/> instance.
        /// </summary>
        /// <param name="module"></param>
        /// <param name="name"></param>
        /// <param name="enumerator"></param>
        public IntegerType(IModule module, string name, Symbol type, ISymbolEnumerator symbols)
            : base (module, name)
        {
            Types? t = GetExactType(type);
            type.Assert(t.HasValue, "Unknown symbol for unsigned type!");
            _type = t.Value;

            _isEnumeration = false;

            Symbol current = symbols.NextNonEOLSymbol();
            if (current == Symbol.OpenBracket)
            {
                _isEnumeration = true;
                symbols.PutBack(current);
                _map = Lexer.DecodeEnumerations(symbols);
            }
            else if (current == Symbol.OpenParentheses)
            {
                symbols.PutBack(current);
                _ranges = Lexer.DecodeRanges(symbols);
                current.Assert(!_ranges.IsSizeDeclaration, "SIZE keyword is not allowed for ranges of integer types!");
            }
            else
            {
                symbols.PutBack(current);
            }
        }

 public ProductsController(INews news, IModule module, IPhoto photo, ICacheManager cache)
 {
     _news = news;
     _module = module;
     _cache = cache;
     _photo = photo;
 }

 public Displace(IModule mod0, IModule xDisplaceModule, IModule yDisplaceModule, IModule zDisplaceModule)
 {
     Module0 = mod0;
     XDisplaceModule = xDisplaceModule;
     YDisplaceModule = yDisplaceModule;
     ZDisplaceModule = zDisplaceModule;
 }

 private static void PersistModuleToFile(string folder, IModule module, IObjectTree tree)
 {
     string fileName = Path.Combine(folder, module.Name + ".module");
     using (StreamWriter writer = new StreamWriter(fileName))
     {
         writer.Write("#");
         foreach (string dependent in module.Dependents)
         {
             writer.Write(dependent);
             writer.Write(',');
         }
         
         writer.WriteLine();
         foreach (IEntity entity in module.Entities)
         {
             IDefinition node = tree.Find(module.Name, entity.Name);
             if (node == null)
             {
                 continue;
             }
             
             uint[] id = node.GetNumericalForm();
             /* 0: id
              * 1: type
              * 2: name
              * 3: parent name
              */
             writer.WriteLine(ObjectIdentifier.Convert(id) + "," + entity.GetType() + "," + entity.Name + "," + entity.Parent);
         }
         
         writer.Close();
     }
 }

        public void LoadModule(IModule module)
        {
            if (this.modules.Contains (module))
                throw new ArgumentException ();

            this.modules.Add (module);
        }

        public CfgManipulator(IModule module, PeReader.DefaultHost host, Log.Log logger, MethodCfg methodCfg) {
            this.host = host;
            this.logger = logger;
            this.module = module;

            this.methodCfg = methodCfg;
        }

 public TranslatePoint(IModule mod0, double xTrans, double yTrans, double zTrans)
 {
     Module0 = mod0;
     XTranslation = xTrans;
     YTranslation = yTrans;
     ZTranslation = zTrans;
 }

        public CompressedCacheEntry(IModule destination, HttpListenerContext context)
        {
            Created = DateTime.Now;
            using (MemoryStream memory = new MemoryStream())
            {
                // Store the raw document.
                destination.Process(memory, context);
                Content = memory.ToArray();

                // Attempt to deflate the document, store if size is reduced.
                using (MemoryStream deflateMemory = new MemoryStream())
                using (DeflateStream deflate = new DeflateStream(deflateMemory, CompressionLevel.Optimal))
                {
                    deflate.Write(Content, 0, Content.Length);
                    if (deflateMemory.Length < Content.Length)
                    {
                        Deflated = deflateMemory.ToArray();
                        IsDeflated = true;
                    }
                    else
                    {
                        IsDeflated = false;
                    }
                }
            }
        }

 public virtual bool SubscribeModule(IModule m)
 {
     if (m.Type == typeof(ControlModule))
     {
         var t = m as ControlModule;
         if(!cmdic.ContainsValue(t))
         {
             cmdic.Add(t.Text, t);
         }
         return true;
     }
     if (m.Type == typeof(AnalysisModule))
     {
         var t = m as AnalysisModule;
         if (!amdic.ContainsValue(t))
         {
             amdic.Add(t.Text, t);
         }
         return true;
     }
     if (m.Type == typeof(SignalModule))
     {
         var t = m as SignalModule;
         if (!smdic.ContainsValue(t))
         {
             smdic.Add(t.Text, t);
         }
         return true;
     }
     return false;
 }

        public void LoadModule(string ModuleName)
        {
            if (ModuleName == "Dummy") return;
            Assembly a = null;
            try {
                a = Assembly.LoadFrom(ModuleName);
            }
            catch {
                throw new ModuleLoadException(string.Format("Не могу загрузить сборку \"{0}\"", ModuleName));
            }

            Type[] allTypes = a.GetTypes();
            foreach (Type type in allTypes) // ищем во всех классах интерфейс IModule
            {
                Type IModule = type.GetInterface("IModule");
                if (IModule != null) {
                    _module = (IModule) Activator.CreateInstance(type);
                    break;
                }
            }

            if (_module == null)
                throw new ModuleLoadException(string.Format("В сборке \"{0}\" не найден интерфейс IModule.", ModuleName));

            _module.Init();
        }

 public ScalePoint(IModule mod0, double xScale, double yScale, double zScale)
 {
     Module0 = mod0;
     XScale = xScale;
     YScale = yScale;
     ZScale = zScale;
 }

        public override StateEnums.Status Execute(Object o, Hashtable inputData)
        {
            int activityIdStarting = UpdateProcessStatus(Enums.ProcessStatus.Starting, "", (State)o );

            try
            {
                for (int i = 0; i < testLoopCycles; i++)
                {
                    if (!ifRetry) throw new Exception("Cancelling " + job.JobName + "...");
                    Thread.Sleep(testLoopInterval);
                }
            }
            catch (Exception ex)
            {
                log.Error(ex.Message);
            }

            log.InfoFormat(((State)o).CurrentJobHash, "NullModule executed.");

            if (impersonatedModule != null)
            {
                IDependency<IModule> impersonatedDependencyToRestore =
                                                            (IDependency<IModule>)this.job.Dependencies[this.Name];
                impersonatedDependencyToRestore.Module = impersonatedModule;
                impersonatedModule = null;
            }

            return StateEnums.Status.Success;
        }

 /// <summary>
 /// Creates new instance of AutofacViewModelFactory using an Autofac Module
 /// 
 /// This will cause the container to be disposed when the AutofacViewModelFactory is disposed
 /// </summary>
 public AutofacViewModelFactory(IModule moduleToRegister)
 {
     var containerBuilder = new ContainerBuilder();
     containerBuilder.RegisterModule(moduleToRegister);
     autofacContainer = containerBuilder.Build();
     shouldDisposeContainer = true;
 }

        public static IModule RewriteModule(IMetadataHost host, ILocalScopeProvider localScopeProvider, ISourceLocationProvider sourceLocationProvider, IModule module)
        {
            var m = new PropertyChangedWeaver(host);
            m._rewriter = new ReferenceReplacementRewriter(host, localScopeProvider, sourceLocationProvider);

            return m.Rewrite(module);
        }

        private static void DemoInferables(IModule module)
        {
            ShowConsoleHeader(module);

            // Here we are getting an inferred type that matches interface IFoo based on the namespace bindings for this module.
            var foo = module.Get<IFoo>();
            foo.Dump("Value for foo");

            // This method resolves the inferred on finding the match patten foo2 for Interface type IFoo.
            var foo2 = module.Get<IFoo>("foo2");
            foo.Dump("Value for foo2");

            // Here we are getting foo again- performance very good this time around since all type generation il code has been cached.
            var fooAgain = module.Get<IFoo>();
            fooAgain.Dump("Value for fooAgain");

            // Here we are mapping explicitly to a Foo type, choosing the appropriate constructor and infering dependencies.
            var explicitFoo = module.GetExplicit<Foo>();
            explicitFoo.Dump("Value of explicit foo");

            ShowFactoryTestsHeader();

            // Here we are binding to a custom factory interface, which will automatically generate a type for this factory, cache the it, and instantiate it.
            var factory = module.GetFactory<IFactory>();
            factory.GetFoo().Dump("Value for GetFoo()");
            factory.GetFoo1().Dump("Value for GetFoo1()");
            factory.GetFoo2().Dump("Value for GetFoo2()");
            factory.GetFoo3().Dump("Value for GetFoo3()");
            factory.GetFoo4().Dump("Value for GetFoo4()");
            factory.GetFoo5().Dump("Value for GetFoo5()");
            factory.GetFoo6().Dump("Value for GetFoo6()");
        }