精华内容
下载资源
问答
  • C# 标签设计器

    2021-02-05 14:02:00
    标签设计元素包括,直线,矩形,多边形,静态字符,动态字符,带自动增长标记字符,图章(log图片),各种条码如Code128,Code39,PDF417等,各种二维码. 对于显示在标签上的动态数据或组合数据及条形码和二维码生成数据...
  • 技术看点 PropertyGrid的使用 自定义控件的使用 对象序列化成XML GDI+Windows驱动打印 ...公司(上海易溯信息科技)是...由于老系统的Windows驱动打印部分出现打印速度不够快,绘图精度不高,标签设计器简陋等问...

    技术看点

    • PropertyGrid的使用
    • 自定义控件的使用
    • 对象序列化成XML
    • GDI+Windows驱动打印

    前言

    是的,一不小心把公司名称透露了。索性帮公司打一下广告。公司(上海易溯信息科技)是中国奶制品行业追溯生产管理方面的龙头。最近也是准备把业务拓展到东南亚地区,筹备走出国门。由于老系统的Windows驱动打印部分出现打印速度不够快,绘图精度不高,标签设计器简陋等问题。于是开始了重构,当然只是参考老程序的实现方式,程序是重新实现的。程序是用很零散的空闲时间写的,效果还需要在项目中实际运用,进行检验。

    设计

    由于一发现不熟悉的技术点就上网搜索,其实大部分技术难题都是搜索解决的。这里就不申明版权问题了,“如有雷同,纯属意外!”。哈哈

    运行时读取模板数据,模板里标签的元素的设计

    设计时可视化自定义控件的设计类图

    编码实现

    1)PropertyGrid的使用

    代码都来自网络,主要就是属性名使用中文。使用英文对实施的电器工程师来说不太友好。

    public delegate void PropertyChanged(object Value);
        /// <summary>
        /// 主要是实现中文化属性显示
        /// </summary>
        public class PropertyBase : ICustomTypeDescriptor
        {
            AttributeCollection ICustomTypeDescriptor.GetAttributes()
            {
                return TypeDescriptor.GetAttributes(this, true);
            }
            string ICustomTypeDescriptor.GetClassName()
            {
                return TypeDescriptor.GetClassName(this, true);
            }
            string ICustomTypeDescriptor.GetComponentName()
            {
                return TypeDescriptor.GetComponentName(this, true);
            }
            TypeConverter ICustomTypeDescriptor.GetConverter()
            {
                return TypeDescriptor.GetConverter(this, true);
            }
            EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
            {
                return TypeDescriptor.GetDefaultEvent(this, true);
            }
            PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
            {
                return null;
            }
            object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
            {
                return TypeDescriptor.GetEditor(this, editorBaseType, true);
            }
            EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
            {
                return TypeDescriptor.GetEvents(this, true);
            }
            EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
            {
                return TypeDescriptor.GetEvents(this, attributes, true);
            }
            PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
            {
                return ((ICustomTypeDescriptor)this).GetProperties(new Attribute[0]);
            }
            PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
            {
                ArrayList props = new ArrayList();
                Type thisType = this.GetType();
                PropertyInfo[] pis = thisType.GetProperties();
                foreach (PropertyInfo p in pis)
                {
                    if (p.DeclaringType == thisType || p.PropertyType.ToString() == "System.Drawing.Color")
                    {
                        //判断属性是否显示
                        BrowsableAttribute Browsable = (BrowsableAttribute)Attribute.GetCustomAttribute(p, typeof(BrowsableAttribute));
                        if (Browsable != null)
                        {
                            if (Browsable.Browsable == true || p.PropertyType.ToString() == "System.Drawing.Color")
                            {
                                PropertyStub psd = new PropertyStub(p, attributes);
                                props.Add(psd);
                            }
                        }
                        else
                        {
                            PropertyStub psd = new PropertyStub(p, attributes);
                            props.Add(psd);
                        }
                    }
                }
                PropertyDescriptor[] propArray = (PropertyDescriptor[])props.ToArray(typeof(PropertyDescriptor));
                return new PropertyDescriptorCollection(propArray);
            }
            object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
            {
                return this;
            }
        }
    
        /// <summary>
        /// 自定义属性拦截器
        /// </summary>
        public class PropertyStub : PropertyDescriptor
        {
            PropertyInfo info;
            public PropertyStub(PropertyInfo propertyInfo, Attribute[] attrs)
                : base(propertyInfo.Name, attrs)
            {
                info = propertyInfo;
            }
            public override Type ComponentType
            {
                get { return info.ReflectedType; }
            }
            public override bool IsReadOnly
            {
                get { return info.CanWrite == false; }
            }
            public override Type PropertyType
            {
                get { return info.PropertyType; }
            }
            public override bool CanResetValue(object component)
            {
                return false;
            }
            public override object GetValue(object component)
            {
                try
                {
                    return info.GetValue(component, null);
                }
                catch
                {
                    return null;
                }
            }
            public override void ResetValue(object component)
            {
            }
            public override void SetValue(object component, object value)
            {
                info.SetValue(component, value, null);
            }
            public override bool ShouldSerializeValue(object component)
            {
                return false;
            }
            //通过重载下面这个属性,可以将属性在PropertyGrid中的显示设置成中文
            public override string DisplayName
            {
                get
                {
                    if (info != null)
                    {
                        ChnPropertyAttribute uicontrolattibute = (ChnPropertyAttribute)Attribute.GetCustomAttribute(info, typeof(ChnPropertyAttribute));
                        if (uicontrolattibute != null)
                            return uicontrolattibute.PropertyName;
                        else
                        {
                            return info.Name;
                        }
                    }
                    else
                        return "";
                }
            }
    
            public override string Description
            {
                get
                {
                    if (info != null)
                    {
                        ChnPropertyAttribute uicontrolattibute = (ChnPropertyAttribute)Attribute.GetCustomAttribute(info, typeof(ChnPropertyAttribute));
                        if (uicontrolattibute != null)
                            return uicontrolattibute.PropertyDescription;
                    }
                    return string.Empty;
                }
            }
        }
    自定义属性拦截器
    /// <summary>
        /// 中文方式自定义属性标识
        /// </summary>
        public class ChnPropertyAttribute : Attribute
        {
            private string _PropertyName;
            private string _PropertyDescription;
            
            public ChnPropertyAttribute(string Name, string Description)
            {
                _PropertyName = Name;
                _PropertyDescription = Description;
            }
            public ChnPropertyAttribute(string Name)
            {
                _PropertyName = Name;
                _PropertyDescription = "";
            }
            public string PropertyName
            {
                get { return _PropertyName; }
            }
            public string PropertyDescription
            {
                get { return _PropertyDescription; }
            }
        }
    自定义中文属性的Attribute

    实际使用中文属性

    2)自定义控件的使用

    /// <summary>
        /// 标签最顶层容器,标签设计时容器
        /// </summary>
        [Serializable]
        public partial class RadiusRectangleSharp : Panel
        {
            #region 鼠标移动和缩放       
            const int Band = 5;
            const int MinWidth = 10;
            const int MinHeight = 10;
            private EnumMousePointPosition _mMousePointPosition;
            private Point _p, _p1;
            private EnumMousePointPosition MousePointPosition(Size size, System.Windows.Forms.MouseEventArgs e)
            {
    
                if ((e.X >= -1 * Band) | (e.X <= size.Width) | (e.Y >= -1 * Band) | (e.Y <= size.Height))
                {
                    if (e.X < Band)
                    {
                        if (e.Y < Band) { return EnumMousePointPosition.MouseSizeTopLeft; }
                        else
                        {
                            if (e.Y > -1 * Band + size.Height)
                            { return EnumMousePointPosition.MouseSizeBottomLeft; }
                            else
                            { return EnumMousePointPosition.MouseSizeLeft; }
                        }
                    }
                    else
                    {
                        if (e.X > -1 * Band + size.Width)
                        {
                            if (e.Y < Band)
                            { return EnumMousePointPosition.MouseSizeTopRight; }
                            else
                            {
                                if (e.Y > -1 * Band + size.Height)
                                { return EnumMousePointPosition.MouseSizeBottomRight; }
                                else
                                { return EnumMousePointPosition.MouseSizeRight; }
                            }
                        }
                        else
                        {
                            if (e.Y < Band)
                            { return EnumMousePointPosition.MouseSizeTop; }
                            else
                            {
                                if (e.Y > -1 * Band + size.Height)
                                { return EnumMousePointPosition.MouseSizeBottom; }
                                else
                                { return EnumMousePointPosition.MouseDrag; }
                            }
                        }
                    }
                }
                else
                { return EnumMousePointPosition.MouseSizeNone; }
            }
            #endregion               
            #region Local Variables       
            private Color _borderColor = Color.White;
            private int _radius = 8;
            private int _opacity = 68;
            private Color _dimmedColor = Color.LightGray;
            protected Rectangle IRect = new Rectangle();
            #endregion
            #region Properties        
            public Color BorderColor
            {
                get { return _borderColor; }
                set { _borderColor = value; Invalidate(); }
            }
            public int Opacity
            {
                get { return _opacity; }
                set { _opacity = value; this.Invalidate(); }
            }      
            public int Radius
            {
                get { return _radius; }
                set { _radius = value; this.Invalidate(); }
            }
            /// <summary>
            /// 当前模板信息
            /// </summary>
            public TemplateItemInfo CurrentTemplateInfo
            {
                get
                {
                    return _currentTempletInfo;
                }
                set
                {
                    _currentTempletInfo = value;
                }
            }
            private TemplateItemInfo _currentTempletInfo = new TemplateItemInfo();
            #endregion        
            public RadiusRectangleSharp()
            {
                InitializeComponent();
                AllowDrop = true;
                BackColor = Color.White;
                SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.ResizeRedraw | ControlStyles.SupportsTransparentBackColor | ControlStyles.UserPaint, true);
                SetStyle(ControlStyles.Opaque, true);
                Margin = new Padding(1, 1, 1, 1);
                Padding = new Padding(0, 0, 0, 0);
                BorderColor = Color.DarkBlue;
                UpdateStyles();
                SendToBack();
            }
            protected override void OnPaint(PaintEventArgs e)
            {
                SmoothingMode sm = e.Graphics.SmoothingMode;
                e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
                e.Graphics.Clear(Color.White);
                DrawBorder(e.Graphics);
                DrawBackground(e.Graphics);
                e.Graphics.SmoothingMode = sm;
            }
            protected void DrawBorder(Graphics g)
            {
                Rectangle rect = ClientRectangle;
                rect.Width--;
                rect.Height--;
                using (GraphicsPath bp = GetPath(rect, _radius))
                {
                    using (Pen p = new Pen(_borderColor))
                    {
                        g.DrawPath(p, bp);
                    }
                }
            }
            protected void DrawBackground(Graphics g)
            {
                Rectangle rect = ClientRectangle;
                IRect = rect;
                rect.X++;
                rect.Y++;
                rect.Width -= 2;
                rect.Height -= 2;
                using (GraphicsPath bb = GetPath(rect, _radius))
                {
                    using (Brush br = new SolidBrush(Color.FromArgb(_opacity, BackColor)))
                    {
                        g.FillPath(br, bb);
                    }
                }
            }
            protected GraphicsPath GetPath(Rectangle rc, int r)
            {
                int x = rc.X, y = rc.Y, w = rc.Width, h = rc.Height;
                r = r << 1;
                GraphicsPath path = new GraphicsPath();
                if (r > 0)
                {
                    if (r > h) { r = h; };                              //Rounded
                    if (r > w) { r = w; };                              //Rounded
                    path.AddArc(x, y, r, r, 180, 90);                    //Upper left corner
                    path.AddArc(x + w - r, y, r, r, 270, 90);            //Upper right corner
                    path.AddArc(x + w - r, y + h - r, r, r, 0, 90);        //Lower right corner
                    path.AddArc(x, y + h - r, r, r, 90, 90);            //Lower left corner
                    path.CloseFigure();
                }
                else
                {
                    path.AddRectangle(rc);
                }
                return path;
            }
            protected override void OnMouseDown(MouseEventArgs e)
            {
                _p.X = e.X;
                _p.Y = e.Y;
                _p1.X = e.X;
                _p1.Y = e.Y;
            }
            protected override void OnMouseUp(MouseEventArgs e)
            {
                _mMousePointPosition = EnumMousePointPosition.MouseSizeNone;
                this.Cursor = Cursors.Arrow;
            }
            protected override void OnMouseMove(MouseEventArgs e)
            {
                if (e.Button == MouseButtons.Left)
                {
                    //本控件是顶层容器,不允许位移
                    switch (_mMousePointPosition)
                    {
                        #region 位置计算
                        case EnumMousePointPosition.MouseDrag:
                            break;
                        case EnumMousePointPosition.MouseSizeBottom:
                            Height = Height + e.Y - _p1.Y;
                            _p1.X = e.X;
                            _p1.Y = e.Y; //'记录光标拖动的当前点    
                            break;
                        case EnumMousePointPosition.MouseSizeBottomRight:
                            Width = Width + e.X - _p1.X;
                            Height = Height + e.Y - _p1.Y;
                            _p1.X = e.X;
                            _p1.Y = e.Y; //'记录光标拖动的当前点    
                            break;
                        case EnumMousePointPosition.MouseSizeRight:
                            Width = Width + e.X - _p1.X;
                            Height = Height + e.Y - _p1.Y;
                            _p1.X = e.X;
                            _p1.Y = e.Y; //'记录光标拖动的当前点    
                            break;
                        case EnumMousePointPosition.MouseSizeTop:
                            Height = Height - (e.Y - _p.Y);
                            break;
                        case EnumMousePointPosition.MouseSizeLeft:
                            Width = Width - (e.X - _p.X);
                            break;
                        case EnumMousePointPosition.MouseSizeBottomLeft:
                            Width = Width - (e.X - _p.X);
                            Height = Height + e.Y - _p1.Y;
                            _p1.X = e.X;
                            _p1.Y = e.Y; //'记录光标拖动的当前点    
                            break;
                        case EnumMousePointPosition.MouseSizeTopRight:
                            Width = Width + (e.X - _p1.X);
                            Height = Height - (e.Y - _p.Y);
                            _p1.X = e.X;
                            _p1.Y = e.Y; //'记录光标拖动的当前点    
                            break;
                        case EnumMousePointPosition.MouseSizeTopLeft:
                            Width = Width - (e.X - _p.X);
                            Height = Height - (e.Y - _p.Y);
                            break;
                        default:
                            break;
                            #endregion
                    }
                    if (Width < MinWidth) Width = MinWidth;
                    if (Height < MinHeight) Height = MinHeight;
                }
                else
                {
                    _mMousePointPosition = MousePointPosition(Size, e);
                    switch (_mMousePointPosition)
                    {
                        #region 改变光标
                        case EnumMousePointPosition.MouseSizeNone:
                            this.Cursor = Cursors.Arrow;        //'箭头    
                            break;
                        case EnumMousePointPosition.MouseDrag:
                            this.Cursor = Cursors.SizeAll;      //'四方向    
                            break;
                        case EnumMousePointPosition.MouseSizeBottom:
                            this.Cursor = Cursors.SizeNS;       //'南北    
                            break;
                        case EnumMousePointPosition.MouseSizeTop:
                            this.Cursor = Cursors.SizeNS;       //'南北    
                            break;
                        case EnumMousePointPosition.MouseSizeLeft:
                            this.Cursor = Cursors.SizeWE;       //'东西    
                            break;
                        case EnumMousePointPosition.MouseSizeRight:
                            this.Cursor = Cursors.SizeWE;       //'东西    
                            break;
                        case EnumMousePointPosition.MouseSizeBottomLeft:
                            this.Cursor = Cursors.SizeNESW;     //'东北到南西    
                            break;
                        case EnumMousePointPosition.MouseSizeBottomRight:
                            this.Cursor = Cursors.SizeNWSE;     //'东南到西北    
                            break;
                        case EnumMousePointPosition.MouseSizeTopLeft:
                            this.Cursor = Cursors.SizeNWSE;     //'东南到西北    
                            break;
                        case EnumMousePointPosition.MouseSizeTopRight:
                            this.Cursor = Cursors.SizeNESW;     //'东北到南西    
                            break;
                        default:
                            break;
                            #endregion
                    }
                }
            }
            protected override void OnResize(EventArgs eventargs)
            {
                if (CurrentTemplateInfo != null)
                {
                    CurrentTemplateInfo.Width = Size.Width;
                    CurrentTemplateInfo.Height = Size.Height;
                    Invalidate();
                }
            }
            protected override void OnDragEnter(DragEventArgs drgevent)
            {
                drgevent.Effect = DragDropEffects.Copy;
                base.OnDragEnter(drgevent);
            }
            protected override void OnDragDrop(DragEventArgs drgevent)
            {
                try
                {
                    string[] strs = (string[])drgevent.Data.GetData(typeof(string[])); //获取拖拽数据
                    PictureBox ctrl = null;
                    #region 实例化元素控件
                    switch (strs.FirstOrDefault())
                    {
                        case "Barcode":
                            ctrl = new BarcodePictureBox();
                            break;
                        case "Image":
                            ctrl = new ImagePictureBox();
                            break;
                        case "Text":
                            ctrl = new StaticTextBox();
                            break;
                        default:
                            break;
                    }
                    #endregion
                    ctrl.Location = PointToClient(new Point(drgevent.X, drgevent.Y)); //屏幕坐标转换成控件容器坐标 
                    ctrl.BringToFront();
                    Controls.Add(ctrl);
                }
                catch (Exception ex)
                {
                    string msg = "初始化控件出错!错误码:" + ex.Message + Environment.NewLine + ex.StackTrace;
                    MessageTip.ShowError(this, msg, 3000);
                }
                base.OnDragDrop(drgevent);
            }
        }

    整体上来说就是GDI+的使用,其中用了Base64编码来序列化图片。

    3)对象序列化成XML

    使用的是标准的方式:

    /// <summary>
            /// 把对象序列化成xml文件
            /// </summary>
            /// <typeparam name="T">对象的类</typeparam>
            /// <param name="outFile">输出的文件和路径</param>
            /// <param name="t">对象的实例</param>
            public static void SerializerToXML<T>(string outFile, T t) where T : class
            {
                using (System.IO.FileStream fs = new System.IO.FileStream(outFile, System.IO.FileMode.Create))
                {
                    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                    ns.Add("", "");
                    XmlSerializer xs = new XmlSerializer(typeof(T));
                    xs.Serialize(fs, t, ns);
                    fs.Flush();
                }
            }
    
            /// <summary>
            /// 从XML文件反序列化成集合对象
            /// </summary>
            /// <typeparam name="T">对象</typeparam>
            /// <param name="inXMLFile">xml的文件,全路径</param>
            /// <returns>对象集合</returns>
            public static T LoadFromXML<T>(string inXMLFile) where T : class
            {
                var t = default(T);
                using (System.IO.FileStream fs = new System.IO.FileStream(inXMLFile, System.IO.FileMode.Open))
                {
                    XmlSerializer xs = new XmlSerializer(typeof(T));
                    t = (T)xs.Deserialize(fs);
                    fs.Close();
                }
                return t;
            }
     /// <summary>
        /// 图形元素
        /// </summary>
        [Serializable]
        public class ImageElementNode : PropertyBase, IElementNodeData, INotifyPropertyChanged
        {
            protected PictureBoxSizeMode _PictureBoxSizeMode = PictureBoxSizeMode.StretchImage;
            [ChnProperty("缩放模式", "图片原始尺寸和元素大小不一致时需要对原始图片进行缩放,设置缩放模式。")]
            [Category("通用属性")]
            public PictureBoxSizeMode ImageBoxSizeMode
            {
                get { return _PictureBoxSizeMode; }
                set { _PictureBoxSizeMode = value; }
            }
    
            private Point _location;
            [ChnProperty("位置", "节点元素的在模板里的位置的坐标,鼠标选中节点即可以移动位置。")]
            [Category("通用属性")]
            public Point Location
            {
                get { return _location; }
                set { _location = value; }
            }
    
            private string _name;
            [ChnProperty("元素名称", "一般自动生成,不需要维护。")]
            [Category("通用属性")]
            [XmlAttribute("Name")]
            public string Name
            {
                get { return _name; }
                set { _name = value; NotifyPropertyChanged("Name"); }
            }
    
            [ChnProperty("元素节点类型", "模板元素节点类型,元素产生时根据添加时自动确定,设计时不要修改类型。"), Category("通用属性")]
            [XmlAttribute("NodeCategory")]
            public ElementNodeCategory NodeCategory
            {
                get { return ElementNodeCategory.静态文本; }
            }
    
            private ImageRoteType _roteDescription = ImageRoteType.正常;
            [ChnProperty("旋转角度", "变形的形态描述,比如顺时针旋转90度。"), Category("通用属性")]
            public ImageRoteType RoteDescription
            {
                get { return _roteDescription; }
                set { _roteDescription = value; NotifyPropertyChanged("RoteDescription"); }
            }
    
            private Size _size;
            [ChnProperty("元素大小", "包括高度和宽度,单位是像素。使用鼠标可调节大小,滚轮进行缩放。"), Category("通用属性")]
            public Size Size
            {
                get { return _size; }
                set { _size = value; }
            }
    
            [ChnProperty("静态表达式", @"可以从‘ProductName,ProductCode,ProductSpec,
                           CorpCode,BatchCode,LineCode,DepartCode,TeamCode,WorkerCode,
                           PackDate,ValidateDate,ProductFullName,CustomerCode,CustomerName’字段中获取值。"),
             Category("表达式")]
            public StaticMapProperty StaticMapProperty { get; set; }
            [ChnProperty("动态表达式", @"可以从‘Code,EncryptCode,ParentCode,CipherFieldCode,Seqence,
                                       VersionCode,VersionName,BatchCode,CorpCode,LineCode,PackDate,ProductCode,WorkPointInt,
                                       WorkPointAZ,Dynamic,’字段中获取值。"),
             Category("表达式")]
            public DynamicMapProperty DynamicMapProperty { get; set; }
    
            private string text;
            [ChnProperty("固定字符", "在不写任何表达式的情况下设置的固定字符"), Category("通用属性")]
            [XmlAttribute("Text")]
            public string Text
            {
                get { return text; }
                set { text = value; NotifyPropertyChanged("Text"); }
            }
    
            private string _动态内容;
            [ChnProperty("动态内容", @"格式:{PropertyName[(Start[,Length])]}[&Blank[(Length)]]&{PropertyName[(Start[,Length])]} 
                                        PropertyName:动态属性里的选项
                                        Start:动态属性对应内容的开始位置
                                        Length:截取内容的长度
                                        Blank:空格
                                        Length:空格的个数
                                        &:为分隔符
                                        设置此内容的时候,请务必小心,设置时系统不检测其值的合法性,在执行的时候可能会报错"), Category("表达式")]
            public string 动态内容
            {
                get { return _动态内容; }
                set { _动态内容 = value; NotifyPropertyChanged("动态内容"); }
            }
            [ChnProperty("图形数据", "Base64编码的图形数据,缩放后序列化的字节码。双击图像元素进行选择和预览。"), Category("图形属性")]
    
            private string _imageData;
            [Browsable(false)]
            public string BinaryData
            {
                get { return _imageData; }
                set { _imageData = value; NotifyPropertyChanged("BinaryData"); }
            }
    
            private string _formatString = string.Empty;
            [ChnProperty("格式掩码", "如yyyyMMdd,HH:MM:SS。"), Category("表达式")]
            public string FormatString
            {
                get
                {
                    return _formatString;
                }
                set
                {
                    _formatString = value;
                    NotifyPropertyChanged("FormatString");
                }
            }
    
            public event PropertyChangedEventHandler PropertyChanged;
    
            public Image GetElmentNodeImage(PrintData data)
            {
                if (string.IsNullOrEmpty(BinaryData))
                    throw new Exception("图片元素没有绑定图片资源!");
                Bitmap bmp = new Bitmap(Size.Width-3, Size.Height-3);
                Graphics g = Graphics.FromImage(bmp);
                g.Clear(Color.White);
                g.SmoothingMode = SmoothingMode.HighQuality;
                byte[] arr = Convert.FromBase64String(BinaryData);
                using (MemoryStream ms = new MemoryStream(arr))
                {
                    Bitmap tempBmp = new Bitmap(ms);
                    using (PictureBox pb = new PictureBox())
                    {
                        pb.Size = Size;
                        pb.SizeMode = ImageBoxSizeMode;
                        pb.Image = tempBmp;
                        return ImageRote.RoteImage(RoteDescription, pb.Image);
                    } 
                } 
            }
    
            private void NotifyPropertyChanged(string property)
            {
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(property));
            }
    
            public ImageElementNode()
            {
                StaticMapProperty = StaticMapProperty.None;
                DynamicMapProperty = DynamicMapProperty.None;
                动态内容 = "";
            } 
        }

    4)GDI+Windows驱动打印

    /// <summary>
        /// GDI Printer驱动类
        /// </summary>
        public class CoolGDIPrinter : WindowsVirtualPrinter
        {
            protected PrintDocument printDocument;
            protected Dictionary<string, TemplateItemInfo> dict = new Dictionary<string, TemplateItemInfo>();
            private object printSync = new object();
            private string templateFile = AppDomain.CurrentDomain.BaseDirectory + "Config\\GDITemplate.Config";
            private string current_data = string.Empty;
            private PrintData pd = null;
            private string current_Template = string.Empty;
            public CoolGDIPrinter(HardwarePort port, ILog log) : base(port, log)
            {
                if (!System.IO.File.Exists(templateFile))
                {
                    throw new Exception(string.Format("模板文件{0}不存在!", templateFile));
                }
                DataList<TemplateItemInfo> list = WinFormHelper.LoadFromXML<DataList<TemplateItemInfo>>(templateFile);
                if (list != null && list.Count > 0)
                {
                    foreach (TemplateItemInfo template in list)
                    {
                        dict.Add(template.Code, template);
                    }
                }
                if (string.IsNullOrEmpty(port.PortName))
                {
                    throw new Exception("打印机名称不能为空!");
                }
                var findPrinter = GetAllLocalPrinters().Find(obj => obj.Contains(port.PortName));
                if (string.IsNullOrEmpty(findPrinter))
                {
                    throw new Exception(string.Format("本地没有打印机{0},请检查打印机驱动是否正确安装。", port.PortName));
                }
                if (dict.Count == 0)
                {
                    throw new Exception(string.Format("模板文件{0}内容为空,或者格式不符!", templateFile));
                }
                #region PrintDocument
                printDocument = new PrintDocument
                {
                    PrinterSettings =
                    {
                        PrinterName = PortName,
                    }
                };
                printDocument.PrintController = new StandardPrintController();
                printDocument.BeginPrint += PrintDocument_BeginPrint;
                printDocument.PrintPage += PrintDocument_PrintPage;
                printDocument.EndPrint += PrintDocument_EndPrint;
                #endregion
                var isvali = printDocument.PrinterSettings.IsValid;
                if (!isvali)
                {
                    throw new Exception(string.Format("没有指定有效的打印机,{0}不可用!", PortName));
                }           
            }
            /// <summary>
            /// 获取本机所有打印机列表
            /// </summary>
            /// <returns>本机所有打印机列表</returns>
            private List<string> GetAllLocalPrinters()
            {
                var fPrinters = new List<string>();
                foreach (string fPrinterName in PrinterSettings.InstalledPrinters)
                {
                    if (!fPrinters.Contains(fPrinterName))
                    {
                        fPrinters.Add(fPrinterName);
                    }
                }
                return fPrinters;
            }
            /// <summary>
            /// 获取打印机的当前状态
            /// </summary>
            /// <param name="PrinterDevice">打印机设备名称</param>
            /// <returns>打印机状态</returns>
            private PrinterStatus GetPrinterStat(string PrinterDevice)
            {
                PrinterStatus ret = 0;
                string path = @"win32_printer.DeviceId='" + PrinterDevice + "'";
                ManagementObject printerMgrObj = new ManagementObject(path);
                printerMgrObj.Get();
                ret = (PrinterStatus)Convert.ToInt32(printerMgrObj.Properties["PrinterStatus"].Value);
                return ret;
            }
            /// <summary>
            /// WMI检测指定的打印机是否可用
            /// </summary>
            /// <param name="printerNameIn">指定的打印机名称</param>
            /// <returns></returns>
            protected bool CheckPrinter(string printerNameIn)
            {
                var scope = new ManagementScope(@"\root\cimv2");
                scope.Connect();
                ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Printer");
                string printerName = "";
                foreach (ManagementObject printer in searcher.Get())
                {
                    printerName = printer["Name"].ToString().ToLower();
                    if (printerName.IndexOf(printerNameIn.ToLower()) > -1)
                    {
                        if (printer["WorkOffline"].ToString().ToLower().Equals("true"))
                        {
                            return false;
                        }
                        else
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
    
            private object printlock = new object();
            /// <summary>
            /// 内部执行打印
            /// </summary>
            /// <param name="data"></param>
            /// <param name="templateKey"></param>
            protected override void WritePrinter(PrintData data, string templateKey)
            {
                var template = dict[templateKey];
                if (template == null)
                {
                    throw new Exception(string.Format("不存在打印机模板[{0}]的配置文件", templateKey));
                }
                lock (printlock)
                {
                    try
                    {
                        printDocument.PrinterSettings.Copies = (short)template.Quantity;
                        printDocument.PrinterSettings.DefaultPageSettings.PaperSize = new PaperSize("GDI_LableSize", template.Width + 2, template.Height + 2);
                        printDocument.OriginAtMargins = true;
                        printDocument.DefaultPageSettings.Margins = new Margins(2, 2, 2, 2);
                        var printerIsonline = CheckPrinter(printDocument.PrinterSettings.PrinterName);
                        if (!printerIsonline)
                        {
                            RaiseException(new Exception(string.Format("打印机状态{0},请稍候进行打印!", "离线,请检查打印机是否正常开启")));
                            return;
                        }
                        current_data = data.Code;
                        pd = data;
                        current_Template = templateKey;
                        PostData(data);
                        printDocument.Print();
                    }
                    catch (Exception ex)
                    {
                        RaiseReceived(ex, null);
                        RaiseException(new Exception(current_data + "打印失败,原因:" + ex.Message));
                    }
                }
            }
            /// <summary>
            /// 外部调用驱动程序,发送打印数据
            /// </summary>
            /// <param name="data">打印数据</param>
            /// <param name="templateKey">模板键</param>
            public override void WriteData(PrintData data, string templateKey)
            {
                base.WriteData(data, templateKey);
                IsPrinting = true;
                WritePrinter(data, templateKey);
                IsPrinting = false;
            }
            /// <summary>
            /// 启动生成标签图形
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void PrintDocument_BeginPrint(object sender, PrintEventArgs e)
            {
                Log.Info(string.Format("开始打印数据:[{0}],[{1}]", PortName, current_data));
            }
            /// <summary>
            /// 执行标签图形生成产生画布
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void PrintDocument_PrintPage(object sender, PrintPageEventArgs e)
            {
                lock (printSync)
                {
                    try
                    {
                        var imgData = BuildTemplateImage(pd, current_Template);
                        if (imgData != null)
                        {
                            e.Graphics.SmoothingMode = SmoothingMode.HighQuality;
                            e.Graphics.DrawImage(imgData, 0, 0, imgData.Width, imgData.Height);
                            if (IsDebug)
                            {
                                string debugPath = AppDomain.CurrentDomain.BaseDirectory + "output";
                                if (!System.IO.Directory.Exists(debugPath))
                                {
                                    System.IO.Directory.CreateDirectory(debugPath);
                                }
                                string bmpFile = System.IO.Path.Combine(debugPath, current_data + DateTime.Now.Ticks + ".PNG");
                                imgData.Save(bmpFile, ImageFormat.Png);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Error(ex);
                        throw new Exception("构建标签图形失败,错误描述:" + ex.Message + Environment.NewLine + ex.StackTrace);
                    }
                }
            }
            /// <summary>
            /// 结束打印绘图,发送给打印机打印数据
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void PrintDocument_EndPrint(object sender, PrintEventArgs e)
            {
                Log.Info(string.Format("[{0}],[{1}],发送打印数据完成", PortName, current_data));
            }
            /// <summary>
            /// 内部通过模板生成图形
            /// </summary>
            /// <param name="data"></param>
            /// <param name="templateKey"></param>
            /// <returns></returns>
            protected override Bitmap BuildTemplateImage(PrintData data, string templateKey)
            {
                var template = dict[templateKey];
                Bitmap bmp = new Bitmap(template.Width, template.Height);
                Graphics graphics = Graphics.FromImage(bmp);
                graphics.SmoothingMode = SmoothingMode.HighQuality;
                graphics.Clear(Color.White);
                //1、画图片元素节点
                foreach (var bmpElement in template.ImageElementList)
                {
                    Rectangle rect = new Rectangle(bmpElement.Location.X, bmpElement.Location.Y, bmpElement.Size.Width, bmpElement.Size.Height);
                    graphics.DrawImage(bmpElement.GetElmentNodeImage(data), rect);
                }
                //2、画条码元素节点
                foreach (var barcodeElement in template.BarcodeElementList)
                {
                    Rectangle rect = new Rectangle(barcodeElement.Location.X, barcodeElement.Location.Y, barcodeElement.Size.Width, barcodeElement.Size.Height);
                    graphics.DrawImage(barcodeElement.GetElmentNodeImage(data), rect);
                }
                //3、画静态文本元素节点
                foreach (var txtElement in template.TextBoxList)
                {
                    Rectangle rect = new Rectangle(txtElement.Location.X, txtElement.Location.Y, txtElement.Size.Width, txtElement.Size.Height);
                    graphics.DrawImage(txtElement.GetElmentNodeImage(data), rect);
                }
                return bmp;
            }
        }

    PrintDocument对象就是对打印机画布进行的封装,主要就是GDI+的操作了。

    成果物

     

     

    展开全文
  • C# 标签(条码)的打印与设计(一) C# 标签(条码)的打印与设计(二) 总结:自定义设计条码
    展开全文
  • C# 程序设计手册(WORD)

    2010-10-19 15:40:30
    C# 程序的一般结构 8 Main() 和命令行自变量 9 命令行自变量 10 显示命令行自变量 12 使用 foreach 存取命令行自变量 13 Main() 传回值 14 数据型别 15 在变量宣告中指定型别 16 转型和型别转换 21 Boxing 和 ...
  • 基于C#的RFID读写上位机准备工作流程 准备 原理的了解 RFID原理-门禁系统 所需元器件 RFID模块:RC-522 IC卡感应模块 送S50复旦卡 优信5.3 [x] 工作流程 成功运作RFID标签 上位机界面设计 结合这...

    基于C#的RFID读写器上位机

    准备

    • 原理的了解
    • 所需元器件
      • RFID模块:RC-522 IC卡感应模块 送S50复旦卡 优信5.3
      • [x]

    工作流程

    • 成功运作RFID标签

    • 上位机界面设计

    • 结合这两者,完成通信

    • 计划任务

    • 完成任务

    展开全文
  • c#编程集合资料,不错的应用设计,另附一些开发案例的下载地址,欢迎大家下载学习。 学习完本课程之后,我们需要达到以下目标: (1) 掌握基本的C#语法,熟练运用C#编写基本的程序逻辑。 (2) 能够创建C#控制台...
  • Microsoft C# Windows程序设计(上下册)

    热门讨论 2011-08-05 10:28:13
    1.9 使用c#的关键特性进行程序设计 1.10 静态方法 1.11 异常处理 1.12 抛出异常 1.13 获取和设置属性 1.14 构造函数 1.15 实例和继承 1.16 更宏伟的蓝图 1.17 命名约定 1.18 几句题外话 .第二...
  • C#设计模式》针对日常的软件开发问题,设计模式提供了一种优雅的、通用的可重用解决方案。程序员可以通过设计模式组织程序中的对象,使其更易于编写和修改。《C#设计模式》正是一本设计模式的实用指南,帮助你采用...
  • C#--使用美化方法设计通用登录窗体

    千次阅读 2017-09-17 06:19:18
    去掉窗体边框设定窗体在桌面的起始位置设置窗体高度宽度设置窗体文本设置背景颜色拾色添加图片框 设置顶层自动填充:. 导入图片设置自动伸展布局覆盖图片文字设置文本 设置字体大小与颜色设置标签可拖动大小 ...

    通用登陆窗体示例

    这里写图片描述

    新建项目

    选择.net4.6程序集-添加项目
    这里写图片描述


    去掉窗体边框

    这里写图片描述


    设定窗体在桌面的起始位置

    这里写图片描述


    设置窗体高度宽度

    这里写图片描述


    设置窗体文本

    这里写图片描述


    设置背景颜色

    拾色器

    这里写图片描述


    添加图片框

    这里写图片描述
    设置顶层自动填充:.
    这里写图片描述

    导入图片

    这里写图片描述

    设置自动伸展布局

    这里写图片描述

    覆盖图片文字

    这里写图片描述

    设置文本
    这里写图片描述

    设置字体大小与颜色

    这里写图片描述

    设置标签可拖动大小
    这里写图片描述

    文字居中
    这里写图片描述

    设置标签背景颜色

    这里写图片描述

    设置标签字体颜色
    这里写图片描述

    这里写图片描述


    设置账号密码登陆文本框

    这里写图片描述

    设置密码掩饰:

    这里写图片描述

    这里写图片描述


    记住密码复选框

    这里写图片描述

    流行的扁平化设计
    这里写图片描述


    登陆按钮

    这里写图片描述

    同样设置扁平化样式

    设置按钮边框颜色

    这里写图片描述

    设置鼠标按下时的颜色

    这里写图片描述

    设置鼠标滑过的颜色

    这里写图片描述


    设置Tab键焦点

    这里写图片描述

    鼠标依次点击焦点

    这里写图片描述

    再次选择视图—再次点击Tab键顺序


    项目代码下载

    展开全文
  • 1.2.6 融入C#语言的迭代机制——迭代(Iterator) 29 1.3 可重载运算符(Overloadable Operators)与转换运算符(Conversion Operators) 35 1.3.1 The Day After Someday 35 1.3.2 用于有限的状态迭代 35 1.3.3 ...
  • 将.NET WinForms,C#或VB.Net主题化为Google的材料设计原则。 该项目暂时暂停(虽然我不经常更新,但我仍计划将来进行;也就是说,我仍然阅读每个问题并检查每个PR) 有一个快速的问题吗? 想讨论一些改进或质疑...
  • 第1 篇 预备知识——发掘用 C#语言进行面向对象化设计的潜力 ............................... 1 第1 章 重新研读 C#语言 ........................................................................................
  • c#期末试卷

    2011-12-21 21:26:08
    C#.NET 程序设计》试题一、单选题(每题 2分,共30 分) 1、打开代码编辑的功能键是( )  A、F1 (帮助) B、F5 (运行) C、F7 D、F12 2、加载窗体时触发的事件是( ) A、Click B、DoubleClick C、Gotfocus ...
  • 主要设计的是一个基于窗体的C#程序,在主对话框上面放置了一个标签控件,并创建了应用程序、进程和性能三个页面,标签控件用于选择并显示页面。三个页面分别用于显示当前运行的窗口程序、进程及进程模块、系统资源...
  • C#完整教程

    2011-11-02 21:47:46
    3.3 标签(Label)控件 59 3.4 按钮(Button)控件 60 3.5 事件处理函数的参数 60 3.6 文本框(TextBox)控件 61 3.7 Convert类 62 3.8 单选按钮(RadioButton)和GroupBox控件 62 3.9 Font类 63 3.10 多选框(CheckBox)控件 ...
  • C#开发典型模块大全

    2014-03-12 18:11:22
    7.3.3 绘制标签框 153 7.3.4 绘制图表中的表格 157 7.3.5 绘制条形图 163 7.3.6 绘制面形图 170 7.3.7 绘制饼形图 174 第8章 电子邮件收发模块 8.1 概述 180 8.2 关键技术 180 8.2.1 Base64编码...
  • C#关于 斑马RFID打印机的使用 ...官方设计软件,可测试rfid可以将设计好的标签模板打印到本地,获取zpl格式代码,改变量 官方SDK安装包需要Java环境,包里没找到可以直接引用的dll,引用时都报错,不过可以看一下tcp/i
  • C#实训教程

    2012-05-31 00:37:34
    14.11 标签、文本框、按钮控件简介 295 14.12 列表框控件简介 296 14.13 复选列表框 296 14.14 组合框 296 14.15 内容总结 302 15 Winform控件 303 15.1 控件分类 303 15.2 在窗体之间建立链接 307 15.3 ...
  • C#网站制作经典实操

    2018-05-29 19:46:49
    4.3.3 定义栏目标签,新闻列表标签的样式 57 4.3.4 定义newslist.aspx页的下拉框对象 58 4.3.5 定义newslist.aspx页的GridView对象 60 4.3.6 设计newlist.aspx页的GridView1对象 61 4.3.7 编辑GridView1对象模板列...
  • 构建高质量的C#代码 完整扫描版

    热门讨论 2014-06-04 12:24:48
    《构建高质量的C#代码》主要内容包括C#的基本语法、结构与应用特点,常用开发资源与技术要点,设计模式在C#中的应用等,以及特别重要的一点,即我们应该养成良好的开发习惯,不仅要注重技术细节,还要从更宽阔的视野...
  • C#全能速查宝典

    热门讨论 2014-04-26 16:16:27
    C#全能速查宝典》不仅适合C#程序设计初学者,也可作为中、高级程序开发人员的参考手册。 ============================================================ 图书目录 第1章 C#语言基础 1 1.1 常用概念、关键字及...
  • 明日科技C#示例源码

    2012-07-05 21:46:17
    实例045 设计信封标签报表 157 实例046 设计汇款单式报表 157 第5章 鼠标键盘控制 实例047 自定义动画鼠标 161 实例048 鼠标设置 163 实例049 屏蔽鼠标按键 167 实例050 虚拟键盘 172 ...
  • 7.3.3 绘制标签框 7.3.4 绘制图表中的表格 7.3.5 绘制条形图 7.3.6 绘制面形图 7.3.7 绘制饼形图 第8章 电子邮件收发模块 8.1 概述 8.2 关键技术 8.2.1 Base64编码格式 8.2.2 SMTP服务 8.2.3 POP3协议 8.2.4 使用...
  • 亮剑.NET_图解C#开发实战_源码完整版

    热门讨论 2013-02-05 18:04:47
     第4章 C#中的面向对象设计  4.1 面向对象设计简介  4.2 面向对象的基础——类  4.2.1 类的声明  4.2.2 类的变量  4.2.3 构造函数  4.2.4 析构函数  4.3 类的活动——方法  4.3.1 方法的定义  ...
  • C# winform典型系统开发模板

    热门讨论 2011-09-17 15:13:21
    第3章 SQL数据表提取模块   3.1 概述 56  3.2 关键技术 56  3.2.1 如何备份数据库 56  3.2.2 如何还原数据库 57  3.2.3 如何附加数据库 58  3.2.4 如何分离数据库 59  3.2.5 设置...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 180
精华内容 72
关键字:

C#标签设计器