自定义逻辑封装SyntaxHighlighter实现代码高亮

2017-02-01 11:41:33  访问(3896) 赞(0) 踩(0)

  • <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="WebPages_EkWeb_WebForms_WebPages_Common_ViewSrc_Default" %>

 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>
        <%=WebPageTitle%></title>
    <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
    <meta name="description" content="<%=MetaDescription %>" />
    <meta name="keywords" content="<%=MetaKeywords %>" />
    <link href="<%=EkWebPhyPath%>/Styles/style.css" rel="stylesheet" />
    <link href="<%=EkWebPhyPath%>/Styles/ek.css" rel="stylesheet" />
    <%=SrcHead%>
</head>
<body>
    <form id="form2" runat="server">
    <table border="0" cellpadding="0" width="100%" cellspacing="0" class="frm">
        <tr>
            <td style="background-color: #ECECEC">
                &nbsp;<b><%=SrcTheName%></b>
                <%=RefreshPageHref %>
            </td>
        </tr>
        <tr>
            <td>
                <%=SrcText%>
            </td>
        </tr>
    </table>
    <%=SrcEnd%>
    </form>
</body>
</html>



  • SrcTheName = model.TheName;

SyntaxHighlighterItem
sItem = new SyntaxHighlighterItem();

sItem.ItemIdSet(model.ID);
sItem.CodeText = model.CodeText;
sItem.EmHighlighterLanguageSet(model.TheName);

SrcHead = sItem.PrintHead(strPhyPath);
SrcText = sItem.PrintCodeText();
SrcEnd = sItem.PrintEnd(strPhyPath);

  • 

/*

无 = 1
CSharp
PHP 
JavaScript 
Java 
Vb 
Sql 
Xml 
Delphi 
Python 
Ruby 
CSS 
C

*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Reflection;

namespace SlowX.Utils.Enums
{
    /// <summary>
    /// 代码高亮语音
    /// </summary>
    [Serializable]
    public partial class HighlighterLanguage
    {
        /// <summary>
        /// $Em.HighlighterLanguage
        /// </summary>
        public const string _SortClassName = "$Em.HighlighterLanguage";

        #region 枚举 显示表达式

        /// <summary>
        /// 显示表达式
        /// </summary>
        public enum EmShowExpress
        {
            
            /// <summary>
            /// 默认
            /// </summary>
            默认 = 1
        }

        #endregion 枚举 显示表达式

        #region Enum

        /// <summary>
        /// 代码高亮语音
        /// </summary>
        public enum EmHighlighterLanguage
        {

            /// <summary>
            /// 无
            /// </summary>
            无 = 1,
            /// <summary>
            /// CSharp
            /// </summary>
            CSharp,
            /// <summary>
            /// PHP
            /// </summary>
            PHP,
            /// <summary>
            /// JavaScript
            /// </summary>
            JavaScript,
            /// <summary>
            /// Java
            /// </summary>
            Java,
            /// <summary>
            /// Vb
            /// </summary>
            Vb,
            /// <summary>
            /// Sql
            /// </summary>
            Sql,
            /// <summary>
            /// Xml
            /// </summary>
            Xml,
            /// <summary>
            /// Delphi
            /// </summary>
            Delphi,
            /// <summary>
            /// Python
            /// </summary>
            Python,
            /// <summary>
            /// Ruby
            /// </summary>
            Ruby,
            /// <summary>
            /// CSS
            /// </summary>
            CSS,
            /// <summary>
            /// C
            /// </summary>
            C
        }

        #endregion Enum

        /// <summary>
        /// 构造函数
        /// </summary>
        public HighlighterLanguage()
        {

        }

        /// <summary>
        /// 数组
        /// </summary>
        public readonly static EmHighlighterLanguage[] EmArray = new EmHighlighterLanguage[]
        {
EmHighlighterLanguage.无,
EmHighlighterLanguage.CSharp,
EmHighlighterLanguage.PHP,
EmHighlighterLanguage.JavaScript,
EmHighlighterLanguage.Java,
EmHighlighterLanguage.Vb,
EmHighlighterLanguage.Sql,
EmHighlighterLanguage.Xml,
EmHighlighterLanguage.Delphi,
EmHighlighterLanguage.Python,
EmHighlighterLanguage.Ruby,
EmHighlighterLanguage.CSS,
EmHighlighterLanguage.C

        };


        /// <summary>
        /// typeof(HighlighterLanguage) 当前HighlighterLanguage的type值
        /// </summary>
        public readonly static Type curType = typeof(HighlighterLanguage);

        /// <summary>
        /// typeof(HighlighterLanguage).FullName 
        /// </summary>
        public readonly static string curTypeFullName = curType.FullName;


        /// <summary>
        /// typeof(EmHighlighterLanguage) 当前枚举EmHighlighterLanguage的type值
        /// </summary>
        public readonly static Type curEnumType = typeof(EmHighlighterLanguage);

        /// <summary>
        /// typeof(EmHighlighterLanguage).FullName
        /// </summary>
        public readonly static string curEnumTypeFullName = curEnumType.FullName;


        /// <summary>
        /// 默认的枚举值
        /// </summary>
        public static readonly EmHighlighterLanguage defaultEm = EmHighlighterLanguage.无;

        /// <summary>
        /// 默认的枚举值
        /// </summary>
        private static Dictionary<EmShowExpress, DataTable> dictionaryDataTableValue = CreateDataTable();

        /// <summary>
        /// 获得Text的数组
        /// </summary>
        /// <returns></returns>
        public static string[] GetTextArray()
        {
            EmHighlighterLanguage[] emA = EmArray;
            int iLen = emA.Length;
            string[] theResult = new string[iLen];

            for (int i = 0; i < iLen; ++i)
            {
                theResult[i] = emA[i].ToString();
            }

            return theResult;
        }

        /// <summary>
        /// 获得显示名称
        /// </summary>
        /// <param name="em"></param>
        /// <returns></returns>
        public static string GetShowName
            (
                EmHighlighterLanguage em
            )
        {
            return em.ToString();
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="em"></param>
        /// <param name="curEmShowExpress"></param>
        /// <returns></returns>
        public static string GetShowName
            (
                EmHighlighterLanguage em,
                EmShowExpress curEmShowExpress
            )
        {
                 
            if (curEmShowExpress == EmShowExpress.默认)
                return em.ToString();
            else
                return em.ToString();

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strValues"></param>
        /// <param name="valueLinkChar"></param>
        /// <param name="textLinkChar"></param>
        /// <returns></returns>
        public static string GetShowNames
            (
                string strValues,
                string valueLinkChar,
                string textLinkChar
            )
        {
            if (strValues == null || strValues.Length == 0)
                return "";

            string[] sArray = strValues.Split(valueLinkChar.ToCharArray());

            StringBuilder theResult = new StringBuilder();
            bool isFirst = true;

            foreach (string s in sArray)
            {
                if (s == null || s.Length == 0)
                    continue;

                if (isFirst)
                {
                    isFirst = false;
                }
                else
                {
                    theResult.Append(textLinkChar);
                }

                theResult.Append
                    (
                        GetShowName
                            (
                                GetEmByString(s) 
                            )
                    );
            }

            return theResult.ToString();
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="strValues"></param>
        /// <param name="valueLinkChar"></param>
        /// <param name="textLinkChar"></param>
        /// <returns></returns>
        public static string GetShowNames
            (
                string strValues,
                string valueLinkChar,
                string textLinkChar,
                EmShowExpress curEmShowExpress
            )
        {
            if (strValues == null || strValues.Length == 0)
                return "";

            string[] sArray = strValues.Split(valueLinkChar.ToCharArray());

            StringBuilder theResult = new StringBuilder();
            bool isFirst = true;

            foreach (string s in sArray)
            {
                if (s == null || s.Length == 0)
                    continue;

                if (isFirst)
                {
                    isFirst = false;
                }
                else
                {
                    theResult.Append(textLinkChar);
                }

                theResult.Append
                    (
                        GetShowName
                            (
                                GetEmByString(s),
                                curEmShowExpress
                            )
                    );
            }

            return theResult.ToString();
        }

        /// <summary>
        /// 创建数据表
        /// </summary>
        /// <returns></returns>
        private static Dictionary<EmShowExpress, DataTable> CreateDataTable()
        {
            Dictionary<EmShowExpress, DataTable> theResult = new Dictionary<EmShowExpress, DataTable>();

            theResult.Add(EmShowExpress.默认, CreateDataTableByEmShowExpress(EmShowExpress.默认));


            return theResult;
        }

        /// <summary>
        /// 创建数据表
        /// </summary>
        /// <param name="curEmShowExpress"></param>
        /// <returns></returns>
        private static DataTable CreateDataTableByEmShowExpress(EmShowExpress curEmShowExpress)
        {
            DataTable dt = new DataTable();

            dt.Columns.Add("ID", typeof(int));
            dt.Columns.Add("TheName");

            EmHighlighterLanguage[] emA = EmArray;

            DataRow dr = null;

            foreach (EmHighlighterLanguage em in emA)
            {
                dr = dt.NewRow();

                dt.Rows.Add(dr);

                dr["ID"] = (int)em;
                dr["TheName"] = GetShowName(em, curEmShowExpress);
            }

            return dt;
        }

        /// <summary>
        /// 获得DataTable
        /// </summary>
        /// <returns></returns>
        public static DataTable ReturnDataTable()
        {
            return dictionaryDataTableValue[EmShowExpress.默认];
        }

        /// <summary>
        /// 获得DataTable
        /// </summary>
        /// <returns></returns>
        public static DataTable GetDataTable()
        {
            return dictionaryDataTableValue[EmShowExpress.默认];
        }

        /// <summary>
        /// 获得DataTable
        /// </summary>
        /// <param name="curEmShowExpress"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(EmShowExpress curEmShowExpress)
        {
            return dictionaryDataTableValue[curEmShowExpress];
        }

        /// <summary>
        /// 获得数据集
        /// </summary>
        /// <param name="fromCache"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(bool fromCache)
        {
            if (fromCache)
                return dictionaryDataTableValue[EmShowExpress.默认];
            else
                return CreateDataTableByEmShowExpress(EmShowExpress.默认);
        }


        /// <summary>
        /// 获得数据集
        /// </summary>
        /// <param name="curEmShowExpress"></param>
        /// <param name="fromCache"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(EmShowExpress curEmShowExpress,bool fromCache)
        {
            if (fromCache)
                return dictionaryDataTableValue[curEmShowExpress];
            else
                return CreateDataTableByEmShowExpress(curEmShowExpress);
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByInt(int theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (int)em)
                    return em;
            }

            MethodBase methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue = " + theValue.ToString() + "没有找到对应的枚举值。");
        }


        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByLong(long theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (long)em)
                    return em;
            }

            MethodBase methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue = " + theValue.ToString() + "没有找到对应的枚举值。");
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByString(string theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == ((int)em).ToString())
                    return em;
            }

            MethodBase methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue = " + theValue.ToString() + "没有找到对应的枚举值。");

        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByObj(object theValue)
        {
            MethodBase methodBaseValue = null;

            if (theValue == null)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue为null，没有找到对应的枚举值。");
            }

            if (theValue is EmHighlighterLanguage)
                return (EmHighlighterLanguage)theValue;

            string strValue = theValue.ToString();

            if (strValue.Length == 0)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue为空，没有找到对应的枚举值。");
            }


            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (strValue == ((int)em).ToString())
                    return em;
            }

            methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue = " + strValue.ToString() + "没有找到对应的枚举值。");
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByInt(int theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (int)em)
                    return em;
            }

            return defaultEm;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByLong(long theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (long)em)
                    return em;
            }

            return defaultEm;
        }


        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByString(string theValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == ((int)em).ToString())
                    return em;
            }

            return defaultEm;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByObj(object theValue)
        {
            if (theValue == null)
                return defaultEm;

            if (theValue is EmHighlighterLanguage)
                return (EmHighlighterLanguage)theValue;

            string strValue = theValue.ToString();

            if (strValue.Length == 0)
                return defaultEm;

            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (strValue == ((int)em).ToString())
                    return em;
            }

            return defaultEm;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByInt(int theValue, EmHighlighterLanguage defaultValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (int)em)
                    return em;
            }

            return defaultValue;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByLong(long theValue, EmHighlighterLanguage defaultValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == (long)em)
                    return em;
            }

            return defaultValue;
        }


        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByString(string theValue, EmHighlighterLanguage defaultValue)
        {
            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theValue == ((int)em).ToString())
                    return em;
            }

            return defaultValue;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByObj(object theValue, EmHighlighterLanguage defaultValue)
        {
            if (theValue == null)
                return defaultValue;

            string strValue = theValue.ToString();

            if (strValue.Length == 0)
                return defaultValue;

            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (strValue == ((int)em).ToString())
                    return em;
            }

            return defaultValue;
        }

        /// <summary>
        /// 获得 Text 获得 EmHighlighterLanguage 
        /// </summary>
        /// <param name="theText"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByText(string theText)
        {
            MethodBase methodBaseValue = null;

            if (theText == null)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theText为null，没有找到对应的枚举值。");
            }

            if (theText.Length == 0)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theText为空，没有找到对应的枚举值。");
            }

            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theText == (em).ToString())
                    return em;
            }

            methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theText = " + theText.ToString() + "没有找到对应的枚举值。");
        }


        /// <summary>
        /// 获得 Text 获得 EmHighlighterLanguage 
        /// </summary>
        /// <param name="theText"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByText(string theText, EmHighlighterLanguage defaultValue)
        {
            if (theText == null)
                return defaultValue;

            if (theText.Length == 0)
                return defaultValue;

            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (theText == (em).ToString())
                    return em;
            }

            return defaultValue;
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param> 
        /// <returns></returns>
        public static EmHighlighterLanguage GetEmByAllObj(object theValue)
        {
            MethodBase methodBaseValue = null;

            if (theValue == null)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue为null，没有找到对应的枚举值。");
            }

            if (theValue is EmHighlighterLanguage)
                return (EmHighlighterLanguage)theValue;

            string strValue = theValue.ToString();

            if (strValue.Length == 0)
            {
                methodBaseValue = MethodBase.GetCurrentMethod();

                throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue为空，没有找到对应的枚举值。");
            }


            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (strValue == ((int)em).ToString() || strValue == em.ToString())
                    return em;
            }

            methodBaseValue = MethodBase.GetCurrentMethod();

            throw new Exception("Method :==> " + methodBaseValue.ReflectedType.FullName + " ~ " + methodBaseValue.ToString() + " Exception :==> " + "theValue = " + strValue.ToString() + "没有找到对应的枚举值。");
        
        }

        /// <summary>
        /// 获得枚举
        /// </summary>
        /// <param name="theValue"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static EmHighlighterLanguage GetDefaultEmByAllObj(object theValue, EmHighlighterLanguage defaultValue)
        {
            if (theValue == null)
                return defaultValue;

            string strValue = theValue.ToString();

            if (strValue.Length == 0)
                return defaultValue;

            EmHighlighterLanguage[] emA = EmArray;

            foreach (EmHighlighterLanguage em in emA)
            {
                if (strValue == ((int)em).ToString() || strValue == em.ToString())
                    return em;
            }

            return defaultValue;
        }

    }

        
}




  • using System;
using System.Collections.Generic;
using System.Text;

namespace SlowX.Utils.Ctrls.SyntaxHighlighter
{
    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    public class SyntaxHighlighterContainer
    {
        /// <summary>
        /// 
        /// </summary>
        public SyntaxHighlighterContainer()
        {
            m_ItemList = new List<SyntaxHighlighterItem>();
        }

        /// <summary>
        /// 
        /// </summary>
        protected List<SyntaxHighlighterItem> m_ItemList = null;

        /// <summary>
        /// 
        /// </summary>
        public List<SyntaxHighlighterItem> ItemList
        {
            get
            {
                return m_ItemList;
            }
            set
            {
                m_ItemList = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="item"></param>
        public void AddItem(SyntaxHighlighterItem item)
        {
            ItemList.Add(item);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public SyntaxHighlighterItem FindItem(string itemId)
        {
            List<SyntaxHighlighterItem> theList = ItemList;

            if (theList == null)
                return null;

            foreach (SyntaxHighlighterItem item in theList)
            {
                if (item == null)
                    continue;

                if (item.ItemId == itemId)
                    return item;
            }

            return null;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public SyntaxHighlighterItem FindItemByIndex(int idx)
        {
            List<SyntaxHighlighterItem> theList = ItemList;

            if (theList == null)
                return null;


            if (idx < 0 || idx >= theList.Count)
                return null;

            return theList[idx];
 
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public string PrintItem(string itemId)
        {
            SyntaxHighlighterItem item = FindItem(itemId);

            if (item == null)
                return "";

            return item.PrintCodeText();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public string PrintItem(int idx)
        {
            SyntaxHighlighterItem item = FindItemByIndex(idx);

            if (item == null)
                return "";

            return item.PrintCodeText();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public string PrintItemList()
        {
            List<SyntaxHighlighterItem> theList = ItemList;

            if (theList == null)
                return "";

            StringBuilder theResult = new StringBuilder();

            string strCodeText = null;

            foreach (SyntaxHighlighterItem item in theList)
            {
                if (item == null)
                    continue;

                if (!item.AutoPrint)
                    continue;

                strCodeText = item.PrintCodeText();

                theResult.AppendLine(strCodeText);

            }

            return theResult.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strPhyPath"></param>
        /// <returns></returns>
        public string PrintHead(string strPhyPath)
        {
            return "<link type=\"text/css\" rel=\"stylesheet\" href=\"" + strPhyPath + "/SyntaxHighlighter1v5/Styles/SyntaxHighlighter.css\" />";
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public List<string> ShBrushScriptListBuild()
        {
            List<string> theResult = new List<string>();

            List<SyntaxHighlighterItem> theList = ItemList;

            if (theList == null)
                return theResult;

            string strCodeText = null;

            foreach (SyntaxHighlighterItem item in theList)
            {
                if (item == null)
                    continue;

                strCodeText = item.ShBrushScriptGet();

                if (strCodeText == null || strCodeText.Length == 0)
                    continue;

                if (theResult.Contains(strCodeText))
                    continue;

                theResult.Add(strCodeText);
            }

            return theResult;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strPhyPath"></param>
        /// <returns></returns>
        public string PrintEnd(string strPhyPath)
        {
            List<SyntaxHighlighterItem> theList = ItemList;

            if (theList == null)
                return "";

            StringBuilder theResult = new StringBuilder();


            theResult.AppendLine(@"<script type=""text/javascript"" language=""javascript"" src=""" + strPhyPath + @"/SyntaxHighlighter1v5/Scripts/shCore.js""></script>");

            List<string> shList = ShBrushScriptListBuild();

            foreach (string s in shList)
            {
                theResult.AppendLine(@"<script type=""text/javascript"" language=""javascript"" src=""" + strPhyPath + @"/SyntaxHighlighter1v5/Scripts/" + s + @".js""></script>");
            }


            theResult.AppendLine(@"  
<script type=""text/javascript"" language=""javascript"">  
    dp.SyntaxHighlighter.ClipboardSwf = ""/Web/SyntaxHighlighter1v5/Scripts/clipboard.swf""; ");

            foreach (SyntaxHighlighterItem item in theList)
            {
                if (item == null)
                    continue;

                theResult.AppendLine(@"
    dp.SyntaxHighlighter.HighlightAll(""" + item.ItemId + @""");  
  ");
            }

            theResult.AppendLine(@"
</script> 
");

            return theResult.ToString();
        }
 
    }
}


  • using System;
using System.Collections.Generic;
using System.Text;

namespace SlowX.Utils.Ctrls.SyntaxHighlighter
{
    /// <summary>
    /// 
    /// </summary>
    [Serializable]
    public class SyntaxHighlighterItem
    {



        /// <summary>
        /// 
        /// </summary>
        public SyntaxHighlighterItem()
        {
            
        }


        #region ItemId ~ 高亮代码ID

        /// <summary>
        /// ItemId ~ 高亮代码ID
        /// </summary>
        protected string m_ItemId = null;

        /// <summary>
        /// ItemId ~ 高亮代码ID
        /// </summary>
        public string ItemId
        {
            get
            {
                return m_ItemId;
            }
            set
            {
                m_ItemId = value;
            }
        }

        #endregion ItemId ~ 高亮代码ID



        #region EmHighlighterLanguageV ~ 高亮语言

        /// <summary>
        /// EmHighlighterLanguageV ~ 高亮语言
        /// </summary>
        protected SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage
            m_EmHighlighterLanguageV 
            =
            SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无;

        /// <summary>
        /// EmHighlighterLanguageV ~ 高亮语言
        /// </summary>
        public SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage EmHighlighterLanguageV
        {
            get
            {
                return m_EmHighlighterLanguageV;
            }
            set
            {
                m_EmHighlighterLanguageV = value;
            }
        }

        #endregion EmHighlighterLanguageV ~ 高亮语言


        #region CodeText ~ 代码内容

        /// <summary>
        /// CodeText ~ 代码内容
        /// </summary>
        protected string m_CodeText = null;

        /// <summary>
        /// CodeText ~ 代码内容
        /// </summary>
        public string CodeText
        {
            get
            {
                return m_CodeText;
            }
            set
            {
                m_CodeText = value;
            }
        }

        #endregion CodeText ~ 代码内容


        #region AutoPrint ~ 自动打印

        /// <summary>
        /// AutoPrint ~ 自动打印
        /// </summary>
        protected bool m_AutoPrint = true;

        /// <summary>
        /// AutoPrint ~ 自动打印
        /// </summary>
        public bool AutoPrint
        {
            get
            {
                return m_AutoPrint;
            }
            set
            {
                m_AutoPrint = value;
            }
        }

        #endregion AutoPrint ~ 自动打印

        /// <summary>
        /// 
        /// </summary>
        /// <param name="curId"></param>
        public void ItemIdSet(long curId)
        {
            ItemId = "code_" + curId.ToString();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strFileName"></param>
        public void EmHighlighterLanguageSet(string strFileName)
        {
            EmHighlighterLanguageV = SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无;

            if (strFileName == null || strFileName.Length == 0)
            {
                return;
            }

            int idx = strFileName.LastIndexOf('.');

            if (idx == -1)
            {
                return;
            }

            string strEx = strFileName.Substring(idx);

            EmHighlighterLanguageV = EmHighlighterLanguageGetByEx(strEx);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strEx"></param>
        /// <returns></returns>
        protected SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage EmHighlighterLanguageGetByEx
            (
                string strEx
            )
        {
            if (strEx == null || strEx.Length == 0)
                return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无;

            strEx = strEx.Trim().ToLower();

            if (strEx.Length == 0)
                return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无;

            switch (strEx)
            {
                case ".cs":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.CSharp;
                case ".c":
                case ".h":
                case ".cpp":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.C;
                case ".css":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.CSS;
                case ".java":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Java;
                case ".js":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.JavaScript;
                case ".php":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.PHP;
                case ".pas":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Delphi;
                case ".python":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Python;
                case ".ruby":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Ruby;
                case ".sql":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Sql;
                case ".vb":
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Vb;
                case ".html":
                case ".htm":
                default:
                    return SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.Xml;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="theValue"></param>
        /// <returns></returns>
        protected string ConvertChar(string theValue)
        {
            if (theValue == null)
                return "";

            theValue = theValue.Replace("&", "&amp;");
            theValue = theValue.Replace("<", "&lt;");
            theValue = theValue.Replace(">", "&gt;");

            return theValue;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="em"></param>
        /// <returns></returns>
        protected string GetCssClass( SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage  em)
        {
            switch (em)
            { 
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无:
                    return "";
               
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.CSharp:
                    return "c-sharp";
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.JavaScript:
                    return "js"; 
                default:
                    return em.ToString().ToLower();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public string ShBrushScriptGet()
        {
            return ShBrushScriptGetByEm(EmHighlighterLanguageV);
        }

        protected string ShBrushScriptGetByEm(SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage em)
        {
            //C#：class="c-sharp" ~ shBrushCSharp  
            //PHP：class="php" ~ shBrushPhp  
            //JScript：class="js" ~ shBrushJScript  
            //Java：class="java" ~ shBrushJava  
            //Vb：class="vb" ~ shBrushVb  
            //Sql：class="sql" ~ shBrushSql  
            //Xml：class="xml" ~ shBrushXml  
            //Delphi：class="delphi" ~ shBrushDelphi  
            //Python：class="python" ~ shBrushPython  
            //Ruby：class="ruby" ~ shBrushRuby  
            //CSS：class="css" ~ shBrushCss  
            //C或C++： class="c" ~ shBrushCpp 

            switch (em)
            {
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.CSharp:
                    return "shBrushCSharp";
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.C:
                    return "shBrushCpp";
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.JavaScript:
                    return "shBrushJScript";
                case SlowX.Utils.Enums.HighlighterLanguage.EmHighlighterLanguage.无:
                    return "";
                default:
                    return "shBrush" + em.ToString();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public string PrintCodeText()
        {
            string strCodeText = ConvertChar(CodeText);


            string strCssClass = GetCssClass(EmHighlighterLanguageV);

            if (strCssClass == null || strCssClass.Length == 0)
                return strCodeText;

            return "<pre name=\"" + ItemId + "\" class=\"" + strCssClass + "\">" + strCodeText + "</pre>";  
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="strPhyPath"></param>
        /// <returns></returns>
        public string PrintHead(string strPhyPath)
        {
            return "<link type=\"text/css\" rel=\"stylesheet\" href=\"" + strPhyPath + "/SyntaxHighlighter1v5/Styles/SyntaxHighlighter.css\" />";
        }

      

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strPhyPath"></param>
        /// <returns></returns>
        public string PrintEnd(string strPhyPath)
        {
            StringBuilder theResult = new StringBuilder();

            // 引用shCore.js // 
            theResult.AppendLine(@"<script type=""text/javascript"" language=""javascript"" src=""" + strPhyPath + @"/SyntaxHighlighter1v5/Scripts/shCore.js""></script>");

            string shBrushScript = ShBrushScriptGet();

            theResult.AppendLine(@"<script type=""text/javascript"" language=""javascript"" src=""" + strPhyPath + @"/SyntaxHighlighter1v5/Scripts/" + shBrushScript + @".js""></script>");



            theResult.AppendLine(@"  
<script type=""text/javascript"" language=""javascript"">  
    dp.SyntaxHighlighter.ClipboardSwf = """ + strPhyPath + @"/SyntaxHighlighter1v5/Scripts/clipboard.swf""; ");


            theResult.AppendLine(@"
    dp.SyntaxHighlighter.HighlightAll(""" + ItemId + @""");  
  ");


            theResult.AppendLine(@"
</script> 
");

            return theResult.ToString();
        }
 
    }
}

标签：C#    代码高亮    SyntaxHighlighter组建    逻辑代码 

上一条：

下一条：


 

相关评论

评论加载中……
 

发表评论

类型：
内容：
  (Alt+Enter)
 
  ┈全部┈  
 
（显示全部分类）