Click here to Skip to main content
12,349,572 members (28,881 online)
Click here to Skip to main content
Articles » Languages » XML » Web Services » Downloads

Stats

58K views
742 downloads
38 bookmarked
Posted

Implementing WS-SecureConversation in Microsoft IssueVision

, 27 Sep 2005
Adding secure communications to the Microsoft IssueVision sample application using WSE 2.0.
Database
IssueVision
Controls
Outlook
Images
statusbar
toolbar
types
Libraries
ThreadHelper Documentation
Panes
Patterns
Web References
localhost
IssueVisionWebWseCS
Libraries
App.ico
IssueVision.csproj.user
IssueVision.snk
IssueVisionServices.disco
IssueVisionServices.wsdl
Reference.map
AppUpdater.dll
ThreadHelper.dll
About BackgroundWorker.doc
Async Windows Forms Programming with BackgroundWorker.doc
IssueVision-about-banner.png
mosaic-light.png
Signin.png
all_staffers.png
all_types.png
computer.png
environmental.png
help_desk.png
network.png
none.png
printer.png
staff.png
technicians.png
technicians_group.png
telecom.png
new_task.png
synchronize.png
work_offline.png
StatusConnected.ico
StatusDisconnected.ico
StatusSynchronizing.ico
IssueVisionWebWseCS.csproj.webinfo
IVDataSet.xsx
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace IssueVision
{
	// Chart control that displays three horizontal bars: Resolved,
	// Escalated and Open. Exposes public properties to set the three
	// values and specify chart colors.
	public class Chart : UserControl
	{
		// const values
		private const int Border = 10;
		private const int BottomBorder = 50;
		private const int LabelBorder = 1;
		private const int MessageBorder = 5;
		private const int MinBarWidth = 15;
		private const int LeftPos = 60;
		
		// bounding areas for chart and bars
		private Rectangle m_boundsChart;
		private RectangleF[] m_bounds = new RectangleF[3];
		
		private int m_barHeight;
		
		private int[] m_values = new int[3];
		
		private Color m_barColor = Color.FromArgb(250, 230, 165);
		private Color m_gridLineColor = Color.Gainsboro;
		private Color m_gridLineBaseColor = Color.SteelBlue;
		private Color m_labelColor = Color.DimGray;
		private Color m_valueColor = Color.Black;
		
		// text alignment
		private StringFormat m_formatRight;
		private StringFormat m_formatTop;
		private StringFormat m_formatLeft;
		private StringFormat m_formatCenter;
		
		// gdi objects
		private Brush m_brushLabel;
		private Brush m_brushValue;
		private Brush m_brushBar;
		private Pen m_penBaseGridLine;
		private Pen m_penGridLine;
		
		private IContainer components = null;

		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Number of open issues.")]
		[DefaultValueAttribute(0)]
		public int Open
		{
			get
			{
				return m_values[2];
			}

			set
			{
				if (value < 0)
				{
					value = 0;
				}
				m_values[2] = value;
				Invalidate();
			}
		}

		[DefaultValueAttribute(0)]
		[DescriptionAttribute("Number of resolved issues.")]
		[CategoryAttribute("Chart")]
		public int Resolved
		{
			get
			{
				return m_values[0];
			}

			set
			{
				if (value < 0)
				{
					value = 0;
				}
				m_values[0] = value;
				Invalidate();
			}
		}

		[DefaultValueAttribute(0)]
		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Number of escalated issues.")]
		public int Escalated
		{
			get
			{
				return m_values[1];
			}

			set
			{
				if (value < 0)
				{
					value = 0;
				}
				m_values[1] = value;
				Invalidate();
			}
		}

		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Color of the chart bars.")]
		[DefaultValueAttribute(typeof(Color), "250, 230, 165")]
		public Color BarColor
		{
			get
			{
				return m_barColor;
			}

			set
			{
				if (value == Color.Empty)
				{
					value = Color.FromArgb(250, 230, 165);
				}
				m_barColor = value;
				m_brushBar = new SolidBrush(m_barColor);
				Invalidate();
			}
		}

		[DescriptionAttribute("Color of the gridlines.")]
		[DefaultValueAttribute(typeof(Color), "Gainsboro")]
		[CategoryAttribute("Chart")]
		public Color GridLineColor
		{
			get
			{
				return m_gridLineColor;
			}

			set
			{
				if (value == Color.Empty)
				{
					value = Color.Gainsboro;
				}
				m_gridLineColor = value;
				m_penGridLine = new Pen(m_gridLineColor);
				Invalidate();
			}
		}

		[DescriptionAttribute("Color of the base gridline.")]
		[CategoryAttribute("Chart")]
		[DefaultValueAttribute(typeof(Color), "SteelBlue")]
		public Color BaseGridLineColor
		{
			get
			{
				return m_gridLineBaseColor;
			}

			set
			{
				if (value == Color.Empty)
				{
					value = Color.SteelBlue;
				}
				m_gridLineBaseColor = value;
				m_penBaseGridLine = new Pen(m_gridLineBaseColor);
				Invalidate();
			}
		}

		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Color of the labels and message.")]
		[DefaultValueAttribute(typeof(Color), "DimGray")]
		public Color LabelColor
		{
			get
			{
				return m_labelColor;
			}

			set
			{
				if (value == Color.Empty)
				{
					value = Color.DimGray;
				}
				m_labelColor = value;
				m_brushLabel = new SolidBrush(m_labelColor);
				Invalidate();
			}
		}

		[DefaultValueAttribute(typeof(Color), "Black")]
		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Color of the bar values.")]
		public Color ValueColor
		{
			get
			{
				return m_valueColor;
			}

			set
			{
				if (value == Color.Empty)
				{
					value = Color.Black;
				}
				m_valueColor = value;
				m_brushValue = new SolidBrush(m_valueColor);
				Invalidate();
			}
		}

		[DefaultValueAttribute("")]
		[CategoryAttribute("Chart")]
		[DescriptionAttribute("Chart message at the bottom.")]
		public string Message
		{
			get
			{
				return base.Text;
			}

			set
			{
				base.Text = value;
			}
		}

		public Chart()
		{
			// init the gdi objects, do this by setting the
			// color properties (creates the associated gdi object)
			BarColor = m_barColor;
			GridLineColor = m_gridLineColor;
			BaseGridLineColor = m_gridLineBaseColor;
			LabelColor = m_labelColor;
			ValueColor = m_valueColor;
			
			// init the font
			Font = new Font("arial", 7.0F, FontStyle.Regular);
			
			// setup text alignments, used later when draw strings
			m_formatRight = new StringFormat();
			m_formatRight.Alignment = StringAlignment.Far;
			m_formatRight.LineAlignment = StringAlignment.Center;
			
			m_formatTop = new StringFormat();
			m_formatTop.Alignment = StringAlignment.Center;
			m_formatTop.LineAlignment = StringAlignment.Near;
			
			m_formatLeft = new StringFormat();
			m_formatLeft.LineAlignment = StringAlignment.Center;
			
			m_formatCenter = new StringFormat();
			m_formatCenter.Alignment = StringAlignment.Center;
			m_formatCenter.LineAlignment = StringAlignment.Center;
			
			// turn on double buffering
			SetStyle(ControlStyles.UserPaint | ControlStyles.ResizeRedraw | ControlStyles.AllPaintingInWmPaint | ControlStyles.DoubleBuffer, true);
			
			InitializeComponent();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && components != null)
			{
				components.Dispose();
			}
			base.Dispose(disposing);
		}

		[DebuggerStepThroughAttribute()]
		private void InitializeComponent()
		{
			Name = "Chart";
			Size = new Size(120, 120);
		}

		// recalculate the position of the bars and labels
		protected override void OnSizeChanged(EventArgs e)
		{
			CalculateBounds();
			base.OnSizeChanged(e);
		}
		
		// recalculate the position of the bars and labels
		protected override void OnFontChanged(EventArgs e)
		{
			base.OnFontChanged(e);
			CalculateBounds();
		}

		// update right away
		protected override void OnTextChanged(EventArgs e)
		{
			base.OnTextChanged(e);
			CalculateBounds();
			Invalidate();
		}

		// draw the chart
		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);
			
			// clear and init the drawing surface
			e.Graphics.Clear(Parent.BackColor);
			e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
			
			// only draw if sized large enough to display the data
			if (Width > LeftPos && m_barHeight > 1)
			{
				DrawLabels(e.Graphics);
				DrawChart(e.Graphics);
			}
			
			// always draw the message
			DrawMessage(e.Graphics);
		}

		// calculate the bounding area, used later when drawing the chart
		private void CalculateBounds()
		{
			// chart area
			m_boundsChart = new Rectangle(LeftPos, Border, Width - Border - LeftPos, Height - Font.Height - (Border * 2));
			
			// see if need to leave room for the message
			if (Text != null && Text.Length > 0)
			{
				m_boundsChart.Height -= (Font.Height + MessageBorder);
			}
			
			// bar height
			m_barHeight = m_boundsChart.Height / 6;
			
			// resolved area
			m_bounds[0] = new RectangleF(0.0F, (m_boundsChart.Top + m_barHeight), (LeftPos - LabelBorder), m_barHeight);
			
			// escalated area
			m_bounds[1] = new RectangleF(0.0F, (m_boundsChart.Top + (m_boundsChart.Height / 2) - (m_barHeight / 2)), (LeftPos - LabelBorder), m_barHeight);
			
			// open area
			m_bounds[2] = new RectangleF(0.0F, (m_boundsChart.Bottom - (m_barHeight * 2)), (LeftPos - LabelBorder), m_barHeight);
		}

		// labels on the left side
		private void DrawLabels(Graphics g)
		{
			g.DrawString("Resolved", Font, m_brushLabel, m_bounds[0], m_formatRight);
			g.DrawString("Escalated", Font, m_brushLabel, m_bounds[1], m_formatRight);
			g.DrawString("Open", Font, m_brushLabel, m_bounds[2], m_formatRight);
		}

		// message at the bottom left
		private void DrawMessage(Graphics g)
		{
			if (Text != null && Text.Length != 0)
			{
				// draw the message
				g.DrawString(Text, Font, m_brushLabel, MessageBorder, (Bottom - MessageBorder - Font.Height));
			}
		}

		// draw the chart, gridlines, bars and values
		private void DrawChart(Graphics g)
		{
			// calcualte the distance between the gridlines
			int space = m_boundsChart.Width / 5;
			
			// draw the gridlines
			for (int i = 1; i <= 5; i++)
			{
				g.DrawLine(m_penGridLine, m_boundsChart.Left + (space * i), m_boundsChart.Top, m_boundsChart.Left + (space * i), m_boundsChart.Bottom);
			}
			
			// draw the gridline labels
			int tick = (int)Math.Round(Math.Ceiling(Math.Max(Math.Max(m_values[0], m_values[1]), m_values[2]) / 5.0));
			for (int i = 0; i <= 5; i++)
			{
				g.DrawString((tick * i).ToString(), Font, m_brushLabel, (m_boundsChart.Left + space * i), m_boundsChart.Bottom, m_formatTop);
			}
			
			// calculate the real chart width (might be less then the control width)
			int chartWidth = space * 5;
			
			// ending tick mark
			int totalTicks = tick * 5;
			
			// loop through and draw each bar
			int barWidth = 0;
			
			for (int i = 0; i <= 2; i++)
			{
				// bar
				if (totalTicks > 0)
				{
					barWidth = (chartWidth * m_values[i]) / totalTicks;
				}
				
				g.FillRectangle(m_brushBar, m_boundsChart.Left, m_bounds[i].Top, barWidth, m_barHeight);
				
				// label
				if (barWidth > MinBarWidth)
				{
					// center label
					g.DrawString(	m_values[i].ToString(), 
									Font, 
									m_brushValue, 
									(m_boundsChart.Left + (barWidth / 2)), 
									m_bounds[i].Top + (int)Math.Round((double)(m_bounds[i].Height / 2.0F)) + 1.0F, 
									m_formatCenter);
				}
				else
				{
					// label outside of the bar
					g.DrawString(	m_values[i].ToString(), 
									Font, 
									m_brushValue, 
									(m_boundsChart.Left + barWidth + 2), 
									m_bounds[i].Top + (int)Math.Round((double)(m_bounds[i].Height / 2.0F)) + 1.0F, 
									m_formatLeft);
				}
			}

			// draw the baseline last
			g.DrawLine(m_penBaseGridLine, m_boundsChart.Left, m_boundsChart.Top, m_boundsChart.Left, m_boundsChart.Bottom);
		}
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Weidong Shen
Software Developer (Senior)
United States United States
Weidong has been an information system professional since 1990. He has a Master's degree in Computer Science, and is currently a MCSD .NET

You may also be interested in...

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.160621.1 | Last Updated 27 Sep 2005
Article Copyright 2005 by Weidong Shen
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid