C# XML.ProjectLayoutElement类代码示例

 protected override ElementString TranslateToElementString(string sRawString, int nCardIndex, DeckLine zDeckLine, ProjectLayoutElement zElement)
 {
     using (var engine = new V8ScriptEngine())
     {
         var sScript = GetJavaScript(nCardIndex, zDeckLine, sRawString);
         try
         {
             var sValue = engine.Evaluate(sScript);
             if (sValue is string || sValue is int)
             {
                 return new ElementString()
                 {
                     String = sValue.ToString()
                 };
             }
             else
             {
                 Logger.AddLogLine(sValue.GetType().ToString());
             }
         }
         catch (Exception e)
         {
             Logger.AddLogLine(e.Message);
         }
     }
     return new ElementString()
     {
         String = string.Empty
     };
 }

        protected float GetLargestMarkupHeight(ProjectLayoutElement zElement, List<MarkupBase> listMarkups)
        {
            if (0 == listMarkups.Count)
            {
                return 0;
            }

            var zLastMarkup = listMarkups[listMarkups.Count - 1];
            var nLineNumber = zLastMarkup.LineNumber;
            // find the largest total height on the last row (inclusive of the Y position)
            var fLargestTotal = zLastMarkup.TargetRect.Y + zLastMarkup.TargetRect.Height;
            var nIdx = listMarkups.Count - 2;
            while (nIdx > -1)
            {
                var zMarkup = listMarkups[nIdx];
                if (nLineNumber == zMarkup.LineNumber)
                {
                    fLargestTotal = Math.Max(fLargestTotal, zMarkup.TargetRect.Y + zMarkup.TargetRect.Height);
                }
                else
                {
                    break;
                }
                nIdx--;
            }
            return fLargestTotal;
        }

        public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
        {
            MarkupToClose.CloseMarkup(zData, zProcessData, zGraphics);

            // keep only the necessary markups
            return s_dictionaryKeepTypesOnProcess.ContainsKey(MarkupToClose.GetType());
        }

        public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
        {
            var arrayComponents = m_sVariable.Split(new char[] { ';' });
            if (1 > arrayComponents.Length)
            {
                return false;
            }

            int nXPush;
            if (!int.TryParse(arrayComponents[0], out nXPush))
            {
                return false;
            }

            var nYPush = 0;
            if (2 <= arrayComponents.Length)
            {
                if (!int.TryParse(arrayComponents[1], out nYPush))
                {
                    return false;
                }
            }

            zProcessData.CurrentX += nXPush;
            zProcessData.CurrentY += nYPush;
            if (zProcessData.CurrentX > zElement.width)
            {
                zProcessData.MoveToNextLine(zElement);
            }

            return false;
        }

        public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
        {
            int nSpaces;
            if (!int.TryParse(m_sVariable, out nSpaces))
            {
                return false;
            }

            LineNumber = zProcessData.CurrentLine;

            float fWidth = (float)nSpaces * ((float)zProcessData.FontSpaceWidth + (float)zElement.wordspace);

            if (0 == fWidth)
            {
                return false;
            }

            if (zProcessData.CurrentX + fWidth >= zElement.width)
            {
                if (Optional)
                {
                    return false;
                }
                zProcessData.MoveToNextLine(zElement);
            }

            TargetRect = new RectangleF(zProcessData.CurrentX, zProcessData.CurrentY, fWidth, zProcessData.FontSpaceHeight);

            zProcessData.CurrentX += fWidth;
            return true;
        }

        private static void DrawGraphic(Graphics zGraphics, string sFile, ProjectLayoutElement zElement)
        {
            string sPath = sFile;
            if (sPath.Equals("none", StringComparison.CurrentCultureIgnoreCase))
            {
                return;
            }
            if (!File.Exists(sPath))
            {
                sPath = CardMakerMDI.ProjectPath + sFile;
            }
            if (File.Exists(sPath))
            {
                var zBmp = 255 != zElement.opacity
                    ? LoadOpacityImageFromCache(sPath, zElement)
                    : LoadImageFromCache(sPath);

                int nWidth = zElement.width;
                int nHeight = zElement.height;

                if (zElement.keeporiginalsize)
                {
                    DrawGraphicOriginalSize(zGraphics, zBmp, zElement);
                    return;
                }

                if (zElement.lockaspect)
                {
                    var fAspect = (float)zBmp.Tag;

                    var nTargetHeight = (int)((float)nWidth / fAspect);
                    if (nTargetHeight < nHeight)
                    {
                        nHeight = (int)((float)nWidth / fAspect);
                    }
                    else
                    {
                        nWidth = (int)((float)nHeight * fAspect);
                    }
                }

                int nX = 0;
                int nY = 0;

                // standard alignment adjustment
                UpdateAlignmentValue(zElement.horizontalalign, ref nX, zElement.width, nWidth);
                UpdateAlignmentValue(zElement.verticalalign, ref nY, zElement.height, nHeight);

                zGraphics.DrawImage(zBmp, nX, nY, nWidth, nHeight);

            }
            else
            {
                MDIIssues.Instance.AddIssue("Image file not found: " + sFile);
            }
            // draw nothing
        }

        public override float GetVerticalAlignOffset(ProjectLayoutElement zElement, List<MarkupBase> listMarkups)
        {
            if (0 == listMarkups.Count)
            {
                return 0;
            }

            return (((float)zElement.height - GetLargestMarkupHeight(zElement, listMarkups))) / 2f;
        }

 public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
 {
     float fNewSize;
     if (float.TryParse(m_sVariable, out fNewSize) && fNewSize > 0)
     {
         m_zPreviousFont = zProcessData.Font;
         zProcessData.SetFont(new Font(zProcessData.Font.FontFamily, fNewSize, zProcessData.Font.Style), zGraphics);
     }
     return false;
 }

 public static void DrawElementDebugBorder(Graphics zGraphics, ProjectLayoutElement zElement, int nX, int nY, bool bSelected)
 {
     // note that the border is inclusive in the width/height consuming 2 pixels (0 to total-1)
     zGraphics.TranslateTransform(nX, nY);
     zGraphics.DrawRectangle(s_zPenDebugBorder, zElement.x, zElement.y, zElement.width - 1, zElement.height - 1);
     if (bSelected)
     {
         zGraphics.DrawRectangle(m_zPenElementSelect, zElement.x - 2, zElement.y - 2, zElement.width + 3, zElement.height + 3);
     }
 }

 public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
 {
     float fYOffset;
     if (float.TryParse(m_sVariable, out fYOffset))
     {
         m_fPreviousOffset = zProcessData.CurrentYOffset;
         zProcessData.CurrentYOffset = fYOffset;
     }
     return false;
 }

 /// <summary>
 /// Updates the position of the markups based on horizontal alignment
 /// </summary>
 /// <param name="nFirst"></param>
 /// <param name="nLast"></param>
 /// <param name="bLastLine"></param>
 /// <param name="zElement"></param>
 /// <param name="listMarkups">List of Markups (all must have Aligns set to true)</param>
 /// <param name="fVerticalOffset">Any vertical offset to apply</param>
 /// <param name="listAllMarkups"></param>
 public virtual void UpdateLineAlignment(int nFirst, int nLast, bool bLastLine, ProjectLayoutElement zElement,
     List<MarkupBase> listMarkups, float fVerticalOffset, IEnumerable<MarkupBase> listAllMarkups)
 {
     var fHorizontalOffset = GetHorizontalOffset(zElement, listMarkups[nLast].TargetRect);
     for (var nIdx = nFirst; nIdx <= nLast; nIdx++)
     {
         var rectCurrent = listMarkups[nIdx].TargetRect;
         listMarkups[nIdx].TargetRect = new RectangleF(rectCurrent.X + fHorizontalOffset, rectCurrent.Y + fVerticalOffset, rectCurrent.Width, rectCurrent.Height);
     }
 }

 public override bool ProcessMarkup(ProjectLayoutElement zElement, FormattedTextData zData, FormattedTextProcessData zProcessData, Graphics zGraphics)
 {
     var zNewFont = ProjectLayoutElement.TranslateFontString(m_sVariable);
     if (zNewFont != null)
     {
         m_zPreviousFont = zProcessData.Font;
         zProcessData.SetFont(zNewFont, zGraphics);
         return true;
     }
     return false;
 }

 public void Render(ProjectLayoutElement zElement, Graphics zGraphics)
 {
     foreach (var zRenderType in s_zTypeRenderOrder)
     {
         foreach (var zMarkup in m_dictionaryTypeMarkupList[zRenderType])
         {
             if (!zMarkup.Render(zElement, zGraphics))
             {
                 RenderLackOfSpaceWarning(zElement, zGraphics);
             }
         }
     }         
 }

        public override void UpdateLineAlignment(int nFirst, int nLast, bool bLastLine, ProjectLayoutElement zElement, List<MarkupBase> listMarkups, float fVerticalOffset, IEnumerable<MarkupBase> listAllMarkups)
        {
            // detect if this is the last line of markups - if so don't bother with jusity alignment
            if (bLastLine)
            {
                base.UpdateLineAlignment(nFirst, nLast, bLastLine, zElement, listMarkups, fVerticalOffset, listAllMarkups);
                return;
            }
            // detect if this line is followed by a line break - if so don't bother with justify alignment on this line
            var lastLineMarkup = listMarkups[nLast];
            var theBigList = listAllMarkups.ToList();
            var lastLineMarkupIndex = theBigList.IndexOf(lastLineMarkup);
            for (var nIdx = lastLineMarkupIndex + 1; nIdx < theBigList.Count; nIdx++)
            {
                if (theBigList[nIdx] is NewlineMarkup)
                {
                    // no justified alignment due to this line ending with an explicit line break
                    base.UpdateLineAlignment(nFirst, nLast, bLastLine, zElement, listMarkups, fVerticalOffset, listAllMarkups);
                    return;
                }
                if (theBigList[nIdx].Aligns)
                {
                    // the next rendered thing aligns so treat this line as though it is part of a paragraph
                    break;
                }
                // default to justify alignment
            }

            // TODO: the space markups are completely ignored by justified (who cares?)
            var listTextMarkups = listMarkups.GetRange(nFirst, (nLast - nFirst) + 1).Where(zMarkup => !(zMarkup is SpaceMarkup)).ToList();
            var fTotalTextWidth = listTextMarkups.Sum(zMarkup => zMarkup.TargetRect.Width);
            var fDifference = (float)zElement.width - fTotalTextWidth;

            var fXOffset = fDifference / ((float)listTextMarkups.Count - 1);

            //Logger.AddLogLine("TotalTextWidth: {0} Difference: {1} SpaceSize: {2} listTextMarkups: {3}".FormatString(fTotalTextWidth, fDifference, fXOffset, listTextMarkups.Count));
            var fCurrentPosition = listMarkups[nFirst].TargetRect.X;
            for (var nIdx = nFirst; nIdx <= nLast; nIdx++)
            {
                if (listMarkups[nIdx].Aligns && !(listMarkups[nIdx] is SpaceMarkup))
                {
                    var rectCurrent = listMarkups[nIdx].TargetRect;
                    listMarkups[nIdx].TargetRect = new RectangleF(fCurrentPosition,
                        rectCurrent.Y + fVerticalOffset, rectCurrent.Width, rectCurrent.Height);
                    fCurrentPosition += listMarkups[nIdx].TargetRect.Width + fXOffset;
                }
            }
        }

 public override bool Render(ProjectLayoutElement zElement, Graphics zGraphics)
 {
     // Custom Graphics Setting
     // disable smoothing so the background color has a sharp edge
     SmoothingMode ePreviousSmoothingMode = zGraphics.SmoothingMode;
     zGraphics.SmoothingMode = SmoothingMode.None;
     foreach (var rect in m_listRectangles)
     {
         var rectAdjusted = rect;
         // do not draw any rectangles outside of the element
         rectAdjusted.Height = Math.Min(rect.Bottom - rect.Top, zElement.y + zElement.height);
         zGraphics.FillRectangle(m_zBrush, rectAdjusted);
     }
     zGraphics.SmoothingMode = ePreviousSmoothingMode;
     return true;
 }