This implementation of IIBVisitor collects all the IBPartialClassDescription instances of an IBArchive.
Наследование: IIBVisitor
 /// <summary>
 /// Returns whether a designed class should be generated.
 /// </summary>
 private static bool ShouldGenerateForXib(ClassDescriptionCollector visitor, String className)
 {
     // Not clean, but needed anyway...
     if (String.Equals ("FirstResponder", className)) {
         return false;
     }
     // TODO: Skip classes that are standard ones
     IEnumerable<IBPartialClassDescription> enumerable = visitor [className];
     return (enumerable.SelectMany (d => d.Outlets).Count () > 0 || enumerable.SelectMany (d => d.Actions).Count () > 0);
 }
        private static void GenerateXibDesignCode(CodeBehindWriter writer, ProjectFile file, ProjectFile designerFile)
        {
            // Create the compilation unit
            CodeCompileUnit ccu = new CodeCompileUnit ();
            CodeNamespace ns = new CodeNamespace (((DotNetProject)file.Project).GetDefaultNamespace (designerFile.FilePath));
            ccu.Namespaces.Add (ns);

            // Add namespaces
            ns.Imports.AddRange(CodeBehindGenerator.GetNamespaces(file.Project));

            // Parse the XIB document to collect the class names and their definitions
            IBDocument document = IBDocument.LoadFromFile (file.FilePath.FullPath);
            ClassDescriptionCollector collector = new ClassDescriptionCollector ();
            document.Root.Accept (collector);

            // Iterate over the extracted class names
            foreach (String className in collector.ClassNames) {
                CodeTypeDeclaration ctd = CodeBehindGenerator.GetType(collector, writer, className);
                if (ctd != null) {
                    ns.Types.Add(ctd);
                }
            }

            // Write the result
            writer.Write (ccu, designerFile.FilePath);
        }
        public static CodeTypeDeclaration GetType(ClassDescriptionCollector collector, CodeBehindWriter writer, String className)
        {
            List<IBPartialClassDescription> descriptions = collector[className];

            // Don't generate the partial class if there are neither actions nor outlets
            int actions = descriptions.Sum (description => description.Actions.Count);
            int outlets = descriptions.Sum (description => description.Outlets.Count);
            if (actions == 0 && outlets == 0) {
                return null;
            }

            // Create the partial class
            CodeTypeDeclaration type = new CodeTypeDeclaration(className);
            type.IsClass = true;
            type.IsPartial = true;

            // Create fields for outlets
            foreach (IBPartialClassDescription.OutletDescription outlet in descriptions.SelectMany(description => description.Outlets)) {
                type.Members.Add(GetOutletField(outlet));
            }

            // Create methods for actions
            foreach (IBPartialClassDescription.ActionDescription action in descriptions.SelectMany(description => description.Actions)) {
                type.Members.Add(GetPartialMethod(action, writer));
                type.Members.Add(GetExposedMethod(action));
            }

            return type;
        }
        private IList<FilePath> GenerateCodeBehindForXib(ProjectTypeCache cache, CodeBehindWriter writer, FilePath file)
        {
            IDELogger.Log ("CodeBehindHandler::GenerateCodeBehindForXib -- Parsing {0}", file);

            // Parse and collect information from the document
            IBDocument document = IBDocument.LoadFromFile (file);
            ClassDescriptionCollector visitor = new ClassDescriptionCollector ();
            document.Root.Accept (visitor);

            List<FilePath> designerFiles = new List<FilePath> ();
            foreach (string className in visitor.ClassNames) {
                // Check if the class should be generated
                if (!ShouldGenerateForXib (visitor, className)) {
                    IDELogger.Log ("CodeBehindHandler::GenerateCodeBehindForXib -- Skipping {0} (no outlets, no actions or reserved name)", className);
                    continue;
                }

                // Generate the designer part
                FilePath designerFile = this.CodeGenerator.GenerateCodeBehindCode (cache, writer, className, visitor [className]);
                if (designerFile != FilePath.Null) {
                    designerFiles.Add (designerFile);
                }
            }

            return designerFiles;
        }
Пример #5
0
        public void TestMainMenuReading012()
        {
            String content = ReadResource(Resources.MainMenu_012);
            IBDocument document = IBDocument.LoadFromXml(content);
            CheckDocument(document);

            ClassDescriptionCollector collector = new ClassDescriptionCollector();
            document.Root.Accept(collector);
            Assert.AreEqual(3, collector.ClassNames.Count());
            Assert.IsTrue(collector.ClassNames.Contains("MainController"));
            IEnumerable<IBPartialClassDescription> classDescriptions = collector["MainController"];
            IEnumerable<IBOutletDescriptor> outlets = classDescriptions.SelectMany(d => d.Outlets);
            IEnumerable<IBActionDescriptor> actions = classDescriptions.SelectMany(d => d.Actions);
            Assert.AreEqual(3, outlets.Count());
            Assert.AreEqual(2, actions.Count());
        }