Browse Source
git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1471 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61shortcuts
Daniel Grunwald
20 years ago
182 changed files with 4732 additions and 2951 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,20 +0,0 @@
@@ -1,20 +0,0 @@
|
||||
/* |
||||
* Created by SharpDevelop. |
||||
* User: Forstmeier Helmut |
||||
* Date: 10.08.2005 |
||||
* Time: 22:14 |
||||
* |
||||
* To change this template use Tools | Options | Coding | Edit Standard Headers. |
||||
*/ |
||||
|
||||
/// <summary>
|
||||
/// Each DesignControl Visitor has to implement this Interface
|
||||
/// </summary>
|
||||
using System; |
||||
|
||||
namespace SharpReport.Designer{ |
||||
public interface IDesignerVisitor { |
||||
void Visit (SharpReport.Designer.BaseDesignerControl designer); |
||||
} |
||||
} |
||||
|
||||
@ -1,21 +0,0 @@
@@ -1,21 +0,0 @@
|
||||
/* |
||||
* Created by SharpDevelop. |
||||
* User: Forstmeier Peter |
||||
* Date: 10.08.2005 |
||||
* Time: 13:38 |
||||
* |
||||
* To change this template use Tools | Options | Coding | Edit Standard Headers. |
||||
*/ |
||||
|
||||
using System; |
||||
using SharpReport.Designer; |
||||
|
||||
namespace SharpReport.Designer{ |
||||
/// <summary>
|
||||
/// Implemented in SharpReportDesigner
|
||||
/// </summary>
|
||||
|
||||
public interface IVisitor{ |
||||
void Accept(IDesignerVisitor visitor); |
||||
} |
||||
} |
||||
@ -0,0 +1,207 @@
@@ -0,0 +1,207 @@
|
||||
/* |
||||
* Created by SharpDevelop. |
||||
* User: Forstmeier Peter |
||||
* Date: 25.05.2006 |
||||
* Time: 09:19 |
||||
* |
||||
* To change this template use Tools | Options | Coding | Edit Standard Headers. |
||||
*/ |
||||
|
||||
using System; |
||||
using System.Drawing; |
||||
using System.Windows.Forms; |
||||
|
||||
namespace SharpReport.Designer{ |
||||
|
||||
/// <summary>
|
||||
/// Description of ContainerControl.
|
||||
/// </summary>
|
||||
public class ContainerControl:ReportControlBase,ITracker{ |
||||
private RectTracker rectTracker = new RectTracker(); |
||||
private ReportControlBase selectedControl; |
||||
|
||||
public ContainerControl():base(){ |
||||
this.Body.MouseMove += new MouseEventHandler( OnMouseMove); |
||||
this.Body.MouseDown += new MouseEventHandler(OnMouseDown); |
||||
} |
||||
|
||||
private Rectangle GetParentRectangle () { |
||||
return this.Body.ClientRectangle; |
||||
} |
||||
|
||||
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e){ |
||||
base.OnPaint(e); |
||||
} |
||||
|
||||
#region overrides
|
||||
/* |
||||
protected override CreateParams CreateParams{ |
||||
get { |
||||
CreateParams cp=base.CreateParams; |
||||
cp.ExStyle|=0x00000020; //WS_EX_TRANSPARENT
|
||||
return cp; |
||||
} |
||||
} |
||||
*/ |
||||
#endregion
|
||||
|
||||
private void OnMouseDown(object sender, System.Windows.Forms.MouseEventArgs e){ |
||||
|
||||
if (this.rectTracker == null) { |
||||
return; |
||||
} |
||||
if(e.Button != MouseButtons .Left){ |
||||
return; |
||||
} |
||||
Point pt = this.Body.PointToClient(Cursor.Position); |
||||
|
||||
Rectangle rcForm = GetParentRectangle(); |
||||
|
||||
if(rcForm.Contains(pt)){ |
||||
Rectangle rcObject; |
||||
if (this.rectTracker.HitTest(pt) == RectTracker.TrackerHit.hitNothing) { |
||||
// System.Console.WriteLine("2");
|
||||
this.selectedControl = null; |
||||
this.rectTracker.m_rect = new Rectangle(0,0,0,0); |
||||
// just to demonstrate RectTracker::TrackRubberBand
|
||||
RectTracker tracker=new RectTracker(); |
||||
if (tracker.TrackRubberBand(this.Body, pt, false)){ |
||||
// see if rubber band intersects with the doc's tracker
|
||||
|
||||
tracker.NormalizeRect(ref tracker.m_rect); |
||||
Rectangle rectIntersect = tracker.m_rect; |
||||
foreach (Control ctrl in this.Body.Controls){ |
||||
rcObject = ctrl.Bounds; |
||||
if(tracker.m_rect.Contains(rcObject)){ |
||||
|
||||
this.rectTracker.m_rect = rcObject; |
||||
this.selectedControl = (ReportControlBase)ctrl; |
||||
this.selectedControl.Selected = true; |
||||
// MainForm.m_propertyWindow.SetSelectedObject(m_seletedCtrl);
|
||||
break; |
||||
} |
||||
} |
||||
} |
||||
else{ |
||||
|
||||
// No rubber band, see if the point selects an object.
|
||||
|
||||
foreach (Control ctrl in this.Body.Controls){ |
||||
rcObject = ctrl.Bounds ; |
||||
if(rcObject.Contains(pt)){ |
||||
|
||||
this.rectTracker.m_rect = rcObject; |
||||
this.selectedControl = (ReportControlBase)ctrl; |
||||
this.selectedControl.Selected = true; |
||||
// MainForm.m_propertyWindow.SetSelectedObject(ctrl);
|
||||
break; |
||||
} |
||||
} |
||||
} |
||||
if(this.selectedControl == null){ |
||||
// NotifySectionClick();
|
||||
|
||||
// MainForm.m_propertyWindow.SetSelectedObject(m_Form);
|
||||
// m_FormTracker.m_rect = rcForm;
|
||||
} |
||||
else{ |
||||
// System.Console.WriteLine("6");
|
||||
// m_FormTracker.Clear();
|
||||
|
||||
} |
||||
} |
||||
else if(this.selectedControl != null){// normal tracking action, when tracker is hit
|
||||
// System.Console.WriteLine("7");
|
||||
if (this.rectTracker.Track(this.Body, pt, false,null)) { |
||||
Rectangle rc = this.rectTracker.m_rect; |
||||
this.selectedControl.SetBounds(rc.Left, rc.Top, rc.Width, rc.Height); |
||||
} |
||||
} |
||||
} |
||||
else{ |
||||
if(this.selectedControl == null){//select the container form
|
||||
// System.Console.WriteLine("9");
|
||||
// MainForm.m_propertyWindow.SetSelectedObject(m_Form);
|
||||
/* |
||||
if(m_FormTracker.HitTest(pt) == RectTracker.TrackerHit.hitNothing) |
||||
{ |
||||
m_FormTracker.m_rect = rcForm; |
||||
} |
||||
else if(!m_FormTracker.IsEmpty()) |
||||
{ |
||||
m_FormTracker.Track(this, pt, false,null); |
||||
} |
||||
*/ |
||||
} |
||||
else{ |
||||
// System.Console.WriteLine("10");
|
||||
// m_FormTracker.Clear();
|
||||
} |
||||
} |
||||
this.InvalidateEx(); |
||||
|
||||
} |
||||
|
||||
private void OnMouseMove (object sender, MouseEventArgs e) { |
||||
|
||||
if (this.rectTracker != null) { |
||||
Point mousept=new Point(e.X,e.Y); |
||||
|
||||
if(this.selectedControl != null){ |
||||
if(!rectTracker.SetCursor(this,0,mousept)) |
||||
this.Cursor=Cursors.Arrow; |
||||
} |
||||
|
||||
// else{
|
||||
// if(!m_FormTracker.SetCursor(this,0,mousept))
|
||||
// this.Cursor=Cursors.Arrow;
|
||||
// }
|
||||
} |
||||
} |
||||
|
||||
#region ITracker implementation
|
||||
|
||||
public virtual void ClearSelections() { |
||||
base.ControlHelper.Clear(this); |
||||
this.selectedControl = null; |
||||
this.InvalidateEx(); |
||||
} |
||||
|
||||
public ReportControlBase SelectedControl { |
||||
set { |
||||
this.selectedControl = value; |
||||
} |
||||
} |
||||
|
||||
public RectTracker RectTracker { |
||||
get { |
||||
return this.rectTracker; |
||||
} |
||||
} |
||||
|
||||
public System.Windows.Forms.Control DesignSurface { |
||||
get { |
||||
return this.Body; |
||||
} |
||||
} |
||||
|
||||
public void InvalidateEx(){ |
||||
this.Invalidate(); |
||||
|
||||
if (this.Parent == null) { |
||||
return; |
||||
} |
||||
Rectangle rc = new Rectangle (this.Body.Location,this.Body.Size); |
||||
this.Invalidate(rc,true); |
||||
|
||||
if(this.selectedControl != null){ |
||||
rc = this.rectTracker.m_rect; |
||||
|
||||
this.selectedControl.SetBounds(rc.Left, rc.Top, rc.Width, rc.Height); |
||||
this.selectedControl.Invalidate(); |
||||
} |
||||
} |
||||
|
||||
#endregion
|
||||
} |
||||
} |
||||
@ -0,0 +1,50 @@
@@ -0,0 +1,50 @@
|
||||
/* |
||||
* Created by SharpDevelop. |
||||
* User: Forstmeier Peter |
||||
* Date: 25.05.2006 |
||||
* Time: 09:54 |
||||
* |
||||
* To change this template use Tools | Options | Coding | Edit Standard Headers. |
||||
*/ |
||||
|
||||
using System; |
||||
using System.Windows.Forms; |
||||
|
||||
|
||||
namespace SharpReport.Designer |
||||
{ |
||||
/// <summary>
|
||||
/// Description of ITracker.
|
||||
/// </summary>
|
||||
public interface ITracker{ |
||||
|
||||
/// <summary>
|
||||
/// Clear all selections
|
||||
/// </summary>
|
||||
|
||||
void ClearSelections(); |
||||
/// <summary>
|
||||
/// Invalidate the DesignSurface and draw the Tracking rectangle
|
||||
/// </summary>
|
||||
void InvalidateEx(); |
||||
|
||||
/// <summary>
|
||||
/// The selected Control
|
||||
/// </summary>
|
||||
ReportControlBase SelectedControl |
||||
{set;} |
||||
|
||||
/// <summary>
|
||||
/// The <see cref="RectTracker"></see>
|
||||
/// </summary>
|
||||
RectTracker RectTracker |
||||
{get;} |
||||
|
||||
///<summary>
|
||||
/// The Body Conrol to draw the Treckung Rectangle on
|
||||
/// </summary>
|
||||
|
||||
Control DesignSurface |
||||
{get;} |
||||
} |
||||
} |
||||
@ -0,0 +1,800 @@
@@ -0,0 +1,800 @@
|
||||
using System; |
||||
using System.Windows.Forms; |
||||
using System.Drawing; |
||||
using System.Drawing.Imaging; |
||||
using System.Diagnostics; |
||||
using System.Runtime.InteropServices; |
||||
using System.Drawing.Drawing2D; |
||||
|
||||
namespace SharpReport.Designer |
||||
{ |
||||
/// <summary>
|
||||
/// Draw a Focus and DragRectangle
|
||||
/// http://www.codeproject.com/csharp/SharpFormEditorDemo.asp
|
||||
/// <seealso cref="http://www.codeproject.com/csharp/SharpFormEditorDemo.asp">
|
||||
/// </seealso>
|
||||
/// </summary>
|
||||
public class RectTracker |
||||
{ |
||||
#region Win32API
|
||||
protected struct POINT |
||||
{ |
||||
public Int32 x; |
||||
public Int32 y; |
||||
}; |
||||
|
||||
protected struct MSG |
||||
{ |
||||
public Int32 hwnd; |
||||
public Int32 message; |
||||
public Int32 wParam; |
||||
public Int32 lParam; |
||||
public Int32 time; |
||||
public POINT pt; |
||||
}; |
||||
|
||||
[DllImport("user32.dll", SetLastError=true )] |
||||
protected static extern Int32 GetMessage (ref MSG lpMsg,Int32 hwnd,Int32 wMsgFilterMin,Int32 wMsgFilterMax); |
||||
|
||||
[DllImport("user32.dll", SetLastError=true )] |
||||
protected static extern Int32 DispatchMessage (ref MSG lpMsg); |
||||
|
||||
[DllImport("user32.dll", SetLastError=true )] |
||||
private static extern Int32 TranslateMessage (ref MSG lpMsg); |
||||
|
||||
private const int CX_BORDER=1; |
||||
private const int CY_BORDER=1; |
||||
protected const int WM_MOUSEFIRST = 0x0200; |
||||
protected const int WM_MOUSEMOVE = 0x0200; |
||||
protected const int WM_LBUTTONDOWN = 0x0201; |
||||
protected const int WM_LBUTTONUP = 0x0202; |
||||
protected const int WM_LBUTTONDBLCLK = 0x0203; |
||||
protected const int WM_RBUTTONDOWN = 0x0204; |
||||
protected const int WM_RBUTTONUP = 0x0205; |
||||
protected const int WM_RBUTTONDBLCLK = 0x0206; |
||||
protected const int WM_MBUTTONDOWN = 0x0207; |
||||
protected const int WM_MBUTTONUP = 0x0208; |
||||
protected const int WM_MBUTTONDBLCLK = 0x0209; |
||||
protected const int WM_KEYDOWN = 0x100; |
||||
protected const int WM_KEYUP = 0x101; |
||||
private static Cursor[] Cursors =new Cursor[10]; |
||||
private static HatchBrush HatchBrush = null; |
||||
private static Pen BlackDottedPen = null; |
||||
private static int HandleSize = 4; |
||||
private static Pen DotedPen=null; |
||||
|
||||
#endregion
|
||||
|
||||
//
|
||||
// Style Flags
|
||||
public enum StyleFlags |
||||
{ |
||||
solidLine = 1, dottedLine = 2, hatchedBorder = 4, |
||||
resizeInside = 8, resizeOutside = 16, hatchInside = 32, |
||||
}; |
||||
|
||||
// Hit-Test codes
|
||||
public enum TrackerHit |
||||
{ |
||||
hitNothing = -1, |
||||
hitTopLeft = 0, hitTopRight = 1, hitBottomRight = 2, hitBottomLeft = 3, |
||||
hitTop = 4, hitRight = 5, hitBottom = 6, hitLeft = 7, hitMiddle = 8 |
||||
}; |
||||
public enum backMode |
||||
{ |
||||
TRANSPARENT= 1, |
||||
OPAQUE= 2 |
||||
}; |
||||
public enum rectPos |
||||
{ |
||||
Left =0, |
||||
Right, |
||||
Top, |
||||
Bottom |
||||
}; |
||||
struct HANDLEINFO |
||||
{ |
||||
public HANDLEINFO(rectPos X,rectPos Y,int CX,int CY,int HX,int HY,int IX,int IY) |
||||
{ |
||||
nOffsetX=X; |
||||
nOffsetY=Y; |
||||
nCenterX=CX; |
||||
nCenterY=CY; |
||||
nHandleX=HX; |
||||
nHandleY=HY; |
||||
nInvertX=IX; |
||||
nInvertY=IY; |
||||
} |
||||
public rectPos nOffsetX; // offset within RECT for X coordinate
|
||||
public rectPos nOffsetY; // offset within RECT for Y coordinate
|
||||
public int nCenterX; // adjust X by Width()/2 * this number
|
||||
public int nCenterY; // adjust Y by Height()/2 * this number
|
||||
public int nHandleX; // adjust X by handle size * this number
|
||||
public int nHandleY; // adjust Y by handle size * this number
|
||||
public int nInvertX; // handle converts to this when X inverted
|
||||
public int nInvertY; // handle converts to this when Y inverted
|
||||
}; |
||||
struct RECTINFO |
||||
{ |
||||
public RECTINFO(rectPos offset,int nsign) |
||||
{ |
||||
nOffsetAcross=offset; |
||||
nSignAcross=nsign; |
||||
} |
||||
public rectPos nOffsetAcross; // offset of opposite point (ie. left->right)
|
||||
public int nSignAcross; // sign relative to that point (ie. add/subtract)
|
||||
} |
||||
|
||||
static HANDLEINFO[] HandleInfo=new HANDLEINFO[]{ |
||||
// corner handles (top-left, top-right, bottom-right, bottom-left
|
||||
new HANDLEINFO(rectPos.Left, rectPos.Top,0, 0, 0, 0, 1, 3 ), |
||||
new HANDLEINFO(rectPos.Right,rectPos.Top,0, 0, -1, 0, 0, 2), |
||||
new HANDLEINFO(rectPos.Right,rectPos.Bottom,0, 0, -1, -1, 3, 1), |
||||
new HANDLEINFO(rectPos.Left, rectPos.Bottom, 0, 0, 0, -1, 2, 0 ), |
||||
// side handles (top, right, bottom, left)
|
||||
new HANDLEINFO(rectPos.Left, rectPos.Top,1, 0, 0, 0, 4, 6), |
||||
new HANDLEINFO(rectPos.Right,rectPos.Top,0, 1, -1, 0, 7, 5), |
||||
new HANDLEINFO(rectPos.Left, rectPos.Bottom, 1, 0, 0, -1, 6, 4 ), |
||||
new HANDLEINFO(rectPos.Left, rectPos.Top,0, 1, 0, 0, 5, 7) |
||||
}; |
||||
static RECTINFO[] RectInfo=new RECTINFO[]{ |
||||
new RECTINFO(rectPos.Right, +1), |
||||
new RECTINFO(rectPos.Bottom, +1), |
||||
new RECTINFO(rectPos.Left,-1), |
||||
new RECTINFO(rectPos.Top, -1 ) |
||||
}; |
||||
// Attributes
|
||||
public StyleFlags m_nStyle; // current state
|
||||
public Rectangle m_rect; // current position (always in pixels)
|
||||
public Size m_sizeMin; // minimum X and Y size during track operation
|
||||
public int m_nHandleSize=0; // size of resize handles (default from WIN.INI)
|
||||
protected bool m_bAllowInvert=false; // flag passed to Track or TrackRubberBand
|
||||
protected Rectangle m_rectLast; |
||||
protected Size m_sizeLast; |
||||
protected bool m_bErase=false; // TRUE if DrawTrackerRect is called for erasing
|
||||
protected bool m_bFinalErase=false; // TRUE if DragTrackerRect called for final erase
|
||||
protected static bool bInitialized=false; |
||||
|
||||
public RectTracker() |
||||
{ |
||||
Construct(); |
||||
m_nHandleSize = 6; |
||||
m_nStyle = StyleFlags.resizeOutside; |
||||
} |
||||
public RectTracker(Rectangle rect, StyleFlags nStyle) |
||||
{ |
||||
Construct(); |
||||
m_rect=rect; |
||||
m_nStyle = nStyle; |
||||
} |
||||
protected void Construct() |
||||
{ |
||||
if(false==bInitialized) |
||||
{ |
||||
// initialize the cursor array
|
||||
Cursors[0] = System.Windows.Forms.Cursors.SizeNWSE; |
||||
Cursors[1] = System.Windows.Forms.Cursors.SizeNESW; |
||||
Cursors[2] = Cursors[0]; |
||||
Cursors[3] = Cursors[1]; |
||||
Cursors[4] = System.Windows.Forms.Cursors.SizeNS; |
||||
Cursors[5] = System.Windows.Forms.Cursors.SizeWE; |
||||
Cursors[6] = Cursors[4]; |
||||
Cursors[7] = Cursors[5]; |
||||
Cursors[8] = System.Windows.Forms.Cursors.SizeAll; |
||||
Cursors[9] = System.Windows.Forms.Cursors.PanSW; |
||||
bInitialized = true; |
||||
BlackDottedPen=new Pen(System.Drawing.Color.Black,1); |
||||
HatchBrush=new HatchBrush(HatchStyle.Percent20,Color.Black,Color.FromArgb(0)); |
||||
DotedPen=new Pen(Color.Black,1); |
||||
DotedPen.DashStyle=DashStyle.Dot; |
||||
} |
||||
m_nStyle = 0; |
||||
m_nHandleSize = HandleSize; |
||||
m_sizeMin.Height = m_sizeMin.Width = m_nHandleSize*2; |
||||
|
||||
m_rectLast=new Rectangle(0,0,0,0); |
||||
m_sizeLast.Width = m_sizeLast.Height = 0; |
||||
m_bErase = false; |
||||
m_bFinalErase = false; |
||||
} |
||||
|
||||
|
||||
// Operations
|
||||
public virtual void Draw(Graphics gs) |
||||
{ |
||||
System.Drawing.Drawing2D.GraphicsState OldState=gs.Save(); |
||||
|
||||
// IntPtr hdc = new IntPtr();
|
||||
// get normalized rectangle
|
||||
Rectangle rect = m_rect; |
||||
NormalizeRect(ref rect); |
||||
|
||||
// draw lines
|
||||
if ((m_nStyle & (StyleFlags.dottedLine|StyleFlags.solidLine)) != 0) |
||||
{ |
||||
if((m_nStyle&StyleFlags.dottedLine)!=0) |
||||
BlackDottedPen.DashStyle=DashStyle.Dot; |
||||
else |
||||
BlackDottedPen.DashStyle=DashStyle.Solid; |
||||
rect.Inflate(new Size(+1, +1)); // borders are one pixel outside
|
||||
gs.DrawRectangle(BlackDottedPen,rect); |
||||
} |
||||
|
||||
|
||||
// hatch inside
|
||||
if ((m_nStyle & StyleFlags.hatchInside) != 0) |
||||
{ |
||||
gs.FillRectangle(HatchBrush,rect.Left+1, rect.Top+1, rect.Width-1, rect.Height-1); |
||||
} |
||||
|
||||
// draw hatched border
|
||||
if (true)//(m_nStyle & StyleFlags.hatchedBorder) != 0)
|
||||
{ |
||||
Rectangle rectTrue=new Rectangle(0,0,0,0); |
||||
GetTrueRect(ref rectTrue); |
||||
gs.FillRectangle(HatchBrush,rectTrue.Left, rectTrue.Top, rectTrue.Width,rect.Top-rectTrue.Top); |
||||
gs.FillRectangle(HatchBrush,rectTrue.Left, rect.Bottom,rectTrue.Width,rectTrue.Bottom-rect.Bottom); |
||||
gs.FillRectangle(HatchBrush,rectTrue.Left, rect.Top, rect.Left-rectTrue.Left,rect.Height); |
||||
gs.FillRectangle(HatchBrush,rect.Right, rect.Top, rectTrue.Right-rect.Right,rect.Height); |
||||
} |
||||
|
||||
// draw resize handles
|
||||
if ((m_nStyle & (StyleFlags.resizeInside|StyleFlags.resizeOutside)) != 0) |
||||
{ |
||||
uint mask = GetHandleMask(); |
||||
for (int i = 0; i < 8; ++i) |
||||
{ |
||||
if ((mask&(1<<i))!=0) |
||||
{ |
||||
GetHandleRect(i, ref rect); |
||||
SolidBrush brush=new SolidBrush(Color.Black); |
||||
Pen pen = new Pen(brush,1); |
||||
SolidBrush brushWhite = new SolidBrush(Color.White); |
||||
gs.FillRectangle(brushWhite,rect); |
||||
gs.DrawRectangle(pen,rect); |
||||
} |
||||
} |
||||
} |
||||
gs.Restore(OldState); |
||||
} |
||||
public void GetTrueRect(ref Rectangle TrueRect) |
||||
{ |
||||
// get normalized rectangle
|
||||
Rectangle rect = m_rect; |
||||
NormalizeRect(ref rect); |
||||
int nInflateBy = 0; |
||||
if ((m_nStyle & (StyleFlags.resizeOutside|StyleFlags.hatchedBorder)) != 0) |
||||
nInflateBy += GetHandleSize(new Rectangle(0,0,0,0)) - 1; |
||||
if ((m_nStyle & (StyleFlags.solidLine|StyleFlags.dottedLine)) != 0) |
||||
++nInflateBy; |
||||
rect.Inflate(new Size(nInflateBy, nInflateBy)); |
||||
TrueRect = rect; |
||||
} |
||||
|
||||
public virtual bool SetCursor(Control frm, uint nHitTest,Point MousePoint) |
||||
{ |
||||
// trackers should only be in client area
|
||||
frm.PointToClient(MousePoint); |
||||
if (!frm.ClientRectangle.Contains(MousePoint)) |
||||
return false; |
||||
|
||||
// convert cursor position to client co-ordinates
|
||||
// do hittest and normalize hit
|
||||
int nHandle = (int)HitTestHandles(MousePoint); |
||||
if (nHandle < 0) |
||||
return false; |
||||
|
||||
// need to normalize the hittest such that we get proper cursors
|
||||
nHandle = NormalizeHit(nHandle); |
||||
|
||||
// handle special case of hitting area between handles
|
||||
// (logically the same -- handled as a move -- but different cursor)
|
||||
if (nHandle == (int)TrackerHit.hitMiddle && !m_rect.Contains(MousePoint)) |
||||
{ |
||||
// only for trackers with hatchedBorder (ie. in-place resizing)
|
||||
if ((m_nStyle & StyleFlags.hatchedBorder)!=0) |
||||
nHandle = 9; |
||||
} |
||||
|
||||
Debug.Assert(nHandle < 10); |
||||
frm.Cursor=Cursors[nHandle]; |
||||
return true; |
||||
} |
||||
public virtual bool Track(Control frm, Point point, bool bAllowInvert,Form frmClipTo) |
||||
{ |
||||
// perform hit testing on the handles
|
||||
int nHandle = (int)HitTestHandles(point); |
||||
if (nHandle < 0) |
||||
{ |
||||
// didn't hit a handle, so just return FALSE
|
||||
return false; |
||||
} |
||||
|
||||
// otherwise, call helper function to do the tracking
|
||||
m_bAllowInvert = bAllowInvert; |
||||
return TrackHandle(nHandle, frm, point, frmClipTo); |
||||
} |
||||
public bool TrackRubberBand(Control frm, Point point, bool bAllowInvert) |
||||
{ |
||||
// simply call helper function to track from bottom right handle
|
||||
m_bAllowInvert = bAllowInvert; |
||||
m_rect=new Rectangle(point.X, point.Y,0, 0); |
||||
return TrackHandle((int)TrackerHit.hitBottomRight, frm, point, null); |
||||
} |
||||
public virtual TrackerHit HitTest(Point point) |
||||
{ |
||||
TrackerHit hitResult = TrackerHit.hitNothing; |
||||
|
||||
Rectangle rectTrue=new Rectangle(); |
||||
GetTrueRect(ref rectTrue); |
||||
Debug.Assert(rectTrue.Left <= rectTrue.Right); |
||||
Debug.Assert(rectTrue.Top <= rectTrue.Bottom); |
||||
|
||||
if (rectTrue.Contains(point)) |
||||
{ |
||||
if ((m_nStyle & (StyleFlags.resizeInside|StyleFlags.resizeOutside)) != 0) |
||||
hitResult = HitTestHandles(point); |
||||
else |
||||
hitResult = TrackerHit.hitMiddle; |
||||
} |
||||
return hitResult; |
||||
} |
||||
protected int NormalizeHit(int nHandle) |
||||
{ |
||||
Debug.Assert(nHandle <= 8 && nHandle >= -1); |
||||
if (nHandle == (int)TrackerHit.hitMiddle || nHandle ==(int)TrackerHit.hitNothing) |
||||
return nHandle; |
||||
|
||||
HANDLEINFO handleInfo = HandleInfo[nHandle]; |
||||
if (m_rect.Width< 0) |
||||
{ |
||||
nHandle = handleInfo.nInvertX; |
||||
handleInfo = HandleInfo[nHandle]; |
||||
} |
||||
if (m_rect.Height< 0) |
||||
nHandle = handleInfo.nInvertY; |
||||
return nHandle; |
||||
} |
||||
|
||||
|
||||
private void DrawDragRect(Graphics gs,Rectangle rect,Rectangle rectLast) |
||||
{ |
||||
ControlPaint.DrawReversibleFrame(rectLast,Color.White,FrameStyle.Dashed); |
||||
ControlPaint.DrawReversibleFrame(rect,Color.White,FrameStyle.Dashed); |
||||
|
||||
} |
||||
|
||||
public virtual void DrawTrackerRect(Rectangle Rect, Form ClipToFrm,Graphics gs,Control frm) |
||||
{ |
||||
|
||||
Rectangle rect = Rect; |
||||
// convert to client coordinates
|
||||
if (ClipToFrm != null) |
||||
{ |
||||
rect=ClipToFrm.RectangleToScreen(rect); |
||||
rect=ClipToFrm.RectangleToClient(rect); |
||||
} |
||||
|
||||
Size size=new Size(0, 0); |
||||
if (!m_bFinalErase) |
||||
{ |
||||
// otherwise, size depends on the style
|
||||
if ((m_nStyle & StyleFlags.hatchedBorder)!=0) |
||||
{ |
||||
size.Width = size.Height = Math.Max(1, GetHandleSize(rect)-1); |
||||
rect.Inflate(size); |
||||
} |
||||
else |
||||
{ |
||||
size.Width = CX_BORDER; |
||||
size.Height = CY_BORDER; |
||||
} |
||||
} |
||||
|
||||
if (m_bFinalErase || !m_bErase) |
||||
{ |
||||
Rectangle rcScreen = frm.RectangleToScreen(rect); |
||||
Rectangle rcLast = frm.RectangleToScreen(m_rectLast); |
||||
DrawDragRect(gs,rcScreen,rcLast); |
||||
} |
||||
// remember last rectangles
|
||||
m_rectLast = rect; |
||||
m_sizeLast = size; |
||||
} |
||||
|
||||
public virtual void AdjustRect(int nHandle, ref Rectangle Rect) |
||||
{ |
||||
if (nHandle ==(int)TrackerHit.hitMiddle) |
||||
return; |
||||
|
||||
// convert the handle into locations within m_rect
|
||||
int px=-1, py=-1; |
||||
int ix=-1,iy=-1; |
||||
GetModifyPointers(nHandle,ref px, ref py,ref ix, ref iy,false); |
||||
|
||||
// enforce minimum width
|
||||
int nNewWidth = m_rect.Width; |
||||
int nAbsWidth = m_bAllowInvert ? Math.Abs(nNewWidth) : nNewWidth; |
||||
if (nAbsWidth < m_sizeMin.Width) |
||||
{ |
||||
nNewWidth = nAbsWidth != 0 ? nNewWidth / nAbsWidth : 1; |
||||
RECTINFO refrectinfo=RectInfo[px]; |
||||
px = GetRectInt((int)refrectinfo.nOffsetAcross) + |
||||
nNewWidth * m_sizeMin.Width * -refrectinfo.nSignAcross; |
||||
} |
||||
|
||||
// enforce minimum height
|
||||
int nNewHeight = m_rect.Height; |
||||
int nAbsHeight = m_bAllowInvert ? Math.Abs(nNewHeight) : nNewHeight; |
||||
if ((py != -1)&&(nAbsHeight < m_sizeMin.Height)) |
||||
{ |
||||
nNewHeight = nAbsHeight != 0 ? nNewHeight / nAbsHeight : 1; |
||||
Debug.Assert(py<4); |
||||
RECTINFO refrectinfo=RectInfo[py]; |
||||
py = GetRectInt((int)refrectinfo.nOffsetAcross) + |
||||
nNewHeight * m_sizeMin.Width * -refrectinfo.nSignAcross; |
||||
} |
||||
} |
||||
|
||||
public virtual void OnChangedRect(Rectangle rectOld) |
||||
{ |
||||
} |
||||
|
||||
public virtual uint GetHandleMask() |
||||
{ |
||||
uint mask = 0x0F; // always have 4 corner handles
|
||||
int size = m_nHandleSize*3; |
||||
if (Math.Abs(m_rect.Width) - size > 4) |
||||
mask |= 0x50; |
||||
if (Math.Abs(m_rect.Height) - size > 4) |
||||
mask |= 0xA0; |
||||
return mask; |
||||
} |
||||
|
||||
protected virtual TrackerHit HitTestHandles(Point point) |
||||
{ |
||||
Rectangle Truerect=new Rectangle(0,0,0,0); |
||||
uint mask = GetHandleMask(); |
||||
|
||||
// see if hit anywhere inside the tracker
|
||||
GetTrueRect(ref Truerect); |
||||
if (!Truerect.Contains(point)) |
||||
return TrackerHit.hitNothing; // totally missed
|
||||
|
||||
// see if we hit a handle
|
||||
for (int i = 0; i < 8; ++i) |
||||
{ |
||||
if((mask&(1<<i))!=0) |
||||
{ |
||||
GetHandleRect(i, ref Truerect); |
||||
if (Truerect.Contains(point)) |
||||
return (TrackerHit)i; |
||||
} |
||||
} |
||||
|
||||
// last of all, check for non-hit outside of object, between resize handles
|
||||
if ((m_nStyle & StyleFlags.hatchedBorder) == 0) |
||||
{ |
||||
// get normalized rectangle
|
||||
Rectangle rect = m_rect; |
||||
NormalizeRect(ref rect); |
||||
if ((m_nStyle & (StyleFlags.dottedLine|StyleFlags.solidLine)) != 0) |
||||
rect.Inflate(+1, +1); |
||||
if (!rect.Contains(point)) |
||||
return TrackerHit.hitNothing; // must have been between resize handles
|
||||
} |
||||
return TrackerHit.hitMiddle; // no handle hit, but hit object (or object border)
|
||||
} |
||||
|
||||
protected void GetHandleRect(int nHandle, ref Rectangle Changerect) |
||||
{ |
||||
System.Diagnostics.Debug.Assert(nHandle < 8); |
||||
|
||||
// get normalized rectangle of the tracker
|
||||
Rectangle rectT = m_rect; |
||||
NormalizeRect(ref rectT); |
||||
|
||||
if ((m_nStyle & (StyleFlags.solidLine|StyleFlags.dottedLine)) != 0) |
||||
rectT.Inflate(+1, +1); |
||||
|
||||
// since the rectangle itself was normalized, we also have to invert the
|
||||
// resize handles.
|
||||
nHandle = NormalizeHit(nHandle); |
||||
|
||||
// handle case of resize handles outside the tracker
|
||||
int size = GetHandleSize(new Rectangle()); |
||||
if ((m_nStyle&StyleFlags.resizeOutside)!=0) |
||||
rectT.Inflate(size, size); |
||||
|
||||
// calculate position of the resize handle
|
||||
int nWidth = rectT.Width; |
||||
int nHeight = rectT.Height; |
||||
Rectangle rect=new Rectangle(); |
||||
HANDLEINFO handleInfo = HandleInfo[nHandle]; |
||||
int[] arr=new int[4]{rectT.Left,rectT.Right,rectT.Top,rectT.Bottom}; |
||||
|
||||
rect.X = arr[(int)handleInfo.nOffsetX]; |
||||
rect.Y = arr[(int)handleInfo.nOffsetY]; |
||||
rect.X += size * handleInfo.nHandleX; |
||||
rect.Y += size * handleInfo.nHandleY; |
||||
rect.X += handleInfo.nCenterX * (nWidth - size) / 2; |
||||
rect.Y += handleInfo.nCenterY * (nHeight - size) / 2; |
||||
rect.Width = size; |
||||
rect.Height = size; |
||||
|
||||
Changerect = rect; |
||||
} |
||||
|
||||
protected int GetRectInt(int index) |
||||
{ |
||||
switch(index) |
||||
{ |
||||
case 0: |
||||
return m_rect.Left; |
||||
case 1: |
||||
return m_rect.Right; |
||||
case 2: |
||||
return m_rect.Top; |
||||
case 3: |
||||
return m_rect.Bottom; |
||||
default: |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
protected void SetRectInt(int index,int p) |
||||
{ |
||||
if( p >= 32768) |
||||
p=0; |
||||
switch(index) |
||||
{ |
||||
case 0://left
|
||||
m_rect.Width += (m_rect.X - p); |
||||
m_rect.X = p; |
||||
break; |
||||
case 1://right
|
||||
m_rect.Width = p - m_rect.X; |
||||
break; |
||||
case 2://top
|
||||
m_rect.Height += m_rect.Y - p; |
||||
m_rect.Y = p ; |
||||
break; |
||||
case 3://bottom
|
||||
m_rect.Height = p - m_rect.Y; |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
|
||||
} |
||||
|
||||
protected void GetModifyPointers(int nHandle,ref int ppx,ref int ppy,ref int px,ref int py,bool bModify) |
||||
{ |
||||
Debug.Assert(nHandle >= 0); |
||||
Debug.Assert(nHandle <= 8); |
||||
|
||||
if (nHandle ==(int)TrackerHit.hitMiddle) |
||||
nHandle = (int)TrackerHit.hitTopLeft; // same as hitting top-left
|
||||
|
||||
ppx = -1; |
||||
ppy = -1; |
||||
|
||||
// fill in the part of the rect that this handle modifies
|
||||
// (Note: handles that map to themselves along a given axis when that
|
||||
// axis is inverted don't modify the value on that axis)
|
||||
|
||||
HANDLEINFO handleInfo = HandleInfo[nHandle]; |
||||
|
||||
if (handleInfo.nInvertX != nHandle) |
||||
{ |
||||
ppx=(int)handleInfo.nOffsetX; |
||||
if (bModify) |
||||
px = GetRectInt(ppx); |
||||
} |
||||
else |
||||
{ |
||||
// middle handle on X axis
|
||||
if (bModify) |
||||
px = m_rect.Left + Math.Abs(m_rect.Width) / 2; |
||||
} |
||||
if (handleInfo.nInvertY != nHandle) |
||||
{ |
||||
ppy=(int)handleInfo.nOffsetY; |
||||
if (bModify) |
||||
py = GetRectInt(ppy); |
||||
} |
||||
else |
||||
{ |
||||
// middle handle on Y axis
|
||||
if (bModify) |
||||
py = m_rect.Top + Math.Abs(m_rect.Height) / 2; |
||||
} |
||||
} |
||||
|
||||
protected virtual int GetHandleSize(Rectangle rect) |
||||
{ |
||||
if (rect.IsEmpty) |
||||
rect = m_rect; |
||||
|
||||
int size = m_nHandleSize; |
||||
if ((m_nStyle & StyleFlags.resizeOutside)==0) |
||||
{ |
||||
// make sure size is small enough for the size of the rect
|
||||
int sizeMax = Math.Min(Math.Abs(rect.Right - rect.Left),Math.Abs(rect.Bottom - rect.Top)); |
||||
if (size * 2 > sizeMax) |
||||
size = sizeMax / 2; |
||||
} |
||||
return size; |
||||
} |
||||
|
||||
protected bool TrackHandle(int nHandle,Control frm,Point point,Form frmClipTo) |
||||
{ |
||||
Debug.Assert(nHandle >= 0); |
||||
Debug.Assert(nHandle <= 8); // handle 8 is inside the rect
|
||||
|
||||
// don't handle if capture already set
|
||||
//if(frm.Capture) return false;
|
||||
|
||||
Debug.Assert(!m_bFinalErase); |
||||
|
||||
// save original width & height in pixels
|
||||
int nWidth = m_rect.Width; |
||||
int nHeight = m_rect.Height; |
||||
|
||||
// set capture to the window which received this message
|
||||
frm.Capture=true; |
||||
Debug.Assert(frm.Capture); |
||||
frm.Update(); |
||||
if (frmClipTo!=null) |
||||
frmClipTo.Update(); |
||||
Rectangle rectSave = m_rect; |
||||
|
||||
// find out what x/y coords we are supposed to modify
|
||||
int px=0, py=0; |
||||
int xDiff=0, yDiff=0; |
||||
GetModifyPointers(nHandle,ref px,ref py,ref xDiff,ref yDiff,true); |
||||
xDiff = point.X - xDiff; |
||||
yDiff = point.Y - yDiff; |
||||
|
||||
// get DC for drawing
|
||||
Graphics gs; |
||||
if (frmClipTo!=null) |
||||
{ |
||||
// clip to arbitrary window by using adjusted Window DC
|
||||
gs=frmClipTo.CreateGraphics(); |
||||
} |
||||
else |
||||
{ |
||||
// otherwise, just use normal DC
|
||||
gs=frm.CreateGraphics(); |
||||
} |
||||
|
||||
Rectangle rectOld; |
||||
bool bMoved = false; |
||||
|
||||
// get messages until capture lost or cancelled/accepted
|
||||
for (;;) |
||||
{ |
||||
MSG msg=new MSG(); |
||||
if(GetMessage(ref msg, 0, 0, 0)!=1) break; |
||||
if(!frm.Capture) break; |
||||
|
||||
switch (msg.message) |
||||
{ |
||||
// handle movement/accept messages
|
||||
case WM_LBUTTONUP: |
||||
case WM_MOUSEMOVE: |
||||
rectOld = m_rect; |
||||
// handle resize cases (and part of move)
|
||||
SetRectInt(px,LoWord(msg.lParam) - xDiff); |
||||
SetRectInt(py,HiWord(msg.lParam) - yDiff); |
||||
// handle move case
|
||||
if (nHandle == (int)TrackerHit.hitMiddle) |
||||
{ |
||||
m_rect.Width=nWidth; |
||||
m_rect.Height=nHeight; |
||||
} |
||||
// allow caller to adjust the rectangle if necessary
|
||||
AdjustRect(nHandle,ref m_rect); |
||||
|
||||
// only redraw and callback if the rect actually changed!
|
||||
m_bFinalErase = (msg.message == WM_LBUTTONUP); |
||||
if (m_bFinalErase) |
||||
goto ExitLoop; |
||||
|
||||
if (!rectOld.Equals(m_rect) || m_bFinalErase) |
||||
{ |
||||
if (bMoved) |
||||
{ |
||||
m_bErase = true; |
||||
DrawTrackerRect(rectOld, frmClipTo, gs, frm); |
||||
} |
||||
OnChangedRect(rectOld); |
||||
if (msg.message != WM_LBUTTONUP) |
||||
bMoved = true; |
||||
} |
||||
if (m_bFinalErase) |
||||
goto ExitLoop; |
||||
|
||||
if (!rectOld.Equals(m_rect)) |
||||
{ |
||||
m_bErase = false; |
||||
DrawTrackerRect(m_rect, frmClipTo, gs, frm); |
||||
} |
||||
break; |
||||
|
||||
// handle cancel messages
|
||||
case WM_KEYDOWN: |
||||
if (msg.wParam != 0x1B)//VK_ESCAPE
|
||||
break; |
||||
goto default; |
||||
case WM_RBUTTONDOWN: |
||||
if (bMoved) |
||||
{ |
||||
m_bErase = m_bFinalErase = true; |
||||
DrawTrackerRect(m_rect, frmClipTo, gs, frm); |
||||
} |
||||
m_rect = rectSave; |
||||
goto ExitLoop; |
||||
|
||||
// just dispatch rest of the messages
|
||||
default: |
||||
DispatchMessage(ref msg); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
ExitLoop: |
||||
gs.Dispose(); |
||||
frm.Capture=false; |
||||
// restore rect in case bMoved is still FALSE
|
||||
if (!bMoved) |
||||
m_rect = rectSave; |
||||
m_bFinalErase = false; |
||||
m_bErase = false; |
||||
|
||||
// return TRUE only if rect has changed
|
||||
return !rectSave.Equals(m_rect); |
||||
} |
||||
|
||||
public void NormalizeRect(ref Rectangle rect) |
||||
{ |
||||
Rectangle rc = new Rectangle(rect.Location,rect.Size); |
||||
if(rect.Left > rect.Right) |
||||
{ |
||||
rc.Width = -rect.Width; |
||||
rc.X = rect.Right; |
||||
} |
||||
if(rect.Top > rect.Bottom) |
||||
{ |
||||
rc.Height = -rect.Height; |
||||
rc.Y = rect.Bottom; |
||||
} |
||||
rect = rc; |
||||
} |
||||
|
||||
#region Helper functions
|
||||
|
||||
static int MakeLong(int LoWord, int HiWord) |
||||
{ |
||||
return (HiWord << 16) | (LoWord & 0xffff); |
||||
} |
||||
|
||||
static IntPtr MakeLParam(int LoWord, int HiWord) |
||||
{ |
||||
return (IntPtr) ((HiWord << 16) | (LoWord & 0xffff)); |
||||
} |
||||
|
||||
static int HiWord(int Number) |
||||
{ |
||||
return (Number >> 16) & 0xffff; |
||||
} |
||||
|
||||
static int LoWord(int Number) |
||||
{ |
||||
return Number & 0xffff; |
||||
} |
||||
|
||||
#endregion
|
||||
} |
||||
} |
||||
@ -1,77 +0,0 @@
@@ -1,77 +0,0 @@
|
||||
//------------------------------------------------------------------------------
|
||||
// <autogenerated>
|
||||
// This code was generated by a tool.
|
||||
// Runtime Version: 1.1.4322.2032
|
||||
//
|
||||
// Changes to this file may cause incorrect behavior and will be lost if
|
||||
// the code is regenerated.
|
||||
// </autogenerated>
|
||||
//------------------------------------------------------------------------------
|
||||
using System; |
||||
using System.Xml; |
||||
|
||||
using SharpReport.Designer; |
||||
|
||||
using SharpReportCore; |
||||
namespace SharpReport.Visitors |
||||
{ |
||||
|
||||
|
||||
/// <summary>
|
||||
/// Abstract Class for Designer Visitor
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// created by - Forstmeier Peter
|
||||
/// created on - 02.12.2004 16:53:00
|
||||
/// </remarks>
|
||||
public class AbstractVisitor : object, SharpReport.Designer.IDesignerVisitor { |
||||
private readonly string nodesQuery = "controls/control"; |
||||
private string fileName; |
||||
private XmlFormReader xmlFormReader; |
||||
|
||||
public AbstractVisitor() { |
||||
} |
||||
|
||||
public AbstractVisitor(string fileName){ |
||||
this.fileName = fileName; |
||||
xmlFormReader = new XmlFormReader() ; |
||||
} |
||||
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// All classes how use this baseclass have to override this method
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Interface method from IDesignerVisitor
|
||||
///
|
||||
/// </remarks>
|
||||
public virtual void Visit(SharpReport.Designer.BaseDesignerControl designer) { |
||||
|
||||
} |
||||
|
||||
|
||||
|
||||
#region Properties
|
||||
protected string FileName { |
||||
get { |
||||
return fileName; |
||||
} |
||||
} |
||||
|
||||
protected XmlFormReader XmlFormReader { |
||||
get { |
||||
return xmlFormReader; |
||||
} |
||||
} |
||||
|
||||
protected string NodesQuery { |
||||
get { |
||||
return nodesQuery; |
||||
} |
||||
} |
||||
|
||||
#endregion
|
||||
|
||||
} |
||||
} |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue