private static void DrawText(PdfContentByte canvas, string text, Rectangle rectangle,
                                     float textWidthOffset, float textHeightOffset, Font font)
        {
            const int textRotation = 270;

            TextSharpHelpers.WriteNonWrappingTextInRectangle(canvas, text, rectangle, textWidthOffset, textHeightOffset, font, textRotation);
        }
예제 #2
0
        private static void DrawCardText(
            Rectangle rectangle,
            Cursor topCursor,
            Cursor bottomCursor,
            PdfCanvas canvas,
            string cardName,
            PdfFont font,
            CardSuperType cardSuperType)
        {
            const float textPadding         = 2f;
            const float textHeight          = 12f;
            const float maxFontSize         = 10f;
            var         textRectangleHeight = topCursor.GetCurrent() - bottomCursor.GetCurrent() - textPadding * 2;
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, cardName, textRectangleHeight, font, maxFontSize);
            var         fontWeight          = GetMainTextFontWeight(cardSuperType);
            var         fontColor           = GetMainTextFontColor(cardSuperType);
            var         textWidthOffset     = 8 + (maxFontSize - textFontSize) * .35f;
            var         textRectangle       = new Rectangle(
                rectangle.GetLeft() + textWidthOffset,
                bottomCursor.GetCurrent() + textPadding,
                textHeight,
                topCursor.GetCurrent() - (bottomCursor.GetCurrent() + 2 * textPadding));

            DrawText(canvas, cardName, textRectangle, -2.5f, 0f, font, fontColor, textFontSize, fontWeight);
        }
예제 #3
0
        private static void DrawBeerName(
            Rectangle rectangle,
            Cursor topCursor,
            PdfCanvas canvas,
            Beer beer,
            PdfFont font)
        {
            var textRectangle = new Rectangle(
                rectangle.GetLeft(),
                rectangle.GetBottom(),
                rectangle.GetWidth(),
                topCursor.GetCurrent() - rectangle.GetBottom());
            var fontSize = TextSharpHelpers.GetMultiLineFontSize(
                canvas,
                beer.FullName,
                textRectangle,
                font,
                12) - .5f;

            DrawCenteredWrappingText(
                canvas,
                beer.FullName,
                textRectangle,
                font,
                ColorConstants.BLACK,
                fontSize);
        }
 private static Image DrawImage(
     Rectangle rectangle,
     PdfContentByte canvas,
     string imagePath,
     bool scaleAbsolute      = false,
     bool centerVertically   = false,
     bool centerHorizontally = false)
 {
     return(TextSharpHelpers.DrawImage(rectangle, canvas, imagePath, 0, scaleAbsolute, centerVertically, centerHorizontally));
 }
예제 #5
0
 private static void DrawImage(
     Rectangle rectangle,
     PdfCanvas canvas,
     string imagePath,
     bool scaleAbsolute      = false,
     bool centerVertically   = false,
     bool centerHorizontally = false)
 {
     TextSharpHelpers.DrawImage(rectangle, canvas, imagePath, System.Drawing.RotateFlipType.Rotate90FlipNone, scaleAbsolute, centerVertically, centerHorizontally);
 }
예제 #6
0
        private static void DrawCenteredWrappingText(
            PdfCanvas canvas,
            string text,
            Rectangle rectangle,
            PdfFont font,
            Color color,
            float size)
        {
            const float textRotation = (float)(3 * Math.PI / 2);

            TextSharpHelpers.WriteWrappingTextInRectangle(canvas, text, rectangle, font, color, size, textRotation);
        }
        private static void DrawImage(
            Rectangle rectangle,
            PdfContentByte canvas,
            string imagePath,
            bool scaleAbsolute      = false,
            bool centerVertically   = false,
            bool centerHorizontally = false)
        {
            const float imageRotationInRadians = 4.71239f;

            TextSharpHelpers.DrawImage(rectangle, canvas, imagePath, imageRotationInRadians, scaleAbsolute, centerVertically, centerHorizontally);
        }
예제 #8
0
        private static void DrawText(
            PdfCanvas canvas,
            string text,
            Rectangle rectangle,
            float textWidthOffset,
            float textHeightOffset,
            PdfFont font,
            Color color,
            float size)
        {
            const float textRotation = (float)(3 * Math.PI / 2);

            TextSharpHelpers.WriteNonWrappingTextInRectangle(canvas, text, rectangle, textWidthOffset, textHeightOffset, font, color, size, textRotation, FontWeight.Regular);
        }
예제 #9
0
 private static Action <PdfCanvas, Rectangle> CreateActionToDrawNameAndSet(string name, string set, PdfFont baseFont, Color color)
 {
     return((canvas, rectangle) =>
     {
         var topCursor = new Cursor();
         var bottomCursor = new Cursor();
         const float startOfLabelOffset = 4f;
         topCursor.AdvanceCursor(rectangle.GetTop() - startOfLabelOffset);
         bottomCursor.AdvanceCursor(rectangle.GetBottom() + startOfLabelOffset);
         TextSharpHelpers.DrawRoundedRectangle(canvas, rectangle, color);
         DrawCardText(rectangle, topCursor, bottomCursor, canvas, name, baseFont);
         DrawSetText(rectangle, topCursor, bottomCursor, canvas, set, baseFont);
     });
 }
        private static float GetFontSize(Rectangle rectangle, string name, PdfContentByte canvas, BaseFont baseFont,
                                         float xOffset)
        {
            const float maxFontSize = 16f;
            var         fontSize    = TextSharpHelpers.GetFontSize(
                canvas,
                name,
                rectangle.Width - (xOffset + 5),
                baseFont,
                maxFontSize,
                Element.ALIGN_LEFT,
                Font.NORMAL);

            return(fontSize);
        }
        public static byte[] CreateLabels()
        {
            var garamond     = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts), "GARA.TTF");
            var garamondBold = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts), "GARABD.TTF");
            var baseFont     = BaseFont.CreateFont(garamond, BaseFont.IDENTITY_H, BaseFont.EMBEDDED);
            var boldBaseFont = BaseFont.CreateFont(garamondBold, BaseFont.IDENTITY_H, BaseFont.EMBEDDED);

            var beers                = GetBeers();
            var labelBackground      = new CMYKColor(0, 8, 26, 0);
            var drawActionRectangles = beers.SelectMany(beer => new List <Action <PdfContentByte, Rectangle> >
            {
                (canvas, rectangle) =>
                {
                    TextSharpHelpers.DrawRectangle(canvas, rectangle, labelBackground);
                    //name
                    //gold label
                    const float startOfLabelOffset = 4f;
                    var topCursor = new Cursor();
                    topCursor.AdvanceCursor(rectangle.Top - startOfLabelOffset);
                    if (beer.Points > 0)
                    {
                        DrawPoints(rectangle, topCursor, canvas, beer, boldBaseFont);
                    }
                    if (beer.Barrel)
                    {
                        DrawBarrel(rectangle, topCursor, canvas);
                    }
                    if (beer.Hops)
                    {
                        DrawHops(rectangle, topCursor, canvas);
                    }
                    if (!string.IsNullOrEmpty(beer.GoldLabelImageName))
                    {
                        DrawGoldLabel(rectangle, topCursor, canvas, beer);
                    }

                    DrawBeerName(rectangle, topCursor, canvas, beer, baseFont);
                }
            }).ToList();

            var drawActionRectangleQueue = new Queue <Action <PdfContentByte, Rectangle> >(drawActionRectangles);

            return(PdfGenerator.DrawRectangles(
                       drawActionRectangleQueue,
                       BaseColor.WHITE));
        }
예제 #12
0
        public static byte[] CreateLabels()
        {
            var garamond     = Path.Combine(CurrentPath, "Fonts", "GARA.TTF");
            var garamondBold = Path.Combine(CurrentPath, "Fonts", "GARABD.TTF");
            var font         = PdfFontFactory.CreateFont(garamond, true);
            var boldFont     = PdfFontFactory.CreateFont(garamondBold, true);

            var beers                = GetBeers();
            var labelBackground      = new DeviceRgb(254, 246, 229);
            var drawActionRectangles = beers.SelectMany(beer => new List <Action <PdfCanvas, Rectangle> >
            {
                (canvas, rectangle) =>
                {
                    TextSharpHelpers.DrawRectangle(canvas, rectangle, labelBackground);
                    //name
                    //gold label
                    const float startOfLabelOffset = 4f;
                    var topCursor = new Cursor();
                    topCursor.AdvanceCursor(rectangle.GetTop() - startOfLabelOffset);
                    if (beer.Points > 0)
                    {
                        DrawPoints(rectangle, topCursor, canvas, beer, boldFont);
                    }
                    if (beer.Barrel)
                    {
                        DrawBarrel(rectangle, topCursor, canvas);
                    }
                    if (beer.Hops)
                    {
                        DrawHops(rectangle, topCursor, canvas);
                    }
                    if (!string.IsNullOrEmpty(beer.GoldLabelImageName))
                    {
                        DrawGoldLabel(rectangle, topCursor, canvas, beer);
                    }

                    DrawBeerName(rectangle, topCursor, canvas, beer, font);
                }
            }).ToList();

            var drawActionRectangleQueue = new Queue <Action <PdfCanvas, Rectangle> >(drawActionRectangles);

            return(PdfGenerator.DrawRectangles(
                       drawActionRectangleQueue,
                       ColorConstants.WHITE));
        }
        private static void DrawCardText(Rectangle rectangle, Cursor topCursor, Cursor bottomCursor,
                                         PdfContentByte canvas, string cardName, BaseFont baseFont, CardSuperType cardSuperType)
        {
            const float textPadding         = 2f;
            const float textHeight          = 12f;
            const float maxFontSize         = 10f;
            var         textRectangleHeight = topCursor.GetCurrent() - bottomCursor.GetCurrent() - textPadding * 2;
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, cardName, textRectangleHeight, baseFont, maxFontSize, Element.ALIGN_LEFT, Font.NORMAL);
            var         font            = GetMainTextFont(baseFont, textFontSize, cardSuperType);
            var         textWidthOffset = 8 + (maxFontSize - font.Size) * .35f;
            var         textRectangle   = new Rectangle(
                rectangle.Left + textWidthOffset,
                bottomCursor.GetCurrent() + textPadding,
                rectangle.Left + textWidthOffset + textHeight,
                topCursor.GetCurrent() - textPadding);

            DrawText(canvas, cardName, textRectangle, 0, 0, font);
        }
        private static void DrawBeerName(Rectangle rectangle, Cursor topCursor, PdfContentByte canvas, Beer beer,
                                         BaseFont baseFont)
        {
            var textRectangle         = new Rectangle(rectangle.Left, rectangle.Bottom, rectangle.Right, topCursor.GetCurrent());
            var templateTextRectangle = new Rectangle(textRectangle.Height, textRectangle.Width);
            var template = canvas.CreateTemplate(templateTextRectangle.Width, templateTextRectangle.Height);
            var fontSize = TextSharpHelpers.GetMultiLineFontSize(canvas, beer.FullName, templateTextRectangle, baseFont, 12,
                                                                 Element.ALIGN_LEFT, Font.NORMAL) - .5f;
            var textFont = new Font(baseFont, fontSize, Font.NORMAL, BaseColor.BLACK);

            TextSharpHelpers.WriteWrappingTextInRectangle(template, beer.FullName, textFont, templateTextRectangle,
                                                          Element.ALIGN_LEFT);
            var angle = Math.PI / 2;

            canvas.AddTemplate(template,
                               (float)Math.Cos(angle), -(float)Math.Sin(angle),
                               (float)Math.Sin(angle), (float)Math.Cos(angle),
                               textRectangle.Left, textRectangle.Top);
        }
예제 #15
0
        private static void DrawSetText(
            Rectangle rectangle,
            Cursor topCursor,
            Cursor bottomCursor,
            PdfCanvas canvas,
            string heroName,
            PdfFont font)
        {
            const float maxFontSize = 4f;
            var         potentialTextRectangleHeight = topCursor.GetCurrent() - bottomCursor.GetCurrent(); // - textPadding * 2
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, heroName, potentialTextRectangleHeight, font, maxFontSize);
            var         textRectangleHeight = textFontSize * .9f;
            var         textWidthOffset     = 2f;
            var         textRectangle       = new Rectangle(
                rectangle.GetLeft() + textWidthOffset,
                bottomCursor.GetCurrent(),
                textRectangleHeight,
                topCursor.GetCurrent() - bottomCursor.GetCurrent());

            DrawText(canvas, heroName, textRectangle, -1f, 0, font, ColorConstants.BLACK, textFontSize);
        }
        private static void DrawSetText(
            Rectangle rectangle,
            Cursor topCursor,
            Cursor bottomCursor,
            PdfContentByte canvas,
            string heroName,
            BaseFont baseFont)
        {
            const float maxFontSize = 4f;
            var         potentialTextRectangleHeight = topCursor.GetCurrent() - bottomCursor.GetCurrent(); // - textPadding * 2
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, heroName, potentialTextRectangleHeight, baseFont, maxFontSize, Element.ALIGN_LEFT, Font.NORMAL);
            var         font                = new Font(baseFont, textFontSize, Font.NORMAL, BaseColor.BLACK);
            var         textRectangleHeight = textFontSize * .9f;
            var         textWidthOffset     = 2f;
            var         textRectangle       = new Rectangle(
                rectangle.Left + textWidthOffset,
                bottomCursor.GetCurrent(),
                rectangle.Left + textWidthOffset + textRectangleHeight,
                topCursor.GetCurrent());

            DrawText(canvas, heroName, textRectangle, 0, 0, font);
        }
예제 #17
0
        private static void DrawName(
            PdfCanvas canvas,
            Rectangle rectangle,
            string name,
            PdfFont font,
            CenteringCursor centeringCursor
            )
        {
            const float maxFontSize = 10f;
            var         potentialTextRectangleHeight = centeringCursor.GetCurrentStartWithCentering() - centeringCursor.GetCurrentEndWithCentering();
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, name, potentialTextRectangleHeight, font, maxFontSize);
            var         textRectangleHeight = textFontSize * .9f;

            var textWidthOffsetToCenter            = (rectangle.GetWidth() / 2.0f - textRectangleHeight / 2.0f) - 3f;
            var extraWidthOffsetForBackgroundImage = textFontSize / 3;
            var textRectangle = new Rectangle(
                rectangle.GetLeft() + textWidthOffsetToCenter + extraWidthOffsetForBackgroundImage,
                centeringCursor.GetCurrentEndWithCentering(),
                textWidthOffsetToCenter + extraWidthOffsetForBackgroundImage + textRectangleHeight,
                potentialTextRectangleHeight);

            DrawCenteredText(canvas, name, textRectangle, font, ColorConstants.BLACK, textFontSize, FontWeight.Regular);
        }
        private static void DrawName(
            PdfContentByte canvas,
            Rectangle rectangle,
            string name,
            BaseFont baseFont,
            CenteringCursor centeringCursor
            )
        {
            const float maxFontSize = 15f;
            var         potentialTextRectangleHeight = centeringCursor.GetCurrentStartWithCentering() - centeringCursor.GetCurrentEndWithCentering();
            var         textFontSize        = TextSharpHelpers.GetFontSize(canvas, name, potentialTextRectangleHeight, baseFont, maxFontSize, Element.ALIGN_LEFT, Font.NORMAL);
            var         font                = new Font(baseFont, textFontSize, Font.NORMAL, BaseColor.BLACK);
            var         textRectangleHeight = textFontSize * .9f;

            var textWidthOffsetToCenter            = (rectangle.Width / 2.0f - textRectangleHeight / 2.0f);
            var extraWidthOffsetForBackgroundImage = textFontSize / 3;
            var textRectangle = new Rectangle(
                rectangle.Left + textWidthOffsetToCenter + extraWidthOffsetForBackgroundImage,
                centeringCursor.GetCurrentEndWithCentering(),
                rectangle.Left + textWidthOffsetToCenter + extraWidthOffsetForBackgroundImage + textRectangleHeight,
                centeringCursor.GetCurrentStartWithCentering());

            DrawCenteredText(canvas, name, textRectangle, font);
        }
        private static void DrawCenteredText(PdfContentByte canvas, string text, Rectangle rectangle, Font font)
        {
            const int textRotation = 270;

            TextSharpHelpers.WriteCenteredNonWrappingTextInRectangle(canvas, text, rectangle, font, textRotation);
        }
예제 #20
0
        public static byte[] CreateLabels(IEnumerable <Expansion> selectedExpansions, bool includeSpecialSetupCards)
        {
            var allHeroes        = DataAccess.GetHeroCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(heroCardSet => heroCardSet.Heroes);
            var allMasterminds   = DataAccess.GetMastermindCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(mastermindCardSet => mastermindCardSet.Masterminds);
            var allVillains      = DataAccess.GetVillainCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(villainCardSet => villainCardSet.Villains);
            var allHenchmen      = DataAccess.GetHenchmenCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(henchmenCardSet => henchmenCardSet.Henchmen);
            var allStartingCards = DataAccess.GetStartingCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(startingCardSet => startingCardSet.StartingCards);
            var allSetupCards    = DataAccess.GetSetupCardSets()
                                   .Where(set => selectedExpansions.Contains(set.Expansion))
                                   .SelectMany(setupCardSet => setupCardSet.SetupCards)
                                   .Where(setupCard => includeSpecialSetupCards || !setupCard.IsSpecialCard);
            var allVillainSetupCards = DataAccess.GetVillainSetupCardSets().Where(set => selectedExpansions.Contains(set.Expansion)).SelectMany(setupCardSet => setupCardSet.VillainSetupCards);

            var mastermindBaseColor       = new DeviceRgb(255, 61, 83);
            var villainBaseColor          = new DeviceRgb(255, 102, 119);
            var henchmenBaseColor         = new DeviceRgb(255, 173, 182);
            var startingCardBaseColor     = new DeviceRgb(200, 200, 200);
            var setupCardBaseColor        = new DeviceRgb(35, 255, 39);
            var villainSetupCardBaseColor = new DeviceRgb(255, 73, 197);

            var fontPath        = Path.Combine(CurrentPath, "Fonts", "KOMIKAX.TTF");
            var font            = PdfFontFactory.CreateFont(fontPath, true);
            var drawHeroActions = allHeroes.Select(hero => new Action <PdfCanvas, Rectangle>(
                                                       (canvas, rectangle) =>
            {
                var topCursor    = new Cursor();
                var bottomCursor = new Cursor();
                const float startOfLabelOffset = 4f;
                topCursor.AdvanceCursor(rectangle.GetTop() - startOfLabelOffset);
                bottomCursor.AdvanceCursor(rectangle.GetBottom() + startOfLabelOffset);
                TextSharpHelpers.DrawRoundedRectangle(canvas, rectangle, new DeviceRgb(168, 255, 247));

                DrawFactionsAndTypes(hero, rectangle, canvas, topCursor, bottomCursor);

                DrawCardText(rectangle, topCursor, bottomCursor, canvas, hero.Name, font);
                DrawSetText(rectangle, topCursor, bottomCursor, canvas, hero.Expansion.GetExpansionName(), font);
            }
                                                       )).ToList();
            var drawMastermindActions = allMasterminds.Select(mastermind =>
                                                              CreateActionToDrawNameAndSet(
                                                                  mastermind.Name,
                                                                  mastermind.Expansion.GetExpansionName(),
                                                                  font,
                                                                  mastermindBaseColor
                                                                  ));
            var drawVillainActions = allVillains.Select(villain =>
                                                        CreateActionToDrawNameAndSet(
                                                            villain.Name,
                                                            villain.Expansion.GetExpansionName(),
                                                            font,
                                                            villainBaseColor
                                                            ));
            var drawHenchmenActions = allHenchmen.Select(henchmen =>
                                                         CreateActionToDrawNameAndSet(
                                                             henchmen.Name,
                                                             henchmen.Expansion.GetExpansionName(),
                                                             font,
                                                             henchmenBaseColor
                                                             ));
            var drawStartingCardsActions = allStartingCards.Select(startingCard =>
                                                                   CreateActionToDrawNameAndSet(
                                                                       startingCard.Name,
                                                                       startingCard.Expansion.GetExpansionName(),
                                                                       font,
                                                                       startingCardBaseColor
                                                                       ));
            var drawSetupCardsActions = allSetupCards.Select(setupCard =>
                                                             CreateActionToDrawNameAndSet(
                                                                 setupCard.Name,
                                                                 setupCard.Expansion.GetExpansionName(),
                                                                 font,
                                                                 setupCardBaseColor
                                                                 ));
            var drawVillainSetupCardsActions = allVillainSetupCards.Select(villainSetupCard =>
                                                                           CreateActionToDrawNameAndSet(
                                                                               villainSetupCard.Name,
                                                                               villainSetupCard.Expansion.GetExpansionName(),
                                                                               font,
                                                                               villainSetupCardBaseColor
                                                                               ));


            var allActions = drawHeroActions
                             .Concat(drawMastermindActions)
                             .Concat(drawVillainActions)
                             .Concat(drawHenchmenActions)
                             .Concat(drawStartingCardsActions)
                             .Concat(drawSetupCardsActions)
                             .Concat(drawVillainSetupCardsActions);

            var drawActionRectangleQueue = new Queue <Action <PdfCanvas, Rectangle> >(allActions);

            return(PdfGenerator.DrawRectangles(drawActionRectangleQueue, ColorConstants.WHITE));
        }