Esempio n. 1
0
        /// <summary>
        /// Creates a new file of the specified type.
        /// </summary>
        public static void CreateFile(string fileName, KnownFileType fileType)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write, FileShare.Read))
            {
                if (fileType == KnownFileType.SchemeView ||
                    fileType == KnownFileType.TableView ||
                    fileType == KnownFileType.XmlFile)
                {
                    XmlDocument    xmlDoc  = new XmlDocument();
                    XmlDeclaration xmlDecl = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null);
                    xmlDoc.AppendChild(xmlDecl);

                    if (fileType == KnownFileType.SchemeView)
                    {
                        xmlDoc.AppendChild(xmlDoc.CreateElement("SchemeView"));
                    }
                    else if (fileType == KnownFileType.TableView)
                    {
                        xmlDoc.AppendChild(xmlDoc.CreateElement("TableView"));
                    }

                    xmlDoc.Save(stream);
                }
            }
        }
Esempio n. 2
0
 /// <summary>
 /// Gets an extension corresponds to the file type.
 /// </summary>
 public static string GetExtension(KnownFileType fileType)
 {
     return(fileType switch
     {
         KnownFileType.SchemeView => "sch",
         KnownFileType.TableView => "tbl",
         KnownFileType.TextFile => "txt",
         KnownFileType.XmlFile => "xml",
         _ => ""
     });
Esempio n. 3
0
        public static byte[] ConvertFromDxt(KnownFileType dxtType, byte[] data, uint width, uint height)
        {
            byte[] dds = new byte[128 + data.Length];
            dds[0] = 0x44; // "D"
            dds[1] = 0x44; // "D"
            dds[2] = 0x53; // "S"
            dds[3] = 0x20; // " "

            dds[4] = 124;  // size of remaining header

            // header flags
            dds[8]  = 0x07;
            dds[9]  = 0x10;
            dds[10] = 0x0A;


            var widthBytes  = BitConverter.GetBytes(width);
            var heightBytes = BitConverter.GetBytes(height);
            var pitchBytes  = BitConverter.GetBytes((uint)data.Length);

            Array.Copy(widthBytes, 0, dds, 12, 4);
            Array.Copy(heightBytes, 0, dds, 16, 4);
            Array.Copy(pitchBytes, 0, dds, 20, 4);

            dds[28] = 1;  // mipmap count
            dds[76] = 32; // size of sub-struct, static
            dds[80] = 4;  // DDPF_FOURCC

            dds[84] = 68; // "D"
            dds[85] = 88; // "X"
            dds[86] = 84; // "T"

            switch (dxtType)
            {
            case KnownFileType.DXT1:
                dds[87] = 49;     // "1"
                break;

            case KnownFileType.DXT3:
                dds[87] = 51;     // "3"
                break;

            case KnownFileType.DXT5:
                dds[87] = 53;     // "5"
                break;
            }

            // DDSCAPS flags
            dds[108] = 8;  // DDSCAPS_COMPLEX
            dds[109] = 16; // DDSCAPS_TEXTURE
            dds[110] = 64; // DDSCAPS_MIPMAP

            Array.Copy(data, 0, dds, 128, data.Length);
            return(dds);
        }
Esempio n. 4
0
        public static Converter Get(KnownFileType type)
        {
            switch (type)
            {
            case KnownFileType.Word:
                return(new ConverterWord());

            case KnownFileType.Excel:
                return(new ConverterExcel());

            default:
                return(null);
            }
        }
Esempio n. 5
0
        public void Load(string filename)
        {
            var xDoc = XDocument.Load(filename);

            this.TypeName = xDoc.Root.Attribute("TypeName").Value;
            this.FileType = (KnownFileType)Enum.Parse(typeof(KnownFileType), xDoc.Root.Attribute("FileType").Value);

            var xExtensions = xDoc.Root.Element("FileExtensions").Elements("FileExtension");

            this.FileExtensions = new Dictionary <string, FileExtension>();
            xExtensions.ToList().ForEach(x =>
            {
                var ext = new FileExtension(
                    x.Attribute("Extension").Value, x.Attribute("Name").Value, x.Attribute("Category").Value);
                this.AddFileExtension(ext);
            });
        }
Esempio n. 6
0
        /// <summary>
        /// Gets an extension corresponds to the file type.
        /// </summary>
        public static string GetExtension(KnownFileType fileType)
        {
            switch (fileType)
            {
            case KnownFileType.SchemeView:
                return("sch");

            case KnownFileType.TableView:
                return("tbl");

            case KnownFileType.TextFile:
                return("txt");

            case KnownFileType.XmlFile:
                return("xml");

            default:
                return("");
            }
        }
Esempio n. 7
0
        public static byte[] CreateBitmap(KnownFileType fileType, byte[] data, int width, int height)
        {
            byte[] result = null;

            switch (fileType)
            {
            case KnownFileType.DXT1:
                result = DxtUtil.DecompressDxt1(data, width, height);
                break;

            case KnownFileType.DXT3:
                result = DxtUtil.DecompressDxt3(data, width, height);
                break;

            case KnownFileType.DXT5:
                result = DxtUtil.DecompressDxt5(data, width, height);
                break;
            }

            return(result);
        }