public void Update(Graphics g, string text, Font font, Padding internalBounds,
Rectangle bounds, Color color, TextFormatFlags formatFlags, IThemeTextOption[] options) {
IntPtr compatHdc = this._TextHDC;
if (bounds.Equals(_TextHDCBounds)) {
//Same bounds, reuse HDC and Clear it
IntPtr hClearBrush = Native.GDI.CreateSolidBrush(ColorTranslator.ToWin32(Color.Black));
Native.RECT cleanRect = new Native.RECT(bounds);
Native.GDI.FillRect(compatHdc, ref cleanRect, hClearBrush);
Native.GDI.DeleteObject(hClearBrush);
}
else {
//Other bounds, create new HDC
IntPtr outputHdc = g.GetHdc();
IntPtr DIB;
compatHdc = CreateNewHDC(outputHdc, bounds, out DIB);
//Store new data
_TextHDC = compatHdc;
_TextHDCBounds = bounds;
//Clear up
CleanUpHDC(DIB);
g.ReleaseHdc(outputHdc);
}
DrawOnHDC(compatHdc, text, font, internalBounds, bounds, color, formatFlags, options);
}
/// <summary>
/// 重载此方法,主要是为了做padding位置的调整.
/// 其它的东西和Contontainer中的一致
/// </summary>
public override void UpdateBounds()
{
int iLineTop = this.paddingTop; //上间距
System.Drawing.Rectangle NewBounds = System.Drawing.Rectangle.Empty;
foreach (ZYTextLine myLine in myLines)
{
myLine.Top = iLineTop;
myLine.RealTop = this.RealTop + iLineTop;
myLine.RealLeft = this.RealLeft + this.paddingLeft; //左间距
if (myLine.LastElement != null && myLine.LastElement.isNewParagraph())
{
myLine.LineSpacing = myOwnerDocument.Info.ParagraphSpacing;
}
else
{
myLine.LineSpacing = myOwnerDocument.Info.LineSpacing;
}
iLineTop += myLine.FullHeight;
foreach (ZYTextElement myElement in myLine.Elements)
{
NewBounds = new System.Drawing.Rectangle
(myElement.RealLeft,
myElement.RealTop,
myElement.Width + myElement.WidthFix,
myElement.Height);
if (NewBounds.Equals(myElement.Bounds) == false)
{
if (myOwnerDocument.OwnerControl != null && !(myElement is ZYTextContainer))
{
if (myElement.Bounds.IsEmpty == false)
{
myOwnerDocument.OwnerControl.AddInvalidateRect(myElement.Bounds);
}
myOwnerDocument.OwnerControl.AddInvalidateRect(NewBounds);
}
myElement.myBounds = NewBounds;
}
if (myElement is ZYTextContainer)
{
ZYTextContainer c = (ZYTextContainer)myElement;
c.UpdateBounds();
}
}
}
}
// ------------------------------------------------------------------
/// <summary>
/// Gets the brush.
/// </summary>
/// <param name="rectangle">The rectangle.</param>
/// <returns>Brush</returns>
// ------------------------------------------------------------------
public Brush GetBrush(Rectangle rectangle) {
if (rectangle.Equals(Rectangle.Empty)) {
return new SolidBrush(mStartColor);
} else {
if (rectangle.Width == 0) {
rectangle.Width = 1;
}
if (rectangle.Height == 0) {
rectangle.Height = 1;
}
return new LinearGradientBrush(
rectangle,
mStartColor,
mEndColor,
mAngle,
true);
}
}
void DrawArrowButton(Rectangle buttonRect, ButtonState state)
{
if (HasChild())
{
// No drawing buttons if there is a child control in the current band
return;
}
// Directly draw the arrow button
using (Graphics g = Graphics.FromHwnd(Handle))
{
bool up = true;
ScrollButton buttonType = ScrollButton.Up;
if (buttonRect.Equals(downArrowRect))
{
buttonType = ScrollButton.Down;
up = false;
}
if (flatArrowButtons && !HasChild())
{
int first;
int last;
GetVisibleRange(g, out first, out last);
if (up && first == 0)
{
// up arrow is not visible no need to pain it
return;
}
else if (up == false && last == bands[currentBandIndex].Items.Count - 1)
{
// down arrow is not visible no need to pain it
return;
}
// If using flat button and the mouse is still over the button
// then don't allow drawing it without the hightlight
Point pos = Control.MousePosition;
pos = PointToClient(pos);
if (buttonRect.Contains(pos))
{
if (up)
UpFlatArrowState = DrawState.Hot;
else
DownFlatArrowState = DrawState.Hot;
DrawFlatArrowButton(g, buttonRect, up, DrawState.Hot);
}
else
{
if (up)
UpFlatArrowState = DrawState.Normal;
else
DownFlatArrowState = DrawState.Normal;
DrawFlatArrowButton(g, buttonRect, up, DrawState.Normal);
}
}
else
ControlPaint.DrawScrollButton(g, buttonRect, buttonType, state);
}
}
public void TestXmlSerialize()
{
PointF p = new PointF(0.0f, 0.0f);
XmlDocument xDoc = Toolbox.XmlSerialize<PointF>(p, new Type[] { typeof(Point) });
PointF p2 = Toolbox.XmlDeserialize<PointF>(xDoc, new Type[] { typeof(Point) });
Assert.IsTrue(p.Equals(p2));
Rectangle rect = new Rectangle(3, 4, 5, 3);
XmlDocument xDoc2 = Toolbox.XmlSerialize<Rectangle>(rect);
Rectangle rect2 = Toolbox.XmlDeserialize<Rectangle>(xDoc2);
Assert.IsTrue(rect.Equals(rect2));
}
/// <summary>
/// Граничи ли първият обект с вторият
/// </summary>
/// <param name="firstObject"></param>
/// <param name="secondObject"></param>
/// <returns>връща true ако граничат или false ако не граничат</returns>
private bool IsColliding(Rectangle firstObject, Rectangle secondObject)
{
if (!firstObject.Equals(secondObject))
return firstObject.IntersectsWith(secondObject);
else
return false;
}
private void ProcessSecurityFrame(object sender, EventArgs e)
{
//Get Current Frame
Image<Bgr, byte> currentFrame = capture.QueryFrame();
Image<Gray, byte> grayFrame = currentFrame.Convert<Gray, byte>();
facePos = FaceDetection.Detect(grayFrame);
SecurityStateManager.AddToHistory(grayFrame.Copy(), facePos);
PrintInstruction();
if (!facePos.Equals(Rectangle.Empty))
{
BlinkStateManager.faceDetected = true;
Image<Gray, byte> faceImage = grayFrame.Copy(facePos);
detected = FaceRecognition.Recognize(faceImage);
SecurityStateManager.AddToHistory(username.Equals(detected));
checkBlink(faceImage);
}
imageBox.Image = currentFrame;
}
/// <summary>
/// Returns all rectangles that intersect with the target rectangle.
/// </summary>
/// <param name="rectangle">The target rectangle.</param>
/// <param name="rectangles">The candidate rectangles.</param>
/// <returns>A collection of rectangles.</returns>
public static IEnumerable<Rectangle> ChildrenAndIntersectingSiblings(Rectangle rectangle, IEnumerable<Rectangle> rectangles)
{
return rectangles.Where(r => rectangle.HitTest(r) && !rectangle.Equals(r) && !r.Encompasses(rectangle));
}
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
bool skipMessage = false;
Rectangle newBounds = new Rectangle(x, y, width, height);
if (GUIGraphicsContext._useScreenSelector && isMaximized)
{
if (!newBounds.Equals(GUIGraphicsContext.currentScreen.Bounds))
{
skipMessage = true;
}
}
if (skipMessage)
{
Log.Info("d3dapp: Screenselector: skipped SetBoundsCore {0} does not match {1}", newBounds.ToString(),
GUIGraphicsContext.currentScreen.Bounds.ToString());
}
else
{
base.SetBoundsCore(x, y, width, height, specified);
}
}
/// <summary>
/// Wstawia prostok�t do kontenera
/// </summary>
/// <param name="r">Prostok�t do wstawienia</param>
/// <param name="rLeftTop">Lewy g�rny wierzcho�ek prostok�ta</param>
/// <param name="o">Orientacja prostok�ta</param>
public void InsertRectangle(Rectangle r, Point rLeftTop, Rectangle.Orientation o)
{
Console.WriteLine("insert rect[(" + r.LeftTop.X + ", " + r.LeftTop.Y + "), (" +
r.RightDown.X + ", " + r.RightDown.Y + ")]" + " -> (" + rLeftTop.X + ", " +
rLeftTop.Y + ")");
InsertRectangleCheckParameters(r, rLeftTop);
if (o.Equals(Rectangle.Orientation.Horizontal) && r.SideA < r.SideB)
r.Rotate();
else if (o.Equals(Rectangle.Orientation.Vertical) && r.SideA > r.SideB)
r.Rotate();
if (rectangles.Count == 0)
FirstRectanglePreparation(r);
else
r.Move(rLeftTop);
rectangles.Add(r);
//jesli to byl pierwszy prostakat wszystko jest dobrze - nie trzeba tego robic
if (rectangles.Count > 1)
{
// spr. czy po dodaniu wciaz prawidlowy prostokat
if (isCorrectRectangle)
{
// doklejamy od dolu prostokata
if (r.LeftTop.X == maxCorrectRect.LeftTop.X &&
r.RightDown.X == maxCorrectRect.RightDown.X &&
r.LeftTop.Y <= maxCorrectRect.RightDown.Y)
UpdateMaxRectangles(r);
// doklejamy z prawej strony prostokata
else if (r.LeftTop.Y == maxCorrectRect.LeftTop.Y &&
r.RightDown.Y == maxCorrectRect.RightDown.Y &&
r.LeftTop.X <= maxCorrectRect.RightDown.X)
UpdateMaxRectangles(r);
// naklejamy na prostokat
else if (maxCorrectRect.Covers(r))
r.SetParentRectangle(maxCorrectRect);
// zaklejamy ca�y prostok�t - to r�wnie g�upi przypadek jak poprzedni, ale skoro kto� tak chce...
else if (r.Covers(maxCorrectRect))
UpdateMaxRectangles(r);
// calosc przestaje byc poprawnym prostokatem
else
{
isCorrectRectangle = false;
AddNewEmptyFields(r);
UpdateMaxPossibleRectangle(r);
}
}// gdy calosc nie jest prawidlowym prostokatem
else
{
//sprawdzenie czy dodanie prostokata nie pokrylo calkowicie jakichs emptyFields
//spr. czy przeciecia dodanego z empty sa niepuste (jesli tak - usuwamy odpow. empty z listy i wstawiamy zamiast niego empty-dodany)
//spr. czy nie zmienil sie maxPossibleRect
UpdateEmptyFields(r);
if (emptyFields.Count == 0)
UpdateMaxCorrectAfterFillingAllEmpties();
UpdateMaxPossibleRectangle(r);
}
}
}
private RecognitionResult GetAnswer(Rectangle fragment)
{
foreach (var answer in sampleResults)
{
if (fragment.Equals(answer.Region))
{
return answer;
}
}
return null;
}
/// <summary>
/// Create a BitmapBuffer from a Bitmap, a Rectangle specifying what part from the Bitmap to take and a flag if we need a clone
/// </summary>
/// <param name="sourceBmp">Bitmap</param>
/// <param name="applyRect">Rectangle</param>
/// <param name="clone">bool specifying if the bitmap needs to be cloned</param>
public BitmapBuffer(Bitmap sourceBmp, Rectangle applyRect, bool clone)
{
this.clone = clone;
Rectangle sourceRect = new Rectangle(applyRect.X, applyRect.Y, applyRect.Width, applyRect.Height);
Rectangle bitmapRect = new Rectangle(0,0, sourceBmp.Width, sourceBmp.Height);
if(sourceRect.Equals(Rectangle.Empty)) {
sourceRect = bitmapRect;
} else {
sourceRect.Intersect(bitmapRect);
}
// Does the rect have any pixels?
if (sourceRect.Height <= 0 || sourceRect.Width <= 0) {
return;
}
if (SupportsPixelFormat(sourceBmp)) {
if (clone) {
// Create copy with supported format
this.bitmap = sourceBmp.Clone(sourceRect, sourceBmp.PixelFormat);
} else {
this.bitmap = sourceBmp;
}
} else {
// We can only clone, as we don't support the pixel format!
if (!clone) {
throw new ArgumentException("Not supported pixel format: " + sourceBmp.PixelFormat);
}
// When sourceRect is the whole bitmap there is a GDI+ bug in Clone
// Clone will than return the same PixelFormat as the source
// a quick workaround is using new Bitmap which uses a default of Format32bppArgb
if (sourceRect.Equals(bitmapRect)) {
this.bitmap = new Bitmap(sourceBmp);
} else {
this.bitmap = sourceBmp.Clone(sourceRect, PixelFormat.Format32bppArgb);
}
}
// Set "this" rect to location 0,0
// as the Cloned Bitmap is only the part we want to work with
this.rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
}
private void RenderDiagramImplementation(Rectangle renderRectangle)
{
if (! Suspended)
{
if (! renderRectangle.Equals(mRenderRectangle)) DisposeGraphicsStateBitmap();
Graphics graphics = CreateGraphics(renderRectangle);
if (graphics==null) return;
OnPreRender(graphics);
//Render the elements if the renderer isnt locked
if (!mLocked) RenderDiagramElements(graphics);
//Render the decorations
if (mDrawDecorations) RenderDecorations(graphics, renderRectangle);
OnPostRender(graphics);
graphics.Dispose();
}
}
public unsafe override void Apply(Graphics graphics, Bitmap applyBitmap, Rectangle applyRect, RenderMode renderMode)
{
Rectangle sourceRect = new Rectangle(applyRect.X, applyRect.Y, applyRect.Width, applyRect.Height);
Rectangle bitmapRect = new Rectangle(0,0, applyBitmap.Width, applyBitmap.Height);
if(sourceRect.Equals(Rectangle.Empty)) {
sourceRect = bitmapRect;
} else {
sourceRect.Intersect(bitmapRect);
}
// Does the rect have any pixels?
if (sourceRect.Height <= 0 || sourceRect.Width <= 0) {
return;
}
int blurRadius = GetFieldValueAsInt(FieldType.BLUR_RADIUS);
// Calculate new sourceRect to include the matrix size if possible
int leftOffset = Math.Min(sourceRect.X, blurRadius);
int rightOffset = Math.Min(applyBitmap.Width - (sourceRect.X + sourceRect.Width), blurRadius);
int topOffset = Math.Min(sourceRect.Y, blurRadius);
int bottomOffset = Math.Min(applyBitmap.Height - (sourceRect.Y + sourceRect.Height), blurRadius);
LOG.Debug(String.Format("Offsets: {0},{1},{2},{3}", leftOffset, rightOffset, topOffset, bottomOffset));
LOG.Debug(String.Format("SourceRect before: {0},{1},{2},{3}", sourceRect.X, sourceRect.Width, sourceRect.Y, sourceRect.Height));
sourceRect.X -= leftOffset;
sourceRect.Width += leftOffset + rightOffset;
sourceRect.Y -= topOffset;
sourceRect.Height += topOffset + bottomOffset;
LOG.Debug(String.Format("SourceRect after: {0},{1},{2},{3}", sourceRect.X, sourceRect.Width, sourceRect.Y, sourceRect.Height));
// Make a copy of the applyBitmap for reading
using (Bitmap sourceBitmap = applyBitmap.Clone(sourceRect, applyBitmap.PixelFormat)) {
ApplySmooth(sourceBitmap, applyBitmap, sourceRect, blurRadius);
}
}
/// <summary>
/// Returns a rectangle inside 'lookInside' that bounds any energy greater than 'threshold'.
/// </summary>
/// <param name="image"></param>
/// <param name="lookInside">A rectangle of 'image' to look inside. </param>
/// <param name="threshold">1-255, the energy threshold to detect activity. 80-150 is a good range.</param>
/// <returns></returns>
public Rectangle FindBoxSobel(Bitmap originalImage, Rectangle lookInside, byte threshold)
{
Bitmap image = originalImage;
try {
//Convert if needed (makes an extra copy)
if (image.PixelFormat != PixelFormat.Format24bppRgb &&
image.PixelFormat != PixelFormat.Format32bppArgb &&
image.PixelFormat != PixelFormat.Format32bppRgb) {
image = AForge.Imaging.Image.Clone(image, PixelFormat.Format24bppRgb);
}
//Crop if needed (makes an extra copy unless we converted too, then only 1 extra copy)
if (!lookInside.Equals(new Rectangle(0, 0, image.Width, image.Height))) {
Bitmap oldImage = image;
try {
image = new Crop(lookInside).Apply(image);
} finally {
if (oldImage != originalImage) oldImage.Dispose(); //Dispose the cloned
}
}
//Makes 1 more copy at 1/3rd the size, in grayscale
Rectangle result = FindBoxSobel(image, threshold);
return new Rectangle(lookInside.X + result.X, lookInside.Y + result.Y, result.Width, result.Height);
} finally {
if (image != originalImage) image.Dispose();
}
}
protected virtual void CommonEditorUse(Control ctl, Rectangle rectTarget)
{
Rectangle bounds = ctl.Bounds;
Rectangle clientRectangle = base.ClientRectangle;
clientRectangle.Inflate(-1, -1);
try
{
rectTarget = Rectangle.Intersect(clientRectangle, rectTarget);
if (!rectTarget.IsEmpty)
{
if (!rectTarget.Equals(bounds))
{
ctl.SetBounds(rectTarget.X, rectTarget.Y, rectTarget.Width, rectTarget.Height);
}
ctl.Visible = true;
}
}
catch
{
rectTarget = Rectangle.Empty;
}
if (rectTarget.IsEmpty)
{
ctl.Visible = false;
}
this.currentEditor = ctl;
}
/// <summary>
/// Crop the surface
/// </summary>
/// <param name="cropRectangle"></param>
/// <returns></returns>
public bool ApplyCrop(Rectangle cropRectangle)
{
if (IsCropPossible(ref cropRectangle))
{
Rectangle imageRectangle = new Rectangle(Point.Empty, Image.Size);
Bitmap tmpImage;
// Make sure we have information, this this fails
try
{
tmpImage = ImageHelper.CloneArea(Image, cropRectangle, PixelFormat.DontCare);
}
catch (Exception ex)
{
ex.Data.Add("CropRectangle", cropRectangle);
ex.Data.Add("Width", Image.Width);
ex.Data.Add("Height", Image.Height);
ex.Data.Add("Pixelformat", Image.PixelFormat);
throw;
}
Matrix matrix = new Matrix();
matrix.Translate(-cropRectangle.Left, -cropRectangle.Top, MatrixOrder.Append);
// Make undoable
MakeUndoable(new SurfaceBackgroundChangeMemento(this, matrix), false);
// Do not dispose otherwise we can't undo the image!
SetImage(tmpImage, false);
_elements.Transform(matrix);
if (_surfaceSizeChanged != null && !imageRectangle.Equals(new Rectangle(Point.Empty, tmpImage.Size)))
{
_surfaceSizeChanged(this, null);
}
Invalidate();
return true;
}
return false;
}
public override void PostRender(float timePassed, int iLayer)
{
if (GUIWindowManager.IsRouted)
{
return;
}
if (iLayer != 2)
{
return;
}
if (!base.IsAnimating(AnimationType.WindowClose))
{
if (GUIPropertyManager.GetProperty("#Play.Current.Thumb") != _thumbLogo)
{
_fileName = g_Player.CurrentFile;
}
long lPTS1 = (long)(g_Player.CurrentPosition);
int hh = (int)(lPTS1 / 3600) % 100;
int mm = (int)((lPTS1 / 60) % 60);
int ss = (int)((lPTS1 / 1) % 60);
int iSpeed = g_Player.Speed;
if (hh == 0 && mm == 0 && ss < 5)
{
if (iSpeed < 1)
{
iSpeed = 1;
g_Player.Speed = iSpeed;
g_Player.SeekAbsolute(0.0d);
}
}
if (_imagePlayLogo != null)
{
_imagePlayLogo.Visible = ((g_Player.Paused == false) && (g_Player.Playing));
}
if (_imagePauseLogo != null)
{
_imagePauseLogo.Visible = (g_Player.Paused == true);
}
if (_imageFastForward != null)
{
_imageFastForward.Visible = (g_Player.Speed > 1);
}
if (_imageRewind != null)
{
_imageRewind.Visible = (g_Player.Speed < 0);
}
if (_imageNormal != null)
{
_imageNormal.Visible = (g_Player.PlaybackType == (int)PlayBackType.NORMAL);
}
if (_imageGapless != null)
{
_imageGapless.Visible = (g_Player.PlaybackType == (int)PlayBackType.GAPLESS);
}
if (_imageCrossfade != null)
{
_imageCrossfade.Visible = (g_Player.PlaybackType == (int)PlayBackType.CROSSFADE);
}
if (_videoWindow != null)
{
_videoWindow.Visible = _visualisationEnabled; // switch it of when we do not have any vizualisation
}
if (_videoRectangle != null)
{
if (g_Player.Playing) // && !_videoWindow.SetVideoWindow)
{
_videoRectangle.Visible = GUIGraphicsContext.ShowBackground;
}
else
{
_videoRectangle.Visible = false;
}
}
// this is called serveral times per second!
if (_videoWindow != null)
{
// Old code for overlay support? Commented out to fix Mantis:
// 0001682: Music visualization it's off position when using UI Calibration
//SetVideoWindow(new Rectangle(_videoWindow.XPosition, _videoWindow.YPosition, _videoWindow.Width, _videoWindow.Height));
}
// still needed?
else if (_videoRectangle != null) // to be compatible to the old version
{
SetVideoWindow(new Rectangle(_videoRectangle.XPosition, _videoRectangle.YPosition, _videoRectangle.Width,
_videoRectangle.Height));
}
else
{
// @ Bav: _videoWindow == null here -> System.NullReferenceException
//SetVideoWindow(new Rectangle());
Rectangle dummyRect = new Rectangle();
if (!dummyRect.Equals(GUIGraphicsContext.VideoWindow))
{
GUIGraphicsContext.VideoWindow = dummyRect;
}
if (_videoWindow != null)
{
_videoWindow.SetVideoWindow = false; // avoid flickering if visualization is turned off
}
}
}
base.Render(timePassed);
}
protected virtual void CommonEditorUse(Control ctl, Rectangle rectTarget) {
Debug.WriteLineIf(CompModSwitches.DebugGridView.TraceVerbose, "PropertyGridView:CommonEditorUse");
Debug.WriteLineIf(GridViewDebugPaint.TraceVerbose, "Showing common editors");
Debug.Assert(ctl != null, "Null control passed to CommonEditorUse");
Rectangle rectCur = ctl.Bounds;
// the client rect minus the border line
Rectangle clientRect = this.ClientRectangle;
clientRect.Inflate(-1,-1);
try {
rectTarget = Rectangle.Intersect(clientRect, rectTarget);
//if (ctl is Button)
// Debug.WriteStackTrace();
if (!rectTarget.IsEmpty) {
if (!rectTarget.Equals(rectCur)) {
ctl.SetBounds(rectTarget.X,rectTarget.Y,
rectTarget.Width,rectTarget.Height);
}
ctl.Visible = true;
}
}
catch {
rectTarget = Rectangle.Empty;
}
if (rectTarget.IsEmpty) {
ctl.Visible = false;
}
currentEditor = ctl;
}
private void SetVideoWindow(Rectangle newRect)
{
if (_visualisationEnabled && _videoWindow != null)
{
_videoWindow.SetVideoWindow = true;
if (!newRect.Equals(GUIGraphicsContext.VideoWindow))
{
GUIGraphicsContext.VideoWindow = newRect;
}
}
}
/// <summary>
/// Matches a top-level window to the application to the window having the specified dimensions.
/// </summary>
/// <param name="applicationName">The name of the application as registered with the AT-SPI registry.</param>
/// <param name="windowRect">A <see cref="System.Drawing.Rectangle"/> representing the window on the screen.</param>
/// <param name="frameExtents">A WindowManagerFrameExtents structure containing the size (in pixels) of the
/// decorations placed on the window by the window manager.</param>
/// <returns>A <see cref="System.IntPtr"/> value that points to the Accessible object representing the top-level window.</returns>
internal IntPtr MatchTopLevelWindowForApplication(string applicationName, Rectangle windowRect, WindowManagerFrameExtents frameExtents)
{
IntPtr windowPointer = IntPtr.Zero;
IList<IntPtr> topLevelWindows = this.GetTopLevelWindowsForApplication(applicationName);
foreach (IntPtr candidateWindow in topLevelWindows)
{
if (Accessible_isComponent(candidateWindow))
{
// Out variables for API call
int x = 0;
int y = 0;
int width = 0;
int height = 0;
int relativeX = 0;
int relativeY = 0;
IntPtr component = Accessible_getComponent(candidateWindow);
AccessibleComponent_getExtents(component, out x, out y, out width, out height, AccessibleCoordType.Screen);
AccessibleComponent_getPosition(component, out relativeX, out relativeY, AccessibleCoordType.Window);
AccessibleComponentLayer layer = AccessibleComponent_getLayer(component);
Rectangle componentRectangle = new Rectangle(x, y, width, height);
AccessibleComponent_unref(component);
// If the component layer is Window, this indicates that the window
// rect as passed in by the X server does not include the window frame
// as drawn by the window manager. If this is the case, adjust the rectangle
// so the window can be found.
if (layer == AccessibleComponentLayer.Window)
{
windowRect.X = windowRect.X - frameExtents.Left;
windowRect.Y = windowRect.Y - frameExtents.Top;
windowRect.Width = windowRect.Width + frameExtents.Left + frameExtents.Right;
windowRect.Height = windowRect.Height + frameExtents.Top + frameExtents.Bottom;
}
// If we found the window, add its pointer to the referenced objects
// cache and remove it from the list of available windows (so it
// does not get unreferenced.
if (windowRect.Equals(componentRectangle))
{
referencedObjectCache.Add(candidateWindow);
topLevelWindows.Remove(candidateWindow);
windowPointer = candidateWindow;
break;
}
}
}
// Unreference every window not matching as the top-level window
// for the application.
foreach (IntPtr referencedWindow in topLevelWindows)
{
Accessible_unref(referencedWindow);
}
return windowPointer;
}
/// <summary>
/// Apply a bitmap effect to the surface
/// </summary>
/// <param name="effect"></param>
public void ApplyBitmapEffect(Effects effect)
{
BackgroundForm backgroundForm = new BackgroundForm("Effect", "Please wait");
backgroundForm.Show();
Application.DoEvents();
try {
Rectangle imageRectangle = new Rectangle(Point.Empty, Image.Size);
Bitmap newImage = null;
Point offset = Point.Empty;
switch (effect) {
case Effects.Shadow:
offset = new Point(6, 6);
newImage = ImageHelper.CreateShadow((Bitmap)Image, 1f, 7, offset, PixelFormat.Format32bppRgb); //Image.PixelFormat);
break;
case Effects.TornEdge:
offset = new Point(5, 5);
using (Bitmap tmpImage = ImageHelper.CreateTornEdge((Bitmap)Image)) {
newImage = ImageHelper.CreateShadow(tmpImage, 1f, 6, offset, PixelFormat.Format32bppRgb); //Image.PixelFormat);
}
break;
case Effects.Border:
newImage = ImageHelper.CreateBorder((Bitmap)Image, 2, Color.Black, Image.PixelFormat, out offset);
break;
case Effects.Grayscale:
newImage = ImageHelper.CreateGrayscale((Bitmap)Image);
break;
case Effects.Invert:
newImage = ImageHelper.CreateNegative((Bitmap)Image);
break;
case Effects.RotateClockwise:
case Effects.RotateCounterClockwise:
MakeUndoable(new DrawableContainerBoundsChangeMemento(elements.AsIDrawableContainerList()), false);
RotateFlipType rotateFlipType = RotateFlipType.Rotate270FlipNone;
if (effect == Effects.RotateClockwise) {
rotateFlipType = RotateFlipType.Rotate90FlipNone;
}
foreach (DrawableContainer drawableContainer in elements) {
if (drawableContainer.CanRotate) {
drawableContainer.Rotate(rotateFlipType);
}
}
newImage = ImageHelper.RotateFlip((Bitmap)Image, rotateFlipType);
break;
}
// The following was added to correct any unneeded pixels, had the bad effect that sometimes everything was cropped... :(
//Rectangle autoCropRectangle = ImageHelper.FindAutoCropRectangle(newImage, 0);
//if (!Size.Empty.Equals(autoCropRectangle.Size) && !autoCropRectangle.Size.Equals(newImage.Size)) {
// LOG.InfoFormat("Crop to {0}", autoCropRectangle);
// using (Bitmap tmpImage = newImage) {
// newImage = ImageHelper.CloneArea(newImage, autoCropRectangle, PixelFormat.DontCare);
// }
// // Fix offset
// offset = new Point(offset.X - autoCropRectangle.X, offset.Y - autoCropRectangle.Y);
//} else {
// LOG.DebugFormat("No cropping needed!");
//}
if (newImage != null) {
// Make sure the elements move according to the offset the effect made the bitmap move
elements.MoveBy(offset.X, offset.Y);
// Make undoable
MakeUndoable(new SurfaceBackgroundChangeMemento(this, offset), false);
SetImage(newImage, false);
Invalidate();
if (SurfaceSizeChanged != null && !imageRectangle.Equals(new Rectangle(Point.Empty, newImage.Size))) {
SurfaceSizeChanged(this);
}
}
} finally {
// Always close the background form
backgroundForm.CloseDialog();
}
}
/// <summary>
/// Adds a marker with its configurations and image to layout manager.
/// </summary>
/// <param name="markerID">The ID of the marker (specified by the ARTag)</param>
/// <param name="upperLeftCorner">The upper left corner (in pixels) of this marker in the entire
/// marker array.</param>
/// <param name="size">The size of this marker to be printed on the marker array. If different
/// from the original image size, the marker image will be resized to fit this size.</param>
/// <param name="cropArea">The area to be retained after cropping other parts outside of
/// this area</param>
/// <param name="imagefile">The file name of the marker image (must have an extension that
/// indicates the image format)</param>
/// <param name="additionalInfos">Additional information that should be added to the config file</param>
/// <exception cref="ArgumentException">If the given marker ID is already added</exception>
/// <exception cref="InvalidOperationException"></exception>
public void AddMarker(int markerID, Point upperLeftCorner, Size size, Rectangle cropArea, String imagefile,
List<KeyValuePair<string, string>> additionalInfos)
{
if (configs.ContainsKey(markerID))
throw new ArgumentException("You can't add same marker ID in one config file");
MarkerConfig config = new MarkerConfig();
config.ID = markerID;
config.Position = upperLeftCorner;
int width = 0, height = 0;
config.Image = ImageReader.Load(imagefile, ref width, ref height);
config.ImageWidth = width;
config.ImageHeight = height;
config.CropArea = cropArea;
config.AdditionalInfo = additionalInfos;
config.ImageFilename = imagefile;
if (size.Equals(Size.Empty))
{
if (!cropArea.Equals(Rectangle.Empty))
config.Size = cropArea.Size;
else
config.Size = new Size(width, height);
}
else
config.Size = size;
// if crop area is not empty, then make sure that the crop area is within the marker size
if (!cropArea.Equals(Rectangle.Empty))
{
if (cropArea.X < 0 || cropArea.X > width)
throw new ArgumentException("Your crop area's X position is outside of the marker size");
if (cropArea.Y < 0 || cropArea.Y > height)
throw new ArgumentException("Your crop area's Y position is outside of the marker size");
if ((cropArea.X + cropArea.Width) > width)
throw new ArgumentException("Your crop area's X dimension exceeds the marker width");
if ((cropArea.Y + cropArea.Height) > height)
throw new ArgumentException("Your crop area's Y dimension exceeds the marker height");
}
configs.Add(markerID, config);
markerIDs.Add(markerID);
}
/// <summary>
/// Crop the surface
/// </summary>
/// <param name="cropRectangle"></param>
/// <returns></returns>
public bool ApplyCrop(Rectangle cropRectangle)
{
if (isCropPossible(ref cropRectangle)) {
Rectangle imageRectangle = new Rectangle(Point.Empty, Image.Size);
// we should not forget to Dispose the images!!
Bitmap tmpImage = ImageHelper.CloneArea(Image, cropRectangle, PixelFormat.DontCare);
Point offset = new Point(-cropRectangle.Left, -cropRectangle.Top);
// Make undoable
MakeUndoable(new SurfaceBackgroundChangeMemento(this, offset), false);
SetImage(tmpImage, false);
elements.MoveBy(offset.X, offset.Y);
if (SurfaceSizeChanged != null && !imageRectangle.Equals(new Rectangle(Point.Empty, tmpImage.Size))) {
SurfaceSizeChanged(this);
}
Invalidate();
return true;
}
return false;
}
void ProcessArrowScrolling(Rectangle arrowButton, ref bool arrowVisible, ref bool arrowPressed, ref bool timerTicking)
{
// Capture the mouse
Capture = true;
// Draw the arrow button pushed
timerTicking = true;
// Draw pushed button
buttonPushed = true;
DrawArrowButton(arrowButton, ButtonState.Pushed);
// Start timer
using (System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer())
{
timer.Tick += new EventHandler(ScrollingTick);
timer.Interval = 300;
timer.Start();
doScrollingLoop = true;
while (doScrollingLoop)
{
// Check messages until we find a condition to break out of the loop
Win32.MSG msg = new Win32.MSG();
WindowsAPI.GetMessage(ref msg, 0, 0, 0);
Point point = new Point(0, 0);
if (msg.message == (int)Msg.WM_MOUSEMOVE || msg.message == (int)Msg.WM_LBUTTONUP)
{
point = WindowsAPI.GetPointFromLPARAM((int)msg.lParam);
}
switch (msg.message)
{
case (int)Msg.WM_MOUSEMOVE:
{
if (arrowButton.Contains(point))
{
if (!buttonPushed)
{
DrawArrowButton(arrowButton, ButtonState.Pushed);
arrowVisible = true;
arrowPressed = true;
buttonPushed = true;
}
}
else
{
if (buttonPushed)
{
DrawArrowButton(arrowButton, ButtonState.Normal);
arrowVisible = false;
arrowPressed = false;
buttonPushed = false;
}
}
break;
}
case (int)Msg.WM_LBUTTONUP:
{
if (buttonPushed)
{
if (!flatArrowButtons)
{
// Only if using regular buttons
DrawArrowButton(arrowButton, ButtonState.Normal);
}
buttonPushed = false;
}
arrowVisible = false;
if (arrowButton.Contains(point))
{
if (arrowButton.Equals(upArrowRect))
{
if (firstItem > 0)
{
firstItem--;
Rectangle rc = GetViewPortRect();
Invalidate(rc);
}
}
else if (arrowButton.Equals(downArrowRect))
{
using (Graphics g = Graphics.FromHwnd(Handle))
{
// Get the last item rectangle
OutlookBarBand band = bands[currentBandIndex];
if (band != null)
{
Rectangle rcItem = GetItemRect(g, band, band.Items.Count - 1, Rectangle.Empty);
Rectangle rc = GetViewPortRect();
if (rcItem.Bottom > rc.Bottom)
{
firstItem++;
Invalidate(rc);
}
}
}
}
}
doScrollingLoop = false;
break;
}
case (int)Msg.WM_KEYDOWN:
{
if ((int)msg.wParam == (int)VirtualKeys.VK_ESCAPE)
doScrollingLoop = false;
break;
}
default:
WindowsAPI.DispatchMessage(ref msg);
break;
}
}
// Release the capture
Capture = false;
// Stop timer
timer.Stop();
}
// Reset flags
arrowVisible = false;
arrowPressed = false;
timerTicking = false;
Rectangle viewPortRect = GetViewPortRect();
Invalidate(viewPortRect);
}
/// <summary>
/// Gets the brush.
/// </summary>
/// <param name="rectangle">The rectangle.</param>
/// <returns></returns>
public Brush GetBrush(Rectangle rectangle)
{
if (rectangle.Equals(Rectangle.Empty))
return new SolidBrush(mStartColor);
else
return new LinearGradientBrush(rectangle, mStartColor, mEndColor, mAngle, true);
}
public bool Contains(Rectangle other)
{
return other.Equals(GetIntersection(other));
}
/// <summary>
/// Apply a bitmap effect to the surface
/// </summary>
/// <param name="effect"></param>
public void ApplyBitmapEffect(IEffect effect)
{
BackgroundForm backgroundForm = new BackgroundForm("Effect", "Please wait");
backgroundForm.Show();
Application.DoEvents();
try
{
Rectangle imageRectangle = new Rectangle(Point.Empty, Image.Size);
Point offset;
Image newImage = ImageHelper.ApplyEffect(Image, effect, out offset);
if (newImage != null)
{
// Make sure the elements move according to the offset the effect made the bitmap move
elements.MoveBy(offset.X, offset.Y);
// Make undoable
MakeUndoable(new SurfaceBackgroundChangeMemento(this, offset), false);
SetImage(newImage, false);
Invalidate();
if (surfaceSizeChanged != null && !imageRectangle.Equals(new Rectangle(Point.Empty, newImage.Size)))
{
surfaceSizeChanged(this, null);
}
}
}
finally
{
// Always close the background form
backgroundForm.CloseDialog();
}
}
public bool Contains(Rectangle other)
{
return(other.Equals(GetIntersection(other)));
}
/// <summary>
/// Apply a bitmap effect to the surface
/// </summary>
/// <param name="effect"></param>
public void ApplyBitmapEffect(IEffect effect)
{
BackgroundForm backgroundForm = new BackgroundForm("Effect", "Please wait");
backgroundForm.Show();
Application.DoEvents();
try
{
Rectangle imageRectangle = new Rectangle(Point.Empty, Image.Size);
Matrix matrix = new Matrix();
Image newImage = ImageHelper.ApplyEffect(Image, effect, matrix);
if (newImage != null)
{
// Make sure the elements move according to the offset the effect made the bitmap move
_elements.Transform(matrix);
// Make undoable
MakeUndoable(new SurfaceBackgroundChangeMemento(this, matrix), false);
SetImage(newImage, false);
Invalidate();
if (_surfaceSizeChanged != null && !imageRectangle.Equals(new Rectangle(Point.Empty, newImage.Size)))
{
_surfaceSizeChanged(this, null);
}
}
else
{
// clean up matrix, as it hasn't been used in the undo stack.
matrix.Dispose();
}
}
finally
{
// Always close the background form
backgroundForm.CloseDialog();
}
}
public void MoveSelected(Point point)
{
ICollection<Operator> selected = GetSelected();
ICollection<Operator> notSelected = GetNotSelected();
bool moveNecessary = false;
foreach (Operator selectedOp in selected)
{
Point p = Operator.QuantizeLocation(new Point(selectedOp.Left + point.X,
selectedOp.Top + point.Y));
Rectangle selectedOpDim = new Rectangle(p.X,
p.Y,
selectedOp.Width,
selectedOp.Height);
if (!selectedOpDim.Equals(selectedOp.Dimension))
moveNecessary = true;
foreach (Operator nonSelectedOp in notSelected)
{
if (nonSelectedOp.Dimension.IntersectsWith(selectedOpDim))
{
// Cannot peform move due to a collision.
return;
}
}
}
if (!moveNecessary)
return;
foreach (Operator op in selected)
{
operators.Remove(op);
Disconnect(op);
}
foreach (Operator op in selected)
{
Move(op, point);
}
foreach (Operator op in selected)
{
operators.Add(op);
Connect(op);
}
OnMoved(selected);
}
private void TimelineChannelsView_MouseMove(object sender, MouseEventArgs e)
{
if (timeline == null)
return;
mouseLocation = new Point(e.X, e.Y);
if (Mode == Modes.Move)
{
if (inSelect)
{
lastSelectionRectangle = selectionRectangle;
selectionRectangle = CalculateSelectionRectangle();
timeline.SelectClips(PixelDimensionToBeatDimension(selectionRectangle));
if (!lastSelectionRectangle.Equals(selectionRectangle))
{
Invalidate(lastSelectionRectangle);
Invalidate(selectionRectangle);
}
}
if (inMove)
{
lastMoveRectangle = moveRectangle;
moveRectangle = CalculateMoveRectangle();
if (!lastMoveRectangle.Equals(moveRectangle))
{
Invalidate(lastMoveRectangle);
Invalidate(moveRectangle);
}
}
if (inResize)
{
lastResizeRectangle = resizeRectangle;
resizeRectangle = CalculateResizeRectangle();
if (!lastResizeRectangle.Equals(resizeRectangle))
{
Invalidate(lastResizeRectangle);
Invalidate(resizeRectangle);
}
}
}
if (mode == Modes.DrawGenerator || mode == Modes.DrawSpline)
{
if (inDraw)
{
lastDrawRectangle = drawRectangle;
drawRectangle = CalculateDrawRectangle();
if (!lastDrawRectangle.Equals(drawRectangle))
{
Invalidate(lastDrawRectangle);
Invalidate(drawRectangle);
}
}
}
}
