Esempio n. 1
0
        /// <summary> Sees if the extended formatting record at the specified position
        /// represents a date.  First checks against the built in formats, and
        /// then checks against the hash map of FormatRecords
        ///
        /// </summary>
        /// <param name="pos">the xf format index
        /// </param>
        /// <returns> TRUE if this format index is formatted as a Date
        /// </returns>
        public bool isDate(int pos)
        {
            XFRecord xfr = (XFRecord)xfRecords[pos];

            if (xfr.isDate())
            {
                return(true);
            }

            FormatRecord fr = (FormatRecord)formats[xfr.FormatRecord];

            return(fr == null?false:fr.Date);
        }
Esempio n. 2
0
        /// <summary> Gets the NumberFormatInfo used to format the cell.
        ///
        /// </summary>
        /// <param name="pos">the xf format index
        /// </param>
        /// <returns> the DateFormat object used to format the date in the original
        /// excel cell
        /// </returns>
        public NumberFormatInfo getNumberFormat(int pos)
        {
            XFRecord xfr = (XFRecord)xfRecords[pos];

            if (xfr.isNumber())
            {
                return(xfr.NumberFormat);
            }

            FormatRecord fr = (FormatRecord)formats[xfr.FormatRecord];

            if (fr == null)
            {
                return(null);
            }

            return(fr.Number?fr.NumberFormat:null);
        }
Esempio n. 3
0
        /// <summary> Gets the DateFormat used to format the cell.
        ///
        /// </summary>
        /// <param name="pos">the xf format index
        /// </param>
        /// <returns> the DateFormat object used to format the date in the original
        /// excel cell
        /// </returns>
        public DateTimeFormatInfo getDateFormat(int pos)
        {
            XFRecord xfr = (XFRecord)xfRecords[pos];

            if (xfr.isDate())
            {
                return(xfr.DateFormat);
            }

            FormatRecord fr = (FormatRecord)formats[xfr.FormatRecord];

            if (fr == null)
            {
                return(null);
            }

            return(fr.Date?fr.DateFormat:null);
        }
Esempio n. 4
0
 /// <summary> Adds an extended formatting record to the list.  If the XF record passed
 /// in has not been initialized, its index is determined based on the
 /// xfRecords list, and
 /// this position is passed to the XF records initialize method
 ///
 /// </summary>
 /// <param name="xf">the xf record to add
 /// </param>
 /// <exception cref=""> NumFormatRecordsException
 /// </exception>
 public void  addStyle(XFRecord xf)
 {
     if (!xf.isInitialized())
     {
         int pos = xfRecords.Count;
         xf.initialize(pos, this, fonts);
         xfRecords.Add(xf);
     }
     else
     {
         // The XF record has probably been read in.  If the index is greater
         // Than the size of the list, then it is not a preset format,
         // so add it
         if (xf.getXFIndex() >= xfRecords.Count)
         {
             xfRecords.Add(xf);
         }
     }
 }
Esempio n. 5
0
        /// <summary> Copy constructor.  Used for copying writable formats, typically
        /// when duplicating formats to handle merged cells
        ///
        /// </summary>
        /// <param name="fmt">XFRecord
        /// </param>
        protected internal XFRecord(XFRecord fmt) : base(NExcel.Biff.Type.XF)
        {
            initialized        = false;
            locked             = fmt.locked;
            hidden             = fmt.hidden;
            align              = fmt.align;
            valign             = fmt.valign;
            orientation        = fmt.orientation;
            wrap               = fmt.wrap;
            leftBorder         = fmt.leftBorder;
            rightBorder        = fmt.rightBorder;
            topBorder          = fmt.topBorder;
            bottomBorder       = fmt.bottomBorder;
            leftBorderColour   = fmt.leftBorderColour;
            rightBorderColour  = fmt.rightBorderColour;
            topBorderColour    = fmt.topBorderColour;
            bottomBorderColour = fmt.bottomBorderColour;
            pattern            = fmt.pattern;
            xfFormatType       = fmt.xfFormatType;
            shrinkToFit        = fmt.shrinkToFit;
            parentFormat       = fmt.parentFormat;
            backgroundColour   = fmt.backgroundColour;

            // Shallow copy is sufficient for these purposes
            font   = fmt.font;
            format = fmt.format;

            fontIndex   = fmt.fontIndex;
            formatIndex = fmt.formatIndex;

            formatInfoInitialized = fmt.formatInfoInitialized;

            biffType = biff8;
            read     = false;
            copied   = true;
        }
Esempio n. 6
0
        /// <summary> Rationalizes the cell formats.  Duplicate
        /// formats are removed and the format indexed of the cells
        /// adjusted accordingly
        ///
        /// </summary>
        /// <param name="fontMapping">the font mapping index numbers
        /// </param>
        /// <param name="formatMapping">the format mapping index numbers
        /// </param>
        /// <returns> the list of new font index number
        /// </returns>
        public virtual IndexMapping rationalize(IndexMapping fontMapping, IndexMapping formatMapping)
        {
            // Update the index codes for the XF records using the format
            // mapping and the font mapping
            // at the same time
            foreach (XFRecord xfr in xfRecords)
            {
                if (xfr.FormatRecord >= customFormatStartIndex)
                {
                    xfr.FormatIndex = formatMapping.getNewIndex(xfr.FormatRecord);
                }

                xfr.FontIndex = fontMapping.getNewIndex(xfr.FontIndex);
            }

            ArrayList    newrecords = new ArrayList(minXFRecords);
            IndexMapping mapping    = new IndexMapping(xfRecords.Count);
            int          numremoved = 0;

            // Copy across the fundamental styles
            for (int i = 0; i < minXFRecords; i++)
            {
                newrecords.Add(xfRecords[i]);
                mapping.setMapping(i, i);
            }

            // Iterate through the old list
            for (int i = minXFRecords; i < xfRecords.Count; i++)
            {
                XFRecord xf = (XFRecord)xfRecords[i];

                // Compare against formats already on the list
                bool duplicate = false;
                foreach (XFRecord xf2 in newrecords)
                {
                    if (duplicate)
                    {
                        break;
                    }

                    if (xf2.Equals(xf))
                    {
                        duplicate = true;
                        mapping.setMapping(i, mapping.getNewIndex(xf2.getXFIndex()));
                        numremoved++;
                    }
                }

                // If this format is not a duplicate then add it to the new list
                if (!duplicate)
                {
                    newrecords.Add(xf);
                    mapping.setMapping(i, i - numremoved);
                }
            }

            // It is sufficient to merely change the xf index field on all XFRecords
            // In this case, CellValues which refer to defunct format records
            // will nevertheless be written out with the correct index number
            foreach (XFRecord xf in xfRecords)
            {
                xf.rationalize(mapping);
            }

            // Set the new list
            xfRecords = newrecords;

            return(mapping);
        }
Esempio n. 7
0
        /// <summary> A public copy constructor which can be used for copy formats between
        /// different sheets.  Unlike the the other copy constructor, this
        /// version does a deep copy
        ///
        /// </summary>
        /// <param name="cellFormat">the format to copy
        /// </param>
        protected internal XFRecord(CellFormat cellFormat) : base(NExcel.Biff.Type.XF)
        {
            Assert.verify(cellFormat is XFRecord);
            XFRecord fmt = (XFRecord)cellFormat;

            if (!fmt.formatInfoInitialized)
            {
                fmt.initializeFormatInformation();
            }

            locked             = fmt.locked;
            hidden             = fmt.hidden;
            align              = fmt.align;
            valign             = fmt.valign;
            orientation        = fmt.orientation;
            wrap               = fmt.wrap;
            leftBorder         = fmt.leftBorder;
            rightBorder        = fmt.rightBorder;
            topBorder          = fmt.topBorder;
            bottomBorder       = fmt.bottomBorder;
            leftBorderColour   = fmt.leftBorderColour;
            rightBorderColour  = fmt.rightBorderColour;
            topBorderColour    = fmt.topBorderColour;
            bottomBorderColour = fmt.bottomBorderColour;
            pattern            = fmt.pattern;
            xfFormatType       = fmt.xfFormatType;
            parentFormat       = fmt.parentFormat;
            shrinkToFit        = fmt.shrinkToFit;
            backgroundColour   = fmt.backgroundColour;

            // Deep copy of the font
            font = new FontRecord(fmt.Font);

            // Copy the format
            if (fmt.Format == null)
            {
                // format is writable
                if (fmt.format.isBuiltIn())
                {
                    format = fmt.format;
                }
                else
                {
                    // Format is not built in, so do a deep copy
                    format = new FormatRecord((FormatRecord)fmt.format);
                }
            }
            else if (fmt.Format is BuiltInFormat)
            {
                // read excel format is built in
                excelFormat = (BuiltInFormat)fmt.excelFormat;
                format      = (BuiltInFormat)fmt.excelFormat;
            }
            else
            {
                // read excel format is user defined
                Assert.verify(fmt.formatInfoInitialized);

                // in this case FormattingRecords should initialize the excelFormat
                // field with an instance of FormatRecord
                Assert.verify(fmt.excelFormat is FormatRecord);

                // Format is not built in, so do a deep copy
                FormatRecord fr = new FormatRecord((FormatRecord)fmt.excelFormat);

                // Set both format fields to be the same object, since
                // FormatRecord implements all the necessary interfaces
                excelFormat = fr;
                format      = fr;
            }

            biffType = biff8;

            // The format info should be all OK by virtue of the deep copy
            formatInfoInitialized = true;


            // This format was not read in
            read = false;

            // Treat this as a new cell record, so set the copied flag to false
            copied = false;

            // The font or format indexes need to be set, so set initialized to false
            initialized = false;
        }
Esempio n. 8
0
        /// <summary> Equals method.  This is called when comparing writable formats
        /// in order to prevent duplicate formats being added to the workbook
        ///
        /// </summary>
        /// <param name="o">object to compare
        /// </param>
        /// <returns> TRUE if the objects are equal, FALSE otherwise
        /// </returns>
        public override bool Equals(System.Object o)
        {
            if (o == this)
            {
                return(true);
            }

            if (!(o is XFRecord))
            {
                return(false);
            }

            XFRecord xfr = (XFRecord)o;

            // Both records must be writable and have their format info initialized
            if (!formatInfoInitialized)
            {
                initializeFormatInformation();
            }

            if (!xfr.formatInfoInitialized)
            {
                xfr.initializeFormatInformation();
            }

            if (xfFormatType != xfr.xfFormatType || parentFormat != xfr.parentFormat || locked != xfr.locked || hidden != xfr.hidden || usedAttributes != xfr.usedAttributes)
            {
                return(false);
            }

            if (align != xfr.align || valign != xfr.valign || orientation != xfr.orientation || wrap != xfr.wrap || shrinkToFit != xfr.shrinkToFit)
            {
                return(false);
            }

            if (leftBorder != xfr.leftBorder || rightBorder != xfr.rightBorder || topBorder != xfr.topBorder || bottomBorder != xfr.bottomBorder)
            {
                return(false);
            }

            if (leftBorderColour != xfr.leftBorderColour || rightBorderColour != xfr.rightBorderColour || topBorderColour != xfr.topBorderColour || bottomBorderColour != xfr.bottomBorderColour)
            {
                return(false);
            }

            if (backgroundColour != xfr.backgroundColour || pattern != xfr.pattern)
            {
                return(false);
            }

            // Sufficient to just do shallow equals on font, format objects,
            // since we are testing for the presence of clones anwyay
            // Use indices rather than objects because of the rationalization
            // process (which does not set the object on an XFRecord)
            if (fontIndex != xfr.fontIndex || formatIndex != xfr.formatIndex)
            {
                return(false);
            }

            return(true);
        }