Beispiel #1
0
        internal void SaveRangeToStream(IDataStream DataStream, TSaveData SaveData, TXlsCellRange CellRange)
        {
            int FirstRecord = 0;
            int RecordCount = 0;

            CalcIncludedRangeRecords(CellRange, ref FirstRecord, ref RecordCount);

            if (RecordCount > MaxPageBreaks)
            {
                if (SaveData.ThrowExceptionOnTooManyPageBreaks)
                {
                    XlsMessages.ThrowException(XlsErr.ErrTooManyPageBreaks);
                }
                else
                {
                    RecordCount = MaxPageBreaks;
                }
                if (FlexCelTrace.Enabled)
                {
                    FlexCelTrace.Write(new TXlsTooManyPageBreaksError(XlsMessages.GetString(XlsErr.ErrTooManyPageBreaks), DataStream.FileName));
                }
            }

            SaveToStreamExt(DataStream, SaveData, FirstRecord, RecordCount);
        }
Beispiel #2
0
        private void LoadAllFonts(string FontPath, DirectoryInfo di, string FontExtension, Boolean ErrorIfEmpty)
        {
            // Create an array representing the files in the current directory.
            FileInfo[] fi = di.GetFiles(FontExtension);
            if (ErrorIfEmpty && fi.Length == 0)
            {
                FlxMessages.ThrowException(FlxErr.ErrEmptyFolder, FontPath, FontExtension);
            }


            foreach (FileInfo fontFile in fi)
            {
                if (FFontFiles.ContainsKey(fontFile.Name))
                {
                    continue;
                }

                FFontFiles.Add(fontFile.Name, null);
                try
                {
                    LoadFont(fontFile.FullName);
                }
                catch (Exception ex)
                {
                    //Invalid font. nothing to do, just continue reading the other fonts.
                    // What we will do is just ignore it here, and throw an exception when (and if) the user actually tries to use this font.

                    if (FlexCelTrace.HasListeners)
                    {
                        FlexCelTrace.Write(new TPdfCorruptFontInFontFolderError(ex.Message, fontFile.FullName));
                    }
                }
            }
        }
Beispiel #3
0
 public void AddHyperlink(real x1, real y1, real width, real height, string Url)
 {
     try
     {
         Canvas.Hyperlink(x1, y1, width, height, Url);
     }
     catch (UriFormatException ex)
     {
         if (FlexCelTrace.HasListeners)
         {
             FlexCelTrace.Write(new TMalformedUrlError(ex.Message, Url));
         }
     }
 }
Beispiel #4
0
        internal void SaveAllToStream(IDataStream DataStream, TSaveData SaveData)
        {
            if (RealCount() > MaxPageBreaks)
            {
                if (SaveData.ThrowExceptionOnTooManyPageBreaks)
                {
                    XlsMessages.ThrowException(XlsErr.ErrTooManyPageBreaks);
                }

                if (FlexCelTrace.Enabled)
                {
                    FlexCelTrace.Write(new TXlsTooManyPageBreaksError(XlsMessages.GetString(XlsErr.ErrTooManyPageBreaks), DataStream.FileName));
                }
            }

            SaveToStreamExt(DataStream, SaveData, 0, VirtualCount);
        }
Beispiel #5
0
        public static void WriteStringInStream(TPdfStream DataStream, string Text, real FontSize, TPdfFont aFont, ref string LastFont, string EndNewText, string StartNewText2, string EndNewText2, TTracedFonts TracedFonts)
        {
            TPdfFont LastFallbackFont = aFont;
            int      StartText        = 0;

            int TLen = Text.Length;

            for (int i = 0; i <= TLen; i++)
            {
                TPdfFont FallbackFont = null;

                if (i < TLen)
                {
                    FallbackFont = aFont.Fallback(Text[i], 0);
                    if (FallbackFont == null)
                    {
                        FallbackFont = aFont;
                    }
                }

                if (FallbackFont != LastFallbackFont)
                {
                    WriteSimpleString(DataStream, Text.Substring(StartText, i - StartText), LastFallbackFont, EndNewText);

                    StartText = i;

                    if (FallbackFont != null)
                    {
                        TPdfBaseRecord.Write(DataStream, EndNewText2);
                        FallbackFont.Select(DataStream, FontSize, ref LastFont);

                        if (FlexCelTrace.HasListeners && FallbackFont != aFont && !TracedFonts.ContainsKey(aFont.FontName + ";" + FallbackFont.FontName))
                        {
                            TracedFonts.Add(aFont.FontName + ";" + FallbackFont.FontName, String.Empty);
                            FlexCelTrace.Write(new TPdfUsedFallbackFontError(FlxMessages.GetString(FlxErr.ErrUsedFallbackFont, aFont.FontName, FallbackFont.FontName), aFont.FontName, FallbackFont.FontName));
                        }

                        TPdfBaseRecord.Write(DataStream, StartNewText2);
                        LastFallbackFont = FallbackFont;
                    }
                }
            }
        }
Beispiel #6
0
        internal static TPdfFont CreateInstance(TFontMapping Mapping, Font aFont, bool aUnicode, int aId, TFontEmbed aEmbed, TFontSubset aSubset, bool aCompress, bool aUseKerning,
                                                TFontEvents FontEvents, TPdfEmbeddedFontList EmbeddedFontList, TPdfResources aResources)
        {
            if (!aUnicode &&
                (Mapping == TFontMapping.ReplaceAllFonts || (Mapping == TFontMapping.ReplaceStandardFonts && IsStandardFont(aFont.Name)))
                )
            {
                return(new TPdfInternalFont(aFont, aId, aUseKerning, aResources));
            }

            FontStyle        AdditionalStyle;
            TPdfEmbeddedFont EmbeddedData = EmbeddedFontList.Add(aFont, FontEvents, aSubset == TFontSubset.Subset, aUseKerning, out AdditionalStyle);

            if (AdditionalStyle != FontStyle.Regular)
            {
                if (FlexCelTrace.HasListeners)
                {
                    FlexCelTrace.Write(new TPdfFauxBoldOrItalicsError(FlxMessages.GetString(FlxErr.ErrFauxBoldOrItalic, aFont.Name, GetAdditionalStyleName(AdditionalStyle)), aFont.Name, AdditionalStyle));
                }
            }

            if (aUnicode)
            {
                return(new TPdfUnicodeTrueTypeFont(aFont, aId, aSubset, aCompress, aUseKerning, EmbeddedData, AdditionalStyle, aResources));
            }
            else
            {
                bool DoEmbed = aEmbed == TFontEmbed.Embed || EmbeddedData.TrueTypeData.NeedsEmbed(aEmbed);

                if (FontEvents.OnFontEmbed != null)
                {
                    FontEmbedEventArgs ae = new FontEmbedEventArgs(aFont, DoEmbed);
                    FontEvents.OnFontEmbed(FontEvents.Sender, ae);
                    DoEmbed = ae.Embed;
                }

                return(new TPdfWinAnsiTrueTypeFont(aFont, aId, DoEmbed, aSubset, aCompress, aUseKerning, EmbeddedData, AdditionalStyle, aResources));
            }
        }
Beispiel #7
0
        public void DrawImage(Image image, RectangleF destRect, RectangleF srcRect, long transparentColor, int brightness, int contrast, int gamma, Color shadowColor, Stream imgData)
        {
            if (PointOutside.Check(ref srcRect))
            {
                return;
            }
            if (PointOutside.Check(ref destRect))
            {
                return;
            }
            if (image.Height <= 0 || image.Width <= 0)
            {
                return;
            }
            bool ChangedParams = brightness != FlxConsts.DefaultBrightness ||
                                 contrast != FlxConsts.DefaultContrast ||
                                 gamma != FlxConsts.DefaultGamma ||
                                 shadowColor != ColorUtil.Empty;

            ImageAttributes imgAtt = null;

            try
            {
                if (transparentColor != FlxConsts.NoTransparentColor)
                {
                    long  cl  = transparentColor;
                    Color tcl = ColorUtil.FromArgb((int)(cl & 0xFF), (int)((cl & 0xFF00) >> 8), (int)((cl & 0xFF0000) >> 16));
                    imgAtt = new ImageAttributes();
                    imgAtt.SetColorKey(tcl, tcl);
                }

                if (gamma != FlxConsts.DefaultGamma)
                {
                    if (imgAtt == null)
                    {
                        imgAtt = new ImageAttributes();
                    }
                    imgAtt.SetGamma((float)((UInt32)gamma) / 65536f);
                }

                if (!ChangedParams && srcRect.Top == 0 && srcRect.Left == 0 && srcRect.Width == image.Width && srcRect.Height == image.Height && imgAtt == null)
                {
                    bool Retry = false;
                    try
                    {
                        Canvas.DrawImage(image, destRect);                          //Optimizes the most common case, but there is also an error when cropping metafiles. At least we make sure here this won't have any error on 99% of the cases.
                    }
                    catch (System.Runtime.InteropServices.ExternalException ex)
                    {
                        if (FlexCelTrace.HasListeners)
                        {
                            FlexCelTrace.Write(new TRenderMetafileError(ex.Message));
                        }

                        Retry = true;                         //metafiles can raise nasty errors here.
                    }
                    if (Retry)
                    {
                        using (Image bmp = FlgConsts.RasterizeWMF(image))
                        {
                            Canvas.DrawImage(bmp, destRect);
                        }
                    }
                }
                else
                {
                    Image FinalImage = image;
                    try
                    {
                        if (image.RawFormat.Equals(ImageFormat.Wmf) || image.RawFormat.Equals(ImageFormat.Emf))
                        {
                            FinalImage = FlgConsts.RasterizeWMF(image);                             //metafiles do not like cropping or changing attributes.
                        }

                        if (ChangedParams)
                        {
                            if (shadowColor != ColorUtil.Empty)
                            {
                                FlgConsts.MakeImageGray(ref imgAtt, shadowColor);
                            }
                            else
                            {
                                FlgConsts.AdjustImage(ref imgAtt, brightness, contrast);
                            }
                        }

                        PointF[] ImageRect = new PointF[] { new PointF(destRect.Left, destRect.Top), new PointF(destRect.Right, destRect.Top), new PointF(destRect.Left, destRect.Bottom) };
                        Canvas.DrawImage(FinalImage,
                                         ImageRect,
                                         srcRect, GraphicsUnit.Pixel, imgAtt);
                    }
                    finally
                    {
                        if (FinalImage != image)
                        {
                            FinalImage.Dispose();
                        }
                    }
                }
            }
            finally
            {
                if (imgAtt != null)
                {
                    imgAtt.Dispose();
                }
            }
        }