Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Controls/ILPanel.cs @ 10903

Visit:

Last change on this file since 10903 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 93.7 KB

Line
1	///
2	/// This file is part of ILNumerics Community Edition.
3	///
4	/// ILNumerics Community Edition - high performance computing for applications.
5	/// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
6	///
7	/// ILNumerics Community Edition is free software: you can redistribute it and/or modify
8	/// it under the terms of the GNU General Public License version 3 as published by
9	/// the Free Software Foundation.
10	///
11	/// ILNumerics Community Edition is distributed in the hope that it will be useful,
12	/// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	/// GNU General Public License for more details.
15	///
16	/// You should have received a copy of the GNU General Public License
17	/// along with ILNumerics Community Edition. See the file License.txt in the root
18	/// of your distribution package. If not, see <http://www.gnu.org/licenses/>.
19	///
20	/// In addition this software uses the following components and/or licenses:
21	///
22	/// =================================================================================
23	/// The Open Toolkit Library License
24	///
25	/// Copyright (c) 2006 - 2009 the Open Toolkit library.
26	///
27	/// Permission is hereby granted, free of charge, to any person obtaining a copy
28	/// of this software and associated documentation files (the "Software"), to deal
29	/// in the Software without restriction, including without limitation the rights to
30	/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
31	/// the Software, and to permit persons to whom the Software is furnished to do
32	/// so, subject to the following conditions:
33	///
34	/// The above copyright notice and this permission notice shall be included in all
35	/// copies or substantial portions of the Software.
36	///
37	/// =================================================================================
38	///
39
40	#pragma warning disable 1591
41
42	using System;
43	using System.Collections.Generic;
44	using System.Text;
45	using System.Drawing;
46	using System.Reflection;
47	using System.Windows.Forms;
48	using System.IO;
49	using ILNumerics.Drawing;
50	using ILNumerics.Drawing.Interfaces;
51	using ILNumerics.Drawing.Collections;
52	using ILNumerics.Drawing.Graphs;
53	using ILNumerics.Drawing.Labeling;
54	using ILNumerics.Drawing.Misc;
55	using System.Diagnostics;
56
57	namespace ILNumerics.Drawing {
58
59	/// <summary>
60	/// Basic abstract base class for GL dependent display.
61	/// </summary>
62	/// <remarks>This control is the main plot control of ILNumerics.</remarks>
63	public abstract class ILPanel : Control {
64
65	#region attributes
66	protected ILRendererManager m_textRendererManager;
67	protected ILClippingData m_clippingView;
68	protected ILAxisCollection m_axes;
69	protected ILGraphCollection m_graphs;
70	protected ILTextureManager m_textureManager;
71	protected Point m_mouseStart;
72	protected bool m_isDragging;
73	protected bool m_active = false;
74	protected bool m_drawHidden = true;
75	protected bool m_ready = false;
76	private bool m_isStartingUp = true;
77	protected ILCamera m_camera;
78	protected ILCamera m_defaultView;
79	protected bool m_autoDefaultView = true;
80	protected InteractiveModes m_selectingMode = InteractiveModes.Rotating;
81	protected InteractiveModes m_oldSelectingMode;
82	protected bool m_isCtrlKeyDown;
83	protected ILPoint3Df m_scaling;
84	protected Projection m_projection = Projection.Orthographic;
85	protected Color m_backColor = Color.FromKnownColor(KnownColor.Control);
86	protected Color m_cubeBGColor = Color.FromArgb(250, 250, 250);
87	protected ILColormap m_colormap;
88	protected ILLegend m_legend;
89	protected ZoomModes m_zoomMode = ZoomModes.RollHard;
90	protected ILZoomAction m_zoomAction;
91	protected float m_zoomOffset = 50f;
92	protected GraphicDeviceType m_graphicsDevice;
93	protected ILLineProperties m_selectionRectangle;
94	protected bool m_fillBackground = true;
95	private AutoZoomOptions m_autoZoomOptions = AutoZoomOptions.OnDataChanges;
96	protected ILLayoutData m_layoutData = new ILLayoutData();
97	protected ILLightCollection m_lights = new ILLightCollection();
98	protected ILRenderProperties m_renderProperties;
99	protected ILAction m_action;
100	protected List<ILGraph> m_sortingCacheList = new List<ILGraph>();
101	/// <summary>
102	/// pixel size of the current PlotCubeScreenRectangle
103	/// </summary>
104	protected RectangleF m_plotBoxScreenRectF;
105	protected PlotBoxScreenSizeMode m_plotBoxScreenSizeMode;
106	protected AspectRatioMode m_aspectRatio;
107	protected double[] m_clipplanes = new double[24];
108
109	private const int MAXRENDERPASSES = 2;
110	private const float LABELS_VERTICAL_MIN_RHO = 0.8f;
111	protected const float pi05 = (float) Math.PI / 2;
112	protected const float pi2 = (float) Math.PI * 2;
113	protected const float pi32 = (float) Math.PI / 2 * 3;
114	protected const float pi4 = (float) Math.PI / 4;
115	protected const float pi8 = (float) Math.PI / 8;
116	#endregion
117
118	#region properties
119	/// <summary>
120	/// Gets the mode for automatic view angle updates or sets it
121	/// </summary>
122	public bool AutoDefaultView {
123	get { return m_autoDefaultView; }
124	set { m_autoDefaultView = value; }
125	}
126	/// <summary>
127	/// Determines how the projected data plots are mapped to PlotCubeScreenRectF
128	/// </summary>
129	public AspectRatioMode AspectRatio {
130	get { return m_aspectRatio; }
131	set { m_aspectRatio = value; }
132	}
133	/// <summary>
134	/// The normalizes projected size (range 0..1) of plot cube on 2D client area, on set: also sets PlotCubeScreenMode -> Manual
135	/// </summary>
136	public RectangleF PlotBoxScreenRect {
137	get { return m_plotBoxScreenRectF; }
138	set {
139	m_plotBoxScreenRectF = value;
140	m_plotBoxScreenSizeMode = PlotBoxScreenSizeMode.Manual;
141	//Invalidate();
142	}
143	}
144	/// <summary>
145	/// Options for determining the size of the plot cube on the 2D screen client area, default: optimal
146	/// </summary>
147	public PlotBoxScreenSizeMode PlotBoxScreenSizeMode {
148	get { return m_plotBoxScreenSizeMode; }
149	set {
150	m_plotBoxScreenSizeMode = value;
151	if (value == PlotBoxScreenSizeMode.Maximum) {
152	m_plotBoxScreenRectF = new RectangleF(0, 0, 1f, 1f);
153	}
154	}
155	}
156	/// <summary>
157	/// Access collection of lights for configuration
158	/// </summary>
159	public ILLightCollection Lights {
160	get { return m_lights; }
161	}
162	/// <summary>
163	/// Legend for panel's graphs
164	/// </summary>
165	public ILLegend Legend {
166	get {
167	return m_legend;
168	}
169	}
170	/// <summary>
171	/// Get texture manager instance, storing all textures used in the scene
172	/// </summary>
173	internal ILTextureManager TextureManager {
174	get {
175	return m_textureManager;
176	}
177	}
178	/// <summary>
179	/// Colormap used to translate color indices into true colors
180	/// </summary>
181	public ILColormap Colormap {
182	get {
183	return m_colormap;
184	}
185	set {
186	m_colormap = value;
187	OnColormapChanged();
188	}
189	}
190	/// <summary>
191	/// Determines if background of the rendering cube will be filled with the CubeBackgroundColor property value
192	/// </summary>
193	public bool BackgroundFilled {
194	get {
195	return m_fillBackground;
196	}
197	set {
198	m_fillBackground = value;
199	//Invalidate();
200	}
201	}
202	/// <summary>
203	/// True: the control will always be drawn, even if it does not own the focus
204	/// </summary>
205	public bool DrawInactive {
206	get {
207	return m_drawHidden;
208	}
209	set {
210	m_drawHidden = value;
211	//Invalidate();
212	}
213	}
214	/// <summary>
215	/// Get/set the background color for the inner cube drawing
216	/// </summary>
217	public Color BackColorCube {
218	get {
219	return m_cubeBGColor;
220	}
221	set {
222	m_cubeBGColor = value;
223	//Invalidate();
224	}
225	}
226	/// <summary>
227	/// View settings, get access to the clipping limits for all axises
228	/// </summary>
229	public ILClippingData Limits {
230	get {
231	return m_clippingView;
232	}
233	}
234	/// <summary>
235	/// Get the type of device currently used for rendering
236	/// </summary>
237	public GraphicDeviceType GraphicDeviceType {
238	get {
239	return m_graphicsDevice;
240	}
241	}
242	/// <summary>
243	/// Get/set properties for selection rectangle, drawn when zooming with the mouse
244	/// </summary>
245	public ILLineProperties SelectionRectangle {
246	get {
247	return m_selectionRectangle;
248	}
249	}
250	/// <summary>
251	/// color of the figure background
252	/// </summary>
253	public override Color BackColor {
254	get {
255	return m_backColor;
256	}
257	set {
258	m_backColor = value;
259	//Invalidate();
260	}
261	}
262	/// <summary>
263	/// type of projection: orthographic (default) or perspective
264	/// </summary>
265	public Projection Projection {
266	get {
267	return m_projection;
268	}
269	set {
270	m_projection = value;
271	//Invalidate();
272	}
273	}
274	/// <summary>
275	/// Get or set viewport properties (distance & angles)
276	/// </summary>
277	/// <remarks>Changing </remarks>
278	public ILCamera Camera {
279	get {
280	return m_camera;
281	}
282	}
283	/// <summary>
284	/// Get the current mode for mouse interaction or set's it
285	/// </summary>
286	public InteractiveModes InteractiveMode {
287	get {
288	return m_selectingMode;
289	}
290	set {
291	m_selectingMode = value;
292	m_oldSelectingMode = value;
293	//if (value == InteractiveModes.Rotating)
294	// m_axes[AxisNames.ZAxis].Visible = true;
295	//else if (value == InteractiveModes.ZoomRectangle)
296	// m_axes[AxisNames.ZAxis].Visible = false;
297	}
298	}
299	/// <summary>
300	/// Gives all graphs as value collection (readonly)
301	/// </summary>
302	public ILGraphCollection Graphs {
303	get {
304	if (m_graphs == null)
305	CreateControl();
306	return m_graphs;
307	}
308	}
309	/// <summary>
310	/// Get axes collection - holds all 3 axes
311	/// </summary>
312	public ILAxisCollection Axes {
313	get {
314	if (m_axes == null)
315	CreateControl();
316	return m_axes;
317	}
318	}
319	/// <summary>
320	/// (experimental) content for graphs will be clipped outside the unit cube
321	/// </summary>
322	/// <remarks>For 2D plots, not clipping the vertex data may lead to hiding
323	/// the labels drawn next to axes. For 3D plots Clipping may cause unexpected behavior.
324	/// <para>Therefore Clipping will be activated for 2D plots by default and
325	/// deactivated for 3D plots by default.</para></remarks>
326	public bool ClipViewData {
327	get {
328	return m_renderProperties.Clipping;
329	}
330	set {
331	m_renderProperties.Clipping = value;
332	}
333	}
334	/// <summary>
335	/// Manager providing collection of available IILTextRenderer types
336	/// </summary>
337	/// <remarks>IILTextRenderer are used to draw labels for axis of this panel (device specific).
338	/// <para>Text renderer objects must be instantiated through the ILTextRendererManager instance's
339	/// CreateInstance() method.</para></remarks>
340	public ILRendererManager TextRendererManager {
341	get {
342	return m_textRendererManager;
343	}
344	}
345	/// <summary>
346	/// Get or set default camera position for reset of the scene
347	/// </summary>
348	/// <remarks>The default position is used when the scene is reset. That
349	/// reset is usually triggered by double clicking the panel with the mouse.
350	/// <para>setting this value to null will make the panel ignore any double
351	/// clicks, which enables the user to manually react to double click via the
352	/// common DoubleClick event of the panel and reset the camera position from
353	/// outside the component.</para></remarks>
354	public ILCamera DefaultView {
355	get {
356	return m_defaultView;
357	}
358	protected set {
359	if (value != null) {
360	m_defaultView = value;
361	m_autoDefaultView = false;
362	} else {
363	m_autoDefaultView = true;
364	}
365	}
366	}
367	/// <summary>
368	/// Options for the view cube adapting data limit changes
369	/// </summary>
370	public AutoZoomOptions AutoZoomContent {
371	get {
372	return m_autoZoomOptions;
373	}
374	set {
375	m_autoZoomOptions = value;
376	}
377	}
378	/// <summary>
379	/// choose the ramp for zooming
380	/// </summary>
381	public ZoomModes ZoomMode {
382	get { return m_zoomMode; }
383	set { m_zoomMode = value; }
384	}
385	/// <summary>
386	/// How much the view cube will be shrinked/expanded on zooming operations (percent)
387	/// </summary>
388	public float ZoomOffset {
389	set { m_zoomOffset = value; }
390	get { return m_zoomOffset; }
391
392	}
393	protected ILZoomAction ZoomAction {
394	get {
395	return m_zoomAction;
396	}
397	}
398	#endregion
399
400	#region constructors
401	protected ILPanel(GraphicDeviceType graphicsDevice) : base () {
402	#if TRACE
403	Trace.TraceInformation("{0},{1} ILPanel.ctor()",DateTime.Now, Environment.TickCount);
404	#endif
405	this.DoubleBuffered = false;
406	//BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
407	m_plotBoxScreenSizeMode = PlotBoxScreenSizeMode.Optimal;
408	m_graphicsDevice = graphicsDevice;
409	m_textureManager = new ILTextureManager(m_graphicsDevice);
410	m_textureManager.DefaultHeight = 500;
411	m_textureManager.DefaultWidth = 500;
412	m_selectionRectangle = new ILLineProperties();
413	m_selectionRectangle.Antialiasing = false;
414	m_selectionRectangle.Color = Color.Blue;
415	m_selectionRectangle.Width = 1;
416	m_selectionRectangle.Style = LineStyle.Solid;
417	m_selectionRectangle.Changed += new EventHandler(m_selectionRectangle_Changed);
418	m_camera = new ILCamera((float)0.0f,0.0f,10.0f);
419	m_defaultView = new ILCamera(m_camera);
420	m_defaultView.Changed += new EventHandler(m_defaultView_Changed);
421	m_renderProperties = new ILRenderProperties ();
422	m_renderProperties.Camera = Camera;
423	m_textRendererManager = new ILRendererManager(this);
424	m_clippingView = new ILClippingData();
425	m_clippingView.AllowZeroVolume = false;
426	m_layoutData = new ILLayoutData(m_camera);
427	m_clippingView.Changed += new ILClippingDataChangedEvent(m_viewLimits_Changed);
428	m_colormap = new ILColormap();
429	m_colormap.Changed += new EventHandler(m_colormap_Changed);
430	Padding = new Padding(5);
431	BackColor = Color.White;
432	Dock = DockStyle.Fill;
433	m_legend = ILLegend.Create(this);
434	m_legend.Changed += new EventHandler(m_legend_Changed);
435	m_active = false;
436	m_ready = false;
437	}
438
439	#endregion
440
441	#region public interface function
442	/// <summary>
443	/// Dispose this panel, frees all devices, graph- and axis collection
444	/// </summary>
445	public new void Dispose () {
446	Dispose(false);
447	}
448	/// <summary>
449	/// dispose this panel
450	/// </summary>
451	/// <param name="disposing">manual disposing</param>
452	/// <remarks>derived classed (ILDXPanel,ILOGLPanel) free their resources here</remarks>
453	protected override void Dispose(bool disposing) {
454	#if TRACE
455	Trace.TraceInformation("{0},{1} ILPanel.Dispose(bool) start",DateTime.Now, Environment.TickCount);
456	Trace.Indent();
457	#endif
458	m_ready = false;
459	if (m_graphs != null)
460	m_graphs.Dispose();
461	if (m_axes != null)
462	m_axes.Dispose();
463	if (m_textureManager != null)
464	m_textureManager.Dispose();
465	base.Dispose(disposing);
466	#if TRACE
467	Trace.Unindent();
468	Trace.TraceInformation("{0},{1} ILPanel.Dispose(bool) end",DateTime.Now, Environment.TickCount);
469	#endif
470	}
471
472	/// <summary>
473	/// causes the panel to redraw
474	/// </summary>
475	public override void Refresh() {
476	if (InvokeRequired) {
477	Invoke((MethodInvoker) delegate () { Refresh(); });
478	} else {
479	base.Refresh();
480	}
481	}
482	#endregion
483
484	#region events
485	/// <summary>
486	/// fired, if the data limits of any graphs changed
487	/// </summary>
488	public event ILClippingDataChangedEvent DataLimitsChanged;
489	/// <summary>
490	/// fired, if the clipping rectangle for viewing graphs changed
491	/// </summary>
492	public event ILClippingDataChangedEvent ViewLimitsChanged;
493	/// <summary>
494	/// fires, if the current colormap has changed
495	/// </summary>
496	public event EventHandler ColormapChanged;
497	/// <summary>
498	/// fired, if the internal graphics device reset (Direct3D devices only)
499	/// </summary>
500	public event ILGraphicsDeviceResetEvent GraphicsDeviceReset;
501	/// <summary>
502	/// fired, if the internal graphics device has been (re)created
503	/// </summary>
504	public event ILGraphicsDeviceCreatedEvent GraphicsDeviceCreated;
505	#endregion
506
507	#region event handlers
508	protected void m_defaultView_Changed(object sender, EventArgs e) {
509	m_autoDefaultView = false;
510	}
511	protected override void OnHandleCreated(EventArgs e) {
512	#if TRACE
513	Trace.TraceInformation("{0},{1} ILPanel.OnHandleCreated() start",DateTime.Now, Environment.TickCount);
514	Trace.Indent();
515	#endif
516	base.OnHandleCreated(e);
517	this.SetStyle(ControlStyles.AllPaintingInWmPaint,true);
518	this.SetStyle(ControlStyles.UserPaint,true);
519	#if TRACE
520	Trace.Unindent();
521	Trace.TraceInformation("{0},{1} ILPanel.OnHandleCreated() end",DateTime.Now, Environment.TickCount);
522	#endif
523	}
524	protected override void OnHandleDestroyed(EventArgs e) {
525	#if TRACE
526	Trace.TraceInformation("{0},{1} ILPanel.OnHandleDestroyed() start",DateTime.Now, Environment.TickCount);
527	Trace.Indent();
528	#endif
529	if (m_zoomAction != null) m_zoomAction.Cancel();
530	Dispose();
531	base.OnHandleDestroyed(e);
532	#if TRACE
533	Trace.Unindent();
534	Trace.TraceInformation("{0},{1} ILPanel.OnHandleDestroyed() end",DateTime.Now, Environment.TickCount);
535	#endif
536
537	}
538	protected virtual void OnViewLimitsChanged(ClippingChangedEventArgs e) {
539	if (ViewLimitsChanged != null)
540	ViewLimitsChanged(this,e);
541	}
542	protected virtual void OnDataLimitsChanged(ClippingChangedEventArgs e) {
543	if (DataLimitsChanged != null)
544	DataLimitsChanged(this,e);
545	}
546	protected virtual void OnGraphicsDeviceReset() {
547	#if TRACE
548	Trace.TraceInformation("{0},{1} ILPanel.OnGraphicsDeviceReset() start",DateTime.Now, Environment.TickCount);
549	Trace.Indent();
550	#endif
551	Configure();
552	if (GraphicsDeviceReset != null) {
553	GraphicsDeviceReset(this,null);
554	}
555	#if TRACE
556	Trace.Unindent();
557	Trace.TraceInformation("{0},{1} ILPanel.OnGraphicsDeviceReset() end",DateTime.Now, Environment.TickCount);
558	#endif
559	}
560	protected virtual void OnGraphicsDeviceCreated() {
561	#if TRACE
562	Trace.TraceInformation("{0},{1} ILPanel.OnGraphicsDeviceCreated() start",DateTime.Now, Environment.TickCount);
563	Trace.Indent();
564	#endif
565	IILCreationFactory graphFact = GetCreationFactory();
566	m_graphs = new ILGraphCollection(graphFact);
567	m_graphs.CollectionChanged += new ILGraphCollectionChangedEvent(m_graphs_OnCollectionChanged);
568	m_graphs.Limits.Changed += new ILClippingDataChangedEvent(m_dataLimits_Changed);
569	m_graphs.GraphChanged += new ILGraphChangedEvent(m_graphs_GraphChanged);
570	m_axes = new ILAxisCollection(m_clippingView,graphFact);
571	if (GraphicsDeviceCreated!= null) {
572	GraphicsDeviceCreated(this,null);
573	}
574	//Invalidate();
575	#if TRACE
576	Trace.Unindent();
577	Trace.TraceInformation("{0},{1} ILPanel.OnGraphicsDeviceCreated() end",DateTime.Now, Environment.TickCount);
578	#endif
579	}
580
581	protected virtual void OnColormapChanged() {
582	if (ColormapChanged != null)
583	ColormapChanged(this,null);
584	m_graphs.Invalidate();
585	}
586
587	protected override void OnLostFocus(EventArgs e) {
588	base.OnLostFocus(e);
589	m_active = false;
590	}
591	protected override void OnGotFocus(EventArgs e) {
592	base.OnGotFocus(e);
593	m_active = true;
594	}
595	protected override void OnVisibleChanged(EventArgs e) {
596	if (IsHandleCreated && !IsDisposed) {
597	base.OnVisibleChanged(e);
598	if (Visible)
599	m_active = true;
600	else
601	m_active = false;
602	}
603	}
604	protected override void OnSizeChanged(EventArgs e) {
605	base.OnSizeChanged(e);
606	base.Invalidate();
607	}
608
609	protected override void OnMouseMove(MouseEventArgs e) {
610	base.OnMouseMove(e);
611	if (m_selectingMode == InteractiveModes.Rotating) {
612	#region rotation
613	if (m_isDragging \|\| (e.Button == System.Windows.Forms.MouseButtons.Left
614	&& Math.Sqrt(Math.Pow(Math.Abs(e.X - m_mouseStart.X),2) + Math.Pow(Math.Abs(e.Y - m_mouseStart.Y),2)) > 3.0)) {
615	m_isDragging = true;
616	m_camera.EventingSuspend();
617	int distX = e.Location.X - m_mouseStart.X;
618	int distY = e.Location.Y - m_mouseStart.Y;
619	float tmp = m_camera.Phi - distX / 200.0f;
620	// if alt is pressed, lock on even angles
621	if (((Control.ModifierKeys & Keys.Alt) != 0)
622	&& (Math.Abs(Math.Round(tmp/pi4) - (tmp / pi4)) < 0.05)) {
623	tmp = (float)(Math.Round(tmp / pi4) * pi4);
624	}
625	m_camera.Phi = tmp;
626	tmp = m_camera.Rho - distY / 200.0f;
627	// if alt is pressed, lock on even angles
628	if (((Control.ModifierKeys & Keys.Alt) != 0)
629	&& (Math.Abs(Math.Round(tmp/pi8) - (tmp / pi8)) < 0.05)) {
630	tmp = (float)(Math.Round(tmp / pi8) * pi8);
631	}
632	m_camera.Rho = tmp;
633	if (m_camera.Rho > Math.PI) m_camera.Rho = (float)Math.PI;
634	if (m_camera.Rho < 0) m_camera.Rho = 0.0f;
635	m_camera.EventingResume();
636	m_mouseStart = e.Location;
637	Refresh();
638	}
639	#endregion
640	} else if (m_selectingMode == InteractiveModes.ZoomRectangle) {
641	#region selection rectangle
642	if (m_isDragging \|\| (e.Button == System.Windows.Forms.MouseButtons.Left
643	&& Math.Sqrt(Math.Pow(Math.Abs(e.X - m_mouseStart.X),2) + Math.Pow(Math.Abs(e.Y - m_mouseStart.Y),2)) > 3.0)) {
644	m_isDragging = true;
645	Cursor = Cursors.Cross;
646	Refresh();
647	}
648	#endregion
649	} else if (m_selectingMode == InteractiveModes.Translating) {
650	if (m_isDragging \|\| (e.Button == System.Windows.Forms.MouseButtons.Left
651	&& Math.Sqrt(Math.Pow(Math.Abs(e.X - m_mouseStart.X),2) + Math.Pow(Math.Abs(e.Y - m_mouseStart.Y),2)) > 1.0)) {
652	ILPoint3Df p1,p2,dummy;
653	Screen2World(m_mouseStart.X,Height - m_mouseStart.Y, out p1, out dummy);
654	Screen2World(e.X, Height - e.Y, out p2, out dummy);
655	if (m_projection == Projection.Perspective) {
656	p1 = ILPoint3Df.normalize(p1 - m_camera.Position) * m_camera.Distance;
657	p2 = ILPoint3Df.normalize(p2 - m_camera.Position) * m_camera.Distance;
658	}
659	p1 = p2 - p1;
660	m_camera.LookAt -= p1;
661	m_mouseStart = e.Location;
662	Refresh();
663	}
664
665	}
666	}
667	protected override void OnMouseUp(MouseEventArgs e) {
668	base.OnMouseUp(e);
669	//System.Diagnostic.Debug.WriteLine("MouseUp");
670	if (m_selectingMode == InteractiveModes.ZoomRectangle && m_isDragging) {
671	Zoom(Screen2World2D(m_mouseStart.X,Height - m_mouseStart.Y),Screen2World2D(e.X, Height - e.Y));
672	}
673	m_isDragging = false;
674	Cursor = Cursors.Default;
675	}
676	protected override void OnMouseDown(MouseEventArgs e) {
677	base.OnMouseDown(e);
678	m_mouseStart = e.Location;
679	}
680	protected override void OnMouseClick(MouseEventArgs e) {
681	base.OnMouseClick(e);
682	//System.Diagnostic.Debug.WriteLine("Click");
683	if (m_isDragging == false && (m_selectingMode == InteractiveModes.ZoomRectangle
684	\|\| m_selectingMode == InteractiveModes.Rotating)) {
685	// determine new center coords
686	ILPoint3Df near, far;
687	Screen2World(e.X,Height - e.Y, out near, out far); //Limits.CenterF.Z);
688	if (e.Button == System.Windows.Forms.MouseButtons.Left) {
689	Zoom(near,far,m_zoomOffset / 100);
690	}
691	else if (e.Button == System.Windows.Forms.MouseButtons.Right)
692	Zoom(near,far,- m_zoomOffset / 100);
693	}
694	}
695	protected override void OnMouseDoubleClick(MouseEventArgs e) {
696	base.OnMouseDoubleClick(e);
697	ResetView(true);
698	Refresh();
699	}
700	protected override void OnKeyDown(KeyEventArgs e) {
701	if (e.Control && !m_isCtrlKeyDown) {
702	m_oldSelectingMode = m_selectingMode;
703	m_selectingMode = InteractiveModes.Translating;
704	m_isCtrlKeyDown = true;
705	Cursor = Cursors.NoMove2D;
706	//m_isDragging = false;
707	}
708	base.OnKeyDown(e);
709	}
710	protected override void OnKeyUp(KeyEventArgs e) {
711	if (!e.Control) {
712	if (m_isCtrlKeyDown) {
713	m_isCtrlKeyDown = false;
714	m_selectingMode = m_oldSelectingMode;
715	}
716	Cursor = Cursors.Default;
717	//m_isDragging = false;
718	}
719	base.OnKeyUp(e);
720	}
721	protected override void OnPaint(System.Windows.Forms.PaintEventArgs e) {
722	if (DesignMode) {
723	e.Graphics.Clear(Color.LightBlue);
724	return;
725	}
726	if (e.ClipRectangle.Width == 0 \|\| e.ClipRectangle.Height == 0) {
727	#if TRACE
728	Trace.TraceInformation("{0},{1} ILPanel.OnPaint(): ClipRectangle.Size = empty -> skipping",DateTime.Now, Environment.TickCount);
729	#endif
730	return;
731	}
732	/* THIS IS PRELIMINARY IMPLEMENTATION! REASON: While using GDI renderer,
733	* it is importatnt, to have the whole (visible) surface area invalidated
734	* and available for clipping of the graphics objects in 'e'. Otherwise
735	* rendered objects will not show, after the buffers have swapped. The
736	* following code helps pick those situations, where the clipping region
737	* is only a subregion of the controls surface, but it introduces new
738	* problems, if the whole control is (partially) obscured by other controls.
739	* Since the GDI Renderer currently is not the recommended method of rendering,
740	* this code is commented until a better solution was found. */
741	// if (e.ClipRectangle.X > 0 \|\| e.ClipRectangle.Y > 0) {
742	//#if TRACE
743	// Trace.TraceInformation("{0},{1} ILPanel.OnPaint(): partial clipping detected -> refreshing whole controls area",DateTime.Now, Environment.TickCount);
744	//#endif
745	// Refresh();
746	// return;
747	// }
748	try {
749	#if TRACE
750	Trace.TraceInformation("{0},{1} ILPanel.OnPaint(): started (re-)configure",DateTime.Now, Environment.TickCount);
751	Trace.Indent();
752	#endif
753	Configure();
754	if (m_isStartingUp && (m_autoZoomOptions != AutoZoomOptions.Never)) {
755	ResetView(true);
756	}
757	#if TRACE
758	Trace.Unindent();
759	Trace.TraceInformation("{0},{1} ILPanel.OnPaint(): rendering started",DateTime.Now, Environment.TickCount);
760	Trace.Indent();
761	Trace.TraceInformation(String.Format("this: {1}, ClipRectangle: {0}, Graphics.ClipBounds: L:{2} T:{3} W:{4} H:{5}"
762	,e.ClipRectangle.ToString()
763	,this.ClientRectangle.ToString()
764	,e.Graphics.VisibleClipBounds.Left
765	,e.Graphics.VisibleClipBounds.Top
766	,e.Graphics.VisibleClipBounds.Width
767	,e.Graphics.VisibleClipBounds.Height));
768	#endif
769	m_renderProperties.Graphics = e.Graphics;
770	m_renderProperties.Reason = RenderReason.PaintEvent;
771	m_renderProperties.MinX = int.MaxValue;
772	m_renderProperties.MinY = int.MaxValue;
773	m_renderProperties.MaxX = int.MinValue;
774	m_renderProperties.MaxY = int.MinValue;
775	RenderScene(m_renderProperties.Reset());
776	#if TRACE
777	Trace.Unindent();
778	Trace.TraceInformation("{0},{1} ILPanel.OnPaint(): rendering ended",DateTime.Now, Environment.TickCount);
779	#endif
780	if (m_isStartingUp) {
781	m_isStartingUp = false;
782	Refresh();
783	}
784	System.Diagnostics.Debug.WriteLine("Current Camera Setting: " + m_camera.ToString());
785	} catch (Exceptions.ILArgumentException exc) {
786	#if TRACE
787	Trace.TraceWarning("{0},{1} ILPanel.OnPaint(): rendering failed. reason: {2}",DateTime.Now, Environment.TickCount,exc.ToString());
788	Trace.Indent();
789	#endif
790	System.Diagnostics.Debug.WriteLine("ILPanel.OnPaint failed: " + exc.ToString());
791	throw new Exceptions.ILArgumentException("rendering failed. Details attached.",exc);
792	}
793	}
794	void m_legend_Changed(object sender, EventArgs e) {
795	Invalidate();
796	}
797
798	void m_graphs_GraphChanged(object sender, ILGraphChangedEventArgs args) {
799	ResetView(false);
800	}
801	protected void m_graphs_OnCollectionChanged(object sender, ILGraphCollectionChangedEventArgs args) {
802	if (args.Reason == GraphCollectionChangeReason.Added) {
803	if (AutoDefaultView && (args.Configurator != null)) {
804	args.Configurator.ConfigurePanel(this);
805	}
806	}
807	}
808	protected void m_viewLimits_Changed(object sender, ClippingChangedEventArgs e) {
809	if (this.InvokeRequired && IsHandleCreated) {
810	try {
811	Invoke(new ILClippingDataChangedEvent(m_viewLimits_Changed), sender, e);
812	} catch (Exception) { }
813	} else {
814	m_camera.LookAt = m_clippingView.CenterF;
815	OnViewLimitsChanged(e);
816	}
817	}
818	protected void m_dataLimits_Changed(object sender, ClippingChangedEventArgs e) {
819	if (m_autoDefaultView) {
820	m_defaultView.EventingSuspend();
821	bool oldDefaultViewSetting = m_autoDefaultView;
822	m_defaultView.LookAt = m_graphs.Limits.CenterF;
823	m_defaultView.Distance = m_graphs.Limits.SphereRadius * 2;
824	m_defaultView.EventingResume(false);
825	}
826	if (m_autoZoomOptions == AutoZoomOptions.OnDataChanges)
827	ResetView(false);
828	OnDataLimitsChanged(e);
829	}
830
831	protected void m_colormap_Changed(object sender, EventArgs e) {
832	OnColormapChanged();
833	}
834	void m_selectionRectangle_Changed(object sender, EventArgs e) {
835	// nothing to do here
836	}
837
838	#endregion event handler
839
840	#region virtual abstract interface
841	/// <summary>
842	/// Get current rendering device (implementation dependent)
843	/// </summary>
844	/// <returns></returns>
845	public abstract object GetDeviceContext();
846	/// <summary>
847	/// Causes a reconfiguration of all axes and graphs on the next paint event
848	/// </summary>
849	/// <remarks>Call this method after any changes to vertex relevant data. It causes all drawable objects to clear their caches and recalculate all vertex data.</remarks>
850	protected new void Invalidate() {
851	if (!m_ready) return;
852	m_ready = false;
853	m_graphs.Invalidate();
854	m_axes.Invalidate();
855	//base.Invalidate(this.ClientRectangle, true); <- this would cause an immediate redraw also. Use Refresh() for this!
856	}
857	/// <summary>
858	/// update viewing limits to show all data, rotate the scene to default (-> DefaultView)
859	/// </summary>
860	public virtual void ResetView() {
861	ResetView(true);
862	}
863	/// <summary>
864	/// update viewing limits to show all data, optionally reset the scene rotation
865	/// </summary>
866	/// <param name="resetRotation">true: rotate the scene to the default (-> DefaultView)</param>
867	public virtual void ResetView(bool resetRotation) {
868	if (m_zoomAction != null)
869	m_zoomAction.Cancel();
870	m_clippingView.EventingSuspend();
871	m_clippingView.CopyFrom(m_graphs.Limits);
872	m_clippingView.Update(m_clippingView.CenterF,1.1f);
873	m_clippingView.EventingResume();
874	if (m_defaultView != null && resetRotation) {
875	m_camera.LookAt = m_defaultView.LookAt;
876	m_camera.Phi = m_defaultView.Phi;
877	m_camera.Rho = m_defaultView.Rho;
878	m_camera.Distance = m_defaultView.Distance;
879	}
880	}
881	/// <summary>
882	/// Move & shrink/expand current view cube along a given line
883	/// </summary>
884	/// <param name="nearLineEnd"></param>
885	/// <param name="farLineEnd"></param>
886	/// <param name="offset"></param>
887	protected virtual void Zoom(ILPoint3Df nearLineEnd, ILPoint3Df farLineEnd, float offset) {
888	ILPoint3Df minCorner, maxCorner;
889	m_clippingView.GetZoomParameter(nearLineEnd,farLineEnd,offset, out minCorner, out maxCorner);
890	Zoom(minCorner,maxCorner);
891	//m_camera.LookAt = m_clippingView.CenterF;
892	}
893	/// <summary>
894	/// move the center of the viewing cube and expand / shrink the volume by offset
895	/// </summary>
896	/// <param name="center">new center</param>
897	/// <param name="offset">offset multiplicator, 1f means: no change</param>
898	protected virtual void Zoom(ILPoint3Df center, float offset) {
899	m_clippingView.Update(center,offset);
900	Refresh();
901	}
902	/// <summary>
903	/// Zoome the scene to new limits
904	/// </summary>
905	/// <param name="luCorner">'upper left' (first) corner of the new viewing cube</param>
906	/// <param name="rbCorner">'bottom right' (opposed) corner of the viewing cube</param>
907	protected virtual void Zoom(ILPoint3Df luCorner, ILPoint3Df rbCorner) {
908	if (m_zoomAction != null)
909	m_zoomAction.Cancel();
910	ILActionRamp ramp;
911	switch (m_zoomMode) {
912	case ZoomModes.Jump:
913	ramp = ILActionRamp.NoRamp;
914	break;
915	case ZoomModes.RollSoft:
916	ramp = ILActionRamp.Soft;
917	break;
918	case ZoomModes.RollHard:
919	ramp = ILActionRamp.Hard;
920	break;
921	case ZoomModes.RollOverride:
922	ramp = ILActionRamp.Override;
923	break;
924	default:
925	ramp = ILActionRamp.Linear;
926	break;
927	}
928	m_zoomAction = new ILZoomAction(m_clippingView.Min, luCorner, m_clippingView.Max, rbCorner, ramp, this);
929	m_zoomAction.Run();
930	}
931
932
933	/// <summary>
934	/// Transform two coordinates for a line from world to screen coordinates
935	/// </summary>
936	/// <param name="start">1st coordinate (world)</param>
937	/// <param name="end">2nd coordinate (world)</param>
938	/// <param name="start2D">[output] 1st coordinate (screen pixels)</param>
939	/// <param name="end2D">[output] 2nd coordinate (screen pixels)</param>
940	/// <remarks>This function is provided by the concrete derived class, using the
941	/// current rendering framework.</remarks>
942	public abstract void World2Screen(ILPoint3Df start, ILPoint3Df end, out Point start2D, out Point end2D);
943
944	/// <summary>
945	/// Transform from a point on screen into world coordinates [depricated]
946	/// </summary>
947	/// <param name="x">screen x</param>
948	/// <param name="y">screen y: GL viewport coord! -> (0,0) is lower left corner!</param>
949	/// <returns>world coordinate point</returns>
950	public abstract ILPoint3Df Screen2World2D(int x, int y);
951	/// <summary>
952	/// gives the line in world coords, a specific point on screen lays on
953	/// </summary>
954	/// <param name="x">screen x</param>
955	/// <param name="y">screen y: GL viewport coord! -> (0,0) is lower left corner</param>
956	/// <param name="farClip">far end point of the resulting line in world coords</param>
957	/// <param name="nearClip">near end point of the resulting line in world coords</param>
958	public abstract void Screen2World(int x, int y, out ILPoint3Df nearClip, out ILPoint3Df farClip);
959
960	/// <summary>
961	/// Transform world coordinate to screen coordinate under current transformation
962	/// </summary>
963	/// <param name="worldPoint">world coordinate</param>
964	/// <returns>screen location</returns>
965	/// <remarks>the actual transform is carried out in the derived specialized class,
966	/// where the current transformation matrices are known</remarks>
967	public abstract Point World2Screen(ILPoint3Df worldPoint);
968	/// <summary>
969	/// Transform world coordinate to screen coordinate, provide (custom) modelview matrix
970	/// </summary>
971	/// <param name="worldPoint"></param>
972	/// <param name="modelview">(custom) model view matrix. The parameter must match the format required by the deriving concrete ILPanel class. ILOGLPanel: double[16]</param>
973	/// <returns>screen location</returns>
974	/// <remarks>the actual transform is carried out in the derived specialized class,
975	/// where the current transformation matrices are known</remarks>
976	public abstract Point World2Screen(ILPoint3Df worldPoint, double[] modelview);
977
978	/// <summary>
979	/// Draws content of this subfigure into predefined bitmap
980	/// </summary>
981	/// <param name="bitmap">predefined bitmap to draw content into. The size must have been initialized according to 'bounds'.</param>
982	/// <param name="bounds">Rectangle specifying the region to be copied.</param>
983	public new abstract void DrawToBitmap(Bitmap bitmap, Rectangle bounds);
984	#endregion
985
986	#region helper functions
987	/// <summary>
988	/// draws the selection rectangle with GDI functions
989	/// </summary>
990	/// <param name="endPoint">end point</param>
991	/// <remarks>The start point is stored in the member m_mouseStart.</remarks>
992	protected virtual void drawSelectionRect(Point endPoint) {
993	Graphics g = Graphics.FromHwnd(this.Handle);
994	Pen pen = new Pen(m_selectionRectangle.Color, 1.0f);
995	Point[] points = new Point[3];
996	// upper left corner
997	points[0] = new Point(m_mouseStart.X, m_mouseStart.Y + (endPoint.Y - m_mouseStart.Y) / 4);
998	points[1] = new Point(m_mouseStart.X, m_mouseStart.Y);
999	points[2] = new Point(m_mouseStart.X + (endPoint.X - m_mouseStart.X) / 4, m_mouseStart.Y);
1000	g.DrawLines(pen, points);
1001	// lower left corner
1002	points[0] = new Point(m_mouseStart.X, endPoint.Y - (endPoint.Y - m_mouseStart.Y) / 4);
1003	points[1] = new Point(m_mouseStart.X, endPoint.Y);
1004	points[2] = new Point(m_mouseStart.X + (endPoint.X - m_mouseStart.X) / 4, endPoint.Y);
1005	g.DrawLines(pen, points);
1006	// lower right corner
1007	points[0] = new Point(endPoint.X, endPoint.Y - (endPoint.Y - m_mouseStart.Y) / 4);
1008	points[1] = new Point(endPoint.X, endPoint.Y);
1009	points[2] = new Point(endPoint.X - (endPoint.X - m_mouseStart.X) / 4, endPoint.Y);
1010	g.DrawLines(pen, points);
1011	// upper right corner
1012	points[0] = new Point(endPoint.X, m_mouseStart.Y + (endPoint.Y - m_mouseStart.Y) / 4);
1013	points[1] = new Point(endPoint.X, m_mouseStart.Y);
1014	points[2] = new Point(endPoint.X - (endPoint.X - m_mouseStart.X) / 4, m_mouseStart.Y);
1015	g.DrawLines(pen, points);
1016	}
1017	public static short StippleFromLineStyle(LineStyle style, ref int stipFactr) {
1018	short ret = 1;
1019	switch (style) {
1020	case LineStyle.Dashed:
1021	ret = (short)255;
1022	stipFactr = 2;
1023	break;
1024	case LineStyle.PointDash:
1025	ret = (short)255 + 4096;
1026	stipFactr = 1;
1027	break;
1028	case LineStyle.Dotted:
1029	ret = (short)13107; // 3 + 48 + 768 + 8192 + 4096;
1030	stipFactr = 2;
1031	break;
1032	case LineStyle.UserPattern:
1033	break;
1034	// ret = 0;
1035	case LineStyle.None:
1036	break;
1037	default: // solid
1038	ret = (short)-1;
1039	break;
1040	}
1041	return ret;
1042	}
1043	private void calculateDefaultView(bool setPositions, bool setDirection) {
1044	m_defaultView.EventingSuspend();
1045	if (setPositions) {
1046	m_defaultView.LookAt = m_graphs.Limits.CenterF;
1047	m_defaultView.Distance = m_clippingView.SphereRadius * 2f;
1048	}
1049	if (setDirection) {
1050	m_defaultView.Phi = 0; // -(float)Math.PI / 2;
1051	m_defaultView.Rho = 0;
1052	}
1053	m_defaultView.EventingResume(false);
1054	}
1055	#endregion
1056
1057	#region private rendering setup helper
1058	protected void helperUpdateMatrices(float width2D, float height2D, out float worldSceneWidth, out float worldSceneHeight, out ILPoint3Df top, out ILPoint3Df moveOffset)
1059	{
1060	float localPlotCubeScreenRectLeft;
1061	float localPlotCubeScreenRectWidth;
1062
1063	float localPlotCubeScreenRectTop;
1064	float localPlotCubeScreenRectHeight;
1065
1066	float offsetX;
1067	float offsetY;
1068
1069	localPlotCubeScreenRectHeight = m_plotBoxScreenRectF.Height;
1070	localPlotCubeScreenRectWidth = m_plotBoxScreenRectF.Width;
1071	localPlotCubeScreenRectTop = m_plotBoxScreenRectF.Top;
1072	localPlotCubeScreenRectLeft = m_plotBoxScreenRectF.Left;
1073
1074	if (AspectRatio == AspectRatioMode.StretchToFill)
1075	{
1076	worldSceneWidth = width2D / localPlotCubeScreenRectWidth;
1077	worldSceneHeight = height2D / localPlotCubeScreenRectHeight;
1078	}
1079	else
1080	{ //if (RenderAspectRatioMode == RenderAspectRatioMode.MaintainRatios) {
1081	float plotCubeScreenRectAspectRatio =
1082	(m_plotBoxScreenRectF.Width * ClientSize.Width)
1083	/ (m_plotBoxScreenRectF.Height * ClientSize.Height);
1084	float dataAspectRatio = width2D / height2D;
1085	if (plotCubeScreenRectAspectRatio > dataAspectRatio)
1086	{
1087	// width > height
1088	worldSceneHeight = height2D;
1089	worldSceneWidth = worldSceneHeight * dataAspectRatio;
1090	// enlarge the scene, so we have rendering margin outside the data cube
1091	worldSceneHeight /= localPlotCubeScreenRectHeight;
1092	worldSceneWidth /= (localPlotCubeScreenRectWidth * (dataAspectRatio / plotCubeScreenRectAspectRatio));
1093	}
1094	else
1095	{
1096	// height >= width
1097	worldSceneWidth = width2D;
1098	worldSceneHeight = worldSceneWidth / dataAspectRatio;
1099	// enlarge the scene, so we have rendering margin outside the data cube
1100	worldSceneWidth /= localPlotCubeScreenRectWidth;
1101	worldSceneHeight /= (localPlotCubeScreenRectHeight / (dataAspectRatio / plotCubeScreenRectAspectRatio));
1102	}
1103	}
1104	// one more pixel please...
1105	worldSceneHeight = (worldSceneHeight / ClientSize.Height * (ClientSize.Height + 1));
1106	worldSceneWidth = (worldSceneWidth / ClientSize.Width * (ClientSize.Width + 1));
1107	// if PlotCubeScreenRect is not centered, we move the scene out of center accordingly (..further down)
1108	top = new ILPoint3Df(-m_camera.SinPhi * m_camera.CosRho, m_camera.CosPhi * m_camera.CosRho, m_camera.SinRho);
1109	ILPoint3Df moveX = ILPoint3Df.crossN(m_camera.Position - m_camera.LookAt, top);
1110	offsetX = -(localPlotCubeScreenRectLeft + (localPlotCubeScreenRectWidth / 2f) - 0.5f) * worldSceneWidth;
1111	offsetY = -(localPlotCubeScreenRectTop + (localPlotCubeScreenRectHeight / 2f) - 0.5f) * worldSceneHeight;
1112	moveOffset = top * offsetY + moveX * offsetX;
1113	}
1114	protected virtual void RenderScene(ILRenderProperties p) {
1115	//System.Diagnostics.Debug.Print("m_camera:{0}", m_camera);
1116	if (!DesignMode) {
1117	lock (m_sortingCacheList) {
1118	iRenderingState1(p); //make current
1119	// configure axes (determine tick labels in mode 'auto')
1120	m_axes.XAxis.Configure(p);
1121	m_axes.YAxis.Configure(p);
1122	m_axes.ZAxis.Configure(p);
1123
1124
1125	//computeLayoutData(p);
1126	float rotatedViewLimitX, rotatedViewLimitY, rotatedViewLimitZ;
1127	GetTransformedSize(out rotatedViewLimitX, out rotatedViewLimitY, out rotatedViewLimitZ);
1128
1129	// determine needed margins according to current tic label collections (which are left over from last rendering run or empty)
1130	Size ticLabelsMargins = GetMaxTicLabelSize(p.Graphics);
1131	updatePlotCubeScreenRect(rotatedViewLimitX, rotatedViewLimitY, ticLabelsMargins);
1132	p.PassCount = 0;
1133	for (; p.PassCount < MAXRENDERPASSES; p.PassCount++) {
1134	UpdateMatrices(rotatedViewLimitX, rotatedViewLimitY, rotatedViewLimitZ);
1135
1136	updateTickLabelLines();
1137	updateLabelPositions(p);
1138	if (p.PassCount == 0) {
1139	}
1140	iRenderingState2(p); // do the actual drawing
1141	//iRenderingState3(p);
1142	#region check if we can fit the plot cube more precisely
1143	if (m_plotBoxScreenSizeMode == PlotBoxScreenSizeMode.StrictOptimal) {
1144	float t = m_plotBoxScreenRectF.Top;
1145	float l = m_plotBoxScreenRectF.Left;
1146	float r = m_plotBoxScreenRectF.Right;
1147	float b = m_plotBoxScreenRectF.Bottom, tmp;
1148	bool resize = false;
1149	tmp = (float)p.MinX / ClientSize.Width;
1150	if (tmp < l) {
1151	if (p.MinX != 0) {
1152	l -= tmp;
1153	resize = true;
1154	}
1155	} else if (l > 0) {
1156	l = 0;
1157	resize = true;
1158	}
1159	tmp = (float)p.MaxX / ClientSize.Width;
1160	if (tmp > r) {
1161	if (p.MaxX != (ClientSize.Width - 1)) {
1162	r += (1 - tmp);
1163	resize = true;
1164	}
1165	} else if (r < 1) {
1166	r = (float)(ClientSize.Width - 1) / ClientSize.Width;
1167	resize = true;
1168	}
1169	tmp = (float)p.MinY / ClientSize.Height;
1170	if (tmp < t) {
1171	if (p.MinY != 0) {
1172	t -= tmp;
1173	resize = true;
1174	}
1175	} else if (t > 0) {
1176	t = 0;
1177	resize = true;
1178	}
1179	tmp = (float)p.MaxY / ClientSize.Height;
1180	if (tmp > b) {
1181	if (p.MaxY != (ClientSize.Height - 1)) {
1182	b += (1 - tmp);
1183	resize = true;
1184	}
1185	} else if (b < 1) {
1186	b = (float)(ClientSize.Height - 1) / ClientSize.Height;
1187	resize = true;
1188	}
1189	if (resize) {
1190	// ... there is still room left we can use for enlarging the render cube
1191	m_plotBoxScreenRectF = new RectangleF(l, t, r - l, b - t);
1192	p.Reason = RenderReason.RecalcLabels;
1193	p.MaxY = int.MinValue;
1194	p.MaxX = int.MinValue;
1195	p.MinY = int.MaxValue;
1196	p.MinX = int.MaxValue;
1197	}
1198	continue;
1199	}
1200	#endregion
1201	break;
1202	}
1203	iRenderingState3(p);
1204	}
1205
1206	}
1207	}
1208	protected abstract void iRenderingState1(ILRenderProperties p);
1209	/// <summary>
1210	/// [internal] Configure this panel, to make it ready for output, set "m_ready = true" at end!
1211	/// </summary>
1212	protected virtual void Configure() {
1213	foreach (ILGraph graph in m_graphs) {
1214	graph.Configure();
1215	}
1216	// update clipping view
1217	m_clipplanes[0] = -1.0; m_clipplanes[3] = m_clippingView.Max.X;
1218	m_clipplanes[4] = 1.0; m_clipplanes[7] = -m_clippingView.Min.X;
1219	m_clipplanes[9] = -1.0; m_clipplanes[11] = m_clippingView.Max.Y;
1220	m_clipplanes[13] = 1.0; m_clipplanes[15] = -m_clippingView.Min.Y;
1221	m_clipplanes[18] = -1.0; m_clipplanes[19] = m_clippingView.Max.Z;
1222	m_clipplanes[22] = 1.0; m_clipplanes[23] = -m_clippingView.Min.Z;
1223
1224	m_ready = true;
1225	}
1226	/// <summary>
1227	/// draw the scene: all axes, graphs, background etc. (device dependant)
1228	/// </summary>
1229	/// <param name="p"></param>
1230	protected abstract void iRenderingState2(ILRenderProperties p);
1231	protected abstract void iRenderingState3(ILRenderProperties p);
1232	protected abstract void UpdateMatrices(float width2D, float height2D, float depth2D);
1233	/// <summary>
1234	/// initialize all device specific classes, first called after the panel has been created
1235	/// </summary>
1236	/// <remarks>derived types should init all devices here</remarks>
1237	protected virtual void Initialize() { }
1238	protected PointF GetXTickLabelLine(out Point start2D, out Point end2D) {
1239	PointF anchor = new PointF(0,0); // TickLabelAlign.left;
1240	ILPoint3Df start = new ILPoint3Df(), end = new ILPoint3Df();
1241	ILTickCollection ticks = m_axes[0].LabeledTicks;
1242	float tickLen = (ticks.Direction == TickDirection.Outside) ?
1243	ticks.TickFraction : 0f;
1244	float padX = ticks.Padding, padY = padX;
1245	switch (m_camera.Quadrant) {
1246	case CameraQuadrant.TopLeftFront:
1247	start.X = m_clippingView.Min.X;
1248	start.Y = m_clippingView.Min.Y - tickLen;
1249	start.Z = m_clippingView.Min.Z;
1250	end.X = m_clippingView.Max.X;
1251	end.Y = start.Y;
1252	end.Z = start.Z;
1253	anchor = new PointF(0,0); //TickLabelAlign.left \| TickLabelAlign.top;
1254	padX = -m_camera.SinPhi * padX;
1255	padY = (m_camera.CosPhi - m_camera.SinRho * m_camera.SinPhi) * (padY) + m_camera.SinPhi * ticks.Font.Height / 2;
1256	break;
1257	case CameraQuadrant.TopLeftBack:
1258	start.X = m_clippingView.Min.X;
1259	start.Y = m_clippingView.Max.Y + tickLen;
1260	start.Z = m_clippingView.Min.Z;
1261	end.X = m_clippingView.Max.X;
1262	end.Y = start.Y;
1263	end.Z = start.Z;
1264	anchor = new PointF(1,0); //TickLabelAlign.right \| TickLabelAlign.top;
1265	padX *= m_camera.SinPhi;
1266	padY = (-m_camera.CosPhi - m_camera.SinRho * m_camera.SinPhi) * padY + m_camera.SinPhi * ticks.Font.Height / 2;
1267	break;
1268	case CameraQuadrant.TopRightBack:
1269	start.X = m_clippingView.Min.X;
1270	start.Y = m_clippingView.Max.Y + tickLen;
1271	start.Z = m_clippingView.Min.Z;
1272	end.X = m_clippingView.Max.X;
1273	end.Y = start.Y;
1274	end.Z = start.Z;
1275	anchor = new PointF(0,0); //TickLabelAlign.left \| TickLabelAlign.top;
1276	padX *= m_camera.SinPhi;
1277	padY = (-m_camera.CosPhi + m_camera.SinRho * m_camera.SinPhi) * padY - m_camera.SinPhi * ticks.Font.Height / 2;
1278	break;
1279	case CameraQuadrant.TopRightFront:
1280	start.X = m_clippingView.Min.X;
1281	start.Y = m_clippingView.Min.Y - tickLen;
1282	start.Z = m_clippingView.Min.Z;
1283	end.X = m_clippingView.Max.X;
1284	end.Y = start.Y;
1285	end.Z = start.Z;
1286	if (m_camera.Is2DView) {
1287	anchor = new PointF(.5f, 0); //TickLabelAlign.center \| TickLabelAlign.top;
1288	} else {
1289	anchor = new PointF(1,0); //TickLabelAlign.right \| TickLabelAlign.top;
1290	}
1291	padX *= -m_camera.SinPhi;
1292	padY = (m_camera.CosPhi + m_camera.SinRho * m_camera.SinPhi) * padY - m_camera.SinPhi * ticks.Font.Height / 2;
1293	break;
1294	case CameraQuadrant.BottomLeftFront:
1295	start.X = m_clippingView.Min.X;
1296	start.Y = m_clippingView.Max.Y + tickLen;
1297	start.Z = m_clippingView.Min.Z;
1298	end.X = m_clippingView.Max.X;
1299	end.Y = start.Y;
1300	end.Z = start.Z;
1301	anchor = new PointF(1,0); //TickLabelAlign.right \| TickLabelAlign.top;
1302	padX *= m_camera.SinPhi;
1303	padY = (m_camera.CosPhi - m_camera.SinRho * m_camera.SinPhi) * padY + m_camera.SinPhi * ticks.Font.Height / 2;
1304	break;
1305	case CameraQuadrant.BottomLeftBack:
1306	start.X = m_clippingView.Min.X;
1307	start.Y = m_clippingView.Min.Y - tickLen;
1308	start.Z = m_clippingView.Min.Z;
1309	end.X = m_clippingView.Max.X;
1310	end.Y = start.Y;
1311	end.Z = start.Z;
1312	anchor = new PointF(0,0); //TickLabelAlign.left \| TickLabelAlign.top;
1313	padX *= -m_camera.SinPhi;
1314	padY = (-m_camera.CosPhi - m_camera.SinRho * m_camera.SinPhi) * padY + m_camera.SinPhi * ticks.Font.Height / 2;
1315	break;
1316	case CameraQuadrant.BottomRightBack:
1317	start.X = m_clippingView.Min.X;
1318	start.Y = m_clippingView.Min.Y - tickLen;
1319	start.Z = m_clippingView.Min.Z;
1320	end.X = m_clippingView.Max.X;
1321	end.Y = start.Y;
1322	end.Z = start.Z;
1323	anchor = new PointF(1,0); //TickLabelAlign.right \| TickLabelAlign.top;
1324	padX *= -m_camera.SinPhi;
1325	padY = (-m_camera.CosPhi + m_camera.SinRho * m_camera.SinPhi) * padY - m_camera.SinPhi * ticks.Font.Height / 2;
1326	break;
1327	default: // BottomRightFront
1328	start.X = m_clippingView.Min.X;
1329	start.Y = m_clippingView.Max.Y + tickLen;
1330	start.Z = m_clippingView.Min.Z;
1331	end.X = m_clippingView.Max.X;
1332	end.Y = start.Y;
1333	end.Z = start.Z;
1334	anchor = new PointF(0,0); //TickLabelAlign.left \| TickLabelAlign.top;
1335	padX *= m_camera.SinPhi;
1336	padY = (m_camera.CosPhi + m_camera.SinRho * m_camera.SinPhi) * padY - m_camera.SinPhi * ticks.Font.Height / 2;
1337	break;
1338	}
1339	World2Screen(start, end, out start2D, out end2D);
1340	// align in screen coords
1341	// int offY = (int)((m_camera.SinRho - (m_camera.SinPhi % Math.PI))
1342	// * m_axes[0].LabeledTicks.Font.Height / 2
1343	// + padY);
1344	// add padding
1345	//System.Diagnostics.Debug.WriteLine(m_camera.Phi);
1346	start2D.Y += (int)padY + 1;
1347	end2D.Y += (int)padY + 1;
1348	start2D.X += (int)(padX + 1);
1349	end2D.X += (int)(padX + 1);
1350	return anchor;
1351	}
1352	protected PointF GetYTickLabelLine(out Point start2D, out Point end2D) {
1353	PointF anchor; // = new PointF(0,0); // TickLabelAlign.left;
1354	ILPoint3Df start = new ILPoint3Df(), end = new ILPoint3Df();
1355	ILTickCollection ticks = m_axes[1].LabeledTicks;
1356	float tickLen = (ticks.Direction == TickDirection.Outside) ?
1357	ticks.TickFraction : 0f;
1358	float padX = ticks.Padding, padY = padX;
1359	if (m_camera.Is2DView) {
1360	start.X = m_clippingView.Min.X - tickLen;
1361	start.Y = m_clippingView.Min.Y;
1362	start.Z = m_clippingView.Min.Z;
1363	end.X = start.X;
1364	end.Y = m_clippingView.Max.Y;
1365	end.Z = start.Z;
1366	anchor = new PointF(1, 0); // TickLabelAlign.right \| TickLabelAlign.top;
1367	padX *= -m_camera.CosPhi;
1368	padY = (-m_camera.SinPhi + m_camera.SinRho * m_camera.CosPhi) * padY - m_camera.CosPhi * ticks.Font.Height / 2;
1369	} else {
1370	switch (m_camera.Quadrant) {
1371	case CameraQuadrant.TopLeftFront:
1372	start.X = m_clippingView.Min.X - tickLen;
1373	start.Y = m_clippingView.Min.Y;
1374	start.Z = m_clippingView.Min.Z;
1375	end.X = start.X;
1376	end.Y = m_clippingView.Max.Y;
1377	end.Z = start.Z;
1378	anchor = new PointF(1, 0); // TickLabelAlign.right \| TickLabelAlign.top;
1379	padX *= -m_camera.CosPhi;
1380	padY = (-m_camera.SinPhi + m_camera.SinRho * m_camera.CosPhi) * padY - m_camera.CosPhi * ticks.Font.Height / 2;
1381	break;
1382	case CameraQuadrant.TopLeftBack:
1383	start.X = m_clippingView.Min.X - tickLen;
1384	start.Y = m_clippingView.Min.Y;
1385	start.Z = m_clippingView.Min.Z;
1386	end.X = start.X;
1387	end.Y = m_clippingView.Max.Y;
1388	end.Z = start.Z;
1389	anchor = new PointF(0, 0); // TickLabelAlign.left \| TickLabelAlign.top;
1390	padX *= -m_camera.CosPhi;
1391	padY = (-m_camera.SinPhi - m_camera.SinRho * m_camera.CosPhi) * padY + m_camera.CosPhi * ticks.Font.Height / 2;
1392	break;
1393	case CameraQuadrant.TopRightBack:
1394	start.X = m_clippingView.Max.X + tickLen;
1395	start.Y = m_clippingView.Min.Y;
1396	start.Z = m_clippingView.Min.Z;
1397	end.X = start.X;
1398	end.Y = m_clippingView.Max.Y;
1399	end.Z = start.Z;
1400	anchor = new PointF(1,0); // TickLabelAlign.right \| TickLabelAlign.top;
1401	padX *= m_camera.CosPhi;
1402	padY = (m_camera.SinPhi - m_camera.SinRho * m_camera.CosPhi) * padY + m_camera.CosPhi * ticks.Font.Height / 2;
1403	break;
1404	case CameraQuadrant.TopRightFront:
1405	start.X = m_clippingView.Max.X + tickLen;
1406	start.Y = m_clippingView.Min.Y;
1407	start.Z = m_clippingView.Min.Z;
1408	end.X = start.X;
1409	end.Y = m_clippingView.Max.Y;
1410	end.Z = start.Z;
1411	anchor = new PointF(0,0); // TickLabelAlign.left \| TickLabelAlign.top;
1412	padX *= m_camera.CosPhi;
1413	padY = (m_camera.SinPhi + m_camera.SinRho * m_camera.CosPhi) * padY - m_camera.CosPhi * ticks.Font.Height / 2;
1414	break;
1415	case CameraQuadrant.BottomLeftFront:
1416	start.X = m_clippingView.Max.X + tickLen;
1417	start.Y = m_clippingView.Min.Y;
1418	start.Z = m_clippingView.Min.Z;
1419	end.X = start.X;
1420	end.Y = m_clippingView.Max.Y;
1421	end.Z = start.Z;
1422	anchor = new PointF(0,0); // TickLabelAlign.left \| TickLabelAlign.top;
1423	padX *= m_camera.CosPhi;
1424	padY = (-m_camera.SinPhi + m_camera.SinRho * m_camera.CosPhi) * padY - m_camera.CosPhi * ticks.Font.Height / 2;
1425	break;
1426	case CameraQuadrant.BottomLeftBack:
1427	start.X = m_clippingView.Max.X + tickLen;
1428	start.Y = m_clippingView.Min.Y;
1429	start.Z = m_clippingView.Min.Z;
1430	end.X = start.X;
1431	end.Y = m_clippingView.Max.Y;
1432	end.Z = start.Z;
1433	anchor = new PointF(1,0); // TickLabelAlign.right \| TickLabelAlign.top;
1434	padX *= m_camera.CosPhi;
1435	padY = (-m_camera.SinPhi - m_camera.SinRho * m_camera.CosPhi) * padY + m_camera.CosPhi * ticks.Font.Height / 2;
1436	break;
1437	case CameraQuadrant.BottomRightBack:
1438	start.X = m_clippingView.Min.X - tickLen;
1439	start.Y = m_clippingView.Min.Y;
1440	start.Z = m_clippingView.Min.Z;
1441	end.X = start.X;
1442	end.Y = m_clippingView.Max.Y;
1443	end.Z = start.Z;
1444	anchor = new PointF(0,0); // TickLabelAlign.left \| TickLabelAlign.top;
1445	padX *= -m_camera.CosPhi;
1446	padY = (m_camera.SinPhi - m_camera.SinRho * m_camera.CosPhi) * padY + m_camera.CosPhi * ticks.Font.Height / 2;
1447	break;
1448	default: // BottomRightFront
1449	start.X = m_clippingView.Min.X - tickLen;
1450	start.Y = m_clippingView.Min.Y;
1451	start.Z = m_clippingView.Min.Z;
1452	end.X = start.X;
1453	end.Y = m_clippingView.Max.Y;
1454	end.Z = start.Z;
1455	anchor = new PointF(1,0); // TickLabelAlign.right \| TickLabelAlign.top;
1456	padX *= -m_camera.CosPhi;
1457	padY = (m_camera.SinPhi + m_camera.SinRho * m_camera.CosPhi) * padY - m_camera.CosPhi * ticks.Font.Height / 2;
1458	break;
1459	}
1460	}
1461	World2Screen(start, end, out start2D, out end2D);
1462	// align in screen coords
1463	//int offY = (int)(Math.Abs(m_camera.CosPhi) * ticks.Font.Height / 2);
1464	//offY -= (int)(Math.Sin(m_camera.Rho) * ticks.Font.Height / 2);
1465	start2D.Y += (int)padY;
1466	end2D.Y += (int)padY;
1467	start2D.X += (int)padX;
1468	end2D.X += (int)padX;
1469	return anchor;
1470	}
1471	protected PointF GetZTickLabelLine(out Point start2D, out Point end2D) {
1472	PointF anchor = new PointF(1, .5f); // TickLabelAlign.vertCenter \| TickLabelAlign.right;
1473	ILPoint3Df start = new ILPoint3Df(), end = new ILPoint3Df();
1474	ILTickCollection ticks = m_axes[2].LabeledTicks;
1475	float tickLen = 0;
1476	if (ticks.Direction == TickDirection.Outside)
1477	tickLen = ticks.TickFraction;
1478	start.Z = m_clippingView.Min.Z;
1479	switch (m_camera.Quadrant) {
1480	case CameraQuadrant.TopLeftFront:
1481	start.X = m_clippingView.Min.X - tickLen;
1482	start.Y = m_clippingView.Max.Y + tickLen;
1483	break;
1484	case CameraQuadrant.TopLeftBack:
1485	start.X = m_clippingView.Max.X + tickLen;
1486	start.Y = m_clippingView.Max.Y + tickLen;
1487	break;
1488	case CameraQuadrant.TopRightBack:
1489	start.X = m_clippingView.Max.X + tickLen;
1490	start.Y = m_clippingView.Min.Y - tickLen;
1491	break;
1492	case CameraQuadrant.TopRightFront:
1493	start.X = m_clippingView.Min.X - tickLen;
1494	start.Y = m_clippingView.Min.Y - tickLen;
1495	break;
1496	case CameraQuadrant.BottomLeftFront:
1497	start.X = m_clippingView.Min.X - tickLen;
1498	start.Y = m_clippingView.Max.Y + tickLen;
1499	break;
1500	case CameraQuadrant.BottomLeftBack:
1501	start.X = m_clippingView.Max.X + tickLen;
1502	start.Y = m_clippingView.Max.Y + tickLen;
1503	break;
1504	case CameraQuadrant.BottomRightBack:
1505	start.X = m_clippingView.Max.X + tickLen;
1506	start.Y = m_clippingView.Min.Y - tickLen;
1507	break;
1508	case CameraQuadrant.BottomRightFront:
1509	start.X = m_clippingView.Min.X - tickLen;
1510	start.Y = m_clippingView.Min.Y - tickLen;
1511	break;
1512	default:
1513	break;
1514	}
1515	end = start;
1516	end.Z = m_clippingView.Max.Z;
1517	World2Screen(start, end, out start2D, out end2D);
1518	start2D.X -= (ticks.Padding - 1);
1519	end2D.X -= (ticks.Padding - 1);
1520	return anchor;
1521	}
1522	/// <summary>
1523	/// Get size of projected view cube - after (!) rotation but before projection -> world space
1524	/// includes the bounding box, tightly enclosing the current view limits setting
1525	/// No labels, No ticks included!! Just the data cube with roatation!
1526	/// </summary>
1527	/// <param name="x">out, screen size for X</param>
1528	/// <param name="y">out, screen size for Y</param>
1529	/// <param name="z">out, screen size for Z</param>
1530	protected virtual void GetTransformedSize(out float x, out float y, out float z) {
1531	float xSize = m_clippingView.WidthF; // the unrotated width - without labels size
1532	float ySize = m_clippingView.HeightF; // dito for height
1533	float zSize = m_clippingView.DepthF;
1534	if (m_camera.Rho != 0.0f \|\| m_camera.Phi != 0.0f) { // standard 2D view?
1535	float cosPhi = Math.Abs(m_camera.CosPhi);
1536	float sinPhi = Math.Abs(m_camera.SinPhi);
1537	x = (cosPhi * xSize + sinPhi * ySize); //zSize * Math.Abs(m_camera.SinRho) + (Math.Abs(m_camera.CosRho) *
1538	y = zSize * Math.Abs(m_camera.SinRho)
1539	+ (Math.Abs(m_camera.CosRho) * (sinPhi * xSize + cosPhi * ySize));
1540	z = zSize * Math.Abs(m_camera.CosRho)
1541	+ (Math.Abs(m_camera.SinRho) * (sinPhi * xSize + cosPhi * ySize));
1542	} else {
1543	x = xSize;
1544	y = ySize;
1545	z = zSize;
1546	}
1547	}
1548
1549	private void axisLabelVertical2D(ILAxis axis) {
1550	ILLabel label = axis.Label;
1551	ILTickCollection ticks = axis.LabeledTicks;
1552	Size tickSize = ticks.Size, labelSize = label.Size;
1553	label.Orientation = TextOrientation.Vertical;
1554	label.Anchor = new PointF(.5f, 0);
1555	label.m_position.X = ticks.m_lineEnd.X - tickSize.Width - ticks.Padding - label.Padding;
1556	switch (label.Alignment) {
1557	case LabelAlign.Center:
1558	label.m_position.Y = (ticks.m_lineEnd.Y + ticks.m_lineStart.Y) / 2;
1559	break;
1560	case LabelAlign.Upper:
1561	label.m_position.Y = ticks.m_lineEnd.Y + labelSize.Width / 2;
1562	break;
1563	default: // lower
1564	label.m_position.Y = ticks.m_lineStart.Y - labelSize.Width / 2;
1565	break;
1566	}
1567	if (label.m_position.Y < labelSize.Width / 2) {
1568	label.m_position.Y = labelSize.Width / 2;
1569	}
1570	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1571	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1572	}
1573	}
1574	private void positionZAxisLabel(ILAxis axis) {
1575	ILLabel label = axis.Label;
1576	ILTickCollection ticks = axis.LabeledTicks;
1577	Size tickSize = ticks.Size, labelSize = label.Size;
1578	label.Orientation = TextOrientation.Vertical;
1579	label.Anchor = new PointF(.5f, 0);
1580	switch (label.Alignment) {
1581	case LabelAlign.Center:
1582	label.m_position.Y = (ticks.m_lineStart.Y + ticks.m_lineEnd.Y) / 2;
1583	break;
1584	case LabelAlign.Upper:
1585	label.m_position.Y = ticks.m_lineEnd.Y - labelSize.Width / 2;
1586	break;
1587	default: // lower
1588	label.m_position.Y = ticks.m_lineStart.Y + labelSize.Width / 2 ;
1589	break;
1590	}
1591	label.m_position.X = ticks.m_lineStart.X - tickSize.Width - ticks.Padding - label.Padding;
1592	if (label.m_position.Y < labelSize.Width / 2) {
1593	label.m_position.Y = labelSize.Width / 2;
1594	}
1595	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1596	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1597	//label.Orientation = TextOrientation.Horizontal;
1598	//label.m_position.X = label.Padding;
1599	//label.m_position.Y = label.Padding;
1600	}
1601	}
1602	private void axisLabel_BottomRightTopLeft(ILRenderProperties p, ILAxis axis) {
1603	ILLabel label = axis.Label;
1604	ILTickCollection ticks = axis.LabeledTicks;
1605	Size tickSize = ticks.Size, labelSize = label.Size;
1606	label.Anchor = new PointF(.5f, 0);
1607	bool horiz = decideLabelHorizontalOrientation(p, m_camera, axis);
1608	if (horiz) {
1609	#region Horizontal
1610	label.Orientation = TextOrientation.Horizontal;
1611	switch (label.Alignment) {
1612	case LabelAlign.Center:
1613	label.m_position.X = (ticks.m_lineStart.X + ticks.m_lineEnd.X) / 2;
1614	break;
1615	case LabelAlign.Upper:
1616	label.m_position.X = ticks.m_lineEnd.X + labelSize.Width / 2;
1617	break;
1618	default: // lower
1619	label.m_position.X = ticks.m_lineStart.X - labelSize.Width / 2;
1620	break;
1621	}
1622	label.m_position.Y = ticks.m_lineStart.Y + tickSize.Height + ticks.Padding + label.Padding;
1623	if (label.m_position.X < labelSize.Width / 2) {
1624	label.m_position.X = labelSize.Width / 2;
1625	}
1626	#endregion
1627	} else {
1628	#region Vertical
1629	label.Orientation = TextOrientation.Vertical;
1630	switch (label.Alignment) {
1631	case LabelAlign.Center:
1632	label.m_position.Y = (ticks.m_lineStart.Y + ticks.m_lineEnd.Y) / 2;
1633	break;
1634	case LabelAlign.Upper:
1635	label.m_position.Y = ticks.m_lineEnd.Y + labelSize.Width / 2;
1636	break;
1637	default: // lower
1638	label.m_position.Y = ticks.m_lineStart.Y - labelSize.Width / 2;
1639	break;
1640	}
1641	label.m_position.X = ticks.m_lineEnd.X - tickSize.Width - label.Padding - ticks.Padding;
1642	if (label.m_position.Y < labelSize.Width / 2)
1643	label.m_position.Y = labelSize.Width / 2;
1644	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1645	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1646	}
1647	#endregion
1648	}
1649	}
1650	private void axisLabel_BottomLeftTopRight(ILRenderProperties p, ILAxis axis) {
1651	ILLabel label = axis.Label;
1652	ILTickCollection ticks = axis.LabeledTicks;
1653	Size tickSize = ticks.Size, labelSize = label.Size;
1654	bool horiz = decideLabelHorizontalOrientation(p, m_camera, axis);
1655	if (horiz) {
1656	#region Horizontal
1657	label.Orientation = TextOrientation.Horizontal;
1658	label.Anchor = new PointF(0.5f,0);
1659	switch (label.Alignment) {
1660	case LabelAlign.Center:
1661	label.m_position.X = (ticks.m_lineEnd.X + ticks.m_lineStart.X) / 2;
1662	break;
1663	case LabelAlign.Upper:
1664	label.m_position.X = ticks.m_lineEnd.X - label.Size.Width / 2;
1665	break;
1666	default: // lower
1667	label.m_position.X = ticks.m_lineStart.X + label.Size.Width / 2;
1668	break;
1669	}
1670	label.m_position.Y = ticks.m_lineStart.Y + tickSize.Height + ticks.Padding + label.Padding;
1671	if (label.m_position.X > ClientSize.Width - labelSize.Width / 2) {
1672	label.m_position.X = ClientSize.Width - labelSize.Width / 2;
1673	}
1674	#endregion
1675	} else {
1676	#region Vertical
1677	label.Orientation = TextOrientation.Vertical;
1678	label.Anchor = new PointF(0.5f, 1);
1679	switch (label.Alignment) {
1680	case LabelAlign.Center:
1681	label.m_position.Y = (ticks.m_lineEnd.Y + ticks.m_lineStart.Y) / 2;
1682	break;
1683	case LabelAlign.Upper:
1684	label.m_position.Y = ticks.m_lineEnd.Y + labelSize.Width / 2;
1685	break;
1686	default: // lower
1687	label.m_position.Y = ticks.m_lineStart.Y - labelSize.Width / 2;
1688	break;
1689	}
1690	label.m_position.X = ticks.m_lineEnd.X + tickSize.Width + ticks.Padding + label.Padding;
1691	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1692	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1693	}
1694	#endregion
1695	}
1696	}
1697	private void axisLabel_TopRightBottomLeft(ILRenderProperties p, ILAxis axis) {
1698	ILLabel label = axis.Label;
1699	ILTickCollection ticks = axis.LabeledTicks;
1700	Size tickSize = ticks.Size, labelSize = label.Size;
1701	bool horiz = decideLabelHorizontalOrientation(p, m_camera, axis);
1702	label.Anchor = new PointF(.5f, 0);
1703	if (horiz) {
1704	#region Horizontal
1705	label.Orientation = TextOrientation.Horizontal;
1706	switch (label.Alignment) {
1707	case LabelAlign.Center:
1708	label.m_position.X = (ticks.m_lineEnd.X + ticks.m_lineStart.X) / 2;
1709	break;
1710	case LabelAlign.Upper:
1711	label.m_position.X = ticks.m_lineEnd.X + labelSize.Width / 2;
1712	break;
1713	default: // lower
1714	label.m_position.X = ticks.m_lineStart.X - labelSize.Width / 2;
1715	break;
1716	}
1717	label.m_position.Y = ticks.m_lineEnd.Y + tickSize.Height + ticks.Padding + label.Padding;
1718	if (label.m_position.X < labelSize.Width / 2)
1719	label.m_position.X = labelSize.Width / 2;
1720	if (label.m_position.X > ClientSize.Width - labelSize.Width / 2 - 1)
1721	label.m_position.X = ClientSize.Width - labelSize.Width / 2 - 1;
1722	#endregion
1723	} else {
1724	#region Vertical
1725	label.Orientation = TextOrientation.Vertical;
1726	switch (label.Alignment) {
1727	case LabelAlign.Center:
1728	label.m_position.Y = (ticks.m_lineEnd.Y + ticks.m_lineStart.Y) / 2;
1729	break;
1730	case LabelAlign.Upper:
1731	label.m_position.Y = ticks.m_lineEnd.Y - labelSize.Width / 2;
1732	break;
1733	default: // lower
1734	label.m_position.Y = ticks.m_lineStart.Y + labelSize.Width / 2;
1735	break;
1736	}
1737	label.m_position.X = ticks.m_lineStart.X + tickSize.Width + ticks.Padding + label.Padding;
1738	if (label.m_position.Y < labelSize.Width / 2) {
1739	label.m_position.Y = labelSize.Width / 2;
1740	}
1741	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1742	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1743	}
1744	#endregion
1745	}
1746	}
1747	private void axisLabel_TopLeftBottomRight(ILRenderProperties p, ILAxis axis) {
1748	ILLabel label = axis.Label;
1749	ILTickCollection ticks = axis.LabeledTicks;
1750	Size tickSize = ticks.Size, labelSize = label.Size;
1751	bool horiz = decideLabelHorizontalOrientation(p, m_camera, axis);
1752	label.Anchor = new PointF(.5f, 0);
1753	if (horiz) {
1754	#region Horizontal
1755	label.Orientation = TextOrientation.Horizontal;
1756	switch (label.Alignment) {
1757	case LabelAlign.Center:
1758	label.m_position.X = (ticks.m_lineEnd.X + ticks.m_lineStart.X) / 2;
1759	break;
1760	case LabelAlign.Upper:
1761	label.m_position.X = ticks.m_lineEnd.X - labelSize.Width / 2;
1762	break;
1763	default: // lower
1764	label.m_position.X = ticks.m_lineStart.X + labelSize.Width / 2;
1765	break;
1766	}
1767	label.m_position.Y = ticks.m_lineEnd.Y + tickSize.Height + ticks.Padding + label.Padding;
1768	if (label.m_position.X < labelSize.Width / 2) {
1769	label.m_position.X = labelSize.Width / 2;
1770	}
1771	#endregion
1772	} else {
1773	#region Vertical
1774	label.Orientation = TextOrientation.Vertical;
1775	switch (label.Alignment) {
1776	case LabelAlign.Center:
1777	label.m_position.Y = (ticks.m_lineEnd.Y + ticks.m_lineStart.Y) / 2;
1778	break;
1779	case LabelAlign.Upper:
1780	label.m_position.Y = ticks.m_lineEnd.Y - labelSize.Width / 2;
1781	break;
1782	default: // lower
1783	label.m_position.Y = ticks.m_lineStart.Y + labelSize.Width / 2;
1784	break;
1785	}
1786	label.m_position.X = ticks.m_lineStart.X - tickSize.Width - ticks.Padding - label.Padding;
1787	if (label.m_position.Y < labelSize.Width / 2) {
1788	label.m_position.Y = labelSize.Width / 2;
1789	}
1790	if (label.m_position.Y > ClientSize.Height - 1 - labelSize.Width / 2) {
1791	label.m_position.Y = ClientSize.Height - 1 - labelSize.Width / 2;
1792	}
1793	#endregion
1794	}
1795	}
1796
1797	// return true if the label needs horizontal orientation
1798	private bool decideLabelHorizontalOrientation(ILRenderProperties p, ILCamera m_camera, ILAxis axis) {
1799	if (p.Reason == RenderReason.RecalcLabels) {
1800	return axis.Label.Orientation == TextOrientation.Horizontal;
1801	}
1802	float offX = axis.LabeledTicks.m_lineStart.X - axis.LabeledTicks.m_lineEnd.X;
1803	float offY = axis.LabeledTicks.m_lineStart.Y - axis.LabeledTicks.m_lineEnd.Y;
1804	return offY * offY < offX * offX;
1805	//if (axis.Index == 0) {
1806	// b = (float)((1.0 - m_camera.SinRho * 0.9) * Math.Sin(m_camera.Phi * 2.0f));
1807	//} else if (axis.Index == 1) {
1808
1809	//}
1810	//return (m_camera.SinRho >= LABELS_VERTICAL_MIN_RHO
1811	// \|\| Math.Sign(Math.Cos(m_camera.Phi * 2.0)) != (axis.Index * 2 - 1));
1812	}
1813	private int GetMargin4OptimalLabelX() {
1814	return 0;
1815	}
1816	private int GetMargin4OptimalLabelY() {
1817	return 0;
1818	}
1819	private Size GetMaxTicLabelSize(Graphics gr) {
1820	Size ret = m_axes.MeasureMaxTickLabelSize(gr);
1821	// add label sizes
1822	int maxHeight = 0;
1823	if (m_axes[0].Label.Visible && !String.IsNullOrEmpty(m_axes[0].Label.Text)) {
1824	maxHeight = m_axes[0].Label.Size.Height;
1825	}
1826	if (m_axes[1].Label.Visible && !String.IsNullOrEmpty(m_axes[1].Label.Text)) {
1827	if (maxHeight < m_axes[1].Label.Size.Height)
1828	maxHeight = m_axes[1].Label.Size.Height;
1829	}
1830	if (m_axes[2].Label.Visible && !String.IsNullOrEmpty(m_axes[2].Label.Text)) {
1831	if (maxHeight < m_axes[2].Label.Size.Height)
1832	maxHeight = m_axes[2].Label.Size.Height;
1833	}
1834	ret = new Size(ret.Width + maxHeight, ret.Height + maxHeight);
1835	return ret;
1836	}
1837
1838	/// <summary>
1839	/// calculate the real pixels of the plot cube rectangle for drawing into
1840	/// </summary>
1841	/// <param name="xSize"></param>
1842	/// <param name="ySize"></param>
1843	private void updatePlotCubeScreenRect(float xSize, float ySize, Size tickLabelMargins) {
1844	switch (PlotBoxScreenSizeMode) {
1845	//case PlotCubeScreenSizeMode.Maximum: // <- will be done in PlotCubeScreenSizeMode.set()
1846	// m_plotCubeScreenRectF = new RectangleF(0.0f, 0.0f, 1.0f, 1.0f);
1847	// break;
1848	case PlotBoxScreenSizeMode.Optimal:
1849	case PlotBoxScreenSizeMode.StrictOptimal:
1850	float saveX, saveY;
1851	saveX = ((float)tickLabelMargins.Width / ClientSize.Width);
1852	if (saveX < 0) saveX = 0;
1853	if (saveX > 1) saveX = 1;
1854	saveY = ((float)tickLabelMargins.Height / ClientSize.Height);
1855	if (saveY < 0) saveY = 0;
1856	if (saveY > 1) saveY = 1;
1857	m_plotBoxScreenRectF = new RectangleF(saveX, saveY, 1f - (2 * saveX), 1f - (2 * saveY));
1858	break;
1859	default: // manual: use predefined PlotCubeScreenRectF
1860	break;
1861	}
1862	}
1863
1864	private void updateLabelPositions(ILRenderProperties p) {
1865	positionZAxisLabel(m_axes[2]);
1866	switch (m_camera.Quadrant) {
1867	case CameraQuadrant.TopRightFront:
1868	axisLabel_TopLeftBottomRight(p, m_axes[0]);
1869	// special case: 2D view?
1870	if (m_camera.SinPhi < 1e-5 && m_camera.SinRho < 1e-5) {
1871	axisLabelVertical2D(m_axes[1]);
1872	} else {
1873	axisLabel_BottomLeftTopRight(p, m_axes[1]);
1874	}
1875	break;
1876	case CameraQuadrant.TopRightBack:
1877	axisLabel_TopRightBottomLeft(p, m_axes[0]);
1878	axisLabel_TopLeftBottomRight(p, m_axes[1]);
1879	break;
1880	case CameraQuadrant.TopLeftFront:
1881	axisLabel_BottomLeftTopRight(p, m_axes[0]);
1882	axisLabel_BottomRightTopLeft(p, m_axes[1]);
1883	break;
1884	case CameraQuadrant.TopLeftBack:
1885	axisLabel_BottomRightTopLeft(p, m_axes[0]);
1886	axisLabel_TopRightBottomLeft(p, m_axes[1]);
1887	break;
1888	case CameraQuadrant.BottomLeftFront:
1889	axisLabel_TopLeftBottomRight(p, m_axes[0]);
1890	axisLabel_TopRightBottomLeft(p, m_axes[1]);
1891	break;
1892	case CameraQuadrant.BottomLeftBack:
1893	axisLabel_TopRightBottomLeft(p, m_axes[0]);
1894	axisLabel_BottomRightTopLeft(p, m_axes[1]);
1895	break;
1896	case CameraQuadrant.BottomRightBack:
1897	axisLabel_BottomRightTopLeft(p, m_axes[0]);
1898	axisLabel_BottomLeftTopRight(p, m_axes[1]);
1899	break;
1900	case CameraQuadrant.BottomRightFront:
1901	axisLabel_BottomLeftTopRight(p, m_axes[0]);
1902	axisLabel_TopLeftBottomRight(p, m_axes[1]);
1903	break;
1904	default:
1905	break;
1906	}
1907	}
1908
1909	private void updateTickLabelLines() {
1910	// determine tick label lines
1911	ILTickCollection ticks = m_axes[2].LabeledTicks;
1912	ticks.m_anchor = GetZTickLabelLine(out ticks.m_lineStart, out ticks.m_lineEnd);
1913	ticks = m_axes[1].LabeledTicks;
1914	ticks.m_anchor = GetYTickLabelLine(out ticks.m_lineStart, out ticks.m_lineEnd);
1915	ticks = m_axes[0].LabeledTicks;
1916	ticks.m_anchor = GetXTickLabelLine(out ticks.m_lineStart, out ticks.m_lineEnd);
1917	}
1918	#endregion
1919
1920	#region factory member
1921
1922	/// <summary>
1923	/// create OpenGL panel
1924	/// </summary>
1925	/// <returns>OpenGL panel</returns>
1926	public static ILPanel Create () {
1927	return Create(GraphicDeviceType.OpenGL);
1928	}
1929	/// <summary>
1930	/// create graphic device specific panel
1931	/// </summary>
1932	/// <param name="type">specify GL type. Supported are: OpenGL (recommended) or Direct3D (alpha state)</param>
1933	/// <returns>GL specific panel</returns>
1934	public static ILPanel Create (GraphicDeviceType type) {
1935	ILPanel ret; Type panelType; Assembly assembly;
1936	string myPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
1937	switch (type) {
1938	case GraphicDeviceType.Direct3D:
1939	//must create DXPanel dynamically ?
1940	// actually not, because DX is split into individual assembly
1941	// but under mono it seems the runtime tries to load the d3d part
1942	// anyway, so we do without a compile time reference.
1943	assembly = Assembly.LoadFile(Path.Combine(myPath,"ILNumerics.DrawingD3D.dll"));
1944	panelType = assembly.GetType("ILNumerics.Drawing.Platform.OpenGL.ILDXPanel");
1945	ret = (ILPanel)panelType.InvokeMember("ILDXPanel",
1946	BindingFlags.DeclaredOnly \| BindingFlags.Public
1947	\| BindingFlags.NonPublic \| BindingFlags.Instance
1948	\| BindingFlags.CreateInstance,
1949	null, null, null);
1950	return ret;
1951	default:
1952	// the default is to use OpenGL, which is included into the main assembly (this one)
1953	assembly = Assembly.GetExecutingAssembly();
1954	panelType = assembly.GetType("ILNumerics.Drawing.Platform.OpenGL.ILOGLPanel");
1955	ret = (ILPanel)panelType.InvokeMember("ILOGLPanel",
1956	BindingFlags.DeclaredOnly \| BindingFlags.Public
1957	\| BindingFlags.NonPublic \| BindingFlags.Instance
1958	\| BindingFlags.CreateInstance,
1959	null, null, null);
1960	return ret;
1961	}
1962	}
1963
1964	/// <summary>
1965	/// Create GL dependend graph factory
1966	/// </summary>
1967	/// <returns>ILGraphFactory,will be used for creating all graphs</returns>
1968	/// <remarks>derived types may return GL dependend factory</remarks>
1969	internal abstract IILCreationFactory GetCreationFactory();
1970	#endregion
1971
1972
1973	}
1974	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences